Fix prior tests with new EIP-7251 logic

Author: ralexstokes

tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_withdrawals.py

@@ -19,6 +19,7 @@
     next_slot,
 )
 from eth2spec.test.helpers.withdrawals import (
+    get_expected_withdrawals,
     prepare_expected_withdrawals,
     set_eth1_withdrawal_credential_with_balance,
     set_validator_fully_withdrawable,
@@ -62,7 +63,7 @@ def run_withdrawals_processing(spec, state, execution_payload, num_expected_with
       - post-state ('post').
     If ``valid == False``, run expecting ``AssertionError``
     """
-    expected_withdrawals = spec.get_expected_withdrawals(state)
+    expected_withdrawals = get_expected_withdrawals(spec, state)
     assert len(expected_withdrawals) <= spec.MAX_WITHDRAWALS_PER_PAYLOAD
     if num_expected_withdrawals is not None:
         assert len(expected_withdrawals) == num_expected_withdrawals
@@ -87,7 +88,7 @@ def run_withdrawals_processing(spec, state, execution_payload, num_expected_with
         assert state.next_withdrawal_validator_index == next_withdrawal_validator_index % len(state.validators)
     elif len(expected_withdrawals) <= spec.MAX_WITHDRAWALS_PER_PAYLOAD:
         bound = min(spec.MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP, spec.MAX_WITHDRAWALS_PER_PAYLOAD)
-        assert len(spec.get_expected_withdrawals(state)) <= bound
+        assert len(get_expected_withdrawals(spec, state)) <= bound
     elif len(expected_withdrawals) > spec.MAX_WITHDRAWALS_PER_PAYLOAD:
         raise ValueError('len(expected_withdrawals) should not be greater than MAX_WITHDRAWALS_PER_PAYLOAD')
 
@@ -100,7 +101,7 @@ def run_withdrawals_processing(spec, state, execution_payload, num_expected_with
 @with_capella_and_later
 @spec_state_test
 def test_success_zero_expected_withdrawals(spec, state):
-    assert len(spec.get_expected_withdrawals(state)) == 0
+    assert len(get_expected_withdrawals(spec, state)) == 0
 
     next_slot(spec, state)
     execution_payload = build_empty_execution_payload(spec, state)

tests/core/pyspec/eth2spec/test/capella/sanity/test_blocks.py

@@ -1,4 +1,5 @@
 from eth2spec.test.helpers.constants import MINIMAL
+from eth2spec.test.helpers.forks import is_post_eip7251
 from eth2spec.test.context import (
     with_capella_and_later,
     spec_state_test,
@@ -20,6 +21,7 @@
     next_epoch_with_attestations,
 )
 from eth2spec.test.helpers.withdrawals import (
+    get_expected_withdrawals,
     set_eth1_withdrawal_credential_with_balance,
     set_validator_fully_withdrawable,
     set_validator_partially_withdrawable,
@@ -202,7 +204,7 @@ def test_full_withdrawal_in_epoch_transition(spec, state):
     index = 0
     current_epoch = spec.get_current_epoch(state)
     set_validator_fully_withdrawable(spec, state, index, current_epoch)
-    assert len(spec.get_expected_withdrawals(state)) == 1
+    assert len(get_expected_withdrawals(spec, state)) == 1
 
     yield 'pre', state
 
@@ -214,7 +216,7 @@ def test_full_withdrawal_in_epoch_transition(spec, state):
     yield 'post', state
 
     assert state.balances[index] == 0
-    assert len(spec.get_expected_withdrawals(state)) == 0
+    assert len(get_expected_withdrawals(spec, state)) == 0
 
 
 @with_capella_and_later
@@ -224,7 +226,7 @@ def test_partial_withdrawal_in_epoch_transition(spec, state):
     set_validator_partially_withdrawable(spec, state, index, excess_balance=1000000000000)
     pre_balance = state.balances[index]
 
-    assert len(spec.get_expected_withdrawals(state)) == 1
+    assert len(get_expected_withdrawals(spec, state)) == 1
 
     yield 'pre', state
 
@@ -238,7 +240,7 @@ def test_partial_withdrawal_in_epoch_transition(spec, state):
     assert state.balances[index] < pre_balance
     # Potentially less than due to sync committee penalty
     assert state.balances[index] <= spec.MAX_EFFECTIVE_BALANCE
-    assert len(spec.get_expected_withdrawals(state)) == 0
+    assert len(get_expected_withdrawals(spec, state)) == 0
 
 
 @with_capella_and_later
@@ -250,7 +252,7 @@ def test_many_partial_withdrawals_in_epoch_transition(spec, state):
         index = (i + state.next_withdrawal_index) % len(state.validators)
         set_validator_partially_withdrawable(spec, state, index, excess_balance=1000000000000)
 
-    assert len(spec.get_expected_withdrawals(state)) == spec.MAX_WITHDRAWALS_PER_PAYLOAD
+    assert (len(get_expected_withdrawals(spec, state)) == spec.MAX_WITHDRAWALS_PER_PAYLOAD)
 
     yield 'pre', state
 
@@ -261,7 +263,7 @@ def test_many_partial_withdrawals_in_epoch_transition(spec, state):
     yield 'blocks', [signed_block]
     yield 'post', state
 
-    assert len(spec.get_expected_withdrawals(state)) == 1
+    assert len(get_expected_withdrawals(spec, state)) == 1
 
 
 def _perform_valid_withdrawal(spec, state):
@@ -272,7 +274,7 @@ def _perform_valid_withdrawal(spec, state):
     next_slot(spec, state)
     pre_next_withdrawal_index = state.next_withdrawal_index
 
-    expected_withdrawals = spec.get_expected_withdrawals(state)
+    expected_withdrawals = get_expected_withdrawals(spec, state)
 
     pre_state = state.copy()
 
@@ -357,7 +359,11 @@ def test_top_up_and_partial_withdrawable_validator(spec, state):
 
     signed_block = state_transition_and_sign_block(spec, state, block)
 
-    yield 'blocks', [signed_block]
+    # ensure we go through an epoch transition, to account for post-EIP-7251 behavior
+    block_in_next_epoch = build_empty_block(spec, state, slot=state.slot + spec.SLOTS_PER_EPOCH)
+    signed_block_in_next_epoch = state_transition_and_sign_block(spec, state, block_in_next_epoch)
+
+    yield 'blocks', [signed_block, signed_block_in_next_epoch]
     yield 'post', state
 
     # Since withdrawals happen before deposits, it becomes partially withdrawable after state transition.
@@ -395,9 +401,13 @@ def test_top_up_to_fully_withdrawn_validator(spec, state):
 
     signed_block_1 = state_transition_and_sign_block(spec, state, block)
 
+    balance = state.balances[validator_index]
+    if is_post_eip7251(spec):
+        balance += state.pending_balance_deposits[0].amount
+
     assert spec.is_fully_withdrawable_validator(
         state.validators[validator_index],
-        state.balances[validator_index],
+        balance,
         spec.get_current_epoch(state)
     )
 

tests/core/pyspec/eth2spec/test/deneb/epoch_processing/test_process_registry_updates.py

@@ -1,4 +1,5 @@
 from eth2spec.test.helpers.keys import pubkeys
+from eth2spec.test.helpers.forks import is_post_eip7251
 from eth2spec.test.helpers.constants import MINIMAL
 from eth2spec.test.context import (
     with_deneb_and_later,
@@ -47,7 +48,9 @@ def run_test_activation_churn_limit(spec, state):
     # Half should churn in first run of registry update
     for i in range(mock_activations):
         index = validator_count_0 + i
-        if index < validator_count_0 + churn_limit_0:
+        # NOTE: activations are gated different after EIP-7251
+        # all eligible validators have been activated
+        if index < validator_count_0 + churn_limit_0 or is_post_eip7251(spec):
             # The eligible validators within the activation churn limit should have been activated
             assert state.validators[index].activation_epoch < spec.FAR_FUTURE_EPOCH
         else:

tests/core/pyspec/eth2spec/test/helpers/deposits.py

@@ -1,7 +1,7 @@
 from random import Random
 
 from eth2spec.test.context import expect_assertion_error
-from eth2spec.test.helpers.forks import is_post_altair
+from eth2spec.test.helpers.forks import is_post_altair, is_post_eip7251
 from eth2spec.test.helpers.keys import pubkeys, privkeys
 from eth2spec.test.helpers.state import get_balance
 from eth2spec.utils import bls
@@ -241,6 +241,9 @@ def run_deposit_processing(spec, state, deposit, validator_index, valid=True, ef
         pre_balance = get_balance(state, validator_index)
         pre_effective_balance = state.validators[validator_index].effective_balance
 
+    if is_post_eip7251(spec):
+        assert len(state.pending_balance_deposits) == 0
+
     yield 'pre', state
     yield 'deposit', deposit
 
@@ -253,6 +256,20 @@ def run_deposit_processing(spec, state, deposit, validator_index, valid=True, ef
 
     yield 'post', state
 
+    if is_post_eip7251(spec):
+        # balance additions are now routed through "pending balance deposits"
+        # process them here along with any effective balance updates
+        updates_count = len(state.pending_balance_deposits)
+        if updates_count != 0:
+            assert updates_count == 1
+            pending_balance_deposit = state.pending_balance_deposits[0]
+            assert pending_balance_deposit.index == validator_index
+            assert pending_balance_deposit.amount == deposit.data.amount
+            spec.increase_balance(state, validator_index, deposit.data.amount)
+            if not is_top_up:
+                # run effective balance update for new validators
+                spec.process_effective_balance_updates(state)
+
     if not effective or not bls.KeyValidate(deposit.data.pubkey):
         assert len(state.validators) == pre_validator_count
         assert len(state.balances) == pre_validator_count

tests/core/pyspec/eth2spec/test/helpers/execution_payload.py

@@ -4,6 +4,7 @@
 from rlp.sedes import big_endian_int, Binary, List
 
 from eth2spec.debug.random_value import get_random_bytes_list
+from eth2spec.test.helpers.withdrawals import get_expected_withdrawals
 from eth2spec.test.helpers.forks import (
     is_post_capella,
     is_post_deneb,
@@ -227,7 +228,7 @@ def build_empty_execution_payload(spec, state, randao_mix=None):
         transactions=empty_txs,
     )
     if is_post_capella(spec):
-        payload.withdrawals = spec.get_expected_withdrawals(state)
+        payload.withdrawals = get_expected_withdrawals(spec, state)
     if is_post_deneb(spec):
         payload.blob_gas_used = 0
         payload.excess_blob_gas = 0

tests/core/pyspec/eth2spec/test/helpers/proposer_slashings.py

@@ -1,5 +1,5 @@
 from eth2spec.test.helpers.block_header import sign_block_header
-from eth2spec.test.helpers.forks import is_post_altair, is_post_bellatrix
+from eth2spec.test.helpers.forks import is_post_altair, is_post_bellatrix, is_post_eip7251
 from eth2spec.test.helpers.keys import pubkey_to_privkey
 from eth2spec.test.helpers.state import get_balance
 from eth2spec.test.helpers.sync_committee import (
@@ -9,14 +9,23 @@
 
 
 def get_min_slashing_penalty_quotient(spec):
-    if is_post_bellatrix(spec):
+    if is_post_eip7251(spec):
+        return spec.MIN_SLASHING_PENALTY_QUOTIENT_EIP7251
+    elif is_post_bellatrix(spec):
         return spec.MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX
     elif is_post_altair(spec):
         return spec.MIN_SLASHING_PENALTY_QUOTIENT_ALTAIR
     else:
         return spec.MIN_SLASHING_PENALTY_QUOTIENT
 
 
+def get_whistleblower_reward_quotient(spec):
+    if is_post_eip7251(spec):
+        return spec.WHISTLEBLOWER_REWARD_QUOTIENT_EIP7251
+    else:
+        return spec.WHISTLEBLOWER_REWARD_QUOTIENT
+
+
 def check_proposer_slashing_effect(spec, pre_state, state, slashed_index, block=None):
     slashed_validator = state.validators[slashed_index]
     assert slashed_validator.slashed
@@ -25,7 +34,7 @@ def check_proposer_slashing_effect(spec, pre_state, state, slashed_index, block=
 
     proposer_index = spec.get_beacon_proposer_index(state)
     slash_penalty = state.validators[slashed_index].effective_balance // get_min_slashing_penalty_quotient(spec)
-    whistleblower_reward = state.validators[slashed_index].effective_balance // spec.WHISTLEBLOWER_REWARD_QUOTIENT
+    whistleblower_reward = state.validators[slashed_index].effective_balance // get_whistleblower_reward_quotient(spec)
 
     # Altair introduces sync committee (SC) reward and penalty
     sc_reward_for_slashed = sc_penalty_for_slashed = sc_reward_for_proposer = sc_penalty_for_proposer = 0

tests/core/pyspec/eth2spec/test/helpers/withdrawals.py

@@ -1,4 +1,13 @@
 import random
+from eth2spec.test.helpers.forks import is_post_eip7251
+
+
+def get_expected_withdrawals(spec, state):
+    if is_post_eip7251(spec):
+        withdrawals, _ = spec.get_expected_withdrawals(state)
+        return withdrawals
+    else:
+        return spec.get_expected_withdrawals(state)
 
 
 def set_validator_fully_withdrawable(spec, state, index, withdrawable_epoch=None):

tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py

@@ -10,7 +10,10 @@
     get_valid_attester_slashing, get_valid_attester_slashing_by_indices,
     get_indexed_attestation_participants, get_attestation_2_data, get_attestation_1_data,
 )
-from eth2spec.test.helpers.proposer_slashings import get_min_slashing_penalty_quotient
+from eth2spec.test.helpers.proposer_slashings import (
+    get_min_slashing_penalty_quotient,
+    get_whistleblower_reward_quotient,
+)
 from eth2spec.test.helpers.state import (
     get_balance,
     next_epoch_via_block,
@@ -49,7 +52,7 @@ def run_attester_slashing_processing(spec, state, attester_slashing, valid=True)
     }
 
     total_proposer_rewards = sum(
-        effective_balance // spec.WHISTLEBLOWER_REWARD_QUOTIENT
+        effective_balance // get_whistleblower_reward_quotient(spec)
         for effective_balance in pre_slashing_effectives.values()
     )
 
@@ -71,7 +74,9 @@ def run_attester_slashing_processing(spec, state, attester_slashing, valid=True)
             assert slashed_validator.withdrawable_epoch == expected_withdrawable_epoch
         else:
             assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH
-        assert get_balance(state, slashed_index) < pre_slashing_balances[slashed_index]
+        if slashed_index != proposer_index:
+            # NOTE: check proposer balances below
+            assert get_balance(state, slashed_index) < pre_slashing_balances[slashed_index]
 
     if proposer_index not in slashed_indices:
         # gained whistleblower reward