Do not call repeated times FCU

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -42,67 +42,45 @@ func (s *Service) getStateAndBlock(ctx context.Context, r [32]byte) (state.Beaco
 	return headState, newHeadBlock, nil
 }
 
+// fockchoiceUpdateWithExecution is a wrapper around notifyForkchoiceUpdate. It decides whether a new call to FCU should be made.
 func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, newHeadRoot [32]byte, proposingSlot primitives.Slot) error {
 	isNewHead := s.isNewHead(newHeadRoot)
-	isNewProposer := s.isNewProposer(proposingSlot)
-	if !isNewHead && !isNewProposer {
+	if !isNewHead {
 		return nil
 	}
-
-	var headState state.BeaconState
-	var headBlock interfaces.ReadOnlySignedBeaconBlock
-	var headRoot [32]byte
-	var err error
-
-	shouldUpdate := isNewHead
-	if isNewHead && isNewProposer && !features.Get().DisableReorgLateBlocks {
+	isNewProposer := s.isNewProposer(proposingSlot)
+	if isNewProposer && !features.Get().DisableReorgLateBlocks {
 		if proposingSlot == s.CurrentSlot() {
 			proposerHead := s.ForkChoicer().GetProposerHead()
 			if proposerHead != newHeadRoot {
-				shouldUpdate = false
+				return nil
 			}
 		} else if s.ForkChoicer().ShouldOverrideFCU() {
-			shouldUpdate = false
-		}
-	}
-	if shouldUpdate {
-		headRoot = newHeadRoot
-		headState, headBlock, err = s.getStateAndBlock(ctx, newHeadRoot)
-		if err != nil {
-			log.WithError(err).Error("Could not get forkchoice update argument")
 			return nil
 		}
-	} else {
-		// We are guaranteed that the head block is the parent
-		// of the incoming block. We do not process the slot
-		// because it will be processed anyway in notifyForkchoiceUpdate
-		headState = s.headState(ctx)
-		headRoot = s.headRoot()
-		headBlock, err = s.headBlock()
-		if err != nil {
-			return errors.Wrap(err, "could not get head block")
-		}
+	}
+	headState, headBlock, err := s.getStateAndBlock(ctx, newHeadRoot)
+	if err != nil {
+		log.WithError(err).Error("Could not get forkchoice update argument")
+		return nil
 	}
 
 	_, err = s.notifyForkchoiceUpdate(ctx, &notifyForkchoiceUpdateArg{
 		headState: headState,
-		headRoot:  headRoot,
+		headRoot:  newHeadRoot,
 		headBlock: headBlock.Block(),
 	})
 	if err != nil {
 		return errors.Wrap(err, "could not notify forkchoice update")
 	}
 
-	if shouldUpdate {
-		if err := s.saveHead(ctx, newHeadRoot, headBlock, headState); err != nil {
-			log.WithError(err).Error("could not save head")
-		}
-
-		// Only need to prune attestations from pool if the head has changed.
-		if err := s.pruneAttsFromPool(headBlock); err != nil {
-			return err
-		}
+	if err := s.saveHead(ctx, newHeadRoot, headBlock, headState); err != nil {
+		log.WithError(err).Error("could not save head")
 	}
 
+	// Only need to prune attestations from pool if the head has changed.
+	if err := s.pruneAttsFromPool(headBlock); err != nil {
+		log.WithError(err).Error("could not prune attestations from pool")
+	}
 	return nil
 }

beacon-chain/blockchain/process_block.go

@@ -683,6 +683,8 @@ func (s *Service) fillMissingPayloadIDRoutine(ctx context.Context, stateFeed *ev
 	}()
 }
 
+// fillMissingBlockPayloadId is called 4 seconds into the slot and calls FCU if we are proposing next slot
+// and the cache has been missed
 func (s *Service) fillMissingBlockPayloadId(ctx context.Context) error {
 	s.ForkChoicer().RLock()
 	highestReceivedSlot := s.cfg.ForkChoiceStore.HighestReceivedBlockSlot()
@@ -700,6 +702,7 @@ func (s *Service) fillMissingBlockPayloadId(ctx context.Context) error {
 	s.headLock.RLock()
 	headBlock, err := s.headBlock()
 	if err != nil {
+		s.headLock.RUnlock()
 		return err
 	}
 	headState := s.headState(ctx)