From 7eba1612cf2311d74d55c076b2bdaa27b70a0f32 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Tue, 18 May 2021 17:26:18 -0700 Subject: [PATCH] Add fork transition test that finalizes across fork boundary --- .../test/altair/transition/test_transition.py | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py index c3b03d663..fdfea131e 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py @@ -2,6 +2,7 @@ from eth2spec.test.context import fork_transition_test from eth2spec.test.helpers.constants import PHASE0, ALTAIR from eth2spec.test.helpers.state import state_transition_and_sign_block, next_slot from eth2spec.test.helpers.block import build_empty_block_for_next_slot, build_empty_block, sign_block +from eth2spec.test.helpers.attestations import next_slots_with_attestations def _state_transition_and_sign_block_at_slot(spec, state): @@ -242,3 +243,77 @@ def test_transition_only_blocks_post_fork(state, fork_epoch, spec, post_spec, pr yield "blocks", blocks yield "post", state + + +@fork_transition_test(PHASE0, ALTAIR, fork_epoch=3) +def test_transition_with_finality(state, fork_epoch, spec, post_spec, pre_tag, post_tag): + """ + Transition from the initial ``state`` to the epoch after the ``fork_epoch``, + including attestations so as to produce finality through the fork boundary. + """ + yield "pre", state + + current_epoch = spec.get_current_epoch(state) + assert current_epoch < fork_epoch + assert current_epoch == spec.GENESIS_EPOCH + + # regular state transition until fork: + fill_cur_epoch = False + fill_prev_epoch = True + blocks = [] + for _ in range(current_epoch, fork_epoch - 1): + if current_epoch == spec.GENESIS_EPOCH: + fill_cur_epoch = True + fill_prev_epoch = False + + _, blocks_in_epoch, state = next_slots_with_attestations(spec, + state, + spec.SLOTS_PER_EPOCH, + fill_cur_epoch, + fill_prev_epoch) + blocks.extend([pre_tag(block) for block in blocks_in_epoch]) + if current_epoch == spec.GENESIS_EPOCH: + fill_cur_epoch = False + fill_prev_epoch = True + + _, blocks_in_epoch, state = next_slots_with_attestations(spec, + state, + spec.SLOTS_PER_EPOCH - 1, + fill_cur_epoch, + fill_prev_epoch) + blocks.extend([pre_tag(block) for block in blocks_in_epoch]) + assert spec.get_current_epoch(state) == fork_epoch - 1 + assert (state.slot + 1) % spec.SLOTS_PER_EPOCH == 0 + + # irregular state transition to handle fork: + state, block = _do_altair_fork(state, spec, post_spec, fork_epoch) + blocks.append(post_tag(block)) + + # continue regular state transition with new spec into next epoch + for _ in range(4): + _, blocks_in_epoch, state = next_slots_with_attestations(post_spec, + state, + post_spec.SLOTS_PER_EPOCH, + fill_cur_epoch, + fill_prev_epoch) + blocks.extend([post_tag(block) for block in blocks_in_epoch]) + + assert state.slot % post_spec.SLOTS_PER_EPOCH == 0 + assert post_spec.compute_epoch_at_slot(state.slot) == fork_epoch + 4 + + assert state.current_justified_checkpoint.epoch == fork_epoch + 2 + assert state.finalized_checkpoint.epoch == fork_epoch + + assert len(blocks) == (fork_epoch + 4) * post_spec.SLOTS_PER_EPOCH + assert len(blocks) == len(set(blocks)) + + blocks_without_attestations = [block for block in blocks if len(block.message.body.attestations) == 0] + # A boundary condition of ``next_slots_with_attestations`` skips + # over the block with ``slot == 1``. + # And the fork upgrade helper currently does not construct any attestations. + assert len(blocks_without_attestations) == 2 + slots_without_attestations = [b.message.slot for b in blocks_without_attestations] + assert set(slots_without_attestations) == set([1, fork_epoch * spec.SLOTS_PER_EPOCH]) + + yield "blocks", blocks + yield "post", state