Add altair process epoch (#9449)

* Add altair process epoch

* Verify balance

* Gaz

Co-authored-by: Raul Jordan <raul@prysmaticlabs.com>
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>

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"],

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
+}

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)))
+}