Prefer checkpoint cache and NSC over head

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -56,7 +56,7 @@ type fcuConfig struct {
 // sendFCU handles the logic to notify the engine of a forckhoice update
 // when processing an incoming block during regular sync. It
 // always updates the shuffling caches and handles epoch transitions .
-func (s *Service) sendFCU(cfg *postBlockProcessConfig) {
+func (s *Service) sendFCU(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) {
 	if cfg.postState.Version() < version.Fulu {
 		// update the caches to compute the right proposer index
 		// this function is called under a forkchoice lock which we need to release.
@@ -64,8 +64,7 @@ func (s *Service) sendFCU(cfg *postBlockProcessConfig) {
 		s.updateCachesPostBlockProcessing(cfg)
 		s.ForkChoicer().Lock()
 	}
-	fcuArgs, err := s.getFCUArgs(cfg)
-	if err != nil {
+	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
 		log.WithError(err).Error("Could not get forkchoice update argument")
 		return
 	}

beacon-chain/blockchain/process_attestation_helpers.go

@@ -92,10 +92,6 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 // getAttPreState retrieves the att pre state by either from the cache or the DB.
 // The caller of this function must have a lock on forkchoice.
 func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (state.ReadOnlyBeaconState, error) {
-	// If the attestation is recent and canonical we can use the head state to compute the shuffling.
-	if st := s.getRecentPreState(ctx, c); st != nil {
-		return st, nil
-	}
 	// Use a multilock to allow scoped holding of a mutex by a checkpoint root + epoch
 	// allowing us to behave smarter in terms of how this function is used concurrently.
 	epochKey := strconv.FormatUint(uint64(c.Epoch), 10 /* base 10 */)
@@ -128,6 +124,10 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 		}
 		return cachedState, nil
 	}
+	// If the attestation is recent and canonical we can use the head state to compute the shuffling.
+	if st := s.getRecentPreState(ctx, c); st != nil {
+		return st, nil
+	}
 
 	// Do not process attestations for old non viable checkpoints otherwise
 	ok, err := s.cfg.ForkChoiceStore.IsViableForCheckpoint(&forkchoicetypes.Checkpoint{Root: [32]byte(c.Root), Epoch: c.Epoch})

beacon-chain/blockchain/process_block.go

@@ -64,6 +64,7 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		return invalidBlock{error: err}
 	}
 	startTime := time.Now()
+	fcuArgs := &fcuConfig{}
 
 	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
 		defer s.processLightClientUpdates(cfg)
@@ -101,9 +102,7 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		s.logNonCanonicalBlockReceived(cfg.roblock.Root(), cfg.headRoot)
 		return nil
 	}
-	if cfg.roblock.Version() <= version.Gloas {
-		s.sendFCU(cfg)
-	}
+	s.sendFCU(cfg, fcuArgs)
 
 	// Pre-Fulu the caches are updated when computing the payload attributes
 	if cfg.postState.Version() >= version.Fulu {

beacon-chain/blockchain/process_block_helpers.go

@@ -38,26 +38,23 @@ func (s *Service) CurrentSlot() primitives.Slot {
 }
 
 // getFCUArgs returns the arguments to call forkchoice update
-func (s *Service) getFCUArgs(cfg *postBlockProcessConfig) (*fcuConfig, error) {
-
-	fcuArgs, err := s.getFCUArgsEarlyBlock(cfg)
-	if err != nil {
-		return nil, err
+func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
+	if err := s.getFCUArgsEarlyBlock(cfg, fcuArgs); err != nil {
+		return err
 	}
 	fcuArgs.attributes = s.getPayloadAttribute(cfg.ctx, fcuArgs.headState, fcuArgs.proposingSlot, cfg.headRoot[:])
-	return fcuArgs, nil
+	return nil
 }
 
-func (s *Service) getFCUArgsEarlyBlock(cfg *postBlockProcessConfig) (*fcuConfig, error) {
+func (s *Service) getFCUArgsEarlyBlock(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
 	if cfg.roblock.Root() == cfg.headRoot {
-		return &fcuConfig{
-			headState:     cfg.postState,
-			headBlock:     cfg.roblock,
-			headRoot:      cfg.headRoot,
-			proposingSlot: s.CurrentSlot() + 1,
-		}, nil
+		fcuArgs.headState = cfg.postState
+		fcuArgs.headBlock = cfg.roblock
+		fcuArgs.headRoot = cfg.headRoot
+		fcuArgs.proposingSlot = s.CurrentSlot() + 1
+		return nil
 	}
-	return s.fcuArgsNonCanonicalBlock(cfg)
+	return s.fcuArgsNonCanonicalBlock(cfg, fcuArgs)
 }
 
 // logNonCanonicalBlockReceived prints a message informing that the received
@@ -82,17 +79,16 @@ func (s *Service) logNonCanonicalBlockReceived(blockRoot [32]byte, headRoot [32]
 
 // fcuArgsNonCanonicalBlock returns the arguments to the FCU call when the
 // incoming block is non-canonical, that is, based on the head root.
-func (s *Service) fcuArgsNonCanonicalBlock(cfg *postBlockProcessConfig) (*fcuConfig, error) {
+func (s *Service) fcuArgsNonCanonicalBlock(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
 	headState, headBlock, err := s.getStateAndBlock(cfg.ctx, cfg.headRoot)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	return &fcuConfig{
-		headState:     headState,
-		headBlock:     headBlock,
-		headRoot:      cfg.headRoot,
-		proposingSlot: s.CurrentSlot() + 1,
-	}, nil
+	fcuArgs.headState = headState
+	fcuArgs.headBlock = headBlock
+	fcuArgs.headRoot = cfg.headRoot
+	fcuArgs.proposingSlot = s.CurrentSlot() + 1
+	return nil
 }
 
 // sendStateFeedOnBlock sends an event that a new block has been synced

beacon-chain/blockchain/process_block_test.go

@@ -2417,12 +2417,14 @@ func Test_getFCUArgs(t *testing.T) {
 		isValidPayload: true,
 	}
 	// error branch
-	_, err = s.getFCUArgs(cfg)
+	fcuArgs := &fcuConfig{}
+	err = s.getFCUArgs(cfg, fcuArgs)
 	require.ErrorContains(t, "block does not exist", err)
 
 	// canonical branch
 	cfg.headRoot = cfg.roblock.Root()
-	fcuArgs, err := s.getFCUArgs(cfg)
+	fcuArgs = &fcuConfig{}
+	err = s.getFCUArgs(cfg, fcuArgs)
 	require.NoError(t, err)
 	require.Equal(t, cfg.roblock.Root(), fcuArgs.headRoot)
 }

changelog/potuz_gloas_post_block_process.md

@@ -1,2 +0,0 @@
-### Changed
-- Changed fcuArgs parameters passing and only call FCU pre-Gloas

changelog/potuz_prefer_cached_over_head.md

@@ -0,0 +1,2 @@
+### Changed
+- Prefer the cached epoch transition states and the NSC ones over head state for attestation verification.