Use bazel mirror due to expired cert

See https://github.com/DataDog/datadog-agent/pull/44621
and the original issue in
https://github.com/bazelbuild/bazel/issues/28101

.bazeliskrc

@@ -0,0 +1 @@
+BAZELISK_BASE_URL=https://github.com/bazelbuild/bazel/releases/download

.buildkite-bazelrc

@@ -32,6 +32,10 @@ import %workspace%/.bazelrc
 # startup --digest_function=blake3
 
 startup --host_jvm_args=-Xmx8g --host_jvm_args=-Xms4g
+
+# Disable bzlmod to avoid BCR registry access (certificate issues)
+common --noenable_bzlmod
+
 build --experimental_strict_action_env
 build --sandbox_tmpfs_path=/tmp
 build --verbose_failures

bazel.sh

@@ -8,4 +8,5 @@ env -i \
  PATH=/usr/bin:/bin \
  HOME="$HOME" \
  GOOGLE_APPLICATION_CREDENTIALS="$GOOGLE_APPLICATION_CREDENTIALS" \
+ BAZELISK_BASE_URL="https://github.com/bazelbuild/bazel/releases/download" \
  bazel "$@"

beacon-chain/blockchain/execution_engine_test.go

@@ -1053,3 +1053,40 @@ func TestKZGCommitmentToVersionedHashes(t *testing.T) {
 	require.Equal(t, vhs[0].String(), vh0)
 	require.Equal(t, vhs[1].String(), vh1)
 }
+
+func TestComputePayloadAttribute(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx := tr.ctx
+
+	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
+
+	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, Index: 0})
+	// Cache hit, advance state, no fee recipient
+	slot := primitives.Slot(1)
+	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+	blk := util.NewBeaconBlockBellatrix()
+	signed, err := consensusblocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	roblock, err := consensusblocks.NewROBlockWithRoot(signed, [32]byte{'a'})
+	require.NoError(t, err)
+	cfg := &postBlockProcessConfig{
+		ctx:     ctx,
+		roblock: roblock,
+	}
+	fcu := &fcuConfig{
+		headState:     st,
+		proposingSlot: slot,
+		headRoot:      [32]byte{},
+	}
+	require.NoError(t, service.computePayloadAttributes(cfg, fcu))
+	require.Equal(t, false, fcu.attributes.IsEmpty())
+	require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(fcu.attributes.SuggestedFeeRecipient()).String())
+
+	// Cache hit, advance state, has fee recipient
+	suggestedAddr := common.HexToAddress("123")
+	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, FeeRecipient: primitives.ExecutionAddress(suggestedAddr), Index: 0})
+	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+	require.NoError(t, service.computePayloadAttributes(cfg, fcu))
+	require.Equal(t, false, fcu.attributes.IsEmpty())
+	require.Equal(t, suggestedAddr, common.BytesToAddress(fcu.attributes.SuggestedFeeRecipient()))
+}

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -12,7 +12,6 @@ import (
 	payloadattribute "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attribute"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -54,53 +53,58 @@ 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, 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.
-		s.ForkChoicer().Unlock()
-		s.updateCachesPostBlockProcessing(cfg)
-		s.ForkChoicer().Lock()
+// for the first time when processing an incoming block during regular sync. It
+// always updates the shuffling caches and handles epoch transitions when the
+// incoming block is late, preparing payload attributes in this case while it
+// only sends a message with empty attributes for early blocks.
+func (s *Service) sendFCU(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
+	if !s.isNewHead(cfg.headRoot) {
+		return nil
 	}
-	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
-		log.WithError(err).Error("Could not get forkchoice update argument")
-		return
-	}
-	// If head has not been updated and attributes are nil, we can skip the FCU.
-	if !s.isNewHead(cfg.headRoot) && (fcuArgs.attributes == nil || fcuArgs.attributes.IsEmpty()) {
-		return
-	}
-	// If we are proposing and we aim to reorg the block, we have already sent FCU with attributes on lateBlockTasks
 	if fcuArgs.attributes != nil && !fcuArgs.attributes.IsEmpty() && s.shouldOverrideFCU(cfg.headRoot, s.CurrentSlot()+1) {
+		return nil
+	}
+	return s.forkchoiceUpdateWithExecution(cfg.ctx, fcuArgs)
+}
+
+// sendFCUWithAttributes computes the payload attributes and sends an FCU message
+// to the engine if needed
+func (s *Service) sendFCUWithAttributes(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) {
+	slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
+	defer cancel()
+	cfg.ctx = slotCtx
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	if err := s.computePayloadAttributes(cfg, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not compute payload attributes")
 		return
 	}
-	if s.inRegularSync() {
-		go s.forkchoiceUpdateWithExecution(cfg.ctx, fcuArgs)
+	if fcuArgs.attributes.IsEmpty() {
+		return
 	}
-
-	if s.isNewHead(fcuArgs.headRoot) {
-		if err := s.saveHead(cfg.ctx, fcuArgs.headRoot, fcuArgs.headBlock, fcuArgs.headState); err != nil {
-			log.WithError(err).Error("Could not save head")
-		}
-		s.pruneAttsFromPool(s.ctx, fcuArgs.headState, fcuArgs.headBlock)
+	if _, err := s.notifyForkchoiceUpdate(cfg.ctx, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not update forkchoice with payload attributes for proposal")
 	}
 }
 
-// fockchoiceUpdateWithExecution is a wrapper around notifyForkchoiceUpdate. It gets a forkchoice lock and calls the engine.
-// The caller of this function should NOT have a lock in forkchoice store.
-func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuConfig) {
+// fockchoiceUpdateWithExecution is a wrapper around notifyForkchoiceUpdate. It decides whether a new call to FCU should be made.
+func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuConfig) error {
 	_, span := trace.StartSpan(ctx, "beacon-chain.blockchain.forkchoiceUpdateWithExecution")
 	defer span.End()
 	// Note: Use the service context here to avoid the parent context being ended during a forkchoice update.
 	ctx = trace.NewContext(s.ctx, span)
-	s.ForkChoicer().Lock()
-	defer s.ForkChoicer().Unlock()
 	_, err := s.notifyForkchoiceUpdate(ctx, args)
 	if err != nil {
-		log.WithError(err).Error("Could not notify forkchoice update")
+		return errors.Wrap(err, "could not notify forkchoice update")
 	}
+
+	if err := s.saveHead(ctx, args.headRoot, args.headBlock, args.headState); err != nil {
+		log.WithError(err).Error("Could not save head")
+	}
+
+	// Only need to prune attestations from pool if the head has changed.
+	s.pruneAttsFromPool(s.ctx, args.headState, args.headBlock)
+	return nil
 }
 
 // shouldOverrideFCU checks whether the incoming block is still subject to being

beacon-chain/blockchain/forkchoice_update_execution_test.go

@@ -97,7 +97,7 @@ func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
 		headBlock:     wsb,
 		proposingSlot: service.CurrentSlot() + 1,
 	}
-	service.forkchoiceUpdateWithExecution(ctx, args)
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, args))
 
 	payloadID, has := service.cfg.PayloadIDCache.PayloadID(2, [32]byte{2})
 	require.Equal(t, true, has)
@@ -151,7 +151,7 @@ func TestService_forkchoiceUpdateWithExecution_SameHeadRootNewProposer(t *testin
 		headRoot:      r,
 		proposingSlot: service.CurrentSlot() + 1,
 	}
-	service.forkchoiceUpdateWithExecution(ctx, args)
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, args))
 }
 
 func TestShouldOverrideFCU(t *testing.T) {

beacon-chain/blockchain/process_attestation_helpers.go

@@ -22,7 +22,7 @@ import (
 // The caller of this function must have a lock on forkchoice.
 func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) state.ReadOnlyBeaconState {
 	headEpoch := slots.ToEpoch(s.HeadSlot())
-	if c.Epoch+1 < headEpoch || c.Epoch == 0 {
+	if c.Epoch < headEpoch || c.Epoch == 0 {
 		return nil
 	}
 	// Only use head state if the head state is compatible with the target checkpoint.
@@ -30,13 +30,11 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 	if err != nil {
 		return nil
 	}
-	// headEpoch - 1 equals c.Epoch if c is from the previous epoch and equals c.Epoch - 1 if c is from the current epoch.
-	// We don't use the smaller c.Epoch - 1 because forkchoice would not have the data to answer that.
-	headDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(headRoot), headEpoch-1)
+	headDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(headRoot), c.Epoch-1)
 	if err != nil {
 		return nil
 	}
-	targetDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(c.Root), headEpoch-1)
+	targetDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(c.Root), c.Epoch-1)
 	if err != nil {
 		return nil
 	}
@@ -45,7 +43,7 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 	}
 
 	// If the head state alone is enough, we can return it directly read only.
-	if c.Epoch <= headEpoch {
+	if c.Epoch == headEpoch {
 		st, err := s.HeadStateReadOnly(ctx)
 		if err != nil {
 			return nil

beacon-chain/blockchain/process_attestation_test.go

@@ -170,13 +170,12 @@ func TestService_GetRecentPreState(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, blk, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	service.head = &head{
 		root:  [32]byte(ckRoot),
 		state: s,
-		block: blk,
 		slot:  31,
 	}
 	require.NotNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 1, Root: ckRoot}))
@@ -198,13 +197,12 @@ func TestService_GetRecentPreState_Old_Checkpoint(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, blk, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, root, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	service.head = &head{
 		root:  [32]byte(ckRoot),
 		state: s,
-		block: blk,
 		slot:  33,
 	}
 	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{}))
@@ -229,7 +227,6 @@ func TestService_GetRecentPreState_Same_DependentRoots(t *testing.T) {
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 64, [32]byte{'T'}, blk.Root(), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
-	headBlock := blk
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 33, [32]byte{'U'}, [32]byte(ckRoot), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
@@ -238,9 +235,8 @@ func TestService_GetRecentPreState_Same_DependentRoots(t *testing.T) {
 
 	service.head = &head{
 		root:  [32]byte{'T'},
-		block: headBlock,
-		slot:  64,
 		state: s,
+		slot:  64,
 	}
 	require.NotNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 2, Root: cpRoot[:]}))
 }
@@ -267,7 +263,6 @@ func TestService_GetRecentPreState_Different_DependentRoots(t *testing.T) {
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 64, [32]byte{'U'}, blk.Root(), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
-	headBlock := blk
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
 	st, blk, err = prepareForkchoiceState(ctx, 33, [32]byte{'V'}, [32]byte(ckRoot), [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
@@ -275,8 +270,7 @@ func TestService_GetRecentPreState_Different_DependentRoots(t *testing.T) {
 	cpRoot := blk.Root()
 
 	service.head = &head{
-		root:  [32]byte{'U'},
-		block: headBlock,
+		root:  [32]byte{'T'},
 		state: s,
 		slot:  64,
 	}
@@ -293,13 +287,12 @@ func TestService_GetRecentPreState_Different(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, blk, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, root, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	service.head = &head{
 		root:  [32]byte(ckRoot),
 		state: s,
-		block: blk,
 		slot:  33,
 	}
 	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{}))

beacon-chain/blockchain/process_block.go

@@ -66,6 +66,9 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	startTime := time.Now()
 	fcuArgs := &fcuConfig{}
 
+	if s.inRegularSync() {
+		defer s.handleSecondFCUCall(cfg, fcuArgs)
+	}
 	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
 		defer s.processLightClientUpdates(cfg)
 	}
@@ -102,17 +105,14 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		s.logNonCanonicalBlockReceived(cfg.roblock.Root(), cfg.headRoot)
 		return nil
 	}
-	s.sendFCU(cfg, fcuArgs)
-
-	// Pre-Fulu the caches are updated when computing the payload attributes
-	if cfg.postState.Version() >= version.Fulu {
-		go func() {
-			ctx, cancel := context.WithTimeout(s.ctx, slotDeadline)
-			defer cancel()
-			cfg.ctx = ctx
-			s.updateCachesPostBlockProcessing(cfg)
-		}()
+	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not get forkchoice update argument")
+		return nil
 	}
+	if err := s.sendFCU(cfg, fcuArgs); err != nil {
+		return errors.Wrap(err, "could not send FCU to engine")
+	}
+
 	return nil
 }
 
@@ -295,6 +295,14 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 			return errors.Wrap(err, "could not set optimistic block to valid")
 		}
 	}
+	arg := &fcuConfig{
+		headState: preState,
+		headRoot:  lastBR,
+		headBlock: lastB,
+	}
+	if _, err := s.notifyForkchoiceUpdate(ctx, arg); err != nil {
+		return err
+	}
 	return s.saveHeadNoDB(ctx, lastB, lastBR, preState, !isValidPayload)
 }
 
@@ -322,7 +330,6 @@ func (s *Service) areSidecarsAvailable(ctx context.Context, avs das.Availability
 	return nil
 }
 
-// the caller of this function must not hold a lock in forkchoice store.
 func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.BeaconState) error {
 	e := coreTime.CurrentEpoch(st)
 	if err := helpers.UpdateCommitteeCache(ctx, st, e); err != nil {
@@ -352,9 +359,7 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 	if e > 0 {
 		e = e - 1
 	}
-	s.ForkChoicer().RLock()
 	target, err := s.cfg.ForkChoiceStore.TargetRootForEpoch(r, e)
-	s.ForkChoicer().RUnlock()
 	if err != nil {
 		log.WithError(err).Error("Could not update proposer index state-root map")
 		return nil
@@ -367,7 +372,7 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 }
 
 // Epoch boundary tasks: it copies the headState and updates the epoch boundary
-// caches. The caller of this function must not hold a lock in forkchoice store.
+// caches.
 func (s *Service) handleEpochBoundary(ctx context.Context, slot primitives.Slot, headState state.BeaconState, blockRoot []byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.handleEpochBoundary")
 	defer span.End()
@@ -907,6 +912,8 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if currentSlot == s.HeadSlot() {
 		return
 	}
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
 	// return early if we are in init sync
 	if !s.inRegularSync() {
 		return
@@ -919,32 +926,14 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if lastState == nil {
 		lastRoot, lastState = headRoot[:], headState
 	}
-	// Before Fulu we need to process the next slot to find out if we are proposing.
-	if lastState.Version() < version.Fulu {
-		// Copy all the field tries in our cached state in the event of late
-		// blocks.
-		lastState.CopyAllTries()
-		if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
-			log.WithError(err).Debug("Could not update next slot state cache")
-		}
-		if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
-			log.WithError(err).Error("Could not update epoch boundary caches")
-		}
-	} else {
-		// After Fulu, we can update the caches asynchronously after sending FCU to the engine
-		defer func() {
-			go func() {
-				ctx, cancel := context.WithTimeout(s.ctx, slotDeadline)
-				defer cancel()
-				lastState.CopyAllTries()
-				if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
-					log.WithError(err).Debug("Could not update next slot state cache")
-				}
-				if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
-					log.WithError(err).Error("Could not update epoch boundary caches")
-				}
-			}()
-		}()
+	// Copy all the field tries in our cached state in the event of late
+	// blocks.
+	lastState.CopyAllTries()
+	if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
+		log.WithError(err).Debug("Could not update next slot state cache")
+	}
+	if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
+		log.WithError(err).Error("Could not update epoch boundary caches")
 	}
 	// return early if we already started building a block for the current
 	// head root
@@ -974,8 +963,6 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 		headBlock:  headBlock,
 		attributes: attribute,
 	}
-	s.cfg.ForkChoiceStore.Lock()
-	defer s.cfg.ForkChoiceStore.Unlock()
 	_, err = s.notifyForkchoiceUpdate(ctx, fcuArgs)
 	if err != nil {
 		log.WithError(err).Debug("could not perform late block tasks: failed to update forkchoice with engine")

beacon-chain/blockchain/process_block_helpers.go

@@ -42,8 +42,14 @@ func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) er
 	if err := s.getFCUArgsEarlyBlock(cfg, fcuArgs); err != nil {
 		return err
 	}
-	fcuArgs.attributes = s.getPayloadAttribute(cfg.ctx, fcuArgs.headState, fcuArgs.proposingSlot, cfg.headRoot[:])
-	return nil
+	if !s.inRegularSync() {
+		return nil
+	}
+	slot := cfg.roblock.Block().Slot()
+	if slots.WithinVotingWindow(s.genesisTime, slot) {
+		return nil
+	}
+	return s.computePayloadAttributes(cfg, fcuArgs)
 }
 
 func (s *Service) getFCUArgsEarlyBlock(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
@@ -167,19 +173,26 @@ func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {
 
 // updateCachesPostBlockProcessing updates the next slot cache and handles the epoch
 // boundary in order to compute the right proposer indices after processing
-// state transition. The caller of this function must not hold a lock in forkchoice store.
-func (s *Service) updateCachesPostBlockProcessing(cfg *postBlockProcessConfig) {
+// state transition. This function is called on late blocks while still locked,
+// before sending FCU to the engine.
+func (s *Service) updateCachesPostBlockProcessing(cfg *postBlockProcessConfig) error {
 	slot := cfg.postState.Slot()
 	root := cfg.roblock.Root()
 	if err := transition.UpdateNextSlotCache(cfg.ctx, root[:], cfg.postState); err != nil {
-		log.WithError(err).Error("Could not update next slot state cache")
-		return
+		return errors.Wrap(err, "could not update next slot state cache")
 	}
 	if !slots.IsEpochEnd(slot) {
-		return
+		return nil
 	}
-	if err := s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, root[:]); err != nil {
-		log.WithError(err).Error("Could not handle epoch boundary")
+	return s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, root[:])
+}
+
+// handleSecondFCUCall handles a second call to FCU when syncing a new block.
+// This is useful when proposing in the next block and we want to defer the
+// computation of the next slot shuffling.
+func (s *Service) handleSecondFCUCall(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) {
+	if (fcuArgs.attributes == nil || fcuArgs.attributes.IsEmpty()) && cfg.headRoot == cfg.roblock.Root() {
+		go s.sendFCUWithAttributes(cfg, fcuArgs)
 	}
 }
 
@@ -189,6 +202,20 @@ func reportProcessingTime(startTime time.Time) {
 	onBlockProcessingTime.Observe(float64(time.Since(startTime).Milliseconds()))
 }
 
+// computePayloadAttributes modifies the passed FCU arguments to
+// contain the right payload attributes with the tracked proposer. It gets
+// called on blocks that arrive after the attestation voting window, or in a
+// background routine after syncing early blocks.
+func (s *Service) computePayloadAttributes(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
+	if cfg.roblock.Root() == cfg.headRoot {
+		if err := s.updateCachesPostBlockProcessing(cfg); err != nil {
+			return err
+		}
+	}
+	fcuArgs.attributes = s.getPayloadAttribute(cfg.ctx, fcuArgs.headState, fcuArgs.proposingSlot, cfg.headRoot[:])
+	return nil
+}
+
 // getBlockPreState returns the pre state of an incoming block. It uses the parent root of the block
 // to retrieve the state in DB. It verifies the pre state's validity and the incoming block
 // is in the correct time window.

beacon-chain/blockchain/process_block_test.go

@@ -738,9 +738,7 @@ func TestOnBlock_CanFinalize_WithOnTick(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -790,9 +788,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -820,9 +816,25 @@ func TestOnBlock_NilBlock(t *testing.T) {
 	service, tr := minimalTestService(t)
 	signed := &consensusblocks.SignedBeaconBlock{}
 	roblock := consensusblocks.ROBlock{ReadOnlySignedBeaconBlock: signed}
-	service.cfg.ForkChoiceStore.Lock()
 	err := service.postBlockProcess(&postBlockProcessConfig{tr.ctx, roblock, [32]byte{}, nil, true})
-	service.cfg.ForkChoiceStore.Unlock()
+	require.Equal(t, true, IsInvalidBlock(err))
+}
+
+func TestOnBlock_InvalidSignature(t *testing.T) {
+	service, tr := minimalTestService(t)
+	ctx := tr.ctx
+
+	gs, keys := util.DeterministicGenesisState(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+
+	blk, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 1)
+	require.NoError(t, err)
+	blk.Signature = []byte{'a'} // Mutate the signature.
+	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	preState, err := service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	_, err = service.validateStateTransition(ctx, preState, wsb)
 	require.Equal(t, true, IsInvalidBlock(err))
 }
 
@@ -854,9 +866,7 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -1329,9 +1339,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb1, r1)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1343,9 +1351,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb2, r2)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1357,9 +1363,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb3, r3)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1371,9 +1375,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb4, r4)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1398,6 +1400,197 @@ func Test_verifyBlkFinalizedSlot_invalidBlock(t *testing.T) {
 	require.Equal(t, true, IsInvalidBlock(err))
 }
 
+// See the description in #10777 and #10782 for the full setup
+// We sync optimistically a chain of blocks. Block 17 is the last block in Epoch
+// 2. Block 18 justifies block 12 (the first in Epoch 2) and Block 19 returns
+// INVALID from FCU, with LVH block 17. No head is viable. We check
+// that the node is optimistic and that we can actually import a block on top of
+// 17 and recover.
+func TestStore_NoViableHead_FCU(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.SlotsPerEpoch = 6
+	config.AltairForkEpoch = 1
+	config.BellatrixForkEpoch = 2
+	params.OverrideBeaconConfig(config)
+
+	mockEngine := &mockExecution.EngineClient{ErrNewPayload: execution.ErrAcceptedSyncingPayloadStatus, ErrForkchoiceUpdated: execution.ErrAcceptedSyncingPayloadStatus}
+	service, tr := minimalTestService(t, WithExecutionEngineCaller(mockEngine))
+	ctx := tr.ctx
+
+	st, keys := util.DeterministicGenesisState(t, 64)
+	stateRoot, err := st.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	require.NoError(t, service.saveGenesisData(ctx, st))
+
+	genesis := blocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
+
+	parentRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
+	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
+
+	for i := 1; i < 6; i++ {
+		driftGenesisTime(service, primitives.Slot(i), 0)
+		st, err := service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
+		require.NoError(t, err)
+		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		root, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+
+		preState, err := service.getBlockPreState(ctx, wsb.Block())
+		require.NoError(t, err)
+		postState, err := service.validateStateTransition(ctx, preState, wsb)
+		require.NoError(t, err)
+		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
+		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
+		require.NoError(t, err)
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+	}
+
+	for i := 6; i < 12; i++ {
+		driftGenesisTime(service, primitives.Slot(i), 0)
+		st, err := service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlockAltair(st, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
+		require.NoError(t, err)
+		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		root, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		preState, err := service.getBlockPreState(ctx, wsb.Block())
+		require.NoError(t, err)
+		postState, err := service.validateStateTransition(ctx, preState, wsb)
+		require.NoError(t, err)
+		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
+		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
+		require.NoError(t, err)
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
+	}
+
+	for i := 12; i < 18; i++ {
+		driftGenesisTime(service, primitives.Slot(i), 0)
+		st, err := service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlockBellatrix(st, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
+		require.NoError(t, err)
+		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		root, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		preState, err := service.getBlockPreState(ctx, wsb.Block())
+		require.NoError(t, err)
+		postState, err := service.validateStateTransition(ctx, preState, wsb)
+		require.NoError(t, err)
+		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
+		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
+		require.NoError(t, err)
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
+	}
+	// Check that we haven't justified the second epoch yet
+	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
+	require.Equal(t, primitives.Epoch(0), jc.Epoch)
+
+	// import a block that justifies the second epoch
+	driftGenesisTime(service, 18, 0)
+	validHeadState, err := service.HeadState(ctx)
+	require.NoError(t, err)
+	b, err := util.GenerateFullBlockBellatrix(validHeadState, keys, util.DefaultBlockGenConfig(), 18)
+	require.NoError(t, err)
+	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	firstInvalidRoot, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	preState, err := service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	postState, err := service.validateStateTransition(ctx, preState, wsb)
+	require.NoError(t, err)
+	require.NoError(t, service.savePostStateInfo(ctx, firstInvalidRoot, wsb, postState))
+	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, firstInvalidRoot)
+	require.NoError(t, err)
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	require.NoError(t, err)
+	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
+	require.Equal(t, primitives.Epoch(2), jc.Epoch)
+
+	sjc := validHeadState.CurrentJustifiedCheckpoint()
+	require.Equal(t, primitives.Epoch(0), sjc.Epoch)
+	lvh := b.Block.Body.ExecutionPayload.ParentHash
+	// check our head
+	require.Equal(t, firstInvalidRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
+
+	// import another block to find out that it was invalid
+	mockEngine = &mockExecution.EngineClient{ErrNewPayload: execution.ErrAcceptedSyncingPayloadStatus, ErrForkchoiceUpdated: execution.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: lvh}
+	service.cfg.ExecutionEngineCaller = mockEngine
+	driftGenesisTime(service, 19, 0)
+	st, err = service.HeadState(ctx)
+	require.NoError(t, err)
+	b, err = util.GenerateFullBlockBellatrix(st, keys, util.DefaultBlockGenConfig(), 19)
+	require.NoError(t, err)
+	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	root, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	preState, err = service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	postState, err = service.validateStateTransition(ctx, preState, wsb)
+	require.NoError(t, err)
+	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
+	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
+	require.NoError(t, err)
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
+	// Check that forkchoice's head is the last invalid block imported. The
+	// store's headroot is the previous head (since the invalid block did
+	// not finish importing) one and that the node is optimistic
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
+	headRoot, err := service.HeadRoot(ctx)
+	require.NoError(t, err)
+	require.Equal(t, firstInvalidRoot, bytesutil.ToBytes32(headRoot))
+	optimistic, err := service.IsOptimistic(ctx)
+	require.NoError(t, err)
+	require.Equal(t, true, optimistic)
+
+	// import another block based on the last valid head state
+	mockEngine = &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = mockEngine
+	driftGenesisTime(service, 20, 0)
+	b, err = util.GenerateFullBlockBellatrix(validHeadState, keys, &util.BlockGenConfig{}, 20)
+	require.NoError(t, err)
+	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	root, err = b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	preState, err = service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	postState, err = service.validateStateTransition(ctx, preState, wsb)
+	require.NoError(t, err)
+	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
+	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
+	require.NoError(t, err)
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
+	require.NoError(t, err)
+	// Check the newly imported block is head, it justified the right
+	// checkpoint and the node is no longer optimistic
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
+	sjc = service.CurrentJustifiedCheckpt()
+	require.Equal(t, jc.Epoch, sjc.Epoch)
+	require.Equal(t, jc.Root, bytesutil.ToBytes32(sjc.Root))
+	optimistic, err = service.IsOptimistic(ctx)
+	require.NoError(t, err)
+	require.Equal(t, false, optimistic)
+}
+
 // See the description in #10777 and #10782 for the full setup
 // We sync optimistically a chain of blocks. Block 17 is the last block in Epoch
 // 2. Block 18 justifies block 12 (the first in Epoch 2) and Block 19 returns
@@ -1449,9 +1642,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1471,9 +1662,8 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}
 
 	for i := 12; i < 18; i++ {
@@ -1494,9 +1684,8 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
 	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
@@ -1519,9 +1708,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, firstInvalidRoot, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, firstInvalidRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
@@ -1531,10 +1718,6 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	lvh := b.Block.Body.ExecutionPayload.ParentHash
 	// check our head
 	require.Equal(t, firstInvalidRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
-	isBlock18OptimisticAfterImport, err := service.IsOptimisticForRoot(ctx, firstInvalidRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, isBlock18OptimisticAfterImport)
-	time.Sleep(20 * time.Millisecond) // wait for async forkchoice update to be processed
 
 	// import another block to find out that it was invalid
 	mockEngine = &mockExecution.EngineClient{ErrNewPayload: execution.ErrInvalidPayloadStatus, NewPayloadResp: lvh}
@@ -1585,9 +1768,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
@@ -1654,9 +1835,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1677,9 +1856,8 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}
 
 	// import the merge block
@@ -1699,9 +1877,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, lastValidRoot, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, lastValidRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1730,9 +1906,8 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, invalidRoots[i-13], wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, invalidRoots[i-13])
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}
 	// Check that we have justified the second epoch
 	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
@@ -1800,9 +1975,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-	service.cfg.ForkChoiceStore.Unlock()
 	// Check that the head is still INVALID and the node is still optimistic
 	require.Equal(t, invalidHeadRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	optimistic, err = service.IsOptimistic(ctx)
@@ -1827,9 +2000,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, err)
 		st, err = service.cfg.StateGen.StateByRoot(ctx, root)
 		require.NoError(t, err)
@@ -1857,9 +2028,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	sjc = service.CurrentJustifiedCheckpt()
@@ -1903,6 +2072,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, genesisRoot), "Could not save genesis state")
 
 	for i := 1; i < 6; i++ {
+		t.Log(i)
 		driftGenesisTime(service, primitives.Slot(i), 0)
 		st, err := service.HeadState(ctx)
 		require.NoError(t, err)
@@ -1919,9 +2089,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 	}
 
 	for i := 6; i < 12; i++ {
@@ -1941,9 +2109,8 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}
 
 	// import the merge block
@@ -1963,9 +2130,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, lastValidRoot, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, lastValidRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1996,9 +2161,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -2119,9 +2282,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
@@ -2187,9 +2348,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
@@ -2472,10 +2631,7 @@ func TestRollbackBlock(t *testing.T) {
 	require.NoError(t, err)
 
 	// Rollback block insertion into db and caches.
-	service.cfg.ForkChoiceStore.Lock()
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
-	require.ErrorContains(t, fmt.Sprintf("could not insert block %d to fork choice store", roblock.Block().Slot()), err)
+	require.ErrorContains(t, fmt.Sprintf("could not insert block %d to fork choice store", roblock.Block().Slot()), service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
 
 	// The block should no longer exist.
 	require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, root))
@@ -2576,9 +2732,7 @@ func TestRollbackBlock_ContextDeadline(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-	service.cfg.ForkChoiceStore.Unlock()
 
 	b, err = util.GenerateFullBlock(postState, keys, util.DefaultBlockGenConfig(), 34)
 	require.NoError(t, err)
@@ -2612,10 +2766,7 @@ func TestRollbackBlock_ContextDeadline(t *testing.T) {
 	require.NoError(t, postState.SetFinalizedCheckpoint(cj))
 
 	// Rollback block insertion into db and caches.
-	service.cfg.ForkChoiceStore.Lock()
-	err = service.postBlockProcess(&postBlockProcessConfig{cancCtx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
-	require.ErrorContains(t, "context canceled", err)
+	require.ErrorContains(t, "context canceled", service.postBlockProcess(&postBlockProcessConfig{cancCtx, roblock, [32]byte{}, postState, false}))
 
 	// The block should no longer exist.
 	require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, root))
@@ -3111,9 +3262,7 @@ func Test_postBlockProcess_EventSending(t *testing.T) {
 			}
 
 			// Execute postBlockProcess
-			service.cfg.ForkChoiceStore.Lock()
 			err = service.postBlockProcess(cfg)
-			service.cfg.ForkChoiceStore.Unlock()
 
 			// Check error expectation
 			if tt.expectError {

beacon-chain/blockchain/receive_attestation.go

@@ -156,15 +156,13 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 	}
 	if s.inRegularSync() {
 		fcuArgs.attributes = s.getPayloadAttribute(ctx, headState, proposingSlot, newHeadRoot[:])
-		if fcuArgs.attributes != nil && s.shouldOverrideFCU(newHeadRoot, proposingSlot) {
-			return
-		}
-		go s.forkchoiceUpdateWithExecution(s.ctx, fcuArgs)
 	}
-	if err := s.saveHead(s.ctx, fcuArgs.headRoot, fcuArgs.headBlock, fcuArgs.headState); err != nil {
-		log.WithError(err).Error("Could not save head")
+	if fcuArgs.attributes != nil && s.shouldOverrideFCU(newHeadRoot, proposingSlot) {
+		return
+	}
+	if err := s.forkchoiceUpdateWithExecution(s.ctx, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not update forkchoice")
 	}
-	s.pruneAttsFromPool(s.ctx, fcuArgs.headState, fcuArgs.headBlock)
 }
 
 // This processes fork choice attestations from the pool to account for validator votes and fork choice.

beacon-chain/blockchain/receive_attestation_test.go

@@ -117,9 +117,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
 	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-	service.cfg.ForkChoiceStore.Unlock()
 	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
 	require.NoError(t, err)
 	require.Equal(t, 2, fcs.NodeCount())
@@ -179,9 +177,7 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
 	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-	service.cfg.ForkChoiceStore.Unlock()
 	require.Equal(t, 2, fcs.NodeCount())
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	require.Equal(t, tRoot, service.head.root)

beacon-chain/core/altair/BUILD.bazel

@@ -19,7 +19,6 @@ go_library(
         "//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/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
@@ -17,7 +16,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/attestation"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/pkg/errors"
 )
 
@@ -77,12 +75,7 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	beaconState, err = gloas.UpdatePendingPaymentWeight(beaconState, att, indices, participatedFlags)
-	if err != nil {
-		return nil, err
-	}
-
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance, att)
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards
@@ -112,9 +105,7 @@ func SetParticipationAndRewardProposer(
 	beaconState state.BeaconState,
 	targetEpoch primitives.Epoch,
 	indices []uint64,
-	participatedFlags map[uint8]bool,
-	totalBalance uint64,
-	att ethpb.Att) (state.BeaconState, error) {
+	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
 	var proposerRewardNumerator uint64
 	currentEpoch := time.CurrentEpoch(beaconState)
 	var stateErr error
@@ -308,40 +299,6 @@ func AttestationParticipationFlagIndices(beaconState state.ReadOnlyBeaconState,
 		participatedFlags[targetFlagIndex] = true
 	}
 	matchedSrcTgtHead := matchedHead && matchedSrcTgt
-
-	// Spec v1.6.1 (pseudocode excerpt):
-	//
-	//	# [New in Gloas:EIP7732]
-	//	if is_attestation_same_slot(state, data):
-	//	    assert data.index == 0
-	//	    payload_matches = True
-	//	else:
-	//	    slot_index = data.slot % SLOTS_PER_HISTORICAL_ROOT
-	//	    payload_index = state.execution_payload_availability[slot_index]
-	//	    payload_matches = data.index == payload_index
-	//
-	//	# [Modified in Gloas:EIP7732]
-	//	is_matching_head = is_matching_target and head_root_matches and payload_matches
-	var matchingPayload bool
-	if beaconState.Version() >= version.Gloas {
-		ok, err := gloas.SameSlotAttestation(beaconState, [32]byte(data.BeaconBlockRoot), data.Slot)
-		if err != nil {
-			return nil, err
-		}
-		if ok {
-			if data.CommitteeIndex != 0 {
-				return nil, fmt.Errorf("committee index %d for same slot attestation must be 0", data.CommitteeIndex)
-			}
-			matchingPayload = true
-		} else {
-			executionPayloadAvail, err := beaconState.ExecutionPayloadAvailability(data.Slot)
-			if err != nil {
-				return nil, err
-			}
-			matchingPayload = executionPayloadAvail == uint64(data.CommitteeIndex)
-		}
-		matchedSrcTgtHead = matchedSrcTgtHead && matchingPayload
-	}
 	if matchedSrcTgtHead && delay == cfg.MinAttestationInclusionDelay {
 		participatedFlags[headFlagIndex] = true
 	}

beacon-chain/core/altair/attestation_test.go

@@ -1,9 +1,7 @@
 package altair_test
 
 import (
-	"bytes"
 	"fmt"
-	"reflect"
 	"testing"
 
 	"github.com/OffchainLabs/go-bitfield"
@@ -558,7 +556,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 
 			b, err := helpers.TotalActiveBalance(beaconState)
 			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b, &ethpb.Attestation{})
+			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
 			require.NoError(t, err)
 
 			i, err := helpers.BeaconProposerIndex(t.Context(), st)
@@ -777,67 +775,11 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 				headFlagIndex:   true,
 			},
 		},
-		{
-			name: "gloas same-slot committee index non-zero errors",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				prevRoot := bytes.Repeat([]byte{0xCC}, 32)
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, prevRoot, 0, 0)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1, // invalid for same-slot
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay:           1,
-			participationIndices: nil,
-		},
-		{
-			name: "gloas payload availability matches committee index",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				// Same prev root to make SameSlotAttestation false and use payload availability.
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, headRoot, 1, slot)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay: 1,
-			participationIndices: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   true,
-			},
-		},
 	}
 	for _, test := range tests {
 		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
-		if test.participationIndices == nil {
-			require.ErrorContains(t, "committee index", err)
-			continue
-		}
 		require.NoError(t, err)
-		if !reflect.DeepEqual(test.participationIndices, flagIndices) {
-			t.Fatalf("unexpected participation indices: got %v want %v", flagIndices, test.participationIndices)
-		}
+		require.DeepEqual(t, test.participationIndices, flagIndices)
 	}
 }
 
@@ -916,61 +858,3 @@ func TestMatchingStatus(t *testing.T) {
 		require.Equal(t, test.matchedHead, head)
 	}
 }
-
-func buildGloasStateForFlags(t *testing.T, stateSlot, slot primitives.Slot, targetRoot, headRoot, prevRoot []byte, availabilityBit uint8, availabilitySlot primitives.Slot) state.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	blockRoots[0] = targetRoot
-	blockRoots[slot%cfg.SlotsPerHistoricalRoot] = headRoot
-	blockRoots[(slot-1)%cfg.SlotsPerHistoricalRoot] = prevRoot
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-	idx := availabilitySlot % cfg.SlotsPerHistoricalRoot
-	byteIndex := idx / 8
-	bitIndex := idx % 8
-	if availabilityBit == 1 {
-		execPayloadAvailability[byteIndex] |= 1 << bitIndex
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xDD}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Root: checkpointRoot}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return beaconState
-}

beacon-chain/core/blocks/attestation.go

@@ -111,16 +111,7 @@ func VerifyAttestationNoVerifySignature(
 	var indexedAtt ethpb.IndexedAtt
 
 	if att.Version() >= version.Electra {
-		// Spec v1.6.1 (pseudocode excerpt):
-		//
-		//	# [Modified in Gloas:EIP7732]
-		//	assert data.index < 2
-		//
-		if beaconState.Version() >= version.Gloas {
-			if att.GetData().CommitteeIndex >= 2 {
-				return fmt.Errorf("incorrect committee index %d", att.GetData().CommitteeIndex)
-			}
-		} else if att.GetData().CommitteeIndex != 0 {
+		if att.GetData().CommitteeIndex != 0 {
 			return errors.New("committee index must be 0 post-Electra")
 		}
 

beacon-chain/core/blocks/attestation_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"bytes"
 	"context"
 	"testing"
 
@@ -315,75 +314,6 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 	})
 }
 
-func TestVerifyAttestationNoVerifySignature_GloasCommitteeIndexLimit(t *testing.T) {
-	cfg := params.BeaconConfig()
-	stateSlot := cfg.MinAttestationInclusionDelay + 1
-
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xAA}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Epoch: 0, Root: checkpointRoot}
-
-	gloasStateProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: make([]byte, cfg.SlotsPerHistoricalRoot/8),
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(gloasStateProto)
-	require.NoError(t, err)
-
-	committeeBits := bitfield.NewBitvector64()
-	committeeBits.SetBitAt(0, true)
-	aggBits := bitfield.NewBitlist(1)
-	aggBits.SetBitAt(0, true)
-
-	att := &ethpb.AttestationElectra{
-		Data: &ethpb.AttestationData{
-			Slot:            0,
-			CommitteeIndex:  2, // invalid for Gloas (must be <2)
-			BeaconBlockRoot: blockRoots[0],
-			Source:          justified,
-			Target:          justified,
-		},
-		AggregationBits: aggBits,
-		CommitteeBits:   committeeBits,
-		Signature:       bytes.Repeat([]byte{0x00}, fieldparams.BLSSignatureLength),
-	}
-
-	err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
-	assert.ErrorContains(t, "incorrect committee index 2", err)
-}
-
 func TestConvertToIndexed_OK(t *testing.T) {
 	helpers.ClearCache()
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)

beacon-chain/core/blocks/header_test.go

@@ -290,3 +290,52 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	}
 	assert.Equal(t, true, proto.Equal(nsh, expected), "Expected %v, received %v", expected, nsh)
 }
+
+func TestBlockSignatureSet_OK(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := range validators {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	state, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(10))
+	require.NoError(t, state.SetLatestBlockHeader(util.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot:          9,
+		ProposerIndex: 0,
+	})))
+
+	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
+	require.NoError(t, err)
+
+	currentEpoch := time.CurrentEpoch(state)
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
+	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
+	require.NoError(t, err)
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 10
+	block.Block.ProposerIndex = pID
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = latestBlockSignedRoot[:]
+	block.Signature, err = signing.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)
+	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), state)
+	require.NoError(t, err)
+	validators[proposerIdx].Slashed = false
+	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
+	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
+	require.NoError(t, err)
+	set, err := blocks.BlockSignatureBatch(state, block.Block.ProposerIndex, block.Signature, block.Block.HashTreeRoot)
+	require.NoError(t, err)
+
+	verified, err := set.Verify()
+	require.NoError(t, err)
+	assert.Equal(t, true, verified, "Block signature set returned a set which was unable to be verified")
+}

beacon-chain/core/blocks/signature.go

@@ -122,6 +122,24 @@ func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState,
 	return nil
 }
 
+// BlockSignatureBatch retrieves the block signature batch from the provided block and its corresponding state.
+func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
+	proposerIndex primitives.ValidatorIndex,
+	sig []byte,
+	rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
+	currentEpoch := slots.ToEpoch(beaconState.Slot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
+	if err != nil {
+		return nil, err
+	}
+	proposer, err := beaconState.ValidatorAtIndex(proposerIndex)
+	if err != nil {
+		return nil, err
+	}
+	proposerPubKey := proposer.PublicKey
+	return signing.BlockSignatureBatch(proposerPubKey, sig, domain, rootFunc)
+}
+
 // RandaoSignatureBatch retrieves the relevant randao specific signature batch object
 // from a block and its corresponding state.
 func RandaoSignatureBatch(

beacon-chain/core/gloas/BUILD.bazel

@@ -1,31 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["attestation.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["attestation_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)

beacon-chain/core/gloas/attestation.go

@@ -1,144 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-// SameSlotAttestation checks if the attestation is for the same slot as the block root in the state.
-// Spec v1.6.1 (pseudocode excerpt):
-//
-//	is_attestation_same_slot(state, data):
-//	    block_root_at_slot = get_block_root_at_slot(state, data.slot)
-//	    block_root_at_prev_slot = get_block_root_at_slot(state, data.slot - 1)
-//	    return block_root_at_slot == data.beacon_block_root and block_root_at_prev_slot != data.beacon_block_root
-func SameSlotAttestation(state state.ReadOnlyBeaconState, blockRoot [32]byte, slot primitives.Slot) (bool, error) {
-	if slot == 0 {
-		return true, nil
-	}
-
-	blockRootAtSlot, err := helpers.BlockRootAtSlot(state, slot)
-	if err != nil {
-		return false, err
-	}
-	matchingBlockRoot := bytes.Equal(blockRoot[:], blockRootAtSlot)
-
-	blockRootAtPrevSlot, err := helpers.BlockRootAtSlot(state, slot-1)
-	if err != nil {
-		return false, err
-	}
-	matchingPrevBlockRoot := bytes.Equal(blockRoot[:], blockRootAtPrevSlot)
-
-	return matchingBlockRoot && !matchingPrevBlockRoot, nil
-}
-
-// UpdatePendingPaymentWeight updates the builder pending payment weight based on attestation participation.
-// Spec v1.6.1 (pseudocode excerpt):
-//
-//	if data.target.epoch == get_current_epoch(state):
-//	    epoch_participation = state.current_epoch_participation
-//	    payment = state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH]
-//	else:
-//	    epoch_participation = state.previous_epoch_participation
-//	    payment = state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH]
-//
-//	for index in get_attesting_indices(state, attestation):
-//	    will_set_new_flag = False
-//	    for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
-//	        if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
-//	            epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-//	            proposer_reward_numerator += get_base_reward(state, index) * weight
-//	            will_set_new_flag = True
-//	    if will_set_new_flag and is_attestation_same_slot(state, data) and payment.withdrawal.amount > 0:
-//	        payment.weight += state.validators[index].effective_balance
-//
-//	if current_epoch_target:
-//	    state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH] = payment
-//	else:
-//	    state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH] = payment
-func UpdatePendingPaymentWeight(beaconState state.BeaconState, att ethpb.Att, indices []uint64, participatedFlags map[uint8]bool) (state.BeaconState, error) {
-	if beaconState.Version() < version.Gloas {
-		return beaconState, nil
-	}
-
-	data := att.GetData()
-	epoch := slots.ToEpoch(beaconState.Slot())
-
-	isSameSlot, err := SameSlotAttestation(beaconState, [32]byte(data.BeaconBlockRoot), data.Slot)
-	if err != nil {
-		return nil, err
-	}
-	if !isSameSlot {
-		return beaconState, nil
-	}
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	var (
-		paymentSlot        primitives.Slot
-		payment            *ethpb.BuilderPendingPayment
-		epochParticipation []byte
-	)
-	if data.Target.Epoch == epoch {
-		paymentSlot = slotsPerEpoch + (data.Slot % slotsPerEpoch)
-		payment, err = beaconState.BuilderPendingPayment(uint64(paymentSlot))
-		if err != nil {
-			return nil, err
-		}
-		epochParticipation, err = beaconState.CurrentEpochParticipation()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		paymentSlot = data.Slot % slotsPerEpoch
-		payment, err = beaconState.BuilderPendingPayment(uint64(paymentSlot))
-		if err != nil {
-			return nil, err
-		}
-		epochParticipation, err = beaconState.PreviousEpochParticipation()
-		if err != nil {
-			return nil, err
-		}
-	}
-	if payment.Withdrawal.Amount == 0 {
-		return beaconState, nil
-	}
-
-	cfg := params.BeaconConfig()
-	flagIndices := []uint8{cfg.TimelySourceFlagIndex, cfg.TimelyTargetFlagIndex, cfg.TimelyHeadFlagIndex}
-	hasNewFlag := func(idx uint64) bool {
-		participation := epochParticipation[idx]
-		for _, f := range flagIndices {
-			if !participatedFlags[f] {
-				continue
-			}
-			if participation&(1<<f) == 0 {
-				return true
-			}
-		}
-		return false
-	}
-
-	for _, idx := range indices {
-		if !hasNewFlag(idx) {
-			continue
-		}
-		validator, err := beaconState.ValidatorAtIndex(primitives.ValidatorIndex(idx))
-		if err != nil {
-			return nil, err
-		}
-		payment.Weight += primitives.Gwei(validator.EffectiveBalance)
-	}
-
-	if err := beaconState.SetBuilderPendingPayment(uint64(paymentSlot), payment); err != nil {
-		return nil, err
-	}
-
-	return beaconState, nil
-}

beacon-chain/core/gloas/attestation_test.go

@@ -1,288 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-func buildStateWithBlockRoots(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = bytes.Repeat([]byte{0x11}, 32)
-	}
-
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = bytes.Repeat([]byte{0x22}, 32)
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  stateSlot,
-		GenesisValidatorsRoot: bytes.Repeat([]byte{0x33}, 32),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x44}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x44}, 4),
-			Epoch:           0,
-		},
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		Validators:                   []*ethpb.Validator{},
-		Balances:                     []uint64{},
-		BuilderPendingPayments:       make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		BuilderPendingWithdrawals:    []*ethpb.BuilderPendingWithdrawal{},
-	}
-
-	state, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return state.(*state_native.BeaconState)
-}
-
-func TestSameSlotAttestation(t *testing.T) {
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-	rootC := bytes.Repeat([]byte{0xCC}, 32)
-
-	tests := []struct {
-		name      string
-		stateSlot primitives.Slot
-		slot      primitives.Slot
-		blockRoot []byte
-		roots     map[primitives.Slot][]byte
-		want      bool
-	}{
-		{
-			name:      "slot zero always true",
-			stateSlot: 1,
-			slot:      0,
-			blockRoot: rootA,
-			roots:     map[primitives.Slot][]byte{},
-			want:      true,
-		},
-		{
-			name:      "matching current different previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: true,
-		},
-		{
-			name:      "matching current same previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootA,
-			},
-			want: false,
-		},
-		{
-			name:      "non matching current",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootC,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			state := buildStateWithBlockRoots(t, tt.stateSlot, tt.roots)
-			var rootArr [32]byte
-			copy(rootArr[:], tt.blockRoot)
-
-			got, err := SameSlotAttestation(state, rootArr, tt.slot)
-			require.NoError(t, err)
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func buildStateForPaymentTest(t *testing.T, stateSlot primitives.Slot, paymentIdx int, amount primitives.Gwei, weight primitives.Gwei, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = bytes.Repeat([]byte{0x44}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = bytes.Repeat([]byte{0x55}, 32)
-	}
-
-	validator := &ethpb.Validator{
-		PublicKey:             bytes.Repeat([]byte{0x01}, 48),
-		WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x02}, 31)...),
-		EffectiveBalance:      cfg.MinActivationBalance,
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-	payments[paymentIdx] = &ethpb.BuilderPendingPayment{
-		Weight: weight,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-			Amount:       amount,
-		},
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x33}, 32),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		Validators:                   []*ethpb.Validator{validator},
-		Balances:                     []uint64{cfg.MinActivationBalance},
-		CurrentEpochParticipation:    []byte{0},
-		PreviousEpochParticipation:   []byte{0},
-		BuilderPendingPayments:       payments,
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
-			Epoch:           0,
-		},
-	}
-
-	state, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return state.(*state_native.BeaconState)
-}
-
-func TestUpdatePendingPaymentWeight(t *testing.T) {
-	cfg := params.BeaconConfig()
-	slotsPerEpoch := cfg.SlotsPerEpoch
-	slot := primitives.Slot(4)
-	stateSlot := slot + 1
-	currentEpoch := slots.ToEpoch(stateSlot)
-
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-
-	tests := []struct {
-		name          string
-		targetEpoch   primitives.Epoch
-		blockRoot     []byte
-		initialAmount primitives.Gwei
-		initialWeight primitives.Gwei
-		wantWeight    primitives.Gwei
-	}{
-		{
-			name:          "same slot current epoch adds weight",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootA,
-			initialAmount: 10,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-		{
-			name:          "same slot zero amount no weight change",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootA,
-			initialAmount: 0,
-			initialWeight: 5,
-			wantWeight:    5,
-		},
-		{
-			name:          "non matching block root no change",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootB,
-			initialAmount: 10,
-			initialWeight: 7,
-			wantWeight:    7,
-		},
-		{
-			name:          "previous epoch target uses earlier slot",
-			targetEpoch:   currentEpoch - 1,
-			blockRoot:     rootA,
-			initialAmount: 20,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			var paymentIdx int
-			if tt.targetEpoch == currentEpoch {
-				paymentIdx = int(slotsPerEpoch + (slot % slotsPerEpoch))
-			} else {
-				paymentIdx = int(slot % slotsPerEpoch)
-			}
-			state := buildStateForPaymentTest(t, stateSlot, paymentIdx, tt.initialAmount, tt.initialWeight, map[primitives.Slot][]byte{
-				slot:     tt.blockRoot,
-				slot - 1: rootB,
-			})
-
-			att := &ethpb.Attestation{
-				Data: &ethpb.AttestationData{
-					Slot:            slot,
-					CommitteeIndex:  0,
-					BeaconBlockRoot: tt.blockRoot,
-					Source:          &ethpb.Checkpoint{},
-					Target: &ethpb.Checkpoint{
-						Epoch: tt.targetEpoch,
-					},
-				},
-			}
-
-			participatedFlags := map[uint8]bool{
-				cfg.TimelySourceFlagIndex: true,
-				cfg.TimelyTargetFlagIndex: true,
-				cfg.TimelyHeadFlagIndex:   true,
-			}
-			indices := []uint64{0}
-
-			gotState, err := UpdatePendingPaymentWeight(state, att, indices, participatedFlags)
-			require.NoError(t, err)
-
-			payment, err := gotState.BuilderPendingPayment(uint64(paymentIdx))
-			require.NoError(t, err)
-			require.Equal(t, tt.wantWeight, payment.Weight)
-		})
-	}
-}

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -182,6 +182,12 @@ func ProcessBlockNoVerifyAnySig(
 		return nil, nil, err
 	}
 
+	sig := signed.Signature()
+	bSet, err := b.BlockSignatureBatch(st, blk.ProposerIndex(), sig[:], blk.HashTreeRoot)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return nil, nil, errors.Wrap(err, "could not retrieve block signature set")
+	}
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	rSet, err := b.RandaoSignatureBatch(ctx, st, randaoReveal[:])
 	if err != nil {
@@ -195,7 +201,7 @@ func ProcessBlockNoVerifyAnySig(
 
 	// Merge beacon block, randao and attestations signatures into a set.
 	set := bls.NewSet()
-	set.Join(rSet).Join(aSet)
+	set.Join(bSet).Join(rSet).Join(aSet)
 
 	if blk.Version() >= version.Capella {
 		changes, err := signed.Block().Body().BLSToExecutionChanges()

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -157,8 +157,9 @@ func TestProcessBlockNoVerify_SigSetContainsDescriptions(t *testing.T) {
 	set, _, err := transition.ProcessBlockNoVerifyAnySig(t.Context(), beaconState, wsb)
 	require.NoError(t, err)
 	assert.Equal(t, len(set.Signatures), len(set.Descriptions), "Signatures and descriptions do not match up")
-	assert.Equal(t, "randao signature", set.Descriptions[0])
-	assert.Equal(t, "attestation signature", set.Descriptions[1])
+	assert.Equal(t, "block signature", set.Descriptions[0])
+	assert.Equal(t, "randao signature", set.Descriptions[1])
+	assert.Equal(t, "attestation signature", set.Descriptions[2])
 }
 
 func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {

beacon-chain/das/needs.go

@@ -67,9 +67,9 @@ func NewSyncNeeds(current CurrentSlotter, oldestSlotFlagPtr *primitives.Slot, bl
 
 	// Override spec minimum block retention with user-provided flag only if it is lower than the spec minimum.
 	sn.blockRetention = primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-
 	if oldestSlotFlagPtr != nil {
-		if *oldestSlotFlagPtr <= syncEpochOffset(current(), sn.blockRetention) {
+		oldestEpoch := slots.ToEpoch(*oldestSlotFlagPtr)
+		if oldestEpoch < sn.blockRetention {
 			sn.validOldestSlotPtr = oldestSlotFlagPtr
 		} else {
 			log.WithField("backfill-oldest-slot", *oldestSlotFlagPtr).

beacon-chain/das/needs_test.go

@@ -128,9 +128,6 @@ func TestSyncNeedsInitialize(t *testing.T) {
 	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
 	minBlobEpochs := params.BeaconConfig().MinEpochsForBlobsSidecarsRequest
 	minColEpochs := params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest
-	denebSlot := slots.UnsafeEpochStart(params.BeaconConfig().DenebForkEpoch)
-	fuluSlot := slots.UnsafeEpochStart(params.BeaconConfig().FuluForkEpoch)
-	minSlots := slots.UnsafeEpochStart(primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests))
 
 	currentSlot := primitives.Slot(10000)
 	currentFunc := func() primitives.Slot { return currentSlot }
@@ -144,7 +141,6 @@ func TestSyncNeedsInitialize(t *testing.T) {
 		expectedCol       primitives.Epoch
 		name              string
 		input             SyncNeeds
-		current           func() primitives.Slot
 	}{
 		{
 			name:              "basic initialization with no flags",
@@ -178,13 +174,13 @@ func TestSyncNeedsInitialize(t *testing.T) {
 		{
 			name:              "valid oldestSlotFlagPtr (earlier than spec minimum)",
 			blobRetentionFlag: 0,
-			oldestSlotFlagPtr: &denebSlot,
+			oldestSlotFlagPtr: func() *primitives.Slot {
+				slot := primitives.Slot(10)
+				return &slot
+			}(),
 			expectValidOldest: true,
 			expectedBlob:      minBlobEpochs,
 			expectedCol:       minColEpochs,
-			current: func() primitives.Slot {
-				return fuluSlot + minSlots
-			},
 		},
 		{
 			name:              "invalid oldestSlotFlagPtr (later than spec minimum)",
@@ -214,9 +210,6 @@ func TestSyncNeedsInitialize(t *testing.T) {
 		{
 			name:              "both blob retention flag and oldest slot set",
 			blobRetentionFlag: minBlobEpochs + 5,
-			current: func() primitives.Slot {
-				return fuluSlot + minSlots
-			},
 			oldestSlotFlagPtr: func() *primitives.Slot {
 				slot := primitives.Slot(100)
 				return &slot
@@ -239,27 +232,16 @@ func TestSyncNeedsInitialize(t *testing.T) {
 			expectedBlob:      5000,
 			expectedCol:       5000,
 		},
-		{
-			name:              "regression for deneb start",
-			blobRetentionFlag: 8212500,
-			expectValidOldest: true,
-			oldestSlotFlagPtr: &denebSlot,
-			current: func() primitives.Slot {
-				return fuluSlot + minSlots
-			},
-			expectedBlob: 8212500,
-			expectedCol:  8212500,
-		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			if tc.current == nil {
-				tc.current = currentFunc
-			}
-			result, err := NewSyncNeeds(tc.current, tc.oldestSlotFlagPtr, tc.blobRetentionFlag)
+			result, err := NewSyncNeeds(currentFunc, tc.oldestSlotFlagPtr, tc.blobRetentionFlag)
 			require.NoError(t, err)
 
+			// Check that current, deneb, fulu are set correctly
+			require.Equal(t, currentSlot, result.current())
+
 			// Check retention calculations
 			require.Equal(t, tc.expectedBlob, result.blobRetention)
 			require.Equal(t, tc.expectedCol, result.colRetention)

beacon-chain/db/filesystem/BUILD.bazel

@@ -38,7 +38,6 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_spf13_afero//:go_default_library",
-        "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )
 

beacon-chain/db/filesystem/data_column.go

@@ -25,7 +25,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
 	"github.com/spf13/afero"
-	"golang.org/x/sync/errgroup"
 )
 
 const (
@@ -186,162 +185,73 @@ func (dcs *DataColumnStorage) WarmCache() {
 
 	highestStoredEpoch := primitives.Epoch(0)
 
-	// List all period directories
-	periodFileInfos, err := afero.ReadDir(dcs.fs, ".")
-	if err != nil {
-		log.WithError(err).Error("Error reading top directory during warm cache")
-		return
-	}
-
-	// Iterate through periods
-	for _, periodFileInfo := range periodFileInfos {
-		if !periodFileInfo.IsDir() {
-			continue
+	// Walk the data column filesystem to warm up the cache.
+	if err := afero.Walk(dcs.fs, ".", func(path string, info os.FileInfo, fileErr error) (err error) {
+		if fileErr != nil {
+			return fileErr
 		}
 
-		periodPath := periodFileInfo.Name()
+		// If not a leaf, skip.
+		if info.IsDir() {
+			return nil
+		}
 
-		// List all epoch directories in this period
-		epochFileInfos, err := afero.ReadDir(dcs.fs, periodPath)
+		// Extract metadata from the file path.
+		fileMetadata, err := extractFileMetadata(path)
 		if err != nil {
-			log.WithError(err).WithField("period", periodPath).Error("Error reading period directory during warm cache")
-			continue
+			log.WithError(err).Error("Error encountered while extracting file metadata")
+			return nil
 		}
 
-		// Iterate through epochs
-		for _, epochFileInfo := range epochFileInfos {
-			if !epochFileInfo.IsDir() {
-				continue
-			}
-
-			epochPath := path.Join(periodPath, epochFileInfo.Name())
-
-			// List all .sszs files in this epoch
-			files, err := listEpochFiles(dcs.fs, epochPath)
-			if err != nil {
-				log.WithError(err).WithField("epoch", epochPath).Error("Error listing epoch files during warm cache")
-				continue
-			}
-
-			if len(files) == 0 {
-				continue
-			}
-
-			// Process all files in this epoch in parallel
-			epochHighest, err := dcs.processEpochFiles(files)
-			if err != nil {
-				log.WithError(err).WithField("epoch", epochPath).Error("Error processing epoch files during warm cache")
-			}
-
-			highestStoredEpoch = max(highestStoredEpoch, epochHighest)
+		// Open the data column filesystem file.
+		f, err := dcs.fs.Open(path)
+		if err != nil {
+			log.WithError(err).Error("Error encountered while opening data column filesystem file")
+			return nil
 		}
+
+		// Close the file.
+		defer func() {
+			// Overwrite the existing error only if it is nil, since the close error is less important.
+			closeErr := f.Close()
+			if closeErr != nil && err == nil {
+				err = closeErr
+			}
+		}()
+
+		// Read the metadata of the file.
+		metadata, err := dcs.metadata(f)
+		if err != nil {
+			log.WithError(err).Error("Error encountered while reading metadata from data column filesystem file")
+			return nil
+		}
+
+		// Check the indices.
+		indices := metadata.indices.all()
+		if len(indices) == 0 {
+			return nil
+		}
+
+		// Build the ident.
+		dataColumnsIdent := DataColumnsIdent{Root: fileMetadata.blockRoot, Epoch: fileMetadata.epoch, Indices: indices}
+
+		// Update the highest stored epoch.
+		highestStoredEpoch = max(highestStoredEpoch, fileMetadata.epoch)
+
+		// Set the ident in the cache.
+		if err := dcs.cache.set(dataColumnsIdent); err != nil {
+			log.WithError(err).Error("Error encountered while ensuring data column filesystem cache")
+		}
+
+		return nil
+	}); err != nil {
+		log.WithError(err).Error("Error encountered while walking data column filesystem.")
 	}
 
-	// Prune the cache and the filesystem
+	// Prune the cache and the filesystem.
 	dcs.prune()
 
-	totalElapsed := time.Since(start)
-
-	// Log summary
-	log.WithField("elapsed", totalElapsed).Info("Data column filesystem cache warm-up complete")
-}
-
-// listEpochFiles lists all .sszs files in an epoch directory.
-func listEpochFiles(fs afero.Fs, epochPath string) ([]string, error) {
-	fileInfos, err := afero.ReadDir(fs, epochPath)
-	if err != nil {
-		return nil, errors.Wrap(err, "read epoch directory")
-	}
-
-	files := make([]string, 0, len(fileInfos))
-	for _, fileInfo := range fileInfos {
-		if fileInfo.IsDir() {
-			continue
-		}
-
-		fileName := fileInfo.Name()
-		if strings.HasSuffix(fileName, "."+dataColumnsFileExtension) {
-			files = append(files, path.Join(epochPath, fileName))
-		}
-	}
-
-	return files, nil
-}
-
-// processEpochFiles processes all .sszs files in an epoch directory in parallel.
-func (dcs *DataColumnStorage) processEpochFiles(files []string) (primitives.Epoch, error) {
-	var (
-		eg errgroup.Group
-		mu sync.Mutex
-	)
-
-	highestEpoch := primitives.Epoch(0)
-	for _, filePath := range files {
-		eg.Go(func() error {
-			epoch, err := dcs.processFile(filePath)
-			if err != nil {
-				log.WithError(err).WithField("file", filePath).Error("Error processing file during warm cache")
-				return nil
-			}
-
-			mu.Lock()
-			defer mu.Unlock()
-			highestEpoch = max(highestEpoch, epoch)
-
-			return nil
-		})
-	}
-
-	if err := eg.Wait(); err != nil {
-		return highestEpoch, err
-	}
-
-	return highestEpoch, nil
-}
-
-// processFile processes a single .sszs file.
-func (dcs *DataColumnStorage) processFile(filePath string) (primitives.Epoch, error) {
-	// Extract metadata from the file path
-	fileMetadata, err := extractFileMetadata(filePath)
-	if err != nil {
-		return 0, errors.Wrap(err, "extract file metadata")
-	}
-
-	// Open the file (each goroutine gets its own FD)
-	f, err := dcs.fs.Open(filePath)
-	if err != nil {
-		return 0, errors.Wrap(err, "open file")
-	}
-	defer func() {
-		if closeErr := f.Close(); closeErr != nil {
-			log.WithError(closeErr).WithField("file", filePath).Error("Error closing file during warm cache")
-		}
-	}()
-
-	// Read metadata
-	metadata, err := dcs.metadata(f)
-	if err != nil {
-		return 0, errors.Wrap(err, "read metadata")
-	}
-
-	// Extract indices
-	indices := metadata.indices.all()
-	if len(indices) == 0 {
-		return fileMetadata.epoch, nil // No indices, skip
-	}
-
-	// Build ident and set in cache (thread-safe)
-	dataColumnsIdent := DataColumnsIdent{
-		Root:    fileMetadata.blockRoot,
-		Epoch:   fileMetadata.epoch,
-		Indices: indices,
-	}
-
-	if err := dcs.cache.set(dataColumnsIdent); err != nil {
-		return 0, errors.Wrap(err, "cache set")
-	}
-
-	return fileMetadata.epoch, nil
+	log.WithField("elapsed", time.Since(start)).Info("Data column filesystem cache warm-up complete")
 }
 
 // Summary returns the DataColumnStorageSummary.

beacon-chain/rpc/eth/beacon/handlers.go

@@ -14,7 +14,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
-	coreblocks "github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	corehelpers "github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filters"
@@ -958,13 +957,6 @@ func (s *Server) validateConsensus(ctx context.Context, b *eth.GenericSignedBeac
 			}
 		}
 	}
-	blockRoot, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not hash block")
-	}
-	if err := coreblocks.VerifyBlockSignatureUsingCurrentFork(parentState, blk, blockRoot); err != nil {
-		return errors.Wrap(err, "could not verify block signature")
-	}
 	_, err = transition.ExecuteStateTransition(ctx, parentState, blk)
 	if err != nil {
 		return errors.Wrap(err, "could not execute state transition")

beacon-chain/state/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "error.go",
         "interfaces.go",
-        "interfaces_gloas.go",
         "prometheus.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/state",

beacon-chain/state/interfaces.go

@@ -63,7 +63,6 @@ type ReadOnlyBeaconState interface {
 	ReadOnlyDeposits
 	ReadOnlyConsolidations
 	ReadOnlyProposerLookahead
-	readOnlyGloasFields
 	ToProtoUnsafe() any
 	ToProto() any
 	GenesisTime() time.Time
@@ -99,7 +98,6 @@ type WriteOnlyBeaconState interface {
 	WriteOnlyWithdrawals
 	WriteOnlyDeposits
 	WriteOnlyProposerLookahead
-	writeOnlyGloasFields
 	SetGenesisTime(val time.Time) error
 	SetGenesisValidatorsRoot(val []byte) error
 	SetSlot(val primitives.Slot) error

beacon-chain/state/interfaces_gloas.go

@@ -1,15 +0,0 @@
-package state
-
-import (
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-type writeOnlyGloasFields interface {
-	SetBuilderPendingPayment(index uint64, payment *ethpb.BuilderPendingPayment) error
-}
-
-type readOnlyGloasFields interface {
-	BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error)
-	ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error)
-}

beacon-chain/state/state-native/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
         "getters_deposits.go",
         "getters_eth1.go",
         "getters_exit.go",
-        "getters_gloas.go",
         "getters_misc.go",
         "getters_participation.go",
         "getters_payload_header.go",
@@ -37,7 +36,6 @@ go_library(
         "setters_deposit_requests.go",
         "setters_deposits.go",
         "setters_eth1.go",
-        "setters_gloas.go",
         "setters_misc.go",
         "setters_participation.go",
         "setters_payload_header.go",

beacon-chain/state/state-native/getters_gloas.go

@@ -1,42 +0,0 @@
-package state_native
-
-import (
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-)
-
-// BuilderPendingPayment returns the builder pending payment for the given index.
-func (b *BeaconState) BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("BuilderPendingPayment", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.builderPendingPayments[index], nil
-}
-
-// ExecutionPayloadAvailability returns the execution payload availability bit for the given slot.
-func (b *BeaconState) ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error) {
-	if b.version < version.Gloas {
-		return 0, errNotSupported("ExecutionPayloadAvailability", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.executionPayloadAvailability == nil {
-		return 0, nil
-	}
-
-	slotIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
-	byteIndex := slotIndex / 8
-	bitIndex := slotIndex % 8
-
-	bit := (b.executionPayloadAvailability[byteIndex] >> bitIndex) & 1
-
-	return uint64(bit), nil
-}

beacon-chain/state/state-native/setters_gloas.go

@@ -1,22 +0,0 @@
-package state_native
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-)
-
-// SetBuilderPendingPayment sets a builder pending payment at the specified slot.
-func (b *BeaconState) SetBuilderPendingPayment(index uint64, payment *ethpb.BuilderPendingPayment) error {
-	if b.version < version.Gloas {
-		return errNotSupported("SetBuilderPendingPayment", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.builderPendingPayments[index] = ethpb.CopyBuilderPendingPayment(payment)
-
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-	return nil
-}

beacon-chain/sync/validate_data_column.go

@@ -3,12 +3,11 @@ package sync
 import (
 	"context"
 	"fmt"
-	"slices"
+	"math"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -193,13 +192,19 @@ func (s *Service) validateDataColumn(ctx context.Context, pid peer.ID, msg *pubs
 	dataColumnSidecarArrivalGossipSummary.Observe(float64(sinceSlotStartTime.Milliseconds()))
 	dataColumnSidecarVerificationGossipHistogram.Observe(float64(validationTime.Milliseconds()))
 
+	peerGossipScore := s.cfg.p2p.Peers().Scorers().GossipScorer().Score(pid)
+
 	select {
 	case s.dataColumnLogCh <- dataColumnLogEntry{
-		slot:           roDataColumn.Slot(),
-		index:          roDataColumn.Index,
-		root:           roDataColumn.BlockRoot(),
-		validationTime: validationTime,
-		sinceStartTime: sinceSlotStartTime,
+		Slot:            roDataColumn.Slot(),
+		ColIdx:          roDataColumn.Index,
+		PropIdx:         roDataColumn.ProposerIndex(),
+		BlockRoot:       roDataColumn.BlockRoot(),
+		ParentRoot:      roDataColumn.ParentRoot(),
+		PeerSuffix:      pid.String()[len(pid.String())-6:],
+		PeerGossipScore: peerGossipScore,
+		validationTime:  validationTime,
+		sinceStartTime:  sinceSlotStartTime,
 	}:
 	default:
 		log.WithField("slot", roDataColumn.Slot()).Warn("Failed to send data column log entry")
@@ -244,69 +249,68 @@ func computeCacheKey(slot primitives.Slot, proposerIndex primitives.ValidatorInd
 }
 
 type dataColumnLogEntry struct {
-	slot           primitives.Slot
-	index          uint64
-	root           [32]byte
-	validationTime time.Duration
-	sinceStartTime time.Duration
+	Slot            primitives.Slot
+	ColIdx          uint64
+	PropIdx         primitives.ValidatorIndex
+	BlockRoot       [32]byte
+	ParentRoot      [32]byte
+	PeerSuffix      string
+	PeerGossipScore float64
+	validationTime  time.Duration
+	sinceStartTime  time.Duration
 }
 
 func (s *Service) processDataColumnLogs() {
 	ticker := time.NewTicker(1 * time.Second)
-	slotStats := make(map[[fieldparams.RootLength]byte][]dataColumnLogEntry)
+	defer ticker.Stop()
+
+	slotStats := make(map[primitives.Slot][fieldparams.NumberOfColumns]dataColumnLogEntry)
 
 	for {
 		select {
-		case col := <-s.dataColumnLogCh:
-			cols := slotStats[col.root]
-			cols = append(cols, col)
-			slotStats[col.root] = cols
+		case entry := <-s.dataColumnLogCh:
+			cols := slotStats[entry.Slot]
+			cols[entry.ColIdx] = entry
+			slotStats[entry.Slot] = cols
 		case <-ticker.C:
-			for root, columns := range slotStats {
-				indices := make([]uint64, 0, fieldparams.NumberOfColumns)
-				minValidationTime, maxValidationTime, sumValidationTime := time.Duration(0), time.Duration(0), time.Duration(0)
-				minSinceStartTime, maxSinceStartTime, sumSinceStartTime := time.Duration(0), time.Duration(0), time.Duration(0)
+			for slot, columns := range slotStats {
+				var (
+					colIndices      = make([]uint64, 0, fieldparams.NumberOfColumns)
+					peers           = make([]string, 0, fieldparams.NumberOfColumns)
+					gossipScores    = make([]float64, 0, fieldparams.NumberOfColumns)
+					validationTimes = make([]string, 0, fieldparams.NumberOfColumns)
+					sinceStartTimes = make([]string, 0, fieldparams.NumberOfColumns)
+				)
 
 				totalReceived := 0
-				for _, column := range columns {
-					indices = append(indices, column.index)
-
-					sumValidationTime += column.validationTime
-					sumSinceStartTime += column.sinceStartTime
-
-					if totalReceived == 0 {
-						minValidationTime, maxValidationTime = column.validationTime, column.validationTime
-						minSinceStartTime, maxSinceStartTime = column.sinceStartTime, column.sinceStartTime
-						totalReceived++
+				for _, entry := range columns {
+					if entry.PeerSuffix == "" {
 						continue
 					}
-
-					minValidationTime, maxValidationTime = min(minValidationTime, column.validationTime), max(maxValidationTime, column.validationTime)
-					minSinceStartTime, maxSinceStartTime = min(minSinceStartTime, column.sinceStartTime), max(maxSinceStartTime, column.sinceStartTime)
+					colIndices = append(colIndices, entry.ColIdx)
+					peers = append(peers, entry.PeerSuffix)
+					gossipScores = append(gossipScores, roundFloat(entry.PeerGossipScore, 2))
+					validationTimes = append(validationTimes, fmt.Sprintf("%.2fms", float64(entry.validationTime.Milliseconds())))
+					sinceStartTimes = append(sinceStartTimes, fmt.Sprintf("%.2fms", float64(entry.sinceStartTime.Milliseconds())))
 					totalReceived++
 				}
 
-				if totalReceived > 0 {
-					slices.Sort(indices)
-					avgValidationTime := sumValidationTime / time.Duration(totalReceived)
-					avgSinceStartTime := sumSinceStartTime / time.Duration(totalReceived)
-
-					log.WithFields(logrus.Fields{
-						"slot":           columns[0].slot,
-						"root":           fmt.Sprintf("%#x", root),
-						"count":          totalReceived,
-						"indices":        helpers.PrettySlice(indices),
-						"validationTime": prettyMinMaxAverage(minValidationTime, maxValidationTime, avgValidationTime),
-						"sinceStartTime": prettyMinMaxAverage(minSinceStartTime, maxSinceStartTime, avgSinceStartTime),
-					}).Debug("Accepted data column sidecars summary")
-				}
+				log.WithFields(logrus.Fields{
+					"slot":            slot,
+					"receivedCount":   totalReceived,
+					"columnIndices":   colIndices,
+					"peers":           peers,
+					"gossipScores":    gossipScores,
+					"validationTimes": validationTimes,
+					"sinceStartTimes": sinceStartTimes,
+				}).Debug("Accepted data column sidecars summary")
 			}
-
-			slotStats = make(map[[fieldparams.RootLength]byte][]dataColumnLogEntry)
+			slotStats = make(map[primitives.Slot][fieldparams.NumberOfColumns]dataColumnLogEntry)
 		}
 	}
 }
 
-func prettyMinMaxAverage(min, max, average time.Duration) string {
-	return fmt.Sprintf("[min: %v, avg: %v, max: %v]", min, average, max)
+func roundFloat(f float64, decimals int) float64 {
+	mult := math.Pow(10, float64(decimals))
+	return math.Round(f*mult) / mult
 }

beacon-chain/verification/blob_test.go

@@ -687,12 +687,6 @@ func sbrNotFound(t *testing.T, expectedRoot [32]byte) *mockStateByRooter {
 	}}
 }
 
-func sbrReturnsState(st state.BeaconState) *mockStateByRooter {
-	return &mockStateByRooter{sbr: func(_ context.Context, _ [32]byte) (state.BeaconState, error) {
-		return st, nil
-	}}
-}
-
 func sbrForValOverride(idx primitives.ValidatorIndex, val *ethpb.Validator) *mockStateByRooter {
 	return sbrForValOverrideWithT(nil, idx, val)
 }

beacon-chain/verification/data_column.go

@@ -11,10 +11,12 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
+	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/runtime/logging"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
@@ -482,19 +484,88 @@ func (dv *RODataColumnsVerifier) SidecarProposerExpected(ctx context.Context) (e
 
 	defer dv.recordResult(RequireSidecarProposerExpected, &err)
 
-	for _, dataColumn := range dv.dataColumns {
-		dataColumnSlot := dataColumn.Slot()
+	type slotParentRoot struct {
+		slot       primitives.Slot
+		parentRoot [fieldparams.RootLength]byte
+	}
 
-		// Get the verifying state, it is guaranteed to have the correct proposer in the lookahead.
-		verifyingState, err := dv.getVerifyingState(ctx, dataColumn)
-		if err != nil {
-			return columnErrBuilder(errors.Wrap(err, "verifying state"))
+	targetRootBySlotParentRoot := make(map[slotParentRoot][fieldparams.RootLength]byte)
+
+	var targetRootFromCache = func(slot primitives.Slot, parentRoot [fieldparams.RootLength]byte) ([fieldparams.RootLength]byte, error) {
+		// Use cached values if available.
+		slotParentRoot := slotParentRoot{slot: slot, parentRoot: parentRoot}
+		if root, ok := targetRootBySlotParentRoot[slotParentRoot]; ok {
+			return root, nil
 		}
 
-		// Use proposer lookahead directly
-		idx, err := helpers.BeaconProposerIndexAtSlot(ctx, verifyingState, dataColumnSlot)
+		// Compute the epoch of the data column slot.
+		dataColumnEpoch := slots.ToEpoch(slot)
+		if dataColumnEpoch > 0 {
+			dataColumnEpoch = dataColumnEpoch - 1
+		}
+
+		// Compute the target root for the epoch.
+		targetRoot, err := dv.fc.TargetRootForEpoch(parentRoot, dataColumnEpoch)
 		if err != nil {
-			return columnErrBuilder(errors.Wrap(err, "proposer from lookahead"))
+			return [fieldparams.RootLength]byte{}, columnErrBuilder(errors.Wrap(err, "target root from epoch"))
+		}
+
+		// Store the target root in the cache.
+		targetRootBySlotParentRoot[slotParentRoot] = targetRoot
+
+		return targetRoot, nil
+	}
+
+	for _, dataColumn := range dv.dataColumns {
+		// Extract the slot of the data column.
+		dataColumnSlot := dataColumn.Slot()
+
+		// Extract the root of the parent block corresponding to the data column.
+		parentRoot := dataColumn.ParentRoot()
+
+		// Compute the target root for the data column.
+		targetRoot, err := targetRootFromCache(dataColumnSlot, parentRoot)
+		if err != nil {
+			return columnErrBuilder(errors.Wrap(err, "target root"))
+		}
+
+		// Compute the epoch of the data column slot.
+		dataColumnEpoch := slots.ToEpoch(dataColumnSlot)
+		if dataColumnEpoch > 0 {
+			dataColumnEpoch = dataColumnEpoch - 1
+		}
+
+		// Create a checkpoint for the target root.
+		checkpoint := &forkchoicetypes.Checkpoint{Root: targetRoot, Epoch: dataColumnEpoch}
+
+		// Try to extract the proposer index from the data column in the cache.
+		idx, cached := dv.pc.Proposer(checkpoint, dataColumnSlot)
+
+		if !cached {
+			parentRoot := dataColumn.ParentRoot()
+			// Ensure the expensive index computation is only performed once for
+			// concurrent requests for the same signature data.
+			idxAny, err, _ := dv.sg.Do(concatRootSlot(parentRoot, dataColumnSlot), func() (any, error) {
+				verifyingState, err := dv.getVerifyingState(ctx, dataColumn)
+				if err != nil {
+					return nil, columnErrBuilder(errors.Wrap(err, "verifying state"))
+				}
+
+				idx, err = helpers.BeaconProposerIndexAtSlot(ctx, verifyingState, dataColumnSlot)
+				if err != nil {
+					return nil, columnErrBuilder(errors.Wrap(err, "compute proposer"))
+				}
+
+				return idx, nil
+			})
+			if err != nil {
+				return err
+			}
+
+			var ok bool
+			if idx, ok = idxAny.(primitives.ValidatorIndex); !ok {
+				return columnErrBuilder(errors.New("type assertion to ValidatorIndex failed"))
+			}
 		}
 
 		if idx != dataColumn.ProposerIndex() {
@@ -555,3 +626,7 @@ func inclusionProofKey(c blocks.RODataColumn) ([32]byte, error) {
 
 	return sha256.Sum256(unhashedKey), nil
 }
+
+func concatRootSlot(root [fieldparams.RootLength]byte, slot primitives.Slot) string {
+	return string(root[:]) + fmt.Sprintf("%d", slot)
+}

beacon-chain/verification/data_column_test.go

@@ -2,6 +2,7 @@ package verification
 
 import (
 	"reflect"
+	"sync"
 	"testing"
 	"time"
 
@@ -794,90 +795,87 @@ func TestDataColumnsSidecarProposerExpected(t *testing.T) {
 		blobCount  = 1
 	)
 
-	ctx := t.Context()
 	parentRoot := [fieldparams.RootLength]byte{}
-
-	// Create a Fulu state to get the expected proposer from the lookahead.
-	fuluState, _ := util.DeterministicGenesisStateFulu(t, 32)
-	expectedProposer, err := fuluState.ProposerLookahead()
-	require.NoError(t, err)
-	expectedProposerIdx := primitives.ValidatorIndex(expectedProposer[columnSlot])
-
-	// Generate data columns with the expected proposer index.
-	matchingColumns := generateTestDataColumnsWithProposer(t, parentRoot, columnSlot, blobCount, expectedProposerIdx)
-	// Generate data columns with wrong proposer index.
-	wrongColumns := generateTestDataColumnsWithProposer(t, parentRoot, columnSlot, blobCount, expectedProposerIdx+1)
-
-	t.Run("Proposer matches", func(t *testing.T) {
-		initializer := Initializer{
-			shared: &sharedResources{
-				sr: sbrReturnsState(fuluState),
-				hsp: &mockHeadStateProvider{
-					headRoot:          parentRoot[:],
-					headSlot:          columnSlot, // Same epoch so HeadStateReadOnly is used
-					headStateReadOnly: fuluState,
-				},
-				fc: &mockForkchoicer{},
+	columns := GenerateTestDataColumns(t, parentRoot, columnSlot, blobCount)
+	firstColumn := columns[0]
+	ctx := t.Context()
+	testCases := []struct {
+		name          string
+		stateByRooter StateByRooter
+		proposerCache proposerCache
+		columns       []blocks.RODataColumn
+		error         string
+	}{
+		{
+			name:          "Cached, matches",
+			stateByRooter: nil,
+			proposerCache: &mockProposerCache{
+				ProposerCB: pcReturnsIdx(firstColumn.ProposerIndex()),
 			},
-		}
-
-		verifier := initializer.NewDataColumnsVerifier(matchingColumns, GossipDataColumnSidecarRequirements)
-		err := verifier.SidecarProposerExpected(ctx)
-		require.NoError(t, err)
-		require.Equal(t, true, verifier.results.executed(RequireSidecarProposerExpected))
-		require.NoError(t, verifier.results.result(RequireSidecarProposerExpected))
-	})
-
-	t.Run("Proposer does not match", func(t *testing.T) {
-		initializer := Initializer{
-			shared: &sharedResources{
-				sr: sbrReturnsState(fuluState),
-				hsp: &mockHeadStateProvider{
-					headRoot:          parentRoot[:],
-					headSlot:          columnSlot, // Same epoch so HeadStateReadOnly is used
-					headStateReadOnly: fuluState,
-				},
-				fc: &mockForkchoicer{},
+			columns: columns,
+		},
+		{
+			name:          "Cached, does not match",
+			stateByRooter: nil,
+			proposerCache: &mockProposerCache{
+				ProposerCB: pcReturnsIdx(firstColumn.ProposerIndex() + 1),
 			},
-		}
-
-		verifier := initializer.NewDataColumnsVerifier(wrongColumns, GossipDataColumnSidecarRequirements)
-		err := verifier.SidecarProposerExpected(ctx)
-		require.ErrorContains(t, errSidecarUnexpectedProposer.Error(), err)
-		require.Equal(t, true, verifier.results.executed(RequireSidecarProposerExpected))
-		require.NotNil(t, verifier.results.result(RequireSidecarProposerExpected))
-	})
-
-	t.Run("State lookup failure", func(t *testing.T) {
-		columns := GenerateTestDataColumns(t, parentRoot, columnSlot, blobCount)
-		initializer := Initializer{
-			shared: &sharedResources{
-				sr:  sbrNotFound(t, columns[0].ParentRoot()),
-				hsp: &mockHeadStateProvider{},
-				fc:  &mockForkchoicer{},
+			columns: columns,
+			error:   errSidecarUnexpectedProposer.Error(),
+		},
+		{
+			name:          "Not cached, state lookup failure",
+			stateByRooter: sbrNotFound(t, firstColumn.ParentRoot()),
+			proposerCache: &mockProposerCache{
+				ProposerCB: pcReturnsNotFound(),
 			},
-		}
-
-		verifier := initializer.NewDataColumnsVerifier(columns, GossipDataColumnSidecarRequirements)
-		err := verifier.SidecarProposerExpected(ctx)
-		require.ErrorContains(t, "verifying state", err)
-		require.Equal(t, true, verifier.results.executed(RequireSidecarProposerExpected))
-		require.NotNil(t, verifier.results.result(RequireSidecarProposerExpected))
-	})
-}
-
-func generateTestDataColumnsWithProposer(t *testing.T, parent [fieldparams.RootLength]byte, slot primitives.Slot, blobCount int, proposer primitives.ValidatorIndex) []blocks.RODataColumn {
-	roBlock, roBlobs := util.GenerateTestDenebBlockWithSidecar(t, parent, slot, blobCount, util.WithProposer(proposer))
-	blobs := make([]kzg.Blob, 0, len(roBlobs))
-	for i := range roBlobs {
-		blobs = append(blobs, kzg.Blob(roBlobs[i].Blob))
+			columns: columns,
+			error:   "verifying state",
+		},
 	}
 
-	cellsPerBlob, proofsPerBlob := util.GenerateCellsAndProofs(t, blobs)
-	roDataColumnSidecars, err := peerdas.DataColumnSidecars(cellsPerBlob, proofsPerBlob, peerdas.PopulateFromBlock(roBlock))
-	require.NoError(t, err)
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			initializer := Initializer{
+				shared: &sharedResources{
+					sr:  tc.stateByRooter,
+					pc:  tc.proposerCache,
+					hsp: &mockHeadStateProvider{},
+					fc: &mockForkchoicer{
+						TargetRootForEpochCB: fcReturnsTargetRoot([fieldparams.RootLength]byte{}),
+					},
+				},
+			}
 
-	return roDataColumnSidecars
+			verifier := initializer.NewDataColumnsVerifier(tc.columns, GossipDataColumnSidecarRequirements)
+			var wg sync.WaitGroup
+
+			var err1, err2 error
+			wg.Go(func() {
+				err1 = verifier.SidecarProposerExpected(ctx)
+			})
+			wg.Go(func() {
+				err2 = verifier.SidecarProposerExpected(ctx)
+			})
+			wg.Wait()
+
+			require.Equal(t, true, verifier.results.executed(RequireSidecarProposerExpected))
+
+			if len(tc.error) > 0 {
+				require.ErrorContains(t, tc.error, err1)
+				require.ErrorContains(t, tc.error, err2)
+				require.NotNil(t, verifier.results.result(RequireSidecarProposerExpected))
+				return
+			}
+
+			require.NoError(t, err1)
+			require.NoError(t, err2)
+			require.NoError(t, verifier.results.result(RequireSidecarProposerExpected))
+
+			err := verifier.SidecarProposerExpected(ctx)
+			require.NoError(t, err)
+		})
+	}
 }
 
 func TestColumnRequirementSatisfaction(t *testing.T) {
@@ -924,3 +922,12 @@ func TestColumnRequirementSatisfaction(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestConcatRootSlot(t *testing.T) {
+	root := [fieldparams.RootLength]byte{1, 2, 3}
+	const slot = primitives.Slot(3210)
+
+	const expected = "\x01\x02\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x003210"
+
+	actual := concatRootSlot(root, slot)
+	require.Equal(t, expected, actual)
+}

changelog/kasey_fix-backfill-flag.md

@@ -1,2 +0,0 @@
-#### Fixed
-- Fix validation logic for `--backfill-oldest-slot`, which was rejecting slots newer than 1056767.

changelog/manu-cache-warmup.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Data column sidecars cache warmup: Process in parallel all sidecars for a given epoch.

changelog/manu-log.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Summarize DEBUG log corresponding to incoming via gossip data column sidecar.

changelog/potuz_dcs_pc_removal.md

@@ -1,2 +0,0 @@
-### Changed
-- Use lookahead to validate data column sidecar proposer index.

changelog/potuz_dont_lock_fcu.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Notify the engine about forkchoice updates in the background. 

changelog/potuz_fcu_ctx.md

@@ -1,2 +0,0 @@
-### Changed
-- Use a separate context when updating the slot cache. 

changelog/potuz_no_fcu_on_batches.md

@@ -1,2 +0,0 @@
-### Ignored
-- D  not send FCU on block batches. 

changelog/potuz_remove_signature_check.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Do not check block signature on state transition. 

changelog/potuz_use_baze_mirror.md

@@ -0,0 +1,2 @@
+### Ignored
+- Use bazel mirror due to expired certificate.

changelog/potuz_use_head_previous_epoch.md

@@ -1,3 +0,0 @@
-### Added
-
-- Use the head state to validate attestations for the previous epoch if head is compatible with the target checkpoint.

proto/prysm/v1alpha1/cloners.go

@@ -174,28 +174,3 @@ func copyBeaconBlockBodyGloas(body *BeaconBlockBodyGloas) *BeaconBlockBodyGloas
 
 	return copied
 }
-
-// CopyBuilderPendingPayment creates a deep copy of a builder pending payment.
-func CopyBuilderPendingPayment(original *BuilderPendingPayment) *BuilderPendingPayment {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingPayment{
-		Weight:     original.Weight,
-		Withdrawal: copyBuilderPendingWithdrawal(original.Withdrawal),
-	}
-}
-
-// copyBuilderPendingWithdrawal creates a deep copy of a builder pending withdrawal.
-func copyBuilderPendingWithdrawal(original *BuilderPendingWithdrawal) *BuilderPendingWithdrawal {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingWithdrawal{
-		FeeRecipient: bytesutil.SafeCopyBytes(original.FeeRecipient),
-		Amount:       original.Amount,
-		BuilderIndex: original.BuilderIndex,
-	}
-}

testing/spectest/mainnet/BUILD.bazel

@@ -200,7 +200,6 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
-        "gloas__operations__attestation_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",
@@ -279,7 +278,6 @@ go_test(
         "//testing/spectest/shared/fulu/rewards:go_default_library",
         "//testing/spectest/shared/fulu/sanity:go_default_library",
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
-        "//testing/spectest/shared/gloas/operations:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",
         "//testing/spectest/shared/phase0/finality:go_default_library",

testing/spectest/mainnet/gloas__operations__attestation_test.go

@@ -1,11 +0,0 @@
-package mainnet
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
-)
-
-func TestMainnet_Gloas_Operations_Attestation(t *testing.T) {
-	operations.RunAttestationTest(t, "mainnet")
-}

testing/spectest/minimal/BUILD.bazel

@@ -206,7 +206,6 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
-        "gloas__operations__attestation_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",
@@ -289,7 +288,6 @@ go_test(
         "//testing/spectest/shared/fulu/rewards:go_default_library",
         "//testing/spectest/shared/fulu/sanity:go_default_library",
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
-        "//testing/spectest/shared/gloas/operations:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",
         "//testing/spectest/shared/phase0/finality:go_default_library",

testing/spectest/minimal/gloas__operations__attestation_test.go

@@ -1,11 +0,0 @@
-package minimal
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
-)
-
-func TestMinimal_Gloas_Operations_Attestation(t *testing.T) {
-	operations.RunAttestationTest(t, "minimal")
-}

testing/spectest/shared/gloas/operations/BUILD.bazel

@@ -1,22 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "attestation.go",
-        "helpers.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/spectest/shared/common/operations:go_default_library",
-        "//testing/util:go_default_library",
-    ],
-)

testing/spectest/shared/gloas/operations/attestation.go

@@ -1,27 +0,0 @@
-package operations
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-)
-
-func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
-	att := &ethpb.AttestationElectra{}
-	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
-		return nil, err
-	}
-	b := util.NewBeaconBlockGloas()
-	b.Block.Body = &ethpb.BeaconBlockBodyGloas{Attestations: []*ethpb.AttestationElectra{att}}
-	return blocks.NewSignedBeaconBlock(b)
-}
-
-func RunAttestationTest(t *testing.T, config string) {
-	common.RunAttestationTest(t, config, version.String(version.Gloas), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
-}

testing/spectest/shared/gloas/operations/helpers.go

@@ -1,33 +0,0 @@
-package operations
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-func sszToState(b []byte) (state.BeaconState, error) {
-	base := &ethpb.BeaconStateGloas{}
-	if err := base.UnmarshalSSZ(b); err != nil {
-		return nil, err
-	}
-	return state_native.InitializeFromProtoGloas(base)
-}
-
-func sszToBlock(b []byte) (interfaces.SignedBeaconBlock, error) {
-	base := &ethpb.BeaconBlockGloas{}
-	if err := base.UnmarshalSSZ(b); err != nil {
-		return nil, err
-	}
-	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: base})
-}
-
-func sszToBlockBody(b []byte) (interfaces.ReadOnlyBeaconBlockBody, error) {
-	base := &ethpb.BeaconBlockBodyGloas{}
-	if err := base.UnmarshalSSZ(b); err != nil {
-		return nil, err
-	}
-	return blocks.NewBeaconBlockBody(base)
-}

testing/spectest/shared/gloas/ssz_static/ssz_static.go

@@ -15,27 +15,29 @@ import (
 
 // RunSSZStaticTests executes "ssz_static" tests.
 func RunSSZStaticTests(t *testing.T, config string) {
-	common.RunSSZStaticTests(t, config, "gloas", UnmarshalledSSZ, customHtr)
+	common.RunSSZStaticTests(t, config, "gloas", unmarshalledSSZ, customHtr)
 }
 
-func customHtr(t *testing.T, htrs []common.HTR, object interface{}) []common.HTR {
+func customHtr(t *testing.T, htrs []common.HTR, object any) []common.HTR {
 	_, ok := object.(*ethpb.BeaconStateGloas)
 	if !ok {
 		return htrs
 	}
 
-	htrs = append(htrs, func(s interface{}) ([32]byte, error) {
+	htrs = append(htrs, func(s any) ([32]byte, error) {
 		beaconState, err := state_native.InitializeFromProtoGloas(s.(*ethpb.BeaconStateGloas))
 		require.NoError(t, err)
+
 		return beaconState.HashTreeRoot(context.Background())
 	})
 
 	return htrs
 }
 
-// UnmarshalledSSZ unmarshalls serialized input.
-func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (interface{}, error) {
-	var obj interface{}
+// unmarshalledSSZ unmarshalls serialized input.
+func unmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (any, error) {
+	var obj any
+
 	switch folderName {
 	// Gloas specific types
 	case "ExecutionPayloadBid":
@@ -52,22 +54,28 @@ func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (i
 		obj = &ethpb.BeaconBlockGloas{}
 	case "BeaconBlockBody":
 		obj = &ethpb.BeaconBlockBodyGloas{}
+	case "BeaconState":
+		obj = &ethpb.BeaconStateGloas{}
 	case "BuilderPendingPayment":
 		obj = &ethpb.BuilderPendingPayment{}
 	case "BuilderPendingWithdrawal":
 		obj = &ethpb.BuilderPendingWithdrawal{}
 	case "ExecutionPayloadEnvelope":
-		obj = &enginev1.ExecutionPayloadEnvelope{}
+		obj = &ethpb.ExecutionPayloadEnvelope{}
 	case "SignedExecutionPayloadEnvelope":
-		obj = &enginev1.SignedExecutionPayloadEnvelope{}
+		obj = &ethpb.SignedExecutionPayloadEnvelope{}
 	case "ForkChoiceNode":
 		t.Skip("Not a consensus type")
 	case "IndexedPayloadAttestation":
 		t.Skip("Not a consensus type")
+	case "DataColumnSidecar":
+		obj = &ethpb.DataColumnSidecarGloas{}
 
 	// Standard types that also exist in gloas
 	case "ExecutionPayload":
 		obj = &enginev1.ExecutionPayloadDeneb{}
+	case "ExecutionPayloadHeader":
+		obj = &enginev1.ExecutionPayloadHeaderDeneb{}
 	case "Attestation":
 		obj = &ethpb.AttestationElectra{}
 	case "AttestationData":
@@ -78,8 +86,6 @@ func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (i
 		obj = &ethpb.AggregateAttestationAndProofElectra{}
 	case "BeaconBlockHeader":
 		obj = &ethpb.BeaconBlockHeader{}
-	case "BeaconState":
-		obj = &ethpb.BeaconStateGloas{}
 	case "Checkpoint":
 		obj = &ethpb.Checkpoint{}
 	case "Deposit":
@@ -92,7 +98,6 @@ func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (i
 		obj = &ethpb.Eth1Data{}
 	case "Eth1Block":
 		t.Skip("Unused type")
-		return nil, nil
 	case "Fork":
 		obj = &ethpb.Fork{}
 	case "ForkData":
@@ -136,15 +141,15 @@ func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (i
 	case "SyncCommittee":
 		obj = &ethpb.SyncCommittee{}
 	case "LightClientOptimisticUpdate":
-		t.Skip("Need to fix header type first")
+		obj = &ethpb.LightClientOptimisticUpdateDeneb{}
 	case "LightClientFinalityUpdate":
-		t.Skip("Need to fix header type first")
+		obj = &ethpb.LightClientFinalityUpdateElectra{}
 	case "LightClientBootstrap":
-		t.Skip("Need to fix header type first")
+		obj = &ethpb.LightClientBootstrapElectra{}
 	case "LightClientUpdate":
-		t.Skip("Need to fix header type first")
+		obj = &ethpb.LightClientUpdateElectra{}
 	case "LightClientHeader":
-		t.Skip("Need to fix header type first")
+		obj = &ethpb.LightClientHeaderDeneb{}
 	case "BlobIdentifier":
 		obj = &ethpb.BlobIdentifier{}
 	case "BlobSidecar":
@@ -173,8 +178,6 @@ func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (i
 		obj = &enginev1.ConsolidationRequest{}
 	case "ExecutionRequests":
 		obj = &enginev1.ExecutionRequests{}
-	case "DataColumnSidecar":
-		t.Skip("TODO: fix inclusion proof but not a priority")
 	case "DataColumnsByRootIdentifier":
 		obj = &ethpb.DataColumnsByRootIdentifier{}
 	case "MatrixEntry":
@@ -182,11 +185,13 @@ func UnmarshalledSSZ(t *testing.T, serializedBytes []byte, folderName string) (i
 	default:
 		return nil, errors.New("type not found")
 	}
+
 	var err error
 	if o, ok := obj.(fssz.Unmarshaler); ok {
 		err = o.UnmarshalSSZ(serializedBytes)
 	} else {
 		err = errors.New("could not unmarshal object, not a fastssz compatible object")
 	}
+
 	return obj, err
 }

testing/util/deneb.go

@@ -44,13 +44,6 @@ func WithProposerSigning(idx primitives.ValidatorIndex, sk bls.SecretKey, valRoo
 	}
 }
 
-// WithProposer sets the proposer index for the generated block without signing.
-func WithProposer(idx primitives.ValidatorIndex) DenebBlockGeneratorOption {
-	return func(g *denebBlockGenerator) {
-		g.proposer = idx
-	}
-}
-
 func WithPayloadSetter(p *enginev1.ExecutionPayloadDeneb) DenebBlockGeneratorOption {
 	return func(g *denebBlockGenerator) {
 		g.payload = p