def test_transition_with_leaking_at_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag):
"""
Leaking starts at epoch 6 (MIN_EPOCHS_TO_INACTIVITY_PENALTY + 2).
The leaking starts at the fork transition in this case.
"""
transition_until_fork(spec, state, fork_epoch)
assert not spec.is_in_inactivity_leak(state)
assert spec.get_current_epoch(state) < fork_epoch
yield "pre", state
# irregular state transition to handle fork:
blocks = []
state, block = do_altair_fork(state, spec, post_spec, fork_epoch)
blocks.append(post_tag(block))
# check post transition state
assert spec.is_in_inactivity_leak(state)
# continue regular state transition with new spec into next epoch
transition_to_next_epoch_and_append_blocks(post_spec, state, post_tag, blocks, only_last_block=True)
yield "blocks", blocks
yield "post", state
def test_transition_with_non_empty_activation_queue(state, fork_epoch, spec,
post_spec, pre_tag,
post_tag):
"""
Create some deposits before the transition
"""
transition_until_fork(spec, state, fork_epoch)
deposited_indices = set_some_new_deposits(spec,
state,
rng=random.Random(5566))
assert spec.get_current_epoch(state) < fork_epoch
assert len(deposited_indices) > 0
for validator_index in deposited_indices:
assert not spec.is_active_validator(state.validators[validator_index],
spec.get_current_epoch(state))
yield "pre", state
# irregular state transition to handle fork:
blocks = []
state, block = do_fork(state, spec, post_spec, fork_epoch)
blocks.append(post_tag(block))
# continue regular state transition with new spec into next epoch
transition_to_next_epoch_and_append_blocks(post_spec,
state,
post_tag,
blocks,
only_last_block=True)
yield "blocks", blocks
yield "post", state
def test_transition_with_one_fourth_exiting_validators_exit_at_fork(
state, fork_epoch, spec, post_spec, pre_tag, post_tag):
"""
1/4 validators initiated voluntary exit before the fork,
and being exited and inactive *right after* the fork transition.
"""
exited_indices = exit_random_validators(
spec,
state,
rng=random.Random(5566),
fraction=0.25,
exit_epoch=fork_epoch,
from_epoch=spec.get_current_epoch(state),
)
transition_until_fork(spec, state, fork_epoch)
# check pre state
assert len(exited_indices) > 0
for index in exited_indices:
validator = state.validators[index]
assert not validator.slashed
assert fork_epoch == validator.exit_epoch < spec.FAR_FUTURE_EPOCH
assert spec.is_active_validator(validator,
spec.get_current_epoch(state))
assert not spec.is_in_inactivity_leak(state)
assert spec.get_current_epoch(state) < fork_epoch
yield "pre", state
# irregular state transition to handle fork:
blocks = []
state, block = do_altair_fork(state, spec, post_spec, fork_epoch)
blocks.append(post_tag(block))
# check post transition state
for index in exited_indices:
validator = state.validators[index]
assert not validator.slashed
assert not post_spec.is_active_validator(
validator, post_spec.get_current_epoch(state))
assert not post_spec.is_in_inactivity_leak(state)
# ensure that none of the current sync committee members are exited validators
exited_pubkeys = [
state.validators[index].pubkey for index in exited_indices
]
assert not any(
set(exited_pubkeys).intersection(
list(state.current_sync_committee.pubkeys)))
# continue regular state transition with new spec into next epoch
transition_to_next_epoch_and_append_blocks(post_spec,
state,
post_tag,
blocks,
only_last_block=True)
yield "blocks", blocks
yield "post", state
def test_transition_with_one_fourth_slashed_active_validators_pre_fork(
state, fork_epoch, spec, post_spec, pre_tag, post_tag):
"""
1/4 validators are slashed but still active at the fork transition.
"""
# slash 1/4 validators
slashed_indices = slash_random_validators(spec,
state,
rng=random.Random(5566),
fraction=0.25)
assert len(slashed_indices) > 0
# check if some validators are slashed but still active
for validator_index in slashed_indices:
validator = state.validators[validator_index]
assert validator.slashed
assert spec.is_active_validator(validator,
spec.get_current_epoch(state))
assert not spec.is_in_inactivity_leak(state)
transition_until_fork(spec, state, fork_epoch)
assert spec.get_current_epoch(state) < fork_epoch
yield "pre", state
# irregular state transition to handle fork:
state, _ = do_fork(state, spec, post_spec, fork_epoch, with_block=False)
# ensure that some of the current sync committee members are slashed
slashed_pubkeys = [
state.validators[index].pubkey for index in slashed_indices
]
assert any(
set(slashed_pubkeys).intersection(
list(state.current_sync_committee.pubkeys)))
assert any(
set(slashed_pubkeys).difference(
list(state.current_sync_committee.pubkeys)))
# continue regular state transition with new spec into next epoch
# since the proposer might have been slashed, here we only create blocks with non-slashed proposers
blocks = []
transition_to_next_epoch_and_append_blocks(
post_spec,
state,
post_tag,
blocks,
only_last_block=True,
ignoring_proposers=slashed_indices,
)
# check post state
for validator in state.validators:
assert post_spec.is_active_validator(
validator, post_spec.get_current_epoch(state))
assert not post_spec.is_in_inactivity_leak(state)
yield "blocks", blocks
yield "post", state
def test_sample_transition(state, fork_epoch, spec, post_spec, pre_tag, post_tag):
transition_until_fork(spec, state, fork_epoch)
# check pre state
assert spec.get_current_epoch(state) < fork_epoch
yield "pre", state
# irregular state transition to handle fork:
blocks = []
state, block = do_fork(state, spec, post_spec, fork_epoch)
blocks.append(post_tag(block))
# continue regular state transition with new spec into next epoch
transition_to_next_epoch_and_append_blocks(post_spec, state, post_tag, blocks, only_last_block=True)
yield "blocks", blocks
yield "post", state
def test_transition_with_activation_at_fork_epoch(state, fork_epoch, spec,
post_spec, pre_tag,
post_tag):
"""
Create some deposits before the transition
"""
transition_until_fork(spec, state, fork_epoch)
selected_indices = set_some_activations(spec,
state,
rng=random.Random(5566),
activation_epoch=fork_epoch)
assert spec.get_current_epoch(state) < fork_epoch
assert len(selected_indices) > 0
for validator_index in selected_indices:
validator = state.validators[validator_index]
assert not spec.is_active_validator(validator,
spec.get_current_epoch(state))
assert validator.activation_epoch == fork_epoch
yield "pre", state
# irregular state transition to handle fork:
blocks = []
state, block = do_fork(state, spec, post_spec, fork_epoch)
blocks.append(post_tag(block))
# continue regular state transition with new spec into next epoch
transition_to_next_epoch_and_append_blocks(post_spec,
state,
post_tag,
blocks,
only_last_block=True)
# now they are active
for validator_index in selected_indices:
validator = state.validators[validator_index]
assert post_spec.is_active_validator(
validator, post_spec.get_current_epoch(state))
yield "blocks", blocks
yield "post", state