Participation: count atts from orphaned blocks (#7117)

* Cound attestations from orphaned blocks

* Use next epoch's end slot

* Fixed a test

* Fixed a test

* Nishant's feedback

* Typo

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

Author: terencechain

beacon-chain/rpc/beacon/validators.go

@@ -11,7 +11,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	statetrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/cmd"
 	"github.com/prysmaticlabs/prysm/shared/featureconfig"
@@ -474,21 +477,24 @@ func (bs *Server) GetValidatorParticipation(
 			requestedEpoch,
 		)
 	}
-
-	requestedState, err := bs.StateGen.StateBySlot(ctx, helpers.StartSlot(requestedEpoch+1))
+	// Calculate the end slot of the next epoch.
+	// Ex: requested epoch 1, this gets slot 95.
+	nextEpochEndSlot := helpers.StartSlot(requestedEpoch+2) - 1
+	requestedState, err := bs.StateGen.StateBySlot(ctx, nextEpochEndSlot)
 	if err != nil {
 		return nil, status.Error(codes.Internal, "Could not get state")
 	}
 
+	requestedState, err = bs.appendNonFinalizedBlockAttsToState(ctx, requestedState, requestedEpoch)
+
 	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")
+		return nil, status.Errorf(codes.Internal, "Could not pre compute attestations: %v", err)
 	}
-
 	headState, err := bs.HeadFetcher.HeadState(ctx)
 	if err != nil {
 		return nil, status.Error(codes.Internal, "Could not get head state")
@@ -505,6 +511,45 @@ func (bs *Server) GetValidatorParticipation(
 	}, nil
 }
 
+// This appends non finalized block atts to state. To replay for a state, a node does not replay non canonical
+// nor finalized blocks. To count participation, this includes the attestations from the orphaned block to state.
+func (bs *Server) appendNonFinalizedBlockAttsToState(ctx context.Context, s *statetrie.BeaconState, e uint64) (*statetrie.BeaconState, error) {
+	start := helpers.StartSlot(e)
+	end := helpers.StartSlot(e + 1)
+	f := filters.NewFilter().SetStartSlot(start).SetEndSlot(end)
+	blks, err := bs.BeaconDB.Blocks(ctx, f)
+	if err != nil {
+		return nil, err
+	}
+
+	nonFinalizedBlks := make([]*ethpb.SignedBeaconBlock, 0, len(blks))
+	for i := len(blks) - 1; i >= 0; i-- {
+		r, err := stateutil.BlockRoot(blks[i].Block)
+		if err != nil {
+			return nil, err
+		}
+		if !bs.BeaconDB.IsFinalizedBlock(ctx, r) {
+			nonFinalizedBlks = append(nonFinalizedBlks, blks[i])
+		}
+	}
+	for _, b := range nonFinalizedBlks {
+		for _, a := range b.Block.Body.Attestations {
+			if a.Data.Target.Epoch == e {
+				pa := &pb.PendingAttestation{
+					Data:            a.Data,
+					AggregationBits: a.AggregationBits,
+					InclusionDelay:  params.BeaconConfig().FarFutureEpoch,
+				}
+				if err := s.AppendPreviousEpochAttestations(pa); err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+
+	return s, nil
+}
+
 // GetValidatorQueue retrieves the current validator queue information.
 func (bs *Server) GetValidatorQueue(
 	ctx context.Context, _ *ptypes.Empty,

beacon-chain/rpc/beacon/validators_test.go

@@ -1367,7 +1367,7 @@ func TestServer_GetValidatorParticipation_PrevEpoch(t *testing.T) {
 
 	atts := []*pbp2p.PendingAttestation{{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{}}, InclusionDelay: 1}}
 	headState := testutil.NewBeaconState()
-	require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
+	require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch*2-1))
 	require.NoError(t, headState.SetValidators(validators))
 	require.NoError(t, headState.SetBalances(balances))
 	require.NoError(t, headState.SetPreviousEpochAttestations(atts))
@@ -1400,7 +1400,7 @@ func TestServer_GetValidatorParticipation_DoesntExist(t *testing.T) {
 	ctx := context.Background()
 
 	headState := testutil.NewBeaconState()
-	require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
+	require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch*2-1))
 
 	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: params.BeaconConfig().SlotsPerEpoch}}
 	require.NoError(t, db.SaveBlock(ctx, b))
@@ -1860,3 +1860,24 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
 	}
 	assert.DeepEqual(t, wanted, res, "Unexpected response")
 }
+
+func TestServer_appendNonFinalizedBlockAttsToState(t *testing.T) {
+	db, _ := dbTest.SetupDB(t)
+	ctx := context.Background()
+	bs := &Server{
+		BeaconDB: db,
+	}
+	e := uint64(1)
+	b1 := testutil.NewBeaconBlock()
+	b1.Block.Slot = e * params.BeaconConfig().SlotsPerEpoch
+	b1.Block.Body.Attestations = []*ethpb.Attestation{{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: 1}}}}
+	b2 := testutil.NewBeaconBlock()
+	b2.Block.Slot = e*params.BeaconConfig().SlotsPerEpoch + 1
+	b2.Block.Body.Attestations = []*ethpb.Attestation{{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: 1}}}}
+	require.NoError(t, db.SaveBlock(ctx, b1))
+	require.NoError(t, db.SaveBlock(ctx, b2))
+	s := testutil.NewBeaconState()
+	got, err := bs.appendNonFinalizedBlockAttsToState(ctx, s, e)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(got.PreviousEpochAttestations()))
+}