From cd4bb6a9c8b2e19f2bdba0396eb59abfb14a9efd Mon Sep 17 00:00:00 2001 From: terence tsao Date: Tue, 24 Aug 2021 09:07:11 -0700 Subject: [PATCH] Add altair process epoch (#9449) * Add altair process epoch * Verify balance * Gaz Co-authored-by: Raul Jordan Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com> --- beacon-chain/core/altair/BUILD.bazel | 3 + beacon-chain/core/altair/transition.go | 110 ++++++++++++++++++++ beacon-chain/core/altair/transition_test.go | 43 ++++++++ 3 files changed, 156 insertions(+) create mode 100644 beacon-chain/core/altair/transition.go create mode 100644 beacon-chain/core/altair/transition_test.go diff --git a/beacon-chain/core/altair/BUILD.bazel b/beacon-chain/core/altair/BUILD.bazel index 64c7ad6605..46c8a08208 100644 --- a/beacon-chain/core/altair/BUILD.bazel +++ b/beacon-chain/core/altair/BUILD.bazel @@ -10,6 +10,7 @@ go_library( "epoch_spec.go", "reward.go", "sync_committee.go", + "transition.go", "upgrade.go", ], importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/altair", @@ -20,6 +21,7 @@ go_library( ], deps = [ "//beacon-chain/core/blocks:go_default_library", + "//beacon-chain/core/epoch:go_default_library", "//beacon-chain/core/epoch/precompute:go_default_library", "//beacon-chain/core/helpers:go_default_library", "//beacon-chain/p2p/types:go_default_library", @@ -50,6 +52,7 @@ go_test( "epoch_spec_test.go", "reward_test.go", "sync_committee_test.go", + "transition_test.go", "upgrade_test.go", ], embed = [":go_default_library"], diff --git a/beacon-chain/core/altair/transition.go b/beacon-chain/core/altair/transition.go new file mode 100644 index 0000000000..4a588bd700 --- /dev/null +++ b/beacon-chain/core/altair/transition.go @@ -0,0 +1,110 @@ +package altair + +import ( + "context" + + "github.com/pkg/errors" + e "github.com/prysmaticlabs/prysm/beacon-chain/core/epoch" + "github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute" + "github.com/prysmaticlabs/prysm/beacon-chain/state" + "go.opencensus.io/trace" +) + +// ProcessEpoch describes the per epoch operations that are performed on the beacon state. +// It's optimized by pre computing validator attested info and epoch total/attested balances upfront. +// +// Spec code: +// def process_epoch(state: BeaconState) -> None: +// process_justification_and_finalization(state) # [Modified in Altair] +// process_inactivity_updates(state) # [New in Altair] +// process_rewards_and_penalties(state) # [Modified in Altair] +// process_registry_updates(state) +// process_slashings(state) # [Modified in Altair] +// process_eth1_data_reset(state) +// process_effective_balance_updates(state) +// process_slashings_reset(state) +// process_randao_mixes_reset(state) +// process_historical_roots_update(state) +// process_participation_flag_updates(state) # [New in Altair] +// process_sync_committee_updates(state) # [New in Altair] +func ProcessEpoch(ctx context.Context, state state.BeaconStateAltair) (state.BeaconStateAltair, error) { + ctx, span := trace.StartSpan(ctx, "altair.ProcessEpoch") + defer span.End() + + if state == nil || state.IsNil() { + return nil, errors.New("nil state") + } + vp, bp, err := InitializeEpochValidators(ctx, state) + if err != nil { + return nil, err + } + + // New in Altair. + vp, bp, err = ProcessEpochParticipation(ctx, state, bp, vp) + if err != nil { + return nil, err + } + + state, err = precompute.ProcessJustificationAndFinalizationPreCompute(state, bp) + if err != nil { + return nil, errors.Wrap(err, "could not process justification") + } + + // New in Altair. + state, vp, err = ProcessInactivityScores(ctx, state, vp) + if err != nil { + return nil, errors.Wrap(err, "could not process inactivity updates") + } + + // New in Altair. + state, err = ProcessRewardsAndPenaltiesPrecompute(state, bp, vp) + if err != nil { + return nil, errors.Wrap(err, "could not process rewards and penalties") + } + + state, err = e.ProcessRegistryUpdates(state) + if err != nil { + return nil, errors.Wrap(err, "could not process registry updates") + } + + // Modified in Altair. + state, err = ProcessSlashings(state) + if err != nil { + return nil, err + } + + state, err = e.ProcessEth1DataReset(state) + if err != nil { + return nil, err + } + state, err = e.ProcessEffectiveBalanceUpdates(state) + if err != nil { + return nil, err + } + state, err = e.ProcessSlashingsReset(state) + if err != nil { + return nil, err + } + state, err = e.ProcessRandaoMixesReset(state) + if err != nil { + return nil, err + } + state, err = e.ProcessHistoricalRootsUpdate(state) + if err != nil { + return nil, err + } + + // New in Altair. + state, err = ProcessParticipationFlagUpdates(state) + if err != nil { + return nil, err + } + + // New in Altair. + state, err = ProcessSyncCommitteeUpdates(ctx, state) + if err != nil { + return nil, err + } + + return state, nil +} diff --git a/beacon-chain/core/altair/transition_test.go b/beacon-chain/core/altair/transition_test.go new file mode 100644 index 0000000000..814e87c8f2 --- /dev/null +++ b/beacon-chain/core/altair/transition_test.go @@ -0,0 +1,43 @@ +package altair_test + +import ( + "context" + "testing" + + "github.com/prysmaticlabs/prysm/beacon-chain/core/altair" + "github.com/prysmaticlabs/prysm/shared/params" + "github.com/prysmaticlabs/prysm/shared/testutil" + "github.com/prysmaticlabs/prysm/shared/testutil/require" +) + +func TestProcessEpoch_CanProcess(t *testing.T) { + st, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee) + require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch)) + newState, err := altair.ProcessEpoch(context.Background(), st) + require.NoError(t, err) + require.Equal(t, uint64(0), newState.Slashings()[2], "Unexpected slashed balance") + + b := st.Balances() + require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(b))) + require.Equal(t, uint64(31999841265), b[0]) + + s, err := st.InactivityScores() + require.NoError(t, err) + require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(s))) + + p, err := st.PreviousEpochParticipation() + require.NoError(t, err) + require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p))) + + p, err = st.CurrentEpochParticipation() + require.NoError(t, err) + require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p))) + + sc, err := st.CurrentSyncCommittee() + require.NoError(t, err) + require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys))) + + sc, err = st.NextSyncCommittee() + require.NoError(t, err) + require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys))) +}