status-im
/
eth2.0-specs
mirror of https://github.com/status-im/eth2.0-specs.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

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`
This commit is contained in:
Hsiao-Wei Wang 2022-12-13 15:13:44 +08:00 committed by GitHub
parent 06d6d3888f
commit da3f5af919
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 352 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
specs/altair/beacon-chain.md
View File

@ -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))

41
tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_deposit.py Normal file
View File

@ -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,
)

2
tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
View File

@ -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)

12
tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py
View File

@ -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)

63
tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_deposit.py
View File

@ -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,
)

32
tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py
View File

@ -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)

16
tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_voluntary_exit.py
View File

@ -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(

8
tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_bls_to_execution_change.py
View File

@ -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)

38
tests/core/pyspec/eth2spec/test/capella/block_processing/test_process_withdrawals.py
View File

@ -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)

2
tests/core/pyspec/eth2spec/test/capella/sanity/test_blocks.py
View File

@ -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

8
tests/core/pyspec/eth2spec/test/context.py
View File

@ -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)))

43
tests/core/pyspec/eth2spec/test/helpers/deposits.py
View File

@ -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)

116
tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attestation.py
View File

@ -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)

102
tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py
View File

@ -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)

4
tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_block_header.py
View File

@ -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)

68
tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_deposit.py
View File

@ -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,
)

52
tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_proposer_slashing.py
View File

@ -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)

26
tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_voluntary_exit.py
View File

@ -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)

16
tests/core/pyspec/eth2spec/test/phase0/genesis/test_validity.py
View File

@ -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)

20
tests/core/pyspec/eth2spec/test/phase0/sanity/test_blocks.py
View File

@ -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

5
tests/core/pyspec/eth2spec/test/phase0/sanity/test_slots.py
View File

@ -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

13
tests/generators/operations/main.py
View File

@ -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 [