From da3f5af919be4abb5a6db5a80b235deb8b4b5cba Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Tue, 13 Dec 2022 15:13:44 +0800 Subject: [PATCH] Test case naming clean up (#3143) * Add @description decorator * Unify test case naming style * more clean ups * Altair tests cleanup * Clean up Altair and Bellatrix `process_deposit` tests * Clean up Bellatrix tests * Clean up Capella tests * PR feedback from @ralexstokes * Add comments on the deposit fork version tests * Remove `test_incorrect_sig_other_version` since it is duplicate to `test_ineffective_deposit_with_bad_fork_version` * Add `test_ineffective_deposit_with_current_fork_version` --- specs/altair/beacon-chain.md | 1 + .../block_processing/test_process_deposit.py | 41 +++++++ .../test_process_sync_committee_updates.py | 2 +- .../test/altair/sanity/test_blocks.py | 12 +- .../block_processing/test_process_deposit.py | 63 ++-------- .../test_process_execution_payload.py | 32 ++--- .../test_process_voluntary_exit.py | 16 ++- .../test_process_bls_to_execution_change.py | 8 +- .../test_process_withdrawals.py | 38 +++--- .../test/capella/sanity/test_blocks.py | 2 +- tests/core/pyspec/eth2spec/test/context.py | 8 +- .../pyspec/eth2spec/test/helpers/deposits.py | 43 +++++-- .../test_process_attestation.py | 116 +++++++++--------- .../test_process_attester_slashing.py | 102 +++++++-------- .../test_process_block_header.py | 4 +- .../block_processing/test_process_deposit.py | 68 ++++------ .../test_process_proposer_slashing.py | 52 ++++---- .../test_process_voluntary_exit.py | 26 ++-- .../test/phase0/genesis/test_validity.py | 16 +-- .../test/phase0/sanity/test_blocks.py | 20 +-- .../eth2spec/test/phase0/sanity/test_slots.py | 5 +- tests/generators/operations/main.py | 13 +- 22 files changed, 352 insertions(+), 336 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 79ab8d022..fe71a5ff8 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 000000000..25c276726 --- /dev/null +++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py @@ -0,0 +1,41 @@ +from eth2spec.test.context import ( + spec_state_test, + always_bls, + with_phases, + with_altair_and_later, +) +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 + + # 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, + 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, + ) 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 4b0cb70d5..9e8444b54 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 a3299c170..0c2f1c755 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) 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 b111fd9ff..c88463b7a 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,23 @@ from eth2spec.test.context import ( 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): + # 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 - 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 +28,11 @@ 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/bellatrix/block_processing/test_process_execution_payload.py b/tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py index 2819b2a24..6d254f174 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 257247b16..f4fcaac68 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( 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 79d79fa6e..6a1ba5b36 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 8292e66ce..ad3911080 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 @@ -244,7 +244,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( @@ -260,7 +260,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) @@ -272,7 +272,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) @@ -284,7 +284,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) @@ -296,7 +296,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) @@ -308,7 +308,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) @@ -320,7 +320,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) @@ -332,7 +332,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) @@ -344,7 +344,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) @@ -356,7 +356,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, num_partial_withdrawals=spec.MAX_WITHDRAWALS_PER_PAYLOAD) @@ -373,7 +373,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) @@ -385,7 +385,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) @@ -397,7 +397,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) @@ -409,7 +409,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) @@ -421,7 +421,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) @@ -433,7 +433,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) @@ -451,7 +451,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) @@ -469,7 +469,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) @@ -487,7 +487,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 91adc1de3..1df046c9d 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 diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py index 94910fa47..c0e7c2b5f 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))) diff --git a/tests/core/pyspec/eth2spec/test/helpers/deposits.py b/tests/core/pyspec/eth2spec/test/helpers/deposits.py index f8ab75e85..cfff9c5ef 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/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 8d9e67998..7595ce9cb 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 @@ from eth2spec.utils.ssz.ssz_typing import Bitlist @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 13d64e03b..e63554677 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 b57090568..5188d8f91 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 20d8d7d74..bcfcedd92 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,13 +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 @@ -92,56 +91,29 @@ 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): - 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, valid=True, 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) @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 +129,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 +148,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 +168,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) @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 +192,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) @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 +238,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) @@ -307,3 +279,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, + ) 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 6ca87adae..42c94b6f5 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 73602f14c..4a7286d52 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 @@ from eth2spec.test.helpers.voluntary_exits import ( @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/genesis/test_validity.py b/tests/core/pyspec/eth2spec/test/phase0/genesis/test_validity.py index aecc96077..d245b8fcf 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 0e19e65b7..1e9dd2d48 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 @@ from eth2spec.test.context import ( @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 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 198ada6b9..3fa57f0f1 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 diff --git a/tests/generators/operations/main.py b/tests/generators/operations/main.py index bb879a647..4c073ebe4 100644 --- a/tests/generators/operations/main.py +++ b/tests/generators/operations/main.py @@ -11,10 +11,15 @@ if __name__ == "__main__": '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 [