Modify GetValidatorParticipation to use new state service

beacon-chain/rpc/beacon/BUILD.bazel

@@ -75,7 +75,6 @@ go_test(
     deps = [
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",

beacon-chain/rpc/beacon/validators.go

@@ -462,81 +462,57 @@ func (bs *Server) GetValidatorActiveSetChanges(
 func (bs *Server) GetValidatorParticipation(
 	ctx context.Context, req *ethpb.GetValidatorParticipationRequest,
 ) (*ethpb.ValidatorParticipationResponse, error) {
-	headState, err := bs.HeadFetcher.HeadState(ctx)
-	if err != nil {
-		return nil, status.Error(codes.Internal, "Could not get head state")
-	}
-
-	currentEpoch := helpers.CurrentEpoch(headState)
-	prevEpoch := helpers.PrevEpoch(headState)
+	currentEpoch := helpers.SlotToEpoch(bs.GenesisTimeFetcher.CurrentSlot())
 
 	var requestedEpoch uint64
-	var requestingGenesis bool
 	switch q := req.QueryFilter.(type) {
 	case *ethpb.GetValidatorParticipationRequest_Genesis:
-		requestingGenesis = q.Genesis
 		requestedEpoch = 0
 	case *ethpb.GetValidatorParticipationRequest_Epoch:
 		requestedEpoch = q.Epoch
 	default:
-		requestedEpoch = prevEpoch
+		// Prevent underflow and ensure participation is always queried for previous epoch.
+		if currentEpoch > 1 {
+			requestedEpoch = currentEpoch - 1
+		}
 	}
 
-	// If the request is from genesis or another past epoch, we look into our archived
-	// data to find it and return it if it exists.
-	if requestingGenesis || requestedEpoch < prevEpoch {
-		participation, err := bs.BeaconDB.ArchivedValidatorParticipation(ctx, requestedEpoch)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not fetch archived participation: %v", err)
-		}
-		if participation == nil {
-			return nil, status.Errorf(
-				codes.NotFound,
-				"Could not retrieve data for epoch %d, perhaps --archive in the running beacon node is disabled",
-				0,
-			)
-		}
-		return &ethpb.ValidatorParticipationResponse{
-			Epoch:         requestedEpoch,
-			Finalized:     requestedEpoch <= headState.FinalizedCheckpointEpoch(),
-			Participation: participation,
-		}, nil
-	} else if requestedEpoch == currentEpoch {
-		// We cannot retrieve participation for an epoch currently in progress.
+	if requestedEpoch >= currentEpoch {
 		return nil, status.Errorf(
 			codes.InvalidArgument,
-			"Cannot retrieve information about an epoch currently in progress, current epoch %d, requesting %d",
-			currentEpoch,
-			requestedEpoch,
-		)
-	} else if requestedEpoch > currentEpoch {
-		// We are requesting data from the future and we return an error.
-		return nil, status.Errorf(
-			codes.InvalidArgument,
-			"Cannot retrieve information about an epoch in the future, current epoch %d, requesting %d",
+			"Cannot retrieve information about an epoch until older than current epoch, current epoch %d, requesting %d",
 			currentEpoch,
 			requestedEpoch,
 		)
 	}
 
-	p := bs.ParticipationFetcher.Participation(requestedEpoch)
-	if p == nil {
-		p = &precompute.Balance{}
+	requestedState, err := bs.StateGen.StateBySlot(ctx, helpers.StartSlot(requestedEpoch+1))
+	if err != nil {
+		return nil, status.Error(codes.Internal, "Could not get state")
 	}
-	participation := &ethpb.ValidatorParticipation{
-		EligibleEther: p.PrevEpoch,
-		VotedEther:    p.PrevEpochTargetAttesters,
+
+	v, b, err := precompute.New(ctx, requestedState)
+	if err != nil {
+		return nil, status.Error(codes.Internal, "Could not set up pre compute instance")
+	}
+	_, b, err = precompute.ProcessAttestations(ctx, requestedState, v, b)
+	if err != nil {
+		return nil, status.Error(codes.Internal, "Could not pre compute attestations")
 	}
-	participation.GlobalParticipationRate = float32(0)
-	// only divide if prevEpoch is non zero
-	if p.PrevEpoch != 0 {
-		participation.GlobalParticipationRate = float32(p.PrevEpochTargetAttesters) / float32(p.PrevEpoch)
+
+	headState, err := bs.HeadFetcher.HeadState(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, "Could not get head state")
 	}
 
 	return &ethpb.ValidatorParticipationResponse{
-		Epoch:         requestedEpoch,
-		Finalized:     requestedEpoch <= headState.FinalizedCheckpointEpoch(),
-		Participation: participation,
+		Epoch:     requestedEpoch,
+		Finalized: requestedEpoch <= headState.FinalizedCheckpointEpoch(),
+		Participation: &ethpb.ValidatorParticipation{
+			GlobalParticipationRate: float32(b.PrevEpochTargetAttesters) / float32(b.PrevEpoch),
+			VotedEther:              b.PrevEpochTargetAttesters,
+			EligibleEther:           b.PrevEpoch,
+		},
 	}, nil
 }