From 720d1d933700064c8053e8b5afd30ee2a582b2e3 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Tue, 29 Nov 2022 16:48:12 +0800 Subject: [PATCH 01/11] Add @description decorator --- tests/core/pyspec/eth2spec/test/context.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py index 94910fa473..c0e7c2b5f8 100644 --- a/tests/core/pyspec/eth2spec/test/context.py +++ b/tests/core/pyspec/eth2spec/test/context.py @@ -258,6 +258,12 @@ def dump_skipping_message(reason: str) -> None: raise SkippedTest(message) +def description(case_description: str): + def entry(fn): + return with_meta_tags({'description': case_description})(fn) + return entry + + def spec_test(fn): # Bls switch must be wrapped by vector_test, # to fully go through the yielded bls switch data, before setting back the BLS setting. @@ -267,7 +273,7 @@ def spec_test(fn): return vector_test()(bls_switch(fn)) -# shorthand for decorating @spectest() @with_state @single_phase +# shorthand for decorating @spec_test @with_state @single_phase def spec_state_test(fn): return spec_test(with_state(single_phase(fn))) From 0847a963bf1d3f5e30e90df0b411c05399d02e07 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Tue, 29 Nov 2022 22:12:15 +0800 Subject: [PATCH 02/11] Unify test case naming style --- .../test_process_attestation.py | 116 +++++++++--------- .../test_process_attester_slashing.py | 102 +++++++-------- .../test_process_block_header.py | 4 +- .../block_processing/test_process_deposit.py | 28 ++--- .../test_process_proposer_slashing.py | 52 ++++---- .../test_process_voluntary_exit.py | 26 ++-- .../eth2spec/test/phase0/sanity/test_slots.py | 5 +- 7 files changed, 168 insertions(+), 165 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attestation.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attestation.py index 8d9e679982..7595ce9cbe 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attestation.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attestation.py @@ -23,7 +23,7 @@ @with_all_phases @spec_state_test -def test_success(spec, state): +def test_one_basic_attestation(spec, state): attestation = get_valid_attestation(spec, state, signed=True) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -34,7 +34,7 @@ def test_success(spec, state): @spec_test @with_custom_state(balances_fn=low_balances, threshold_fn=lambda spec: spec.config.EJECTION_BALANCE) @single_phase -def test_success_multi_proposer_index_iterations(spec, state): +def test_multi_proposer_index_iterations(spec, state): next_slots(spec, state, spec.SLOTS_PER_EPOCH * 2) attestation = get_valid_attestation(spec, state, signed=True) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -44,7 +44,7 @@ def test_success_multi_proposer_index_iterations(spec, state): @with_all_phases @spec_state_test -def test_success_previous_epoch(spec, state): +def test_previous_epoch(spec, state): attestation = get_valid_attestation(spec, state, signed=True) next_epoch_via_block(spec, state) @@ -58,55 +58,55 @@ def test_invalid_attestation_signature(spec, state): attestation = get_valid_attestation(spec, state) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test @always_bls -def test_empty_participants_zeroes_sig(spec, state): +def test_invalid_empty_participants_zeroes_sig(spec, state): attestation = get_valid_attestation(spec, state, filter_participant_set=lambda comm: []) # 0 participants attestation.signature = spec.BLSSignature(b'\x00' * 96) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test @always_bls -def test_empty_participants_seemingly_valid_sig(spec, state): +def test_invalid_empty_participants_seemingly_valid_sig(spec, state): attestation = get_valid_attestation(spec, state, filter_participant_set=lambda comm: []) # 0 participants # Special BLS value, valid for zero pubkeys on some (but not all) BLS implementations. attestation.signature = spec.BLSSignature(b'\xc0' + b'\x00' * 95) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_before_inclusion_delay(spec, state): +def test_invalid_before_inclusion_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=True) # do not increment slot to allow for inclusion delay - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_after_epoch_slots(spec, state): +def test_invalid_after_epoch_slots(spec, state): attestation = get_valid_attestation(spec, state, signed=True) # increment past latest inclusion slot transition_to_slot_via_block(spec, state, state.slot + spec.SLOTS_PER_EPOCH + 1) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_old_source_epoch(spec, state): +def test_invalid_old_source_epoch(spec, state): next_slots(spec, state, spec.SLOTS_PER_EPOCH * 5) state.finalized_checkpoint.epoch = 2 state.previous_justified_checkpoint.epoch = 3 @@ -121,19 +121,19 @@ def test_old_source_epoch(spec, state): sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test @always_bls -def test_wrong_index_for_committee_signature(spec, state): +def test_invalid_wrong_index_for_committee_signature(spec, state): attestation = get_valid_attestation(spec, state) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) attestation.data.index += 1 - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) def reduce_state_committee_count_from_max(spec, state): @@ -148,7 +148,7 @@ def reduce_state_committee_count_from_max(spec, state): @with_all_phases @spec_state_test @never_bls -def test_wrong_index_for_slot_0(spec, state): +def test_invalid_wrong_index_for_slot_0(spec, state): reduce_state_committee_count_from_max(spec, state) attestation = get_valid_attestation(spec, state) @@ -157,13 +157,13 @@ def test_wrong_index_for_slot_0(spec, state): # Invalid index: current committees per slot is less than the max attestation.data.index = spec.MAX_COMMITTEES_PER_SLOT - 1 - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test @never_bls -def test_wrong_index_for_slot_1(spec, state): +def test_invalid_wrong_index_for_slot_1(spec, state): reduce_state_committee_count_from_max(spec, state) current_epoch = spec.get_current_epoch(state) @@ -175,7 +175,7 @@ def test_wrong_index_for_slot_1(spec, state): # Invalid index: off by one attestation.data.index = committee_count - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @@ -188,12 +188,12 @@ def test_invalid_index(spec, state): # Invalid index: off by one (with respect to valid range) on purpose attestation.data.index = spec.MAX_COMMITTEES_PER_SLOT - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_mismatched_target_and_slot(spec, state): +def test_invalid_mismatched_target_and_slot(spec, state): next_epoch_via_block(spec, state) next_epoch_via_block(spec, state) @@ -202,24 +202,24 @@ def test_mismatched_target_and_slot(spec, state): sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_old_target_epoch(spec, state): +def test_invalid_old_target_epoch(spec, state): assert spec.MIN_ATTESTATION_INCLUSION_DELAY < spec.SLOTS_PER_EPOCH * 2 attestation = get_valid_attestation(spec, state, signed=True) next_slots(spec, state, spec.SLOTS_PER_EPOCH * 2) # target epoch will be too old to handle - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_future_target_epoch(spec, state): +def test_invalid_future_target_epoch(spec, state): assert spec.MIN_ATTESTATION_INCLUSION_DELAY < spec.SLOTS_PER_EPOCH * 2 attestation = get_valid_attestation(spec, state) @@ -236,12 +236,12 @@ def test_future_target_epoch(spec, state): next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_new_source_epoch(spec, state): +def test_invalid_new_source_epoch(spec, state): attestation = get_valid_attestation(spec, state) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -249,12 +249,12 @@ def test_new_source_epoch(spec, state): sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_source_root_is_target_root(spec, state): +def test_invalid_source_root_is_target_root(spec, state): attestation = get_valid_attestation(spec, state) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -262,7 +262,7 @@ def test_source_root_is_target_root(spec, state): sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @@ -289,7 +289,7 @@ def test_invalid_current_source_root(spec, state): sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @@ -315,12 +315,12 @@ def test_invalid_previous_source_root(spec, state): sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_bad_source_root(spec, state): +def test_invalid_bad_source_root(spec, state): attestation = get_valid_attestation(spec, state) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -328,24 +328,24 @@ def test_bad_source_root(spec, state): sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_too_many_aggregation_bits(spec, state): +def test_invalid_too_many_aggregation_bits(spec, state): attestation = get_valid_attestation(spec, state, signed=True) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) # one too many bits attestation.aggregation_bits.append(0b0) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) @with_all_phases @spec_state_test -def test_too_few_aggregation_bits(spec, state): +def test_invalid_too_few_aggregation_bits(spec, state): attestation = get_valid_attestation(spec, state) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -357,7 +357,7 @@ def test_too_few_aggregation_bits(spec, state): # one too few bits attestation.aggregation_bits = attestation.aggregation_bits[:-1] - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) # @@ -366,7 +366,7 @@ def test_too_few_aggregation_bits(spec, state): @with_all_phases @spec_state_test -def test_correct_min_inclusion_delay(spec, state): +def test_correct_attestation_included_at_min_inclusion_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=True) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -375,7 +375,7 @@ def test_correct_min_inclusion_delay(spec, state): @with_all_phases @spec_state_test -def test_correct_sqrt_epoch_delay(spec, state): +def test_correct_attestation_included_at_sqrt_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=True) next_slots(spec, state, spec.integer_squareroot(spec.SLOTS_PER_EPOCH)) @@ -384,7 +384,7 @@ def test_correct_sqrt_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_correct_epoch_delay(spec, state): +def test_correct_attestation_included_at_one_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=True) next_slots(spec, state, spec.SLOTS_PER_EPOCH) @@ -393,13 +393,13 @@ def test_correct_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_correct_after_epoch_delay(spec, state): +def test_invalid_correct_attestation_included_after_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=True) # increment past latest inclusion slot next_slots(spec, state, spec.SLOTS_PER_EPOCH + 1) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) # @@ -408,7 +408,7 @@ def test_correct_after_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_head_min_inclusion_delay(spec, state): +def test_incorrect_head_included_at_min_inclusion_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -420,7 +420,7 @@ def test_incorrect_head_min_inclusion_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_head_sqrt_epoch_delay(spec, state): +def test_incorrect_head_included_at_sqrt_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.integer_squareroot(spec.SLOTS_PER_EPOCH)) @@ -432,7 +432,7 @@ def test_incorrect_head_sqrt_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_head_epoch_delay(spec, state): +def test_incorrect_head_included_at_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.SLOTS_PER_EPOCH) @@ -444,7 +444,7 @@ def test_incorrect_head_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_head_after_epoch_delay(spec, state): +def test_invalid_incorrect_head_included_after_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) # increment past latest inclusion slot @@ -453,7 +453,7 @@ def test_incorrect_head_after_epoch_delay(spec, state): attestation.data.beacon_block_root = b'\x42' * 32 sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) # @@ -475,7 +475,7 @@ def test_incorrect_head_and_target_min_inclusion_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_head_and_target_sqrt_epoch_delay(spec, state): +def test_incorrect_head_and_target_included_at_sqrt_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.integer_squareroot(spec.SLOTS_PER_EPOCH)) @@ -488,7 +488,7 @@ def test_incorrect_head_and_target_sqrt_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_head_and_target_epoch_delay(spec, state): +def test_incorrect_head_and_target_included_at_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.SLOTS_PER_EPOCH) @@ -501,7 +501,7 @@ def test_incorrect_head_and_target_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_head_and_target_after_epoch_delay(spec, state): +def test_invalid_incorrect_head_and_target_included_after_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) # increment past latest inclusion slot next_slots(spec, state, spec.SLOTS_PER_EPOCH + 1) @@ -510,7 +510,7 @@ def test_incorrect_head_and_target_after_epoch_delay(spec, state): attestation.data.target.root = b'\x42' * 32 sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) # @@ -519,7 +519,7 @@ def test_incorrect_head_and_target_after_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_target_min_inclusion_delay(spec, state): +def test_incorrect_target_included_at_min_inclusion_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.MIN_ATTESTATION_INCLUSION_DELAY) @@ -531,7 +531,7 @@ def test_incorrect_target_min_inclusion_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_target_sqrt_epoch_delay(spec, state): +def test_incorrect_target_included_at_sqrt_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.integer_squareroot(spec.SLOTS_PER_EPOCH)) @@ -543,7 +543,7 @@ def test_incorrect_target_sqrt_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_target_epoch_delay(spec, state): +def test_incorrect_target_included_at_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) next_slots(spec, state, spec.SLOTS_PER_EPOCH) @@ -555,7 +555,7 @@ def test_incorrect_target_epoch_delay(spec, state): @with_all_phases @spec_state_test -def test_incorrect_target_after_epoch_delay(spec, state): +def test_invalid_incorrect_target_included_after_epoch_delay(spec, state): attestation = get_valid_attestation(spec, state, signed=False) # increment past latest inclusion slot next_slots(spec, state, spec.SLOTS_PER_EPOCH + 1) @@ -563,4 +563,4 @@ def test_incorrect_target_after_epoch_delay(spec, state): attestation.data.target.root = b'\x42' * 32 sign_attestation(spec, state, attestation) - yield from run_attestation_processing(spec, state, attestation, False) + yield from run_attestation_processing(spec, state, attestation, valid=False) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py index 13d64e03b0..e63554677f 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py @@ -91,7 +91,7 @@ def run_attester_slashing_processing(spec, state, attester_slashing, valid=True) @with_all_phases @spec_state_test -def test_success_double(spec, state): +def test_basic_double(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) yield from run_attester_slashing_processing(spec, state, attester_slashing) @@ -99,7 +99,7 @@ def test_success_double(spec, state): @with_all_phases @spec_state_test -def test_success_surround(spec, state): +def test_basic_surround(spec, state): next_epoch_via_block(spec, state) state.current_justified_checkpoint.epoch += 1 @@ -119,7 +119,7 @@ def test_success_surround(spec, state): @with_all_phases @spec_state_test @always_bls -def test_success_already_exited_recent(spec, state): +def test_already_exited_recent(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) slashed_indices = get_indexed_attestation_participants(spec, attester_slashing.attestation_1) for index in slashed_indices: @@ -131,7 +131,7 @@ def test_success_already_exited_recent(spec, state): @with_all_phases @spec_state_test @always_bls -def test_success_proposer_index_slashed(spec, state): +def test_proposer_index_slashed(spec, state): # Transition past genesis slot because generally doesn't have a proposer next_epoch_via_block(spec, state) @@ -147,7 +147,7 @@ def test_success_proposer_index_slashed(spec, state): @with_all_phases @spec_state_test -def test_success_attestation_from_future(spec, state): +def test_attestation_from_future(spec, state): # Transition state to future to enable generation of a "future" attestation future_state = state.copy() next_epoch_via_block(spec, future_state) @@ -165,7 +165,7 @@ def test_success_attestation_from_future(spec, state): @with_custom_state(balances_fn=low_balances, threshold_fn=lambda spec: spec.config.EJECTION_BALANCE) @spec_test @single_phase -def test_success_low_balances(spec, state): +def test_low_balances(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) yield from run_attester_slashing_processing(spec, state, attester_slashing) @@ -175,7 +175,7 @@ def test_success_low_balances(spec, state): @with_custom_state(balances_fn=misc_balances, threshold_fn=lambda spec: spec.config.EJECTION_BALANCE) @spec_test @single_phase -def test_success_misc_balances(spec, state): +def test_misc_balances(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) yield from run_attester_slashing_processing(spec, state, attester_slashing) @@ -185,7 +185,7 @@ def test_success_misc_balances(spec, state): @with_custom_state(balances_fn=misc_balances, threshold_fn=lambda spec: spec.config.EJECTION_BALANCE) @spec_test @single_phase -def test_success_with_effective_balance_disparity(spec, state): +def test_with_effective_balance_disparity(spec, state): # Jitter balances to be different from effective balances rng = Random(12345) for i in range(len(state.balances)): @@ -200,7 +200,7 @@ def test_success_with_effective_balance_disparity(spec, state): @with_all_phases @spec_state_test @always_bls -def test_success_already_exited_long_ago(spec, state): +def test_already_exited_long_ago(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) slashed_indices = get_indexed_attestation_participants(spec, attester_slashing.attestation_1) for index in slashed_indices: @@ -213,30 +213,30 @@ def test_success_already_exited_long_ago(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_1(spec, state): +def test_invalid_incorrect_sig_1(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_2(spec, state): +def test_invalid_incorrect_sig_2(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False) - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_1_and_2(spec, state): +def test_invalid_incorrect_sig_1_and_2(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=False) - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test -def test_same_data(spec, state): +def test_invalid_same_data(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) indexed_att_1 = attester_slashing.attestation_1 @@ -244,12 +244,12 @@ def test_same_data(spec, state): indexed_att_1.data = att_2_data sign_indexed_attestation(spec, state, attester_slashing.attestation_1) - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test -def test_no_double_or_surround(spec, state): +def test_invalid_no_double_or_surround(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) att_1_data = get_attestation_1_data(spec, attester_slashing) @@ -257,12 +257,12 @@ def test_no_double_or_surround(spec, state): sign_indexed_attestation(spec, state, attester_slashing.attestation_1) - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test -def test_participants_already_slashed(spec, state): +def test_invalid_participants_already_slashed(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) # set all indices to slashed @@ -270,63 +270,63 @@ def test_participants_already_slashed(spec, state): for index in validator_indices: state.validators[index].slashed = True - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att1_high_index(spec, state): +def test_invalid_att1_high_index(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) indices = get_indexed_attestation_participants(spec, attester_slashing.attestation_1) indices.append(spec.ValidatorIndex(len(state.validators))) # off by 1 attester_slashing.attestation_1.attesting_indices = indices - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att2_high_index(spec, state): +def test_invalid_att2_high_index(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) indices = get_indexed_attestation_participants(spec, attester_slashing.attestation_2) indices.append(spec.ValidatorIndex(len(state.validators))) # off by 1 attester_slashing.attestation_2.attesting_indices = indices - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att1_empty_indices(spec, state): +def test_invalid_att1_empty_indices(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) attester_slashing.attestation_1.attesting_indices = [] attester_slashing.attestation_1.signature = spec.bls.G2_POINT_AT_INFINITY - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att2_empty_indices(spec, state): +def test_invalid_att2_empty_indices(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False) attester_slashing.attestation_2.attesting_indices = [] attester_slashing.attestation_2.signature = spec.bls.G2_POINT_AT_INFINITY - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_all_empty_indices(spec, state): +def test_invalid_all_empty_indices(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=False) attester_slashing.attestation_1.attesting_indices = [] @@ -335,13 +335,13 @@ def test_all_empty_indices(spec, state): attester_slashing.attestation_2.attesting_indices = [] attester_slashing.attestation_2.signature = spec.bls.G2_POINT_AT_INFINITY - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att1_bad_extra_index(spec, state): +def test_invalid_att1_bad_extra_index(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) indices = get_indexed_attestation_participants(spec, attester_slashing.attestation_1) @@ -351,13 +351,13 @@ def test_att1_bad_extra_index(spec, state): # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not), # see if the bad extra index is spotted, and slashing is aborted. - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att1_bad_replaced_index(spec, state): +def test_invalid_att1_bad_replaced_index(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) indices = attester_slashing.attestation_1.attesting_indices @@ -367,13 +367,13 @@ def test_att1_bad_replaced_index(spec, state): # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not), # see if the bad replaced index is spotted, and slashing is aborted. - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att2_bad_extra_index(spec, state): +def test_invalid_att2_bad_extra_index(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) indices = attester_slashing.attestation_2.attesting_indices @@ -383,13 +383,13 @@ def test_att2_bad_extra_index(spec, state): # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not), # see if the bad extra index is spotted, and slashing is aborted. - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att2_bad_replaced_index(spec, state): +def test_invalid_att2_bad_replaced_index(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) indices = attester_slashing.attestation_2.attesting_indices @@ -399,13 +399,13 @@ def test_att2_bad_replaced_index(spec, state): # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not), # see if the bad replaced index is spotted, and slashing is aborted. - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att1_duplicate_index_normal_signed(spec, state): +def test_invalid_att1_duplicate_index_normal_signed(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) indices = list(attester_slashing.attestation_1.attesting_indices) @@ -419,13 +419,13 @@ def test_att1_duplicate_index_normal_signed(spec, state): attester_slashing.attestation_1.attesting_indices = sorted(indices) # it will just appear normal, unless the double index is spotted - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att2_duplicate_index_normal_signed(spec, state): +def test_invalid_att2_duplicate_index_normal_signed(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False) indices = list(attester_slashing.attestation_2.attesting_indices) @@ -439,13 +439,13 @@ def test_att2_duplicate_index_normal_signed(spec, state): attester_slashing.attestation_2.attesting_indices = sorted(indices) # it will just appear normal, unless the double index is spotted - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att1_duplicate_index_double_signed(spec, state): +def test_invalid_att1_duplicate_index_double_signed(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) indices = list(attester_slashing.attestation_1.attesting_indices) @@ -454,13 +454,13 @@ def test_att1_duplicate_index_double_signed(spec, state): attester_slashing.attestation_1.attesting_indices = sorted(indices) sign_indexed_attestation(spec, state, attester_slashing.attestation_1) # will have one attester signing it double - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_att2_duplicate_index_double_signed(spec, state): +def test_invalid_att2_duplicate_index_double_signed(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False) indices = list(attester_slashing.attestation_2.attesting_indices) @@ -469,12 +469,12 @@ def test_att2_duplicate_index_double_signed(spec, state): attester_slashing.attestation_2.attesting_indices = sorted(indices) sign_indexed_attestation(spec, state, attester_slashing.attestation_2) # will have one attester signing it double - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test -def test_unsorted_att_1(spec, state): +def test_invalid_unsorted_att_1(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) indices = attester_slashing.attestation_1.attesting_indices @@ -482,12 +482,12 @@ def test_unsorted_att_1(spec, state): indices[1], indices[2] = indices[2], indices[1] # unsort second and third index sign_indexed_attestation(spec, state, attester_slashing.attestation_1) - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) @with_all_phases @spec_state_test -def test_unsorted_att_2(spec, state): +def test_invalid_unsorted_att_2(spec, state): attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False) indices = attester_slashing.attestation_2.attesting_indices @@ -495,4 +495,4 @@ def test_unsorted_att_2(spec, state): indices[1], indices[2] = indices[2], indices[1] # unsort second and third index sign_indexed_attestation(spec, state, attester_slashing.attestation_2) - yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, valid=False) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_block_header.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_block_header.py index b57090568b..5188d8f91b 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_block_header.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_block_header.py @@ -34,7 +34,7 @@ def run_block_header_processing(spec, state, block, prepare_state=True, valid=Tr @with_all_phases @spec_state_test -def test_success_block_header(spec, state): +def test_basic_block_header(spec, state): block = build_empty_block_for_next_slot(spec, state) yield from run_block_header_processing(spec, state, block) @@ -87,7 +87,7 @@ def test_invalid_multiple_blocks_single_slot(spec, state): @with_all_phases @spec_state_test -def test_proposer_slashed(spec, state): +def test_invalid_proposer_slashed(spec, state): # use stub state to get proposer index of next slot stub_state = deepcopy(state) next_slot(spec, stub_state) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py index 20d8d7d746..e464cd9d78 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py @@ -113,35 +113,35 @@ def test_invalid_sig_other_version(spec, state): state.eth1_data.deposit_root = root state.eth1_data.deposit_count = 1 - yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=False) + yield from run_deposit_processing(spec, state, deposit, validator_index, effective=False) @with_all_phases @spec_state_test @always_bls -def test_valid_sig_but_forked_state(spec, state): +def test_correct_sig_but_forked_state(spec, state): validator_index = len(state.validators) amount = spec.MAX_EFFECTIVE_BALANCE # deposits will always be valid, regardless of the current fork state.fork.current_version = spec.Version('0x1234abcd') deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) - yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index, effective=True) @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_new_deposit(spec, state): +def test_incorrect_sig_new_deposit(spec, state): # fresh deposit = next validator index = validator appended to registry validator_index = len(state.validators) amount = spec.MAX_EFFECTIVE_BALANCE deposit = prepare_state_and_deposit(spec, state, validator_index, amount) - yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=False) + yield from run_deposit_processing(spec, state, deposit, validator_index, effective=False) @with_all_phases @spec_state_test -def test_success_top_up__max_effective_balance(spec, state): +def test_top_up__max_effective_balance(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) @@ -157,7 +157,7 @@ def test_success_top_up__max_effective_balance(spec, state): @with_all_phases @spec_state_test -def test_success_top_up__less_effective_balance(spec, state): +def test_top_up__less_effective_balance(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) @@ -176,7 +176,7 @@ def test_success_top_up__less_effective_balance(spec, state): @with_all_phases @spec_state_test -def test_success_top_up__zero_balance(spec, state): +def test_top_up__zero_balance(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) @@ -196,18 +196,18 @@ def test_success_top_up__zero_balance(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_top_up(spec, state): +def test_incorrect_sig_top_up(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 deposit = prepare_state_and_deposit(spec, state, validator_index, amount) # invalid signatures, in top-ups, are allowed! - yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index, effective=True) @with_all_phases @spec_state_test -def test_invalid_withdrawal_credentials_top_up(spec, state): +def test_incorrect_withdrawal_credentials_top_up(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 withdrawal_credentials = spec.BLS_WITHDRAWAL_PREFIX + spec.hash(b"junk")[1:] @@ -220,12 +220,12 @@ def test_invalid_withdrawal_credentials_top_up(spec, state): ) # inconsistent withdrawal credentials, in top-ups, are allowed! - yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index, effective=True) @with_all_phases @spec_state_test -def test_wrong_deposit_for_deposit_count(spec, state): +def test_invalid_wrong_deposit_for_deposit_count(spec, state): deposit_data_leaves = [spec.DepositData() for _ in range(len(state.validators))] # build root for deposit_1 @@ -266,7 +266,7 @@ def test_wrong_deposit_for_deposit_count(spec, state): @with_all_phases @spec_state_test -def test_bad_merkle_proof(spec, state): +def test_invalid_bad_merkle_proof(spec, state): validator_index = len(state.validators) amount = spec.MAX_EFFECTIVE_BALANCE deposit = prepare_state_and_deposit(spec, state, validator_index, amount) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_proposer_slashing.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_proposer_slashing.py index 6ca87adaec..42c94b6f59 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_proposer_slashing.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_proposer_slashing.py @@ -34,7 +34,7 @@ def run_proposer_slashing_processing(spec, state, proposer_slashing, valid=True) @with_all_phases @spec_state_test -def test_success(spec, state): +def test_basic(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) yield from run_proposer_slashing_processing(spec, state, proposer_slashing) @@ -42,7 +42,7 @@ def test_success(spec, state): @with_all_phases @spec_state_test -def test_success_slashed_and_proposer_index_the_same(spec, state): +def test_slashed_and_proposer_index_the_same(spec, state): # Get proposer for next slot block = build_empty_block_for_next_slot(spec, state) proposer_index = block.proposer_index @@ -57,7 +57,7 @@ def test_success_slashed_and_proposer_index_the_same(spec, state): @with_all_phases @spec_state_test -def test_success_block_header_from_future(spec, state): +def test_block_header_from_future(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, slot=state.slot + 5, signed_1=True, signed_2=True) yield from run_proposer_slashing_processing(spec, state, proposer_slashing) @@ -66,31 +66,31 @@ def test_success_block_header_from_future(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_1(spec, state): +def test_invalid_incorrect_sig_1(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=False, signed_2=True) - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_2(spec, state): +def test_invalid_incorrect_sig_2(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=False) - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_1_and_2(spec, state): +def test_invalid_incorrect_sig_1_and_2(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=False, signed_2=False) - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_1_and_2_swap(spec, state): +def test_invalid_incorrect_sig_1_and_2_swap(spec, state): # Get valid signatures for the slashings proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) @@ -98,18 +98,18 @@ def test_invalid_sig_1_and_2_swap(spec, state): signature_1 = proposer_slashing.signed_header_1.signature proposer_slashing.signed_header_1.signature = proposer_slashing.signed_header_2.signature proposer_slashing.signed_header_2.signature = signature_1 - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test -def test_invalid_proposer_index(spec, state): +def test_invalid_incorrect_proposer_index(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) # Index just too high (by 1) proposer_slashing.signed_header_1.message.proposer_index = len(state.validators) proposer_slashing.signed_header_2.message.proposer_index = len(state.validators) - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @@ -125,12 +125,12 @@ def test_invalid_different_proposer_indices(spec, state): header_2.proposer_index = active_indices[0] proposer_slashing.signed_header_2 = sign_block_header(spec, state, header_2, privkeys[header_2.proposer_index]) - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test -def test_epochs_are_different(spec, state): +def test_invalid_slots_of_different_epochs(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=False) # set slots to be in different epochs @@ -139,23 +139,23 @@ def test_epochs_are_different(spec, state): header_2.slot += spec.SLOTS_PER_EPOCH proposer_slashing.signed_header_2 = sign_block_header(spec, state, header_2, privkeys[proposer_index]) - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test -def test_headers_are_same_sigs_are_same(spec, state): +def test_invalid_headers_are_same_sigs_are_same(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=False) # set headers to be the same proposer_slashing.signed_header_2 = proposer_slashing.signed_header_1.copy() - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test -def test_headers_are_same_sigs_are_different(spec, state): +def test_invalid_headers_are_same_sigs_are_different(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=False) # set headers to be the same @@ -165,36 +165,36 @@ def test_headers_are_same_sigs_are_different(spec, state): assert proposer_slashing.signed_header_1.signature != proposer_slashing.signed_header_2.signature - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test -def test_proposer_is_not_activated(spec, state): +def test_invalid_proposer_is_not_activated(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) # set proposer to be not active yet proposer_index = proposer_slashing.signed_header_1.message.proposer_index state.validators[proposer_index].activation_epoch = spec.get_current_epoch(state) + 1 - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test -def test_proposer_is_slashed(spec, state): +def test_invalid_proposer_is_slashed(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) # set proposer to slashed proposer_index = proposer_slashing.signed_header_1.message.proposer_index state.validators[proposer_index].slashed = True - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) @with_all_phases @spec_state_test -def test_proposer_is_withdrawn(spec, state): +def test_invalid_proposer_is_withdrawn(spec, state): proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) # move 1 epoch into future, to allow for past withdrawable epoch @@ -204,4 +204,4 @@ def test_proposer_is_withdrawn(spec, state): proposer_index = proposer_slashing.signed_header_1.message.proposer_index state.validators[proposer_index].withdrawable_epoch = current_epoch - 1 - yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, valid=False) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_voluntary_exit.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_voluntary_exit.py index 73602f14c3..4a7286d523 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_voluntary_exit.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_voluntary_exit.py @@ -14,7 +14,7 @@ @with_all_phases @spec_state_test -def test_success(spec, state): +def test_basic(spec, state): # move state forward SHARD_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.config.SHARD_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH @@ -33,7 +33,7 @@ def test_success(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_signature(spec, state): +def test_invalid_incorrect_signature(spec, state): # move state forward SHARD_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.config.SHARD_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH @@ -46,7 +46,7 @@ def test_invalid_signature(spec, state): ) signed_voluntary_exit = sign_voluntary_exit(spec, state, voluntary_exit, 12345) - yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, valid=False) def run_test_success_exit_queue(spec, state): @@ -134,7 +134,7 @@ def test_default_exit_epoch_subsequent_exit(spec, state): @with_all_phases @spec_state_test -def test_validator_exit_in_future(spec, state): +def test_invalid_validator_exit_in_future(spec, state): # move state forward SHARD_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.config.SHARD_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH @@ -148,12 +148,12 @@ def test_validator_exit_in_future(spec, state): ) signed_voluntary_exit = sign_voluntary_exit(spec, state, voluntary_exit, privkey) - yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, valid=False) @with_all_phases @spec_state_test -def test_validator_invalid_validator_index(spec, state): +def test_invalid_validator_incorrect_validator_index(spec, state): # move state forward SHARD_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.config.SHARD_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH @@ -167,12 +167,12 @@ def test_validator_invalid_validator_index(spec, state): ) signed_voluntary_exit = sign_voluntary_exit(spec, state, voluntary_exit, privkey) - yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, valid=False) @with_all_phases @spec_state_test -def test_validator_not_active(spec, state): +def test_invalid_validator_not_active(spec, state): current_epoch = spec.get_current_epoch(state) validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validators[validator_index].pubkey] @@ -182,12 +182,12 @@ def test_validator_not_active(spec, state): signed_voluntary_exit = sign_voluntary_exit( spec, state, spec.VoluntaryExit(epoch=current_epoch, validator_index=validator_index), privkey) - yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, valid=False) @with_all_phases @spec_state_test -def test_validator_already_exited(spec, state): +def test_invalid_validator_already_exited(spec, state): # move state forward SHARD_COMMITTEE_PERIOD epochs to allow validator able to exit state.slot += spec.config.SHARD_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH @@ -201,12 +201,12 @@ def test_validator_already_exited(spec, state): signed_voluntary_exit = sign_voluntary_exit( spec, state, spec.VoluntaryExit(epoch=current_epoch, validator_index=validator_index), privkey) - yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, valid=False) @with_all_phases @spec_state_test -def test_validator_not_active_long_enough(spec, state): +def test_invalid_validator_not_active_long_enough(spec, state): current_epoch = spec.get_current_epoch(state) validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validators[validator_index].pubkey] @@ -219,4 +219,4 @@ def test_validator_not_active_long_enough(spec, state): spec.config.SHARD_COMMITTEE_PERIOD ) - yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, signed_voluntary_exit, valid=False) diff --git a/tests/core/pyspec/eth2spec/test/phase0/sanity/test_slots.py b/tests/core/pyspec/eth2spec/test/phase0/sanity/test_slots.py index 198ada6b90..3fa57f0f11 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/sanity/test_slots.py +++ b/tests/core/pyspec/eth2spec/test/phase0/sanity/test_slots.py @@ -1,5 +1,8 @@ from eth2spec.test.helpers.state import get_state_root -from eth2spec.test.context import spec_state_test, with_all_phases +from eth2spec.test.context import ( + spec_state_test, + with_all_phases, +) @with_all_phases From e5a0f7cf51bd74e4d55beb63387474452366dee5 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Wed, 30 Nov 2022 14:48:45 +0800 Subject: [PATCH 03/11] more clean ups --- .../test/phase0/genesis/test_validity.py | 16 +++++++-------- .../test/phase0/sanity/test_blocks.py | 20 +++++++++---------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/phase0/genesis/test_validity.py b/tests/core/pyspec/eth2spec/test/phase0/genesis/test_validity.py index aecc96077b..d245b8fcf4 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/genesis/test_validity.py +++ b/tests/core/pyspec/eth2spec/test/phase0/genesis/test_validity.py @@ -47,20 +47,20 @@ def run_is_valid_genesis_state(spec, state, valid=True): @spec_test @single_phase @with_presets([MINIMAL], reason="too slow") -def test_is_valid_genesis_state_true(spec): +def test_full_genesis_deposits(spec): if is_post_altair(spec): yield 'description', 'meta', get_post_altair_description(spec) state = create_valid_beacon_state(spec) - yield from run_is_valid_genesis_state(spec, state, valid=True) + yield from run_is_valid_genesis_state(spec, state) @with_all_phases @spec_test @single_phase @with_presets([MINIMAL], reason="too slow") -def test_is_valid_genesis_state_false_invalid_timestamp(spec): +def test_invalid_invalid_timestamp(spec): if is_post_altair(spec): yield 'description', 'meta', get_post_altair_description(spec) @@ -74,21 +74,21 @@ def test_is_valid_genesis_state_false_invalid_timestamp(spec): @spec_test @single_phase @with_presets([MINIMAL], reason="too slow") -def test_is_valid_genesis_state_true_more_balance(spec): +def test_extra_balance(spec): if is_post_altair(spec): yield 'description', 'meta', get_post_altair_description(spec) state = create_valid_beacon_state(spec) state.validators[0].effective_balance = spec.MAX_EFFECTIVE_BALANCE + 1 - yield from run_is_valid_genesis_state(spec, state, valid=True) + yield from run_is_valid_genesis_state(spec, state) @with_all_phases @spec_test @single_phase @with_presets([MINIMAL], reason="too slow") -def test_is_valid_genesis_state_true_one_more_validator(spec): +def test_one_more_validator(spec): if is_post_altair(spec): yield 'description', 'meta', get_post_altair_description(spec) @@ -104,14 +104,14 @@ def test_is_valid_genesis_state_true_one_more_validator(spec): eth1_timestamp = spec.config.MIN_GENESIS_TIME state = spec.initialize_beacon_state_from_eth1(eth1_block_hash, eth1_timestamp, deposits) - yield from run_is_valid_genesis_state(spec, state, valid=True) + yield from run_is_valid_genesis_state(spec, state) @with_all_phases @spec_test @single_phase @with_presets([MINIMAL], reason="too slow") -def test_is_valid_genesis_state_false_not_enough_validator(spec): +def test_invalid_not_enough_validator_count(spec): if is_post_altair(spec): yield 'description', 'meta', get_post_altair_description(spec) diff --git a/tests/core/pyspec/eth2spec/test/phase0/sanity/test_blocks.py b/tests/core/pyspec/eth2spec/test/phase0/sanity/test_blocks.py index 0e19e65b75..1e9dd2d485 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/sanity/test_blocks.py +++ b/tests/core/pyspec/eth2spec/test/phase0/sanity/test_blocks.py @@ -43,7 +43,7 @@ @with_all_phases @spec_state_test -def test_prev_slot_block_transition(spec, state): +def test_invalid_prev_slot_block_transition(spec, state): # Go to clean slot spec.process_slots(state, state.slot + 1) # Make a block for it @@ -64,7 +64,7 @@ def test_prev_slot_block_transition(spec, state): @with_all_phases @spec_state_test -def test_same_slot_block_transition(spec, state): +def test_invalid_same_slot_block_transition(spec, state): # Same slot on top of pre-state, but move out of slot 0 first. spec.process_slots(state, state.slot + 1) @@ -161,7 +161,7 @@ def process_and_sign_block_without_header_validations(spec, state, block): @with_phases([PHASE0]) @spec_state_test -def test_proposal_for_genesis_slot(spec, state): +def test_invalid_proposal_for_genesis_slot(spec, state): assert state.slot == spec.GENESIS_SLOT yield 'pre', state @@ -184,7 +184,7 @@ def test_proposal_for_genesis_slot(spec, state): @with_all_phases @spec_state_test -def test_parent_from_same_slot(spec, state): +def test_invalid_parent_from_same_slot(spec, state): yield 'pre', state parent_block = build_empty_block_for_next_slot(spec, state) @@ -211,7 +211,7 @@ def test_parent_from_same_slot(spec, state): @with_all_phases @spec_state_test -def test_invalid_state_root(spec, state): +def test_invalid_incorrect_state_root(spec, state): yield 'pre', state block = build_empty_block_for_next_slot(spec, state) @@ -227,7 +227,7 @@ def test_invalid_state_root(spec, state): @with_all_phases @spec_state_test @always_bls -def test_zero_block_sig(spec, state): +def test_invalid_all_zeroed_sig(spec, state): yield 'pre', state block = build_empty_block_for_next_slot(spec, state) @@ -241,7 +241,7 @@ def test_zero_block_sig(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_block_sig(spec, state): +def test_invalid_incorrect_block_sig(spec, state): yield 'pre', state block = build_empty_block_for_next_slot(spec, state) @@ -260,7 +260,7 @@ def test_invalid_block_sig(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_proposer_index_sig_from_expected_proposer(spec, state): +def test_invalid_incorrect_proposer_index_sig_from_expected_proposer(spec, state): yield 'pre', state block = build_empty_block_for_next_slot(spec, state) @@ -282,7 +282,7 @@ def test_invalid_proposer_index_sig_from_expected_proposer(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_proposer_index_sig_from_proposer_index(spec, state): +def test_invalid_incorrect_proposer_index_sig_from_proposer_index(spec, state): yield 'pre', state block = build_empty_block_for_next_slot(spec, state) @@ -707,7 +707,7 @@ def test_high_proposer_index(spec, state): @with_all_phases @spec_state_test -def test_expected_deposit_in_block(spec, state): +def test_invalid_only_increase_deposit_count(spec, state): # Make the state expect a deposit, then don't provide it. state.eth1_data.deposit_count += 1 yield 'pre', state From 5111c226fc2c977564e068f78c4affdae167ab80 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Wed, 30 Nov 2022 15:03:11 +0800 Subject: [PATCH 04/11] Altair tests cleanup --- .../test_process_sync_committee_updates.py | 2 +- .../eth2spec/test/altair/sanity/test_blocks.py | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py index 4b0cb70d5a..9e8444b54a 100644 --- a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py +++ b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py @@ -110,7 +110,7 @@ def test_sync_committees_progress_misc_balances_not_genesis(spec, state): @spec_state_test @always_bls @with_presets([MINIMAL], reason="too slow") -def test_sync_committees_no_progress_not_boundary(spec, state): +def test_sync_committees_no_progress_not_at_period_boundary(spec, state): assert spec.get_current_epoch(state) == spec.GENESIS_EPOCH slot_not_at_period_boundary = state.slot + spec.SLOTS_PER_EPOCH transition_to(spec, state, slot_not_at_period_boundary) diff --git a/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py b/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py index a3299c1704..0c2f1c7550 100644 --- a/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py +++ b/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py @@ -51,40 +51,40 @@ def run_sync_committee_sanity_test(spec, state, fraction_full=1.0, rng=Random(45 @with_altair_and_later @spec_state_test -def test_full_sync_committee_committee(spec, state): +def test_sync_committee_committee__full(spec, state): next_epoch(spec, state) yield from run_sync_committee_sanity_test(spec, state, fraction_full=1.0) @with_altair_and_later @spec_state_test -def test_half_sync_committee_committee(spec, state): +def test_sync_committee_committee__half(spec, state): next_epoch(spec, state) yield from run_sync_committee_sanity_test(spec, state, fraction_full=0.5, rng=Random(1212)) @with_altair_and_later @spec_state_test -def test_empty_sync_committee_committee(spec, state): +def test_sync_committee_committee__empty(spec, state): next_epoch(spec, state) yield from run_sync_committee_sanity_test(spec, state, fraction_full=0.0) @with_altair_and_later @spec_state_test -def test_full_sync_committee_committee_genesis(spec, state): +def test_sync_committee_committee_genesis__full(spec, state): yield from run_sync_committee_sanity_test(spec, state, fraction_full=1.0) @with_altair_and_later @spec_state_test -def test_half_sync_committee_committee_genesis(spec, state): +def test_sync_committee_committee_genesis__half(spec, state): yield from run_sync_committee_sanity_test(spec, state, fraction_full=0.5, rng=Random(2323)) @with_altair_and_later @spec_state_test -def test_empty_sync_committee_committee_genesis(spec, state): +def test_sync_committee_committee_genesis__empty(spec, state): yield from run_sync_committee_sanity_test(spec, state, fraction_full=0.0) From a66cf79c9c0b702a25d9ba0e93af3c2f6e3e1c5b Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Wed, 30 Nov 2022 16:35:41 +0800 Subject: [PATCH 05/11] Clean up Altair and Bellatrix `process_deposit` tests --- specs/altair/beacon-chain.md | 1 + .../block_processing/test_process_deposit.py | 40 +++++++++++++ .../block_processing/test_process_deposit.py | 60 ++----------------- .../pyspec/eth2spec/test/helpers/deposits.py | 43 ++++++++++--- tests/generators/operations/main.py | 13 ++-- 5 files changed, 90 insertions(+), 67 deletions(-) create mode 100644 tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md index 79ab8d0221..fe71a5ff83 100644 --- a/specs/altair/beacon-chain.md +++ b/specs/altair/beacon-chain.md @@ -523,6 +523,7 @@ def process_deposit(state: BeaconState, deposit: Deposit) -> None: if bls.Verify(pubkey, signing_root, deposit.data.signature): state.validators.append(get_validator_from_deposit(deposit)) state.balances.append(amount) + # [New in Altair] state.previous_epoch_participation.append(ParticipationFlags(0b0000_0000)) state.current_epoch_participation.append(ParticipationFlags(0b0000_0000)) state.inactivity_scores.append(uint64(0)) diff --git a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py new file mode 100644 index 0000000000..ac728d4cc3 --- /dev/null +++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py @@ -0,0 +1,40 @@ +from eth2spec.test.context import ( + spec_state_test, + always_bls, + with_altair_and_later, + with_phases, +) +from eth2spec.test.helpers.constants import ( + ALTAIR, +) + + +from eth2spec.test.helpers.deposits import ( + run_deposit_processing_with_specific_fork_version, +) + + +@with_phases([ALTAIR]) +@spec_state_test +@always_bls +def test_effective_deposit_with_previous_fork_version(spec, state): + assert state.fork.previous_version != state.fork.current_version + + yield from run_deposit_processing_with_specific_fork_version( + spec, + state, + fork_version=state.fork.previous_version, + effective=True, + ) + + +@with_altair_and_later +@spec_state_test +@always_bls +def test_ineffective_deposit_with_bad_fork_version_and(spec, state): + yield from run_deposit_processing_with_specific_fork_version( + spec, + state, + fork_version=spec.Version('0xAaBbCcDd'), + effective=False, + ) diff --git a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py index b111fd9ffb..6473b7de65 100644 --- a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py @@ -4,55 +4,21 @@ with_bellatrix_and_later, ) from eth2spec.test.helpers.deposits import ( - deposit_from_context, - run_deposit_processing, + run_deposit_processing_with_specific_fork_version, ) -from eth2spec.test.helpers.keys import ( - privkeys, - pubkeys, -) -from eth2spec.utils import bls - - -def _run_deposit_processing_with_specific_fork_version( - spec, - state, - fork_version, - valid, - effective): - validator_index = len(state.validators) - amount = spec.MAX_EFFECTIVE_BALANCE - - pubkey = pubkeys[validator_index] - privkey = privkeys[validator_index] - withdrawal_credentials = spec.BLS_WITHDRAWAL_PREFIX + spec.hash(pubkey)[1:] - - deposit_message = spec.DepositMessage(pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount) - domain = spec.compute_domain(domain_type=spec.DOMAIN_DEPOSIT, fork_version=fork_version) - deposit_data = spec.DepositData( - pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount, - signature=bls.Sign(privkey, spec.compute_signing_root(deposit_message, domain)) - ) - deposit, root, _ = deposit_from_context(spec, [deposit_data], 0) - - state.eth1_deposit_index = 0 - state.eth1_data.deposit_root = root - state.eth1_data.deposit_count = 1 - - yield from run_deposit_processing(spec, state, deposit, validator_index, valid=valid, effective=effective) @with_bellatrix_and_later @spec_state_test @always_bls -def test_deposit_with_previous_fork_version__valid_ineffective(spec, state): +def test_ineffective_deposit_with_previous_fork_version(spec, state): + # NOTE: it was effective in Altair. assert state.fork.previous_version != state.fork.current_version - yield from _run_deposit_processing_with_specific_fork_version( + yield from run_deposit_processing_with_specific_fork_version( spec, state, fork_version=state.fork.previous_version, - valid=True, effective=False, ) @@ -60,26 +26,12 @@ def test_deposit_with_previous_fork_version__valid_ineffective(spec, state): @with_bellatrix_and_later @spec_state_test @always_bls -def test_deposit_with_genesis_fork_version__valid_effective(spec, state): +def test_effective_deposit_with_genesis_fork_version(spec, state): assert spec.config.GENESIS_FORK_VERSION not in (state.fork.previous_version, state.fork.current_version) - yield from _run_deposit_processing_with_specific_fork_version( + yield from run_deposit_processing_with_specific_fork_version( spec, state, fork_version=spec.config.GENESIS_FORK_VERSION, - valid=True, effective=True, ) - - -@with_bellatrix_and_later -@spec_state_test -@always_bls -def test_deposit_with_bad_fork_version__valid_ineffective(spec, state): - yield from _run_deposit_processing_with_specific_fork_version( - spec, - state, - fork_version=spec.Version('0xAaBbCcDd'), - valid=True, - effective=False, - ) diff --git a/tests/core/pyspec/eth2spec/test/helpers/deposits.py b/tests/core/pyspec/eth2spec/test/helpers/deposits.py index f8ab75e854..cfff9c5ef9 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/deposits.py +++ b/tests/core/pyspec/eth2spec/test/helpers/deposits.py @@ -208,25 +208,50 @@ def run_deposit_processing(spec, state, deposit, validator_index, valid=True, ef if not effective or not bls.KeyValidate(deposit.data.pubkey): assert len(state.validators) == pre_validator_count assert len(state.balances) == pre_validator_count - if validator_index < pre_validator_count: + if is_top_up: assert get_balance(state, validator_index) == pre_balance else: - if validator_index < pre_validator_count: - # top-up + if is_top_up: + # Top-ups do not change effective balance + assert state.validators[validator_index].effective_balance == pre_effective_balance assert len(state.validators) == pre_validator_count assert len(state.balances) == pre_validator_count else: # new validator assert len(state.validators) == pre_validator_count + 1 assert len(state.balances) == pre_validator_count + 1 - assert get_balance(state, validator_index) == pre_balance + deposit.data.amount - - if is_top_up: - # Top-ups do not change effective balance - assert state.validators[validator_index].effective_balance == pre_effective_balance - else: effective_balance = min(spec.MAX_EFFECTIVE_BALANCE, deposit.data.amount) effective_balance -= effective_balance % spec.EFFECTIVE_BALANCE_INCREMENT assert state.validators[validator_index].effective_balance == effective_balance + assert get_balance(state, validator_index) == pre_balance + deposit.data.amount + assert state.eth1_deposit_index == state.eth1_data.deposit_count + + +def run_deposit_processing_with_specific_fork_version( + spec, + state, + fork_version, + valid=True, + effective=True): + validator_index = len(state.validators) + amount = spec.MAX_EFFECTIVE_BALANCE + + pubkey = pubkeys[validator_index] + privkey = privkeys[validator_index] + withdrawal_credentials = spec.BLS_WITHDRAWAL_PREFIX + spec.hash(pubkey)[1:] + + deposit_message = spec.DepositMessage(pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount) + domain = spec.compute_domain(domain_type=spec.DOMAIN_DEPOSIT, fork_version=fork_version) + deposit_data = spec.DepositData( + pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount, + signature=bls.Sign(privkey, spec.compute_signing_root(deposit_message, domain)) + ) + deposit, root, _ = deposit_from_context(spec, [deposit_data], 0) + + state.eth1_deposit_index = 0 + state.eth1_data.deposit_root = root + state.eth1_data.deposit_count = 1 + + yield from run_deposit_processing(spec, state, deposit, validator_index, valid=valid, effective=effective) diff --git a/tests/generators/operations/main.py b/tests/generators/operations/main.py index bb879a6471..4c073ebe40 100644 --- a/tests/generators/operations/main.py +++ b/tests/generators/operations/main.py @@ -11,10 +11,15 @@ 'proposer_slashing', 'voluntary_exit', ]} - _new_altair_mods = {'sync_aggregate': [ - 'eth2spec.test.altair.block_processing.sync_aggregate.test_process_' + key - for key in ['sync_aggregate', 'sync_aggregate_random'] - ]} + _new_altair_mods = { + **{'sync_aggregate': [ + 'eth2spec.test.altair.block_processing.sync_aggregate.test_process_' + key + for key in ['sync_aggregate', 'sync_aggregate_random'] + ]}, + **{key: 'eth2spec.test.altair.block_processing.test_process_' + key for key in [ + 'deposit', + ]} + } altair_mods = combine_mods(_new_altair_mods, phase_0_mods) _new_bellatrix_mods = {key: 'eth2spec.test.bellatrix.block_processing.test_process_' + key for key in [ From 8e88c61701b0574b34014769ec7f616cf98e8dc0 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Wed, 30 Nov 2022 16:50:10 +0800 Subject: [PATCH 06/11] Clean up Bellatrix tests --- .../test_process_execution_payload.py | 32 +++++++++---------- .../test_process_voluntary_exit.py | 16 ++++------ 2 files changed, 23 insertions(+), 25 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py index 2819b2a24b..6d254f174d 100644 --- a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py +++ b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py @@ -104,14 +104,14 @@ def run_bad_execution_test(spec, state): @with_bellatrix_and_later @spec_state_test -def test_bad_execution_first_payload(spec, state): +def test_invalid_bad_execution_first_payload(spec, state): state = build_state_with_incomplete_transition(spec, state) yield from run_bad_execution_test(spec, state) @with_bellatrix_and_later @spec_state_test -def test_bad_execution_regular_payload(spec, state): +def test_invalid_bad_execution_regular_payload(spec, state): state = build_state_with_complete_transition(spec, state) yield from run_bad_execution_test(spec, state) @@ -125,12 +125,12 @@ def test_bad_parent_hash_first_payload(spec, state): execution_payload = build_empty_execution_payload(spec, state) execution_payload.parent_hash = b'\x55' * 32 - yield from run_execution_payload_processing(spec, state, execution_payload, valid=True) + yield from run_execution_payload_processing(spec, state, execution_payload) @with_bellatrix_and_later @spec_state_test -def test_bad_parent_hash_regular_payload(spec, state): +def test_invalid_bad_parent_hash_regular_payload(spec, state): state = build_state_with_complete_transition(spec, state) next_slot(spec, state) @@ -151,14 +151,14 @@ def run_bad_prev_randao_test(spec, state): @with_bellatrix_and_later @spec_state_test -def test_bad_prev_randao_first_payload(spec, state): +def test_invalid_bad_prev_randao_first_payload(spec, state): state = build_state_with_incomplete_transition(spec, state) yield from run_bad_prev_randao_test(spec, state) @with_bellatrix_and_later @spec_state_test -def test_bad_pre_randao_regular_payload(spec, state): +def test_invalid_bad_pre_randao_regular_payload(spec, state): state = build_state_with_complete_transition(spec, state) yield from run_bad_prev_randao_test(spec, state) @@ -176,14 +176,14 @@ def run_bad_everything_test(spec, state): @with_bellatrix_and_later @spec_state_test -def test_bad_everything_first_payload(spec, state): +def test_invalid_bad_everything_first_payload(spec, state): state = build_state_with_incomplete_transition(spec, state) yield from run_bad_everything_test(spec, state) @with_bellatrix_and_later @spec_state_test -def test_bad_everything_regular_payload(spec, state): +def test_invalid_bad_everything_regular_payload(spec, state): state = build_state_with_complete_transition(spec, state) yield from run_bad_everything_test(spec, state) @@ -204,28 +204,28 @@ def run_bad_timestamp_test(spec, state, is_future): @with_bellatrix_and_later @spec_state_test -def test_future_timestamp_first_payload(spec, state): +def test_invalid_future_timestamp_first_payload(spec, state): state = build_state_with_incomplete_transition(spec, state) yield from run_bad_timestamp_test(spec, state, is_future=True) @with_bellatrix_and_later @spec_state_test -def test_future_timestamp_regular_payload(spec, state): +def test_invalid_future_timestamp_regular_payload(spec, state): state = build_state_with_complete_transition(spec, state) yield from run_bad_timestamp_test(spec, state, is_future=True) @with_bellatrix_and_later @spec_state_test -def test_past_timestamp_first_payload(spec, state): +def test_invalid_past_timestamp_first_payload(spec, state): state = build_state_with_incomplete_transition(spec, state) yield from run_bad_timestamp_test(spec, state, is_future=False) @with_bellatrix_and_later @spec_state_test -def test_past_timestamp_regular_payload(spec, state): +def test_invalid_past_timestamp_regular_payload(spec, state): state = build_state_with_complete_transition(spec, state) yield from run_bad_timestamp_test(spec, state, is_future=False) @@ -320,27 +320,27 @@ def run_randomized_non_validated_execution_fields_test(spec, state, execution_va @with_bellatrix_and_later @spec_state_test -def test_randomized_non_validated_execution_fields_first_payload__valid(spec, state): +def test_randomized_non_validated_execution_fields_first_payload__execution_valid(spec, state): state = build_state_with_incomplete_transition(spec, state) yield from run_randomized_non_validated_execution_fields_test(spec, state) @with_bellatrix_and_later @spec_state_test -def test_randomized_non_validated_execution_fields_regular_payload__valid(spec, state): +def test_randomized_non_validated_execution_fields_regular_payload__execution_valid(spec, state): state = build_state_with_complete_transition(spec, state) yield from run_randomized_non_validated_execution_fields_test(spec, state) @with_bellatrix_and_later @spec_state_test -def test_randomized_non_validated_execution_fields_first_payload__invalid(spec, state): +def test_invalid_randomized_non_validated_execution_fields_first_payload__execution_invalid(spec, state): state = build_state_with_incomplete_transition(spec, state) yield from run_randomized_non_validated_execution_fields_test(spec, state, execution_valid=False) @with_bellatrix_and_later @spec_state_test -def test_randomized_non_validated_execution_fields_regular_payload__invalid(spec, state): +def test_invalid_randomized_non_validated_execution_fields_regular_payload__execution_invalid(spec, state): state = build_state_with_complete_transition(spec, state) yield from run_randomized_non_validated_execution_fields_test(spec, state, execution_valid=False) diff --git a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_voluntary_exit.py b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_voluntary_exit.py index 257247b162..f4fcaac689 100644 --- a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_voluntary_exit.py +++ b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_voluntary_exit.py @@ -18,7 +18,7 @@ def _run_voluntary_exit_processing_test( state, fork_version, is_before_fork_epoch, - valid): + valid=True): # create a fork next_epoch(spec, state) state.fork.epoch = spec.get_current_epoch(state) @@ -50,7 +50,7 @@ def _run_voluntary_exit_processing_test( @with_bellatrix_and_later @spec_state_test @always_bls -def test_voluntary_exit_with_current_fork_version_is_before_fork_epoch__invalid(spec, state): +def test_invalid_voluntary_exit_with_current_fork_version_is_before_fork_epoch(spec, state): yield from _run_voluntary_exit_processing_test( spec, state, @@ -63,20 +63,19 @@ def test_voluntary_exit_with_current_fork_version_is_before_fork_epoch__invalid( @with_bellatrix_and_later @spec_state_test @always_bls -def test_voluntary_exit_with_current_fork_version_not_is_before_fork_epoch__valid(spec, state): +def test_voluntary_exit_with_current_fork_version_not_is_before_fork_epoch(spec, state): yield from _run_voluntary_exit_processing_test( spec, state, fork_version=state.fork.current_version, is_before_fork_epoch=False, - valid=True, ) @with_bellatrix_and_later @spec_state_test @always_bls -def test_voluntary_exit_with_previous_fork_version_is_before_fork_epoch__valid(spec, state): +def test_voluntary_exit_with_previous_fork_version_is_before_fork_epoch(spec, state): assert state.fork.previous_version != state.fork.current_version yield from _run_voluntary_exit_processing_test( @@ -84,14 +83,13 @@ def test_voluntary_exit_with_previous_fork_version_is_before_fork_epoch__valid(s state, fork_version=state.fork.previous_version, is_before_fork_epoch=True, - valid=True, ) @with_bellatrix_and_later @spec_state_test @always_bls -def test_voluntary_exit_with_previous_fork_version_not_is_before_fork_epoch__invalid(spec, state): +def test_invalid_voluntary_exit_with_previous_fork_version_not_is_before_fork_epoch(spec, state): assert state.fork.previous_version != state.fork.current_version yield from _run_voluntary_exit_processing_test( @@ -106,7 +104,7 @@ def test_voluntary_exit_with_previous_fork_version_not_is_before_fork_epoch__inv @with_bellatrix_and_later @spec_state_test @always_bls -def test_voluntary_exit_with_genesis_fork_version_is_before_fork_epoch__invalid(spec, state): +def test_invalid_voluntary_exit_with_genesis_fork_version_is_before_fork_epoch(spec, state): assert spec.config.GENESIS_FORK_VERSION not in (state.fork.previous_version, state.fork.current_version) yield from _run_voluntary_exit_processing_test( @@ -121,7 +119,7 @@ def test_voluntary_exit_with_genesis_fork_version_is_before_fork_epoch__invalid( @with_bellatrix_and_later @spec_state_test @always_bls -def test_voluntary_exit_with_genesis_fork_version_not_is_before_fork_epoch__invalid(spec, state): +def test_invalid_voluntary_exit_with_genesis_fork_version_not_is_before_fork_epoch(spec, state): assert spec.config.GENESIS_FORK_VERSION not in (state.fork.previous_version, state.fork.current_version) yield from _run_voluntary_exit_processing_test( From a5fd3f41f8a27d6aeb2c05856f6c91fd8d8c0f57 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Wed, 30 Nov 2022 16:55:39 +0800 Subject: [PATCH 07/11] Clean up Capella tests --- .../test_process_bls_to_execution_change.py | 8 ++-- .../test_process_withdrawals.py | 38 +++++++++---------- .../test/capella/sanity/test_blocks.py | 2 +- 3 files changed, 24 insertions(+), 24 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_bls_to_execution_change.py b/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_bls_to_execution_change.py index 79d79fa6e4..6a1ba5b36a 100644 --- a/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_bls_to_execution_change.py +++ b/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_bls_to_execution_change.py @@ -131,7 +131,7 @@ def test_success_withdrawable(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_val_index_out_of_range(spec, state): +def test_invalid_val_index_out_of_range(spec, state): # Create for one validator beyond the validator list length signed_address_change = get_signed_address_change(spec, state, validator_index=len(state.validators)) @@ -140,7 +140,7 @@ def test_fail_val_index_out_of_range(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_already_0x01(spec, state): +def test_invalid_already_0x01(spec, state): # Create for one validator beyond the validator list length validator_index = len(state.validators) // 2 validator = state.validators[validator_index] @@ -152,7 +152,7 @@ def test_fail_already_0x01(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_incorrect_from_bls_pubkey(spec, state): +def test_invalid_incorrect_from_bls_pubkey(spec, state): # Create for one validator beyond the validator list length validator_index = 2 signed_address_change = get_signed_address_change( @@ -167,7 +167,7 @@ def test_fail_incorrect_from_bls_pubkey(spec, state): @with_phases([CAPELLA]) @spec_state_test @always_bls -def test_fail_bad_signature(spec, state): +def test_invalid_bad_signature(spec, state): signed_address_change = get_signed_address_change(spec, state) # Mutate signature signed_address_change.signature = spec.BLSSignature(b'\x42' * 96) diff --git a/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_withdrawals.py b/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_withdrawals.py index da3ddcb4d9..b223e706f0 100644 --- a/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_withdrawals.py +++ b/tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_withdrawals.py @@ -189,7 +189,7 @@ def test_success_all_partially_withdrawable(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_non_withdrawable_non_empty_withdrawals(spec, state): +def test_invalid_non_withdrawable_non_empty_withdrawals(spec, state): next_slot(spec, state) execution_payload = build_empty_execution_payload(spec, state) withdrawal = spec.Withdrawal( @@ -205,7 +205,7 @@ def test_fail_non_withdrawable_non_empty_withdrawals(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_one_expected_full_withdrawal_and_none_in_withdrawals(spec, state): +def test_invalid_one_expected_full_withdrawal_and_none_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=1) next_slot(spec, state) @@ -217,7 +217,7 @@ def test_fail_one_expected_full_withdrawal_and_none_in_withdrawals(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_one_expected_partial_withdrawal_and_none_in_withdrawals(spec, state): +def test_invalid_one_expected_partial_withdrawal_and_none_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_partial_withdrawals=1) next_slot(spec, state) @@ -229,7 +229,7 @@ def test_fail_one_expected_partial_withdrawal_and_none_in_withdrawals(spec, stat @with_phases([CAPELLA]) @spec_state_test -def test_fail_one_expected_full_withdrawal_and_duplicate_in_withdrawals(spec, state): +def test_invalid_one_expected_full_withdrawal_and_duplicate_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=2) next_slot(spec, state) @@ -241,7 +241,7 @@ def test_fail_one_expected_full_withdrawal_and_duplicate_in_withdrawals(spec, st @with_phases([CAPELLA]) @spec_state_test -def test_fail_two_expected_partial_withdrawal_and_duplicate_in_withdrawals(spec, state): +def test_invalid_two_expected_partial_withdrawal_and_duplicate_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_partial_withdrawals=2) next_slot(spec, state) @@ -253,7 +253,7 @@ def test_fail_two_expected_partial_withdrawal_and_duplicate_in_withdrawals(spec, @with_phases([CAPELLA]) @spec_state_test -def test_fail_max_per_slot_full_withdrawals_and_one_less_in_withdrawals(spec, state): +def test_invalid_max_per_slot_full_withdrawals_and_one_less_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD) next_slot(spec, state) @@ -265,7 +265,7 @@ def test_fail_max_per_slot_full_withdrawals_and_one_less_in_withdrawals(spec, st @with_phases([CAPELLA]) @spec_state_test -def test_fail_max_per_slot_partial_withdrawals_and_one_less_in_withdrawals(spec, state): +def test_invalid_max_per_slot_partial_withdrawals_and_one_less_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_partial_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD) next_slot(spec, state) @@ -277,7 +277,7 @@ def test_fail_max_per_slot_partial_withdrawals_and_one_less_in_withdrawals(spec, @with_phases([CAPELLA]) @spec_state_test -def test_fail_a_lot_fully_withdrawable_too_few_in_withdrawals(spec, state): +def test_invalid_a_lot_fully_withdrawable_too_few_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4) next_slot(spec, state) @@ -289,7 +289,7 @@ def test_fail_a_lot_fully_withdrawable_too_few_in_withdrawals(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_a_lot_partially_withdrawable_too_few_in_withdrawals(spec, state): +def test_invalid_a_lot_partially_withdrawable_too_few_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_partial_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4) next_slot(spec, state) @@ -301,7 +301,7 @@ def test_fail_a_lot_partially_withdrawable_too_few_in_withdrawals(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_a_lot_mixed_withdrawable_in_queue_too_few_in_withdrawals(spec, state): +def test_invalid_a_lot_mixed_withdrawable_in_queue_too_few_in_withdrawals(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4, num_partial_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4) @@ -318,7 +318,7 @@ def test_fail_a_lot_mixed_withdrawable_in_queue_too_few_in_withdrawals(spec, sta @with_phases([CAPELLA]) @spec_state_test -def test_fail_incorrect_withdrawal_index(spec, state): +def test_invalid_incorrect_withdrawal_index(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=1) next_slot(spec, state) @@ -330,7 +330,7 @@ def test_fail_incorrect_withdrawal_index(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_incorrect_address_full(spec, state): +def test_invalid_incorrect_address_full(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=1) next_slot(spec, state) @@ -342,7 +342,7 @@ def test_fail_incorrect_address_full(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_incorrect_address_partial(spec, state): +def test_invalid_incorrect_address_partial(spec, state): prepare_expected_withdrawals(spec, state, num_partial_withdrawals=1) next_slot(spec, state) @@ -354,7 +354,7 @@ def test_fail_incorrect_address_partial(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_incorrect_amount_full(spec, state): +def test_invalid_incorrect_amount_full(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=1) next_slot(spec, state) @@ -366,7 +366,7 @@ def test_fail_incorrect_amount_full(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_incorrect_amount_partial(spec, state): +def test_invalid_incorrect_amount_partial(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=1) next_slot(spec, state) @@ -378,7 +378,7 @@ def test_fail_incorrect_amount_partial(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_one_of_many_incorrectly_full(spec, state): +def test_invalid_one_of_many_incorrectly_full(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4) next_slot(spec, state) @@ -396,7 +396,7 @@ def test_fail_one_of_many_incorrectly_full(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_one_of_many_incorrectly_partial(spec, state): +def test_invalid_one_of_many_incorrectly_partial(spec, state): prepare_expected_withdrawals(spec, state, num_partial_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4) next_slot(spec, state) @@ -414,7 +414,7 @@ def test_fail_one_of_many_incorrectly_partial(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_many_incorrectly_full(spec, state): +def test_invalid_many_incorrectly_full(spec, state): prepare_expected_withdrawals(spec, state, num_full_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4) next_slot(spec, state) @@ -432,7 +432,7 @@ def test_fail_many_incorrectly_full(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_fail_many_incorrectly_partial(spec, state): +def test_invalid_many_incorrectly_partial(spec, state): prepare_expected_withdrawals(spec, state, num_partial_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD * 4) next_slot(spec, state) diff --git a/tests/core/pyspec/eth2spec/test/capella/sanity/test_blocks.py b/tests/core/pyspec/eth2spec/test/capella/sanity/test_blocks.py index 229d8ecc55..aa93a85d28 100644 --- a/tests/core/pyspec/eth2spec/test/capella/sanity/test_blocks.py +++ b/tests/core/pyspec/eth2spec/test/capella/sanity/test_blocks.py @@ -240,7 +240,7 @@ def test_withdrawal_success_two_blocks(spec, state): @with_phases([CAPELLA]) @spec_state_test -def test_withdrawal_fail_second_block_payload_isnt_compatible(spec, state): +def test_invalid_withdrawal_fail_second_block_payload_isnt_compatible(spec, state): _perform_valid_withdrawal(spec, state) # Block 2 From 338806d97f8a8988e0735dc2711a55a6e0a95fed Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Thu, 8 Dec 2022 16:15:08 +0800 Subject: [PATCH 08/11] PR feedback from @ralexstokes --- .../block_processing/test_process_deposit.py | 14 ------------- .../block_processing/test_process_deposit.py | 1 - .../block_processing/test_process_deposit.py | 21 +++++++++++++++---- 3 files changed, 17 insertions(+), 19 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py index ac728d4cc3..f7f468b367 100644 --- a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py @@ -1,7 +1,6 @@ from eth2spec.test.context import ( spec_state_test, always_bls, - with_altair_and_later, with_phases, ) from eth2spec.test.helpers.constants import ( @@ -24,17 +23,4 @@ def test_effective_deposit_with_previous_fork_version(spec, state): spec, state, fork_version=state.fork.previous_version, - effective=True, - ) - - -@with_altair_and_later -@spec_state_test -@always_bls -def test_ineffective_deposit_with_bad_fork_version_and(spec, state): - yield from run_deposit_processing_with_specific_fork_version( - spec, - state, - fork_version=spec.Version('0xAaBbCcDd'), - effective=False, ) diff --git a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py index 6473b7de65..24c94bac68 100644 --- a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py @@ -33,5 +33,4 @@ def test_effective_deposit_with_genesis_fork_version(spec, state): spec, state, fork_version=spec.config.GENESIS_FORK_VERSION, - effective=True, ) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py index e464cd9d78..346a3d9e2a 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py @@ -4,6 +4,7 @@ deposit_from_context, prepare_state_and_deposit, run_deposit_processing, + run_deposit_processing_with_specific_fork_version, sign_deposit_data, ) from eth2spec.test.helpers.keys import privkeys, pubkeys @@ -92,7 +93,7 @@ def test_new_deposit_non_versioned_withdrawal_credentials(spec, state): @with_all_phases @spec_state_test @always_bls -def test_invalid_sig_other_version(spec, state): +def test_incorrect_sig_other_version(spec, state): validator_index = len(state.validators) amount = spec.MAX_EFFECTIVE_BALANCE @@ -125,7 +126,7 @@ def test_correct_sig_but_forked_state(spec, state): # deposits will always be valid, regardless of the current fork state.fork.current_version = spec.Version('0x1234abcd') deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) - yield from run_deposit_processing(spec, state, deposit, validator_index, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index) @with_all_phases @@ -202,7 +203,7 @@ def test_incorrect_sig_top_up(spec, state): deposit = prepare_state_and_deposit(spec, state, validator_index, amount) # invalid signatures, in top-ups, are allowed! - yield from run_deposit_processing(spec, state, deposit, validator_index, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index) @with_all_phases @@ -220,7 +221,7 @@ def test_incorrect_withdrawal_credentials_top_up(spec, state): ) # inconsistent withdrawal credentials, in top-ups, are allowed! - yield from run_deposit_processing(spec, state, deposit, validator_index, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index) @with_all_phases @@ -307,3 +308,15 @@ def test_key_validate_invalid_decompression(spec, state): deposit = prepare_state_and_deposit(spec, state, validator_index, amount, pubkey=pubkey, signed=True) yield from run_deposit_processing(spec, state, deposit, validator_index) + + +@with_all_phases +@spec_state_test +@always_bls +def test_ineffective_deposit_with_bad_fork_version(spec, state): + yield from run_deposit_processing_with_specific_fork_version( + spec, + state, + fork_version=spec.Version('0xAaBbCcDd'), + effective=False, + ) From 34907d23758dd8b7394226514bfa66f8b6a6b1cb Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Thu, 8 Dec 2022 17:14:50 +0800 Subject: [PATCH 09/11] Add comments on the deposit fork version tests --- .../test/altair/block_processing/test_process_deposit.py | 2 ++ .../test/bellatrix/block_processing/test_process_deposit.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py index f7f468b367..2bc29009ff 100644 --- a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py @@ -19,6 +19,8 @@ def test_effective_deposit_with_previous_fork_version(spec, state): assert state.fork.previous_version != state.fork.current_version + # It's only effective in Altair because the default `fork_version` of `compute_domain` is `GENESIS_FORK_VERSION`. + # Therefore it's just a normal `DepositMessage`. yield from run_deposit_processing_with_specific_fork_version( spec, state, diff --git a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py index 24c94bac68..c88463b7ab 100644 --- a/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py @@ -12,6 +12,8 @@ @spec_state_test @always_bls def test_ineffective_deposit_with_previous_fork_version(spec, state): + # Since deposits are valid across forks, the domain is always set with `GENESIS_FORK_VERSION`. + # It's an ineffective deposit because it fails at BLS sig verification. # NOTE: it was effective in Altair. assert state.fork.previous_version != state.fork.current_version From 847c2bf839e393c0852af7bd53223605f01b2a76 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Thu, 8 Dec 2022 17:21:05 +0800 Subject: [PATCH 10/11] Remove `test_incorrect_sig_other_version` since it is duplicate to `test_ineffective_deposit_with_bad_fork_version` --- .../block_processing/test_process_deposit.py | 29 ------------------- 1 file changed, 29 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py index 346a3d9e2a..bcfcedd92a 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py @@ -1,14 +1,12 @@ from eth2spec.test.context import spec_state_test, always_bls, with_all_phases from eth2spec.test.helpers.deposits import ( build_deposit, - deposit_from_context, prepare_state_and_deposit, run_deposit_processing, run_deposit_processing_with_specific_fork_version, sign_deposit_data, ) from eth2spec.test.helpers.keys import privkeys, pubkeys -from eth2spec.utils import bls @with_all_phases @@ -90,33 +88,6 @@ def test_new_deposit_non_versioned_withdrawal_credentials(spec, state): yield from run_deposit_processing(spec, state, deposit, validator_index) -@with_all_phases -@spec_state_test -@always_bls -def test_incorrect_sig_other_version(spec, state): - validator_index = len(state.validators) - amount = spec.MAX_EFFECTIVE_BALANCE - - pubkey = pubkeys[validator_index] - privkey = privkeys[validator_index] - withdrawal_credentials = spec.BLS_WITHDRAWAL_PREFIX + spec.hash(pubkey)[1:] - - # Go through the effort of manually signing, not something normally done. This sig domain will be invalid. - deposit_message = spec.DepositMessage(pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount) - domain = spec.compute_domain(domain_type=spec.DOMAIN_DEPOSIT, fork_version=spec.Version('0xaabbccdd')) - deposit_data = spec.DepositData( - pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount, - signature=bls.Sign(privkey, spec.compute_signing_root(deposit_message, domain)) - ) - deposit, root, _ = deposit_from_context(spec, [deposit_data], 0) - - state.eth1_deposit_index = 0 - state.eth1_data.deposit_root = root - state.eth1_data.deposit_count = 1 - - yield from run_deposit_processing(spec, state, deposit, validator_index, effective=False) - - @with_all_phases @spec_state_test @always_bls From e5709a55b6f998e424fe454684ffe36542da06a5 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Thu, 8 Dec 2022 17:23:29 +0800 Subject: [PATCH 11/11] Add `test_ineffective_deposit_with_current_fork_version` --- .../altair/block_processing/test_process_deposit.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py index 2bc29009ff..25c2767269 100644 --- a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py +++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py @@ -2,6 +2,7 @@ spec_state_test, always_bls, with_phases, + with_altair_and_later, ) from eth2spec.test.helpers.constants import ( ALTAIR, @@ -26,3 +27,15 @@ def test_effective_deposit_with_previous_fork_version(spec, state): state, fork_version=state.fork.previous_version, ) + + +@with_altair_and_later +@spec_state_test +@always_bls +def test_ineffective_deposit_with_current_fork_version(spec, state): + yield from run_deposit_processing_with_specific_fork_version( + spec, + state, + fork_version=state.fork.current_version, + effective=False, + )