Merge branch 'develop' into graffiti-impl

.gitignore

@@ -44,6 +44,3 @@ tmp
 
 # spectest coverage reports
 report.txt
-
-# execution client data
-execution/

CHANGELOG.md

@@ -4,66 +4,6 @@ All notable changes to this project will be documented in this file.
 
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 
-## [v7.1.2](https://github.com/prysmaticlabs/prysm/compare/v7.1.1...v7.1.2) - 2026-01-07
-
-Happy new year! This patch release is very small. The main improvement is better management of pending attestation aggregation via [PR 16153](https://github.com/OffchainLabs/prysm/pull/16153).
-
-### Added
-
-- `primitives.BuilderIndex`: SSZ `uint64` wrapper for builder registry indices. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16169)
-
-### Changed
-
-- the /eth/v2/beacon/pool/attestations and /eth/v1/beacon/pool/sync_committees now returns a 503 error if the node is still syncing, the rest api is also working in a similar process to gRPC broadcasting immediately now. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16152)
-- `validateDataColumn`: Remove error logs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16157)
-- Pending aggregates: When multiple aggregated attestations only differing by the aggregator index are in the pending queue, only process one of them. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16153)
-
-### Fixed
-
-- Fix the missing fork version object mapping for Fulu in light client p2p. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16151)
-- Do not process slots and copy states for next epoch proposers after Fulu. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16168)
-
-## [v7.1.1](https://github.com/prysmaticlabs/prysm/compare/v7.1.0...v7.1.1) - 2025-12-18
-
-Release highlights:
-
-- Fixed potential deadlock scenario in data column batch verification
-- Improved processing and metrics for cells and proofs
-
-We are aware of [an issue](https://github.com/OffchainLabs/prysm/issues/16160) where Prysm struggles to sync from an out of sync state. We will have another release before the end of the year to address this issue.
-
-Our postmortem document from the December 4th mainnet issue has been published on our [documentation site](https://prysm.offchainlabs.com/docs/misc/mainnet-postmortems/)
-
-### Added
-
-- Track the dependent root of the latest finalized checkpoint in forkchoice. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16103)
-- Proposal design document to implement graffiti. Currently it is empty by default and the idea is to have it of the form GE168dPR63af. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15983)
-- Add support for detecting and logging per address reachability via libp2p AutoNAT v2. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16100)
-- Static analyzer that ensures each `httputil.HandleError` call is followed by a `return` statement. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16134)
-- Prometheus histogram `cells_and_proofs_from_structured_computation_milliseconds` to track computation time for cells and proofs from structured blobs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
-- Prometheus histogram `get_blobs_v2_latency_milliseconds` to track RPC latency for `getBlobsV2` calls to the execution layer. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
-
-### Changed
-
-- Optimise migratetocold by not doing brute force for loop. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16101)
-- e2e sync committee evaluator now skips the first slot after startup, we already skip the fork epoch for checks here, this skip only applies on startup, due to altair always from 0 and validators need to warm up. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16145)
-- Run `ComputeCellsAndProofsFromFlat` in parallel to improve performance when computing cells and proofs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
-- Run `ComputeCellsAndProofsFromStructured` in parallel to improve performance when computing cells and proofs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
-
-### Removed
-
-- Unnecessary copy is removed from Eth1DataHasEnoughSupport. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16118)
-
-### Fixed
-
-- Incorrect constructor return type [#16084](https://github.com/OffchainLabs/prysm/pull/16084). [[PR]](https://github.com/prysmaticlabs/prysm/pull/16084)
-- Fixed possible race when validating two attestations at the same time. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16105)
-- Fix missing return after version header check in SubmitAttesterSlashingsV2. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16126)
-- Fix deadlock in data column gossip KZG batch verification when a caller times out preventing result delivery. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16141)
-- Fixed replay state issue in rest api caused by attester and sync committee duties endpoints. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16136)
-- Do not error when committee has been computed correctly but updating the cache failed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16142)
-- Prevent blocked sends to the KZG batch verifier when the caller context is already canceled, avoiding useless queueing and potential hangs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16144)
-
 ## [v7.1.0](https://github.com/prysmaticlabs/prysm/compare/v7.0.0...v7.1.0) - 2025-12-10
 
 This release includes several key features/fixes. If you are running v7.0.0 then you should update to v7.0.1 or later and remove the flag `--disable-last-epoch-targets`. 

WORKSPACE

@@ -273,16 +273,16 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.7.0-alpha.0"
+consensus_spec_version = "v1.6.0"
 
 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
 consensus_spec_tests(
     name = "consensus_spec_tests",
     flavors = {
-        "general": "sha256-b+rJOuVqq+Dy53quPcNYcQwPFoMU7Wp7tdUVe7n0g8w=",
-        "minimal": "sha256-qxRIxtjPxVsVCY90WsBJKhk0027XDSmhjnRvRN14V1c=",
-        "mainnet": "sha256-NsuOQG3LzeiEE1TrWuvQ6vu6BboHv7h7f/RTS0pWkCs=",
+        "general": "sha256-54hTaUNF9nLg+hRr3oHoq0yjZpW3MNiiUUuCQu6Rajk=",
+        "minimal": "sha256-1JHIGg3gVMjvcGYRHR5cwdDgOvX47oR/MWp6gyAeZfA=",
+        "mainnet": "sha256-292h3W2Ffts0YExgDTyxYe9Os7R0bZIXuAaMO8P6kl4=",
     },
     version = consensus_spec_version,
 )
@@ -298,7 +298,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-hwNdUBgdBrkk6pWIpNYbzbwswUuOu6AMD2exN8uv+QQ=",
+    integrity = "sha256-VzBgrEokvYSMIIXVnSA5XS9I3m9oxpvToQGxC1N5lzw=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

beacon-chain/blockchain/BUILD.bazel

@@ -74,6 +74,7 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -173,6 +174,7 @@ go_test(
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/blockchain/receive_block_test.go

@@ -17,7 +17,6 @@ import (
 	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/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	ethpbv1 "github.com/OffchainLabs/prysm/v7/proto/eth/v1"
@@ -131,10 +130,12 @@ func TestService_ReceiveBlock(t *testing.T) {
 				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
-				notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-				require.Eventually(t, func() bool {
-					return len(notifier.ReceivedEvents()) >= 1
-				}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+				// Hacky sleep, should use a better way to be able to resolve the race
+				// between event being sent out and processed.
+				time.Sleep(100 * time.Millisecond)
+				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
 			},
 		},
 		{
@@ -221,10 +222,10 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 		require.NoError(t, s.ReceiveBlock(ctx, wsb, root, nil))
 	})
 	wg.Wait()
-	notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-	require.Eventually(t, func() bool {
-		return len(notifier.ReceivedEvents()) >= 1
-	}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+	time.Sleep(100 * time.Millisecond)
+	if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+		t.Errorf("Received %d state notifications, expected at least 1", recvd)
+	}
 	// Verify fork choice has processed the block. (Genesis block and the new block)
 	assert.Equal(t, 2, s.cfg.ForkChoiceStore.NodeCount())
 }
@@ -264,10 +265,10 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
-				notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-				require.Eventually(t, func() bool {
-					return len(notifier.ReceivedEvents()) >= 1
-				}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+				time.Sleep(100 * time.Millisecond)
+				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
 			},
 		},
 	}
@@ -511,9 +512,8 @@ func Test_executePostFinalizationTasks(t *testing.T) {
 		s.cfg.StateNotifier = notifier
 		s.executePostFinalizationTasks(s.ctx, headState)
 
-		require.Eventually(t, func() bool {
-			return len(notifier.ReceivedEvents()) == 1
-		}, 5*time.Second, 50*time.Millisecond, "Expected exactly 1 state notification")
+		time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+		require.Equal(t, 1, len(notifier.ReceivedEvents()))
 		e := notifier.ReceivedEvents()[0]
 		assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
 		fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
@@ -552,9 +552,8 @@ func Test_executePostFinalizationTasks(t *testing.T) {
 		s.cfg.StateNotifier = notifier
 		s.executePostFinalizationTasks(s.ctx, headState)
 
-		require.Eventually(t, func() bool {
-			return len(notifier.ReceivedEvents()) == 1
-		}, 5*time.Second, 50*time.Millisecond, "Expected exactly 1 state notification")
+		time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+		require.Equal(t, 1, len(notifier.ReceivedEvents()))
 		e := notifier.ReceivedEvents()[0]
 		assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
 		fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
@@ -597,13 +596,13 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 
 			s.executePostFinalizationTasks(s.ctx, l.AttestedState)
 
-			// Wait for the light client bootstrap to be saved (runs in goroutine)
-			var b interfaces.LightClientBootstrap
-			require.Eventually(t, func() bool {
-				var err error
-				b, err = s.lcStore.LightClientBootstrap(ctx, [32]byte(cp.Root))
-				return err == nil && b != nil
-			}, 5*time.Second, 50*time.Millisecond, "Light client bootstrap was not saved within timeout")
+			// wait for the goroutine to finish processing
+			time.Sleep(1 * time.Second)
+
+			// Check that the light client bootstrap is saved
+			b, err := s.lcStore.LightClientBootstrap(ctx, [32]byte(cp.Root))
+			require.NoError(t, err)
+			require.NotNil(t, b)
 
 			btst, err := lightClient.NewLightClientBootstrapFromBeaconState(ctx, l.FinalizedState.Slot(), l.FinalizedState, l.FinalizedBlock)
 			require.NoError(t, err)

beacon-chain/blockchain/service.go

@@ -14,6 +14,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	coreTime "github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
@@ -29,6 +30,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stategen"
+	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -289,6 +291,19 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
 
+	if !params.FuluEnabled() {
+		return nil
+	}
+
+	earliestAvailableSlot, custodySubnetCount, err := s.updateCustodyInfoInDB(saved.Slot())
+	if err != nil {
+		return errors.Wrap(err, "could not get and save custody group count")
+	}
+
+	if _, _, err := s.cfg.P2P.UpdateCustodyInfo(earliestAvailableSlot, custodySubnetCount); err != nil {
+		return errors.Wrap(err, "update custody info")
+	}
+
 	return nil
 }
 
@@ -453,6 +468,73 @@ func (s *Service) removeStartupState() {
 	s.cfg.FinalizedStateAtStartUp = nil
 }
 
+// UpdateCustodyInfoInDB updates the custody information in the database.
+// It returns the (potentially updated) custody group count and the earliest available slot.
+func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot, uint64, error) {
+	isSupernode := flags.Get().Supernode
+	isSemiSupernode := flags.Get().SemiSupernode
+
+	cfg := params.BeaconConfig()
+	custodyRequirement := cfg.CustodyRequirement
+
+	// Check if the node was previously subscribed to all data subnets, and if so,
+	// store the new status accordingly.
+	wasSupernode, err := s.cfg.BeaconDB.UpdateSubscribedToAllDataSubnets(s.ctx, isSupernode)
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "update subscribed to all data subnets")
+	}
+
+	// Compute the target custody group count based on current flag configuration.
+	targetCustodyGroupCount := custodyRequirement
+
+	// Supernode: custody all groups (either currently set or previously enabled)
+	if isSupernode {
+		targetCustodyGroupCount = cfg.NumberOfCustodyGroups
+	}
+
+	// Semi-supernode: custody minimum needed for reconstruction, or custody requirement if higher
+	if isSemiSupernode {
+		semiSupernodeCustody, err := peerdas.MinimumCustodyGroupCountToReconstruct()
+		if err != nil {
+			return 0, 0, errors.Wrap(err, "minimum custody group count")
+		}
+
+		targetCustodyGroupCount = max(custodyRequirement, semiSupernodeCustody)
+	}
+
+	// Safely compute the fulu fork slot.
+	fuluForkSlot, err := fuluForkSlot()
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "fulu fork slot")
+	}
+
+	// If slot is before the fulu fork slot, then use the earliest stored slot as the reference slot.
+	if slot < fuluForkSlot {
+		slot, err = s.cfg.BeaconDB.EarliestSlot(s.ctx)
+		if err != nil {
+			return 0, 0, errors.Wrap(err, "earliest slot")
+		}
+	}
+
+	earliestAvailableSlot, actualCustodyGroupCount, err := s.cfg.BeaconDB.UpdateCustodyInfo(s.ctx, slot, targetCustodyGroupCount)
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "update custody info")
+	}
+
+	if isSupernode {
+		log.WithFields(logrus.Fields{
+			"current": actualCustodyGroupCount,
+			"target":  cfg.NumberOfCustodyGroups,
+		}).Info("Supernode mode enabled. Will custody all data columns going forward.")
+	}
+
+	if wasSupernode && !isSupernode {
+		log.Warningf("Because the `--%s` flag was previously used, the node will continue to act as a super node.", flags.Supernode.Name)
+	}
+
+	return earliestAvailableSlot, actualCustodyGroupCount, nil
+}
+
 func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db db.HeadAccessDatabase) {
 	currentTime := prysmTime.Now()
 	if currentTime.After(genesisTime) {
@@ -469,3 +551,19 @@ func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db d
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
 }
+
+func fuluForkSlot() (primitives.Slot, error) {
+	cfg := params.BeaconConfig()
+
+	fuluForkEpoch := cfg.FuluForkEpoch
+	if fuluForkEpoch == cfg.FarFutureEpoch {
+		return cfg.FarFutureSlot, nil
+	}
+
+	forkFuluSlot, err := slots.EpochStart(fuluForkEpoch)
+	if err != nil {
+		return 0, errors.Wrap(err, "epoch start")
+	}
+
+	return forkFuluSlot, nil
+}

beacon-chain/blockchain/service_test.go

@@ -23,9 +23,11 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stategen"
+	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	consensusblocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -594,3 +596,218 @@ func TestNotifyIndex(t *testing.T) {
 		t.Errorf("Notifier channel did not receive the index")
 	}
 }
+
+func TestUpdateCustodyInfoInDB(t *testing.T) {
+	const (
+		fuluForkEpoch         = 10
+		custodyRequirement    = uint64(4)
+		earliestStoredSlot    = primitives.Slot(12)
+		numberOfCustodyGroups = uint64(64)
+	)
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig()
+	cfg.FuluForkEpoch = fuluForkEpoch
+	cfg.CustodyRequirement = custodyRequirement
+	cfg.NumberOfCustodyGroups = numberOfCustodyGroups
+	params.OverrideBeaconConfig(cfg)
+
+	ctx := t.Context()
+	pbBlock := util.NewBeaconBlock()
+	pbBlock.Block.Slot = 12
+	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(pbBlock)
+	require.NoError(t, err)
+
+	roBlock, err := blocks.NewROBlock(signedBeaconBlock)
+	require.NoError(t, err)
+
+	t.Run("CGC increases before fulu", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Before Fulu
+		// -----------
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(19)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+
+		// After Fulu
+		// ----------
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+	})
+
+	t.Run("CGC increases after fulu", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Before Fulu
+		// -----------
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		// After Fulu
+		// ----------
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+	})
+
+	t.Run("Supernode downgrade prevented", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Enable supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+
+		// Try to downgrade by removing flag
+		gFlags.Supernode = false
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// Should still be supernode
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc) // Still 64, not downgraded
+	})
+
+	t.Run("Semi-supernode downgrade prevented", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Enable semi-supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.SemiSupernode = true
+		flags.Init(gFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
+		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
+
+		// Try to downgrade by removing flag
+		gFlags.SemiSupernode = false
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// UpdateCustodyInfo should prevent downgrade - custody count should remain at 64
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, semiSupernodeCustody, actualCgc) // Still 64 due to downgrade prevention by UpdateCustodyInfo
+	})
+
+	t.Run("Semi-supernode to supernode upgrade allowed", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Start with semi-supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.SemiSupernode = true
+		flags.Init(gFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
+		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
+
+		// Upgrade to full supernode
+		gFlags.SemiSupernode = false
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// Should upgrade to full supernode
+		upgradeSlot := slot + 2
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(upgradeSlot)
+		require.NoError(t, err)
+		require.Equal(t, upgradeSlot, actualEas)           // Earliest slot updates when upgrading
+		require.Equal(t, numberOfCustodyGroups, actualCgc) // Upgraded to 128
+	})
+
+	t.Run("Semi-supernode with high validator requirements uses higher custody", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Enable semi-supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.SemiSupernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// Mock a high custody requirement (simulating many validators)
+		// We need to override the custody requirement calculation
+		// For this test, we'll verify the logic by checking if custodyRequirement > 64
+		// Since custodyRequirement in minimalTestService is 4, we can't test the high case here
+		// This would require a different test setup with actual validators
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
+		// With low validator requirements (4), should use semi-supernode minimum (64)
+		require.Equal(t, semiSupernodeCustody, actualCgc)
+	})
+}

beacon-chain/core/blocks/withdrawals.go

@@ -212,8 +212,7 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get next withdrawal validator index")
 		}
-		bound := min(uint64(st.NumValidators()), params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		nextValidatorIndex += primitives.ValidatorIndex(bound)
+		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
 		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
 	} else {
 		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1

beacon-chain/execution/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "deposit.go",
         "engine_client.go",
         "errors.go",
+        "graffiti_info.go",
         "log.go",
         "log_processing.go",
         "metrics.go",
@@ -40,7 +41,6 @@ go_library(
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/verification:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -89,6 +89,7 @@ go_test(
         "engine_client_fuzz_test.go",
         "engine_client_test.go",
         "execution_chain_test.go",
+        "graffiti_info_test.go",
         "init_test.go",
         "log_processing_test.go",
         "mock_test.go",

beacon-chain/execution/engine_client.go

@@ -11,7 +11,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/execution/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
-	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -61,7 +60,17 @@ var (
 	}
 )
 
+// ClientVersionV1 represents the response from engine_getClientVersionV1.
+type ClientVersionV1 struct {
+	Code    string `json:"code"`
+	Name    string `json:"name"`
+	Version string `json:"version"`
+	Commit  string `json:"commit"`
+}
+
 const (
+	// GetClientVersionMethod is the engine_getClientVersionV1 method for JSON-RPC.
+	GetClientVersionMethod = "engine_getClientVersionV1"
 	// NewPayloadMethod v1 request string for JSON-RPC.
 	NewPayloadMethod = "engine_newPayloadV1"
 	// NewPayloadMethodV2 v2 request string for JSON-RPC.
@@ -350,6 +359,27 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 	return elSupportedEndpointsSlice, nil
 }
 
+// GetClientVersion calls engine_getClientVersionV1 to retrieve EL client information.
+func (s *Service) GetClientVersion(ctx context.Context) ([]ClientVersionV1, error) {
+	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetClientVersion")
+	defer span.End()
+
+	// Per spec, we send our own client info as the parameter
+	clVersion := ClientVersionV1{
+		Code:    CLCode,
+		Name:    "Prysm",
+		Version: version.SemanticVersion(),
+		Commit:  version.GetCommitPrefix(),
+	}
+
+	var result []ClientVersionV1
+	err := s.rpcClient.CallContext(ctx, &result, GetClientVersionMethod, clVersion)
+	if err != nil {
+		return nil, handleRPCError(err)
+	}
+	return result, nil
+}
+
 // GetTerminalBlockHash returns the valid terminal block hash based on total difficulty.
 //
 // Spec code:
@@ -539,10 +569,6 @@ func (s *Service) GetBlobsV2(ctx context.Context, versionedHashes []common.Hash)
 		return nil, errors.New(fmt.Sprintf("%s is not supported", GetBlobsV2))
 	}
 
-	if flags.Get().DisableGetBlobsV2 {
-		return []*pb.BlobAndProofV2{}, nil
-	}
-
 	result := make([]*pb.BlobAndProofV2, len(versionedHashes))
 	err := s.rpcClient.CallContext(ctx, &result, GetBlobsV2, versionedHashes)
 

beacon-chain/execution/graffiti_info.go

@@ -0,0 +1,107 @@
+package execution
+
+import (
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+)
+
+const (
+	// CLCode is the two-letter client code for Prysm.
+	CLCode = "PR"
+)
+
+// GraffitiInfo holds version information for generating block graffiti.
+// It is thread-safe and can be updated by the execution service and read by the validator server.
+type GraffitiInfo struct {
+	mu       sync.RWMutex
+	elCode   string // From engine_getClientVersionV1
+	elCommit string // From engine_getClientVersionV1
+}
+
+// NewGraffitiInfo creates a new GraffitiInfo.
+func NewGraffitiInfo() *GraffitiInfo {
+	return &GraffitiInfo{}
+}
+
+// UpdateFromEngine updates the EL client information.
+func (g *GraffitiInfo) UpdateFromEngine(code, commit string) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	g.elCode = code
+	g.elCommit = commit
+}
+
+// GenerateGraffiti generates graffiti using the flexible standard
+// with the provided user graffiti from the validator client request.
+// It packs as much client info as space allows, followed by a space and user graffiti.
+//
+// Available Space | Format (space added before user graffiti if present)
+// ≥13 bytes       | EL(2)+commit(4)+CL(2)+commit(4)+space+user  e.g. "GEabcdPRxxxx Sushi"
+// 9-12 bytes      | EL(2)+commit(2)+CL(2)+commit(2)+space+user  e.g. "GEabPRxx Sushi"
+// 5-8 bytes       | EL(2)+CL(2)+space+user                      e.g. "GEPR Sushi"
+// 3-4 bytes       | code(2)+space+user                          e.g. "GE Sushi" or "PR Sushi"
+// <3 bytes        | user only                                   e.g. "Sushi"
+func (g *GraffitiInfo) GenerateGraffiti(userGraffiti []byte) [32]byte {
+	g.mu.RLock()
+	defer g.mu.RUnlock()
+
+	var result [32]byte
+	userStr := string(userGraffiti)
+	// Trim trailing null bytes
+	for len(userStr) > 0 && userStr[len(userStr)-1] == 0 {
+		userStr = userStr[:len(userStr)-1]
+	}
+
+	// Prepend space to user graffiti for readability
+	if len(userStr) > 0 {
+		userStr = " " + userStr
+	}
+	available := 32 - len(userStr)
+
+	clCommit := version.GetCommitPrefix()
+	clCommit4 := truncateCommit(clCommit, 4)
+	clCommit2 := truncateCommit(clCommit, 2)
+
+	// If no EL info, clear EL commits but still include CL info
+	var elCommit4, elCommit2 string
+	if g.elCode != "" {
+		elCommit4 = truncateCommit(g.elCommit, 4)
+		elCommit2 = truncateCommit(g.elCommit, 2)
+	}
+
+	var graffiti string
+	switch {
+	case available >= 12:
+		// Full: EL(2)+commit(4)+CL(2)+commit(4)+space+user
+		graffiti = g.elCode + elCommit4 + CLCode + clCommit4 + userStr
+	case available >= 8:
+		// Reduced commits: EL(2)+commit(2)+CL(2)+commit(2)+space+user
+		graffiti = g.elCode + elCommit2 + CLCode + clCommit2 + userStr
+	case available >= 4:
+		// Codes only: EL(2)+CL(2)+space+user
+		graffiti = g.elCode + CLCode + userStr
+	case available >= 2:
+		// EL code only (or CL code if no EL): code(2)+space+user
+		if g.elCode != "" {
+			graffiti = g.elCode + userStr
+		} else {
+			graffiti = CLCode + userStr
+		}
+	default:
+		// User graffiti only (no space needed since no version prefix)
+		// Remove the prepended space since we can't fit any version info
+		graffiti = userStr[1:]
+	}
+
+	copy(result[:], graffiti)
+	return result
+}
+
+// truncateCommit returns the first n characters of the commit string.
+func truncateCommit(commit string, n int) string {
+	if len(commit) <= n {
+		return commit
+	}
+	return commit[:n]
+}

beacon-chain/execution/graffiti_info_test.go

@@ -0,0 +1,194 @@
+package execution
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestGraffitiInfo_GenerateGraffiti(t *testing.T) {
+	tests := []struct {
+		name         string
+		elCode       string
+		elCommit     string
+		userGraffiti []byte
+		wantPrefix   string
+		wantSuffix   string // for checking user graffiti is appended
+	}{
+		// No EL info cases (CL info "PR" + commit still included when space allows)
+		{
+			name:         "No EL - empty user graffiti",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte{},
+			wantPrefix:   "PR", // CL code, no trailing space since no user graffiti
+		},
+		{
+			name:         "No EL - short user graffiti",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("my validator"),
+			wantPrefix:   "PR",       // CL code + commit + space + user
+			wantSuffix:   " my validator", // space before user graffiti
+		},
+		{
+			name:         "No EL - 28 char user graffiti (3 bytes available after space)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("1234567890123456789012345678"), // 28 chars
+			wantPrefix:   "PR ",                                   // CL code + space (3 bytes)
+		},
+		{
+			name:         "No EL - 29 char user graffiti (2 bytes available after space)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("12345678901234567890123456789"), // 29 chars, 2 bytes available = fits PR
+			wantPrefix:   "PR ",                                    // CL code (2 bytes) + space fits exactly
+		},
+		{
+			name:         "No EL - 30 char user graffiti (1 byte available after space)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("123456789012345678901234567890"), // 30 chars, 1 byte available = not enough for code+space
+			wantPrefix:   "123456789012345678901234567890",          // User only
+		},
+		{
+			name:         "No EL - 31 char user graffiti (0 bytes available after space)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("1234567890123456789012345678901"),
+			wantPrefix:   "1234567890123456789012345678901", // User only
+		},
+		// With EL info - flexible standard format cases
+		{
+			name:         "With EL - full format (empty user graffiti)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte{},
+			wantPrefix:   "GEabcdPR", // No trailing space when no user graffiti
+		},
+		{
+			name:         "With EL - full format (short user graffiti)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("Bob"),
+			wantPrefix:   "GEabcdPR", // EL(2)+commit(4)+CL(2)+commit(4)
+			wantSuffix:   " Bob",     // space before user graffiti
+		},
+		{
+			name:         "With EL - full format (18 char user, 13 bytes available after space)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("123456789012345678"), // 18 chars, need 19 with space, leaves 13
+			wantPrefix:   "GEabcdPR",                    // Full format fits (12 bytes)
+		},
+		{
+			name:         "With EL - reduced commits (22 char user, 9 bytes available after space)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("1234567890123456789012"), // 22 chars, need 23 with space, leaves 9
+			wantPrefix:   "GEabPR",                          // Reduced format (8 bytes)
+		},
+		{
+			name:         "With EL - codes only (26 char user, 5 bytes available after space)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("12345678901234567890123456"), // 26 chars, need 27 with space, leaves 5
+			wantPrefix:   "GEPR ",                               // Codes only (4 bytes) + space
+		},
+		{
+			name:         "With EL - EL code only (28 char user, 3 bytes available after space)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("1234567890123456789012345678"), // 28 chars, need 29 with space, leaves 3
+			wantPrefix:   "GE ",                                   // EL code (2 bytes) + space
+		},
+		{
+			name:         "With EL - user only (30 char user, 1 byte available after space)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("123456789012345678901234567890"), // 30 chars, need 31 with space, leaves 1
+			wantPrefix:   "123456789012345678901234567890",          // Not enough for code+space, user only
+		},
+		{
+			name:         "With EL - user only (32 char user, 0 bytes available)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("12345678901234567890123456789012"),
+			wantPrefix:   "12345678901234567890123456789012",
+		},
+		// Null byte handling
+		{
+			name:         "Null bytes - input with trailing nulls",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: append([]byte("test"), 0, 0, 0),
+			wantPrefix:   "GEabcdPR",
+			wantSuffix:   " test",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewGraffitiInfo()
+			if tt.elCode != "" {
+				g.UpdateFromEngine(tt.elCode, tt.elCommit)
+			}
+
+			result := g.GenerateGraffiti(tt.userGraffiti)
+			resultStr := string(result[:])
+
+			// Check prefix
+			require.Equal(t, true, len(resultStr) >= len(tt.wantPrefix), "Result too short for prefix check")
+			require.Equal(t, tt.wantPrefix, resultStr[:len(tt.wantPrefix)], "Prefix mismatch")
+
+			// Check suffix if specified
+			if tt.wantSuffix != "" {
+				trimmed := trimNullBytes(resultStr)
+				require.Equal(t, true, len(trimmed) >= len(tt.wantSuffix), "Result too short for suffix check")
+				require.Equal(t, tt.wantSuffix, trimmed[len(trimmed)-len(tt.wantSuffix):], "Suffix mismatch")
+			}
+		})
+	}
+}
+
+func TestGraffitiInfo_UpdateFromEngine(t *testing.T) {
+	g := NewGraffitiInfo()
+
+	// Initially no EL info - should still have CL info (PR + commit)
+	result := g.GenerateGraffiti([]byte{})
+	resultStr := string(result[:])
+	require.Equal(t, "PR", resultStr[:2], "Expected CL info before update")
+
+	// Update with EL info
+	g.UpdateFromEngine("GE", "1234abcd")
+
+	result = g.GenerateGraffiti([]byte{})
+	resultStr = string(result[:])
+	require.Equal(t, "GE1234PR", resultStr[:8], "Expected EL+CL info after update")
+}
+
+func TestTruncateCommit(t *testing.T) {
+	tests := []struct {
+		commit string
+		n      int
+		want   string
+	}{
+		{"abcd1234", 4, "abcd"},
+		{"ab", 4, "ab"},
+		{"", 4, ""},
+		{"abcdef", 2, "ab"},
+	}
+
+	for _, tt := range tests {
+		got := truncateCommit(tt.commit, tt.n)
+		require.Equal(t, tt.want, got)
+	}
+}
+
+func trimNullBytes(s string) string {
+	for len(s) > 0 && s[len(s)-1] == 0 {
+		s = s[:len(s)-1]
+	}
+	return s
+}

beacon-chain/execution/options.go

@@ -124,3 +124,11 @@ func WithVerifierWaiter(v *verification.InitializerWaiter) Option {
 		return nil
 	}
 }
+
+// WithGraffitiInfo sets the GraffitiInfo for client version tracking.
+func WithGraffitiInfo(g *GraffitiInfo) Option {
+	return func(s *Service) error {
+		s.graffitiInfo = g
+		return nil
+	}
+}

beacon-chain/execution/service.go

@@ -162,6 +162,7 @@ type Service struct {
 	verifierWaiter          *verification.InitializerWaiter
 	blobVerifier            verification.NewBlobVerifier
 	capabilityCache         *capabilityCache
+	graffitiInfo            *GraffitiInfo
 }
 
 // NewService sets up a new instance with an ethclient when given a web3 endpoint as a string in the config.
@@ -318,6 +319,28 @@ func (s *Service) updateConnectedETH1(state bool) {
 	s.updateBeaconNodeStats()
 }
 
+// GraffitiInfo returns the GraffitiInfo struct for graffiti generation.
+func (s *Service) GraffitiInfo() *GraffitiInfo {
+	return s.graffitiInfo
+}
+
+// updateGraffitiInfo fetches EL client version and updates the graffiti info.
+func (s *Service) updateGraffitiInfo() {
+	if s.graffitiInfo == nil {
+		return
+	}
+	ctx, cancel := context.WithTimeout(s.ctx, time.Second)
+	defer cancel()
+	versions, err := s.GetClientVersion(ctx)
+	if err != nil {
+		log.WithError(err).Debug("Could not get execution client version for graffiti")
+		return
+	}
+	if len(versions) >= 1 {
+		s.graffitiInfo.UpdateFromEngine(versions[0].Code, versions[0].Commit)
+	}
+}
+
 // refers to the latest eth1 block which follows the condition: eth1_timestamp +
 // SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE <= current_unix_time
 func (s *Service) followedBlockHeight(ctx context.Context) (uint64, error) {
@@ -598,6 +621,12 @@ func (s *Service) run(done <-chan struct{}) {
 	chainstartTicker := time.NewTicker(logPeriod)
 	defer chainstartTicker.Stop()
 
+	// Update graffiti info 4 times per epoch (~96 seconds with 12s slots and 32 slots/epoch)
+	graffitiTicker := time.NewTicker(96 * time.Second)
+	defer graffitiTicker.Stop()
+	// Initial update
+	s.updateGraffitiInfo()
+
 	for {
 		select {
 		case <-done:
@@ -622,6 +651,8 @@ func (s *Service) run(done <-chan struct{}) {
 				continue
 			}
 			s.logTillChainStart(context.Background())
+		case <-graffitiTicker.C:
+			s.updateGraffitiInfo()
 		}
 	}
 }

beacon-chain/light-client/store_test.go

@@ -75,6 +75,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 	p2p := p2pTesting.NewTestP2P(t)
 	lcStore := NewLightClientStore(p2p, new(event.Feed), testDB.SetupDB(t))
 
+	timeForGoroutinesToFinish := 20 * time.Microsecond
 	// update 0 with basic data and no supermajority following an empty lastFinalityUpdate - should save and broadcast
 	l0 := util.NewTestLightClient(t, version.Altair)
 	update0, err := NewLightClientFinalityUpdateFromBeaconState(l0.Ctx, l0.State, l0.Block, l0.AttestedState, l0.AttestedBlock, l0.FinalizedBlock)
@@ -86,9 +87,8 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update0, true)
 	require.Equal(t, update0, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Eventually(t, func() bool {
-		return p2p.BroadcastCalled.Load()
-	}, time.Second, 10*time.Millisecond, "Broadcast should have been called after setting a new last finality update when previous is nil")
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update when previous is nil")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
 	// update 1 with same finality slot, increased attested slot, and no supermajority - should save but not broadcast
@@ -102,7 +102,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update1, true)
 	require.Equal(t, update1, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called after setting a new last finality update without supermajority")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
@@ -117,9 +117,8 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update2, true)
 	require.Equal(t, update2, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Eventually(t, func() bool {
-		return p2p.BroadcastCalled.Load()
-	}, time.Second, 10*time.Millisecond, "Broadcast should have been called after setting a new last finality update with supermajority")
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update with supermajority")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
 	// update 3 with same finality slot, increased attested slot, and supermajority - should save but not broadcast
@@ -133,7 +132,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update3, true)
 	require.Equal(t, update3, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been when previous was already broadcast")
 
 	// update 4 with increased finality slot, increased attested slot, and supermajority - should save and broadcast
@@ -147,9 +146,8 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update4, true)
 	require.Equal(t, update4, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Eventually(t, func() bool {
-		return p2p.BroadcastCalled.Load()
-	}, time.Second, 10*time.Millisecond, "Broadcast should have been called after a new finality update with increased finality slot")
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after a new finality update with increased finality slot")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
 	// update 5 with the same new finality slot, increased attested slot, and supermajority - should save but not broadcast
@@ -163,7 +161,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update5, true)
 	require.Equal(t, update5, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
 
 	// update 6 with the same new finality slot, increased attested slot, and no supermajority - should save but not broadcast
@@ -177,7 +175,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update6, true)
 	require.Equal(t, update6, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
 }
 

beacon-chain/node/node.go

@@ -775,6 +775,9 @@ func (b *BeaconNode) registerPOWChainService() error {
 		return err
 	}
 
+	// Create GraffitiInfo for client version tracking in block graffiti
+	graffitiInfo := execution.NewGraffitiInfo()
+
 	// skipcq: CRT-D0001
 	opts := append(
 		b.serviceFlagOpts.executionChainFlagOpts,
@@ -787,6 +790,7 @@ func (b *BeaconNode) registerPOWChainService() error {
 		execution.WithFinalizedStateAtStartup(b.finalizedStateAtStartUp),
 		execution.WithJwtId(b.cliCtx.String(flags.JwtId.Name)),
 		execution.WithVerifierWaiter(b.verifyInitWaiter),
+		execution.WithGraffitiInfo(graffitiInfo),
 	)
 	web3Service, err := execution.NewService(b.ctx, opts...)
 	if err != nil {
@@ -993,6 +997,7 @@ func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 		TrackedValidatorsCache:    b.trackedValidatorsCache,
 		PayloadIDCache:            b.payloadIDCache,
 		LCStore:                   b.lcStore,
+		GraffitiInfo:              web3Service.GraffitiInfo(),
 	})
 
 	return b.services.RegisterService(rpcService)

beacon-chain/p2p/broadcaster.go

@@ -22,7 +22,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/sirupsen/logrus"
@@ -358,99 +357,58 @@ func (s *Service) BroadcastDataColumnSidecars(ctx context.Context, sidecars []bl
 	return nil
 }
 
-// broadcastDataColumnSidecars broadcasts multiple data column sidecars to the p2p network.
-// For sidecars with available peers, it uses batch publishing.
-// For sidecars without peers, it finds peers first and then publishes individually.
-// Both paths run in parallel. It returns when all broadcasts are complete, or the context is cancelled.
+// broadcastDataColumnSidecars broadcasts multiple data column sidecars to the p2p network, after ensuring
+// there is at least one peer in each needed subnet. If not, it will attempt to find one before broadcasting.
+// It returns when all broadcasts are complete, or the context is cancelled (whichever comes first).
 func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [fieldparams.VersionLength]byte, sidecars []blocks.VerifiedRODataColumn) {
 	type rootAndIndex struct {
 		root  [fieldparams.RootLength]byte
 		index uint64
 	}
 
-	var timings sync.Map
+	var (
+		wg      sync.WaitGroup
+		timings sync.Map
+	)
+
 	logLevel := logrus.GetLevel()
+
 	slotPerRoot := make(map[[fieldparams.RootLength]byte]primitives.Slot, 1)
-
-	topicFunc := func(sidecar blocks.VerifiedRODataColumn) (topic string, wrappedSubIdx uint64, subnet uint64) {
-		subnet = peerdas.ComputeSubnetForDataColumnSidecar(sidecar.Index)
-		topic = dataColumnSubnetToTopic(subnet, forkDigest)
-		wrappedSubIdx = subnet + dataColumnSubnetVal
-		return
-	}
-
-	sidecarsWithPeers := make([]blocks.VerifiedRODataColumn, 0, len(sidecars))
-	var sidecarsWithoutPeers []blocks.VerifiedRODataColumn
-
-	// Categorize sidecars by peer availability.
 	for _, sidecar := range sidecars {
 		slotPerRoot[sidecar.BlockRoot()] = sidecar.Slot()
 
-		topic, wrappedSubIdx, _ := topicFunc(sidecar)
-		// Check if we have a peer for this subnet (use RLock for read-only check).
-		mu := s.subnetLocker(wrappedSubIdx)
-		mu.RLock()
-		hasPeer := s.hasPeerWithSubnet(topic)
-		mu.RUnlock()
-
-		if hasPeer {
-			sidecarsWithPeers = append(sidecarsWithPeers, sidecar)
-			continue
-		}
-
-		sidecarsWithoutPeers = append(sidecarsWithoutPeers, sidecar)
-	}
-
-	var batchWg, individualWg sync.WaitGroup
-
-	// Batch publish sidecars that already have peers
-	var messageBatch pubsub.MessageBatch
-	for _, sidecar := range sidecarsWithPeers {
-		batchWg.Go(func() {
-			_, span := trace.StartSpan(ctx, "p2p.broadcastDataColumnSidecars")
-			ctx := trace.NewContext(s.ctx, span)
+		wg.Go(func() {
+			// Add tracing to the function.
+			ctx, span := trace.StartSpan(s.ctx, "p2p.broadcastDataColumnSidecars")
 			defer span.End()
 
-			topic, _, _ := topicFunc(sidecar)
+			// Compute the subnet for this data column sidecar.
+			subnet := peerdas.ComputeSubnetForDataColumnSidecar(sidecar.Index)
 
-			if err := s.batchObject(ctx, &messageBatch, sidecar, topic); err != nil {
-				tracing.AnnotateError(span, err)
-				log.WithError(err).Error("Cannot batch data column sidecar")
-				return
-			}
+			// Build the topic corresponding to subnet column subnet and this fork digest.
+			topic := dataColumnSubnetToTopic(subnet, forkDigest)
 
-			if logLevel >= logrus.DebugLevel {
-				root := sidecar.BlockRoot()
-				timings.Store(rootAndIndex{root: root, index: sidecar.Index}, time.Now())
-			}
-		})
-	}
+			// Compute the wrapped subnet index.
+			wrappedSubIdx := subnet + dataColumnSubnetVal
 
-	// For sidecars without peers, find peers and publish individually (no batching).
-	for _, sidecar := range sidecarsWithoutPeers {
-		individualWg.Go(func() {
-			_, span := trace.StartSpan(ctx, "p2p.broadcastDataColumnSidecars")
-			ctx := trace.NewContext(s.ctx, span)
-			defer span.End()
-
-			topic, wrappedSubIdx, subnet := topicFunc(sidecar)
-
-			// Find peers for this sidecar's subnet.
+			// Find peers if needed.
 			if err := s.findPeersIfNeeded(ctx, wrappedSubIdx, DataColumnSubnetTopicFormat, forkDigest, subnet); err != nil {
 				tracing.AnnotateError(span, err)
 				log.WithError(err).Error("Cannot find peers if needed")
 				return
 			}
 
-			// Publish individually (not batched) since we just found peers.
+			// Broadcast the data column sidecar to the network.
 			if err := s.broadcastObject(ctx, sidecar, topic); err != nil {
 				tracing.AnnotateError(span, err)
 				log.WithError(err).Error("Cannot broadcast data column sidecar")
 				return
 			}
 
+			// Increase the number of successful broadcasts.
 			dataColumnSidecarBroadcasts.Inc()
 
+			// Record the timing for log purposes.
 			if logLevel >= logrus.DebugLevel {
 				root := sidecar.BlockRoot()
 				timings.Store(rootAndIndex{root: root, index: sidecar.Index}, time.Now())
@@ -458,18 +416,8 @@ func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [f
 		})
 	}
 
-	// Wait for batch to be populated, then publish.
-	batchWg.Wait()
-	if len(sidecarsWithPeers) > 0 {
-		if err := s.pubsub.PublishBatch(&messageBatch); err != nil {
-			log.WithError(err).Error("Cannot publish batch for data column sidecars")
-		} else {
-			dataColumnSidecarBroadcasts.Add(float64(len(sidecarsWithPeers)))
-		}
-	}
-
-	// Wait for all individual publishes to complete.
-	individualWg.Wait()
+	// Wait for all broadcasts to finish.
+	wg.Wait()
 
 	// The rest of this function is only for debug logging purposes.
 	if logLevel < logrus.DebugLevel {
@@ -556,68 +504,28 @@ func (s *Service) findPeersIfNeeded(
 	return nil
 }
 
-// encodeGossipMessage encodes an object for gossip transmission.
-// It returns the encoded bytes and the full topic with protocol suffix.
-func (s *Service) encodeGossipMessage(obj ssz.Marshaler, topic string) ([]byte, string, error) {
-	buf := new(bytes.Buffer)
-	if _, err := s.Encoding().EncodeGossip(buf, obj); err != nil {
-		return nil, "", fmt.Errorf("could not encode message: %w", err)
-	}
-	return buf.Bytes(), topic + s.Encoding().ProtocolSuffix(), nil
-}
-
-// broadcastObject broadcasts a message to other peers in our gossip mesh.
+// method to broadcast messages to other peers in our gossip mesh.
 func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic string) error {
 	ctx, span := trace.StartSpan(ctx, "p2p.broadcastObject")
 	defer span.End()
 
 	span.SetAttributes(trace.StringAttribute("topic", topic))
 
-	data, fullTopic, err := s.encodeGossipMessage(obj, topic)
-	if err != nil {
+	buf := new(bytes.Buffer)
+	if _, err := s.Encoding().EncodeGossip(buf, obj); err != nil {
+		err := errors.Wrap(err, "could not encode message")
 		tracing.AnnotateError(span, err)
 		return err
 	}
 
 	if span.IsRecording() {
-		id := hash.FastSum64(data)
-		messageLen := int64(len(data))
+		id := hash.FastSum64(buf.Bytes())
+		messageLen := int64(buf.Len())
 		// lint:ignore uintcast -- It's safe to do this for tracing.
 		iid := int64(id)
 		span = trace.AddMessageSendEvent(span, iid, messageLen /*uncompressed*/, messageLen /*compressed*/)
 	}
-
-	if err := s.PublishToTopic(ctx, fullTopic, data); err != nil {
-		err := errors.Wrap(err, "could not publish message")
-		tracing.AnnotateError(span, err)
-		return err
-	}
-	return nil
-}
-
-// batchObject adds an object to a message batch for a future broadcast.
-// The caller MUST publish the batch after all messages have been added.
-func (s *Service) batchObject(ctx context.Context, batch *pubsub.MessageBatch, obj ssz.Marshaler, topic string) error {
-	ctx, span := trace.StartSpan(ctx, "p2p.batchObject")
-	defer span.End()
-
-	span.SetAttributes(trace.StringAttribute("topic", topic))
-
-	data, fullTopic, err := s.encodeGossipMessage(obj, topic)
-	if err != nil {
-		tracing.AnnotateError(span, err)
-		return err
-	}
-
-	if span.IsRecording() {
-		id := hash.FastSum64(data)
-		messageLen := int64(len(data))
-		// lint:ignore uintcast -- It's safe to do this for tracing.
-		iid := int64(id)
-		span = trace.AddMessageSendEvent(span, iid, messageLen /*uncompressed*/, messageLen /*compressed*/)
-	}
-
-	if err := s.addToBatch(ctx, batch, fullTopic, data); err != nil {
+	if err := s.PublishToTopic(ctx, topic+s.Encoding().ProtocolSuffix(), buf.Bytes()); err != nil {
 		err := errors.Wrap(err, "could not publish message")
 		tracing.AnnotateError(span, err)
 		return err

beacon-chain/p2p/broadcaster_test.go

@@ -32,8 +32,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/host"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/libp2p/go-libp2p/core/protocol"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -72,10 +70,7 @@ func TestService_Broadcast(t *testing.T) {
 	sub, err := p2.SubscribeToTopic(topic)
 	require.NoError(t, err)
 
-	// Wait for libp2p mesh to establish
-	require.Eventually(t, func() bool {
-		return len(p.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
 
 	// Async listen for the pubsub, must be before the broadcast.
 	var wg sync.WaitGroup
@@ -189,10 +184,7 @@ func TestService_BroadcastAttestation(t *testing.T) {
 	sub, err := p2.SubscribeToTopic(topic)
 	require.NoError(t, err)
 
-	// Wait for libp2p mesh to establish
-	require.Eventually(t, func() bool {
-		return len(p.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
 
 	// Async listen for the pubsub, must be before the broadcast.
 	var wg sync.WaitGroup
@@ -381,15 +373,7 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 	_, err = tpHandle.Subscribe()
 	require.NoError(t, err)
 
-	// This test specifically tests discovery-based peer finding, which requires
-	// time for nodes to discover each other. Using a fixed sleep here is intentional
-	// as we're testing the discovery timing behavior.
-	time.Sleep(500 * time.Millisecond)
-
-	// Verify mesh establishment after discovery
-	require.Eventually(t, func() bool {
-		return len(p.pubsub.ListPeers(topic)) > 0 && len(p2.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	time.Sleep(500 * time.Millisecond) // libp2p fails without this delay...
 
 	nodePeers := p.pubsub.ListPeers(topic)
 	nodePeers2 := p2.pubsub.ListPeers(topic)
@@ -458,10 +442,7 @@ func TestService_BroadcastSyncCommittee(t *testing.T) {
 	sub, err := p2.SubscribeToTopic(topic)
 	require.NoError(t, err)
 
-	// Wait for libp2p mesh to establish
-	require.Eventually(t, func() bool {
-		return len(p.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
 
 	// Async listen for the pubsub, must be before the broadcast.
 	var wg sync.WaitGroup
@@ -538,10 +519,7 @@ func TestService_BroadcastBlob(t *testing.T) {
 	sub, err := p2.SubscribeToTopic(topic)
 	require.NoError(t, err)
 
-	// Wait for libp2p mesh to establish
-	require.Eventually(t, func() bool {
-		return len(p.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
 
 	// Async listen for the pubsub, must be before the broadcast.
 	var wg sync.WaitGroup
@@ -604,10 +582,7 @@ func TestService_BroadcastLightClientOptimisticUpdate(t *testing.T) {
 	sub, err := p2.SubscribeToTopic(topic)
 	require.NoError(t, err)
 
-	// Wait for libp2p mesh to establish
-	require.Eventually(t, func() bool {
-		return len(p.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
 
 	// Async listen for the pubsub, must be before the broadcast.
 	var wg sync.WaitGroup
@@ -683,10 +658,7 @@ func TestService_BroadcastLightClientFinalityUpdate(t *testing.T) {
 	sub, err := p2.SubscribeToTopic(topic)
 	require.NoError(t, err)
 
-	// Wait for libp2p mesh to establish
-	require.Eventually(t, func() bool {
-		return len(p.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
 
 	// Async listen for the pubsub, must be before the broadcast.
 	var wg sync.WaitGroup
@@ -797,10 +769,8 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	sub, err := p2.SubscribeToTopic(topic)
 	require.NoError(t, err)
 
-	// Wait for libp2p mesh to establish
-	require.Eventually(t, func() bool {
-		return len(service.pubsub.ListPeers(topic)) > 0
-	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
+	// libp2p fails without this delay
+	time.Sleep(50 * time.Millisecond)
 
 	// Broadcast to peers and wait.
 	err = service.BroadcastDataColumnSidecars(ctx, []blocks.VerifiedRODataColumn{verifiedRoSidecar})
@@ -817,190 +787,3 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	require.NoError(t, service.Encoding().DecodeGossip(msg.Data, &result))
 	require.DeepEqual(t, &result, verifiedRoSidecar)
 }
-
-type topicInvoked struct {
-	topic string
-	pid   peer.ID
-}
-
-// rpcOrderTracer is a RawTracer implementation that captures the order of SendRPC calls.
-// It records the topics of messages sent via pubsub to verify round-robin ordering.
-type rpcOrderTracer struct {
-	mu      sync.Mutex
-	invoked []*topicInvoked
-	byTopic map[string][]peer.ID
-}
-
-func (t *rpcOrderTracer) SendRPC(rpc *pubsub.RPC, pid peer.ID) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	for _, msg := range rpc.GetPublish() {
-		invoked := &topicInvoked{topic: msg.GetTopic(), pid: pid}
-		t.invoked = append(t.invoked, invoked)
-		t.byTopic[invoked.topic] = append(t.byTopic[invoked.topic], invoked.pid)
-	}
-}
-
-func newRpcOrderTracer() *rpcOrderTracer {
-	return &rpcOrderTracer{byTopic: make(map[string][]peer.ID)}
-}
-
-func (t *rpcOrderTracer) getTopics() []string {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	result := make([]string, len(t.invoked))
-	for i := range t.invoked {
-		result[i] = t.invoked[i].topic
-	}
-	return result
-}
-
-// No-op implementations for other RawTracer methods.
-func (*rpcOrderTracer) AddPeer(peer.ID, protocol.ID)          {}
-func (*rpcOrderTracer) RemovePeer(peer.ID)                    {}
-func (*rpcOrderTracer) Join(string)                           {}
-func (*rpcOrderTracer) Leave(string)                          {}
-func (*rpcOrderTracer) Graft(peer.ID, string)                 {}
-func (*rpcOrderTracer) Prune(peer.ID, string)                 {}
-func (*rpcOrderTracer) ValidateMessage(*pubsub.Message)       {}
-func (*rpcOrderTracer) DeliverMessage(*pubsub.Message)        {}
-func (*rpcOrderTracer) RejectMessage(*pubsub.Message, string) {}
-func (*rpcOrderTracer) DuplicateMessage(*pubsub.Message)      {}
-func (*rpcOrderTracer) ThrottlePeer(peer.ID)                  {}
-func (*rpcOrderTracer) RecvRPC(*pubsub.RPC)                   {}
-func (*rpcOrderTracer) DropRPC(*pubsub.RPC, peer.ID)          {}
-func (*rpcOrderTracer) UndeliverableMessage(*pubsub.Message)  {}
-
-// TestService_BroadcastDataColumnRoundRobin verifies that when broadcasting multiple
-// data column sidecars, messages are interleaved in round-robin order by column index
-// rather than sending all copies of one column before the next.
-//
-// Without batch publishing: A,A,A,A,B,B,B,B (all peers for column A, then all for column B)
-// With batch publishing:    A,B,A,B,A,B,A,B (interleaved by message ID)
-func TestService_BroadcastDataColumnRoundRobin(t *testing.T) {
-	const (
-		port        = 2100
-		topicFormat = DataColumnSubnetTopicFormat
-	)
-
-	ctx := t.Context()
-
-	// Load the KZG trust setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	gFlags := new(flags.GlobalFlags)
-	gFlags.MinimumPeersPerSubnet = 1
-	flags.Init(gFlags)
-	defer flags.Init(new(flags.GlobalFlags))
-
-	// Create a tracer to capture the order of SendRPC calls.
-	tracer := newRpcOrderTracer()
-
-	// Create the publisher node with the tracer injected.
-	p1 := p2ptest.NewTestP2PWithPubsubOptions(t, []pubsub.Option{pubsub.WithRawTracer(tracer)})
-
-	// Create subscriber peers.
-	expectedPeers := []*p2ptest.TestP2P{
-		p2ptest.NewTestP2P(t),
-		p2ptest.NewTestP2P(t),
-	}
-
-	// Connect peers.
-	for _, p := range expectedPeers {
-		p1.Connect(p)
-	}
-	require.NotEqual(t, 0, len(p1.BHost.Network().Peers()), "No peers")
-
-	// Create a host for discovery.
-	_, pkey, ipAddr := createHost(t, port)
-
-	// Create a shared DB for the service.
-	db := testDB.SetupDB(t)
-
-	// Create and close the custody info channel immediately since custodyInfo is already set.
-	custodyInfoSet := make(chan struct{})
-	close(custodyInfoSet)
-
-	service := &Service{
-		ctx:                   ctx,
-		host:                  p1.BHost,
-		pubsub:                p1.PubSub(),
-		joinedTopics:          map[string]*pubsub.Topic{},
-		cfg:                   &Config{DB: db},
-		genesisTime:           time.Now(),
-		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
-		subnetsLock:           make(map[uint64]*sync.RWMutex),
-		subnetsLockLock:       sync.Mutex{},
-		peers:                 peers.NewStatus(ctx, &peers.StatusConfig{ScorerParams: &scorers.Config{}}),
-		custodyInfo:           &custodyInfo{},
-		custodyInfoSet:        custodyInfoSet,
-	}
-
-	// Create a listener for discovery.
-	listener, err := service.startDiscoveryV5(ipAddr, pkey)
-	require.NoError(t, err)
-	service.dv5Listener = listener
-
-	digest, err := service.currentForkDigest()
-	require.NoError(t, err)
-
-	// Create multiple data column sidecars with different column indices.
-	// Use indices that map to different subnets: 0, 32, 64 (assuming 128 columns and 64 subnets).
-	columnIndices := []uint64{0, 32, 64}
-	params := make([]util.DataColumnParam, len(columnIndices))
-	for i, idx := range columnIndices {
-		params[i] = util.DataColumnParam{Index: idx}
-	}
-	_, verifiedRoSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, params)
-
-	expectedTopics := make(map[string]bool)
-	// Subscribe peers to the relevant topics.
-	for _, idx := range columnIndices {
-		subnet := peerdas.ComputeSubnetForDataColumnSidecar(idx)
-		topic := fmt.Sprintf(topicFormat, digest, subnet) + service.Encoding().ProtocolSuffix()
-		for _, p := range expectedPeers {
-			_, err = p.SubscribeToTopic(topic)
-			require.NoError(t, err)
-		}
-		expectedTopics[topic] = true
-	}
-	// libp2p needs some time to establish mesh connections.
-	time.Sleep(100 * time.Millisecond)
-
-	// Broadcast all sidecars.
-	err = service.BroadcastDataColumnSidecars(ctx, verifiedRoSidecars)
-	require.NoError(t, err)
-	// Give some time for messages to be sent.
-	time.Sleep(100 * time.Millisecond)
-
-	topics := tracer.getTopics()
-	if len(topics) == 0 {
-		t.Fatal("Expected at least one message for each topic to be sent to each peer")
-	}
-
-	unseen := make(map[string]bool)
-	for k := range expectedTopics {
-		unseen[k] = true
-	}
-	// Verify round-robin invariant: before all message IDs are seen, no message ID may be repeated.
-	// In round-robin order, we should see each topic once before any topic repeats.
-	for _, topic := range topics {
-		if !expectedTopics[topic] {
-			continue
-		}
-		if !unseen[topic] {
-			t.Errorf("Topic %s repeated before all topics were seen once. This violates round-robin ordering.", topic)
-		}
-		delete(unseen, topic)
-		if len(unseen) == 0 {
-			break // all have been seen
-		}
-	}
-	require.Equal(t, 0, len(unseen))
-
-	// Verify that we actually saw all expected topics.
-	for topic := range expectedTopics {
-		require.Equal(t, len(expectedPeers), len(tracer.byTopic[topic]))
-	}
-}

beacon-chain/p2p/discovery_test.go

@@ -482,12 +482,12 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) {
 		s.Start()
 		<-exitRoutine
 	}()
-	time.Sleep(50 * time.Millisecond) // Wait for service initialization
+	time.Sleep(50 * time.Millisecond)
 	var vr [32]byte
 	require.NoError(t, cs.SetClock(startup.NewClock(time.Now(), vr)))
-	require.Eventually(t, func() bool {
-		return len(s.host.Network().Peers()) == 5
-	}, 10*time.Second, 100*time.Millisecond, "Not all peers added to peerstore")
+	time.Sleep(4 * time.Second)
+	ps := s.host.Network().Peers()
+	assert.Equal(t, 5, len(ps), "Not all peers added to peerstore")
 	require.NoError(t, s.Stop())
 	exitRoutine <- true
 }

beacon-chain/p2p/pubsub.go

@@ -99,27 +99,6 @@ func (s *Service) PublishToTopic(ctx context.Context, topic string, data []byte,
 	}
 }
 
-// addToBatch joins (if necessary) a topic and adds the message to a message batch.
-func (s *Service) addToBatch(ctx context.Context, batch *pubsub.MessageBatch, topic string, data []byte, opts ...pubsub.PubOpt) error {
-	topicHandle, err := s.JoinTopic(topic)
-	if err != nil {
-		return fmt.Errorf("joining topic: %w", err)
-	}
-
-	// Wait for at least 1 peer to be available to receive the published message.
-	for {
-		if flags.Get().MinimumSyncPeers == 0 || len(topicHandle.ListPeers()) > 0 {
-			return topicHandle.AddToBatch(ctx, batch, data, opts...)
-		}
-		select {
-		case <-ctx.Done():
-			return errors.Wrapf(ctx.Err(), "unable to find requisite number of peers for topic %s, 0 peers found to publish to", topic)
-		case <-time.After(100 * time.Millisecond):
-			// reenter the for loop after 100ms
-		}
-	}
-}
-
 // SubscribeToTopic joins (if necessary) and subscribes to PubSub topic.
 func (s *Service) SubscribeToTopic(topic string, opts ...pubsub.SubOpt) (*pubsub.Subscription, error) {
 	s.awaitStateInitialized() // Genesis time and genesis validators root are required to subscribe.

beacon-chain/p2p/service_test.go

@@ -80,9 +80,8 @@ func TestService_Start_OnlyStartsOnce(t *testing.T) {
 	}()
 	var vr [32]byte
 	require.NoError(t, cs.SetClock(startup.NewClock(time.Now(), vr)))
-	require.Eventually(t, func() bool {
-		return s.started
-	}, 5*time.Second, 100*time.Millisecond, "Expected service to be started")
+	time.Sleep(time.Second * 2)
+	assert.Equal(t, true, s.started, "Expected service to be started")
 	s.Start()
 	require.LogsContain(t, hook, "Attempted to start p2p service when it was already started")
 	require.NoError(t, s.Stop())
@@ -261,9 +260,17 @@ func TestListenForNewNodes(t *testing.T) {
 	err = cs.SetClock(startup.NewClock(genesisTime, gvr))
 	require.NoError(t, err, "Could not set clock in service")
 
-	require.Eventually(t, func() bool {
-		return len(s.host.Network().Peers()) == peerCount
-	}, 5*time.Second, 100*time.Millisecond, "Not all peers added to peerstore")
+	actualPeerCount := len(s.host.Network().Peers())
+	for range 40 {
+		if actualPeerCount == peerCount {
+			break
+		}
+
+		time.Sleep(100 * time.Millisecond)
+		actualPeerCount = len(s.host.Network().Peers())
+	}
+
+	assert.Equal(t, peerCount, actualPeerCount, "Not all peers added to peerstore")
 
 	err = s.Stop()
 	require.NoError(t, err, "Failed to stop service")

beacon-chain/p2p/testing/p2p.go

@@ -70,11 +70,6 @@ type TestP2P struct {
 
 // NewTestP2P initializes a new p2p test service.
 func NewTestP2P(t *testing.T, userOptions ...config.Option) *TestP2P {
-	return NewTestP2PWithPubsubOptions(t, nil, userOptions...)
-}
-
-// NewTestP2PWithPubsubOptions initializes a new p2p test service with custom pubsub options.
-func NewTestP2PWithPubsubOptions(t *testing.T, pubsubOpts []pubsub.Option, userOptions ...config.Option) *TestP2P {
 	ctx := context.Background()
 	options := []config.Option{
 		libp2p.ResourceManager(&network.NullResourceManager{}),
@@ -89,14 +84,10 @@ func NewTestP2PWithPubsubOptions(t *testing.T, pubsubOpts []pubsub.Option, userO
 
 	h, err := libp2p.New(options...)
 	require.NoError(t, err)
-
-	defaultPubsubOpts := []pubsub.Option{
+	ps, err := pubsub.NewFloodSub(ctx, h,
 		pubsub.WithMessageSigning(false),
 		pubsub.WithStrictSignatureVerification(false),
-	}
-	allPubsubOpts := append(defaultPubsubOpts, pubsubOpts...)
-
-	ps, err := pubsub.NewGossipSub(ctx, h, allPubsubOpts...)
+	)
 	if err != nil {
 		t.Fatal(err)
 	}

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

@@ -657,9 +657,8 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Source.Epoch)
 			assert.Equal(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", hexutil.Encode(broadcaster.BroadcastAttestations[0].GetData().Target.Root))
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Target.Epoch)
-			require.Eventually(t, func() bool {
-				return s.AttestationsPool.UnaggregatedAttestationCount() == 1
-			}, time.Second, 10*time.Millisecond, "Expected 1 attestation in pool")
+			time.Sleep(100 * time.Millisecond) // Wait for async pool save
+			assert.Equal(t, 1, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("multiple", func(t *testing.T) {
 			broadcaster := &p2pMock.MockBroadcaster{}
@@ -678,9 +677,8 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, http.StatusOK, writer.Code)
 			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
 			assert.Equal(t, 2, broadcaster.NumAttestations())
-			require.Eventually(t, func() bool {
-				return s.AttestationsPool.UnaggregatedAttestationCount() == 2
-			}, time.Second, 10*time.Millisecond, "Expected 2 attestations in pool")
+			time.Sleep(100 * time.Millisecond) // Wait for async pool save
+			assert.Equal(t, 2, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("phase0 att post electra", func(t *testing.T) {
 			params.SetupTestConfigCleanup(t)
@@ -800,9 +798,8 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Source.Epoch)
 			assert.Equal(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", hexutil.Encode(broadcaster.BroadcastAttestations[0].GetData().Target.Root))
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Target.Epoch)
-			require.Eventually(t, func() bool {
-				return s.AttestationsPool.UnaggregatedAttestationCount() == 1
-			}, time.Second, 10*time.Millisecond, "Expected 1 attestation in pool")
+			time.Sleep(100 * time.Millisecond) // Wait for async pool save
+			assert.Equal(t, 1, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("multiple", func(t *testing.T) {
 			broadcaster := &p2pMock.MockBroadcaster{}
@@ -821,9 +818,8 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, http.StatusOK, writer.Code)
 			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
 			assert.Equal(t, 2, broadcaster.NumAttestations())
-			require.Eventually(t, func() bool {
-				return s.AttestationsPool.UnaggregatedAttestationCount() == 2
-			}, time.Second, 10*time.Millisecond, "Expected 2 attestations in pool")
+			time.Sleep(100 * time.Millisecond) // Wait for async pool save
+			assert.Equal(t, 2, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("no body", func(t *testing.T) {
 			request := httptest.NewRequest(http.MethodPost, "http://example.com", nil)
@@ -1379,9 +1375,9 @@ func TestSubmitSignedBLSToExecutionChanges_Ok(t *testing.T) {
 	writer.Body = &bytes.Buffer{}
 	s.SubmitBLSToExecutionChanges(writer, request)
 	assert.Equal(t, http.StatusOK, writer.Code)
-	require.Eventually(t, func() bool {
-		return broadcaster.BroadcastCalled.Load() && len(broadcaster.BroadcastMessages) == numValidators
-	}, time.Second, 10*time.Millisecond, "Broadcast should be called with all messages")
+	time.Sleep(100 * time.Millisecond) // Delay to let the routine start
+	assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
+	assert.Equal(t, numValidators, len(broadcaster.BroadcastMessages))
 
 	poolChanges, err := s.BLSChangesPool.PendingBLSToExecChanges()
 	require.Equal(t, len(poolChanges), len(signedChanges))
@@ -1595,10 +1591,10 @@ func TestSubmitSignedBLSToExecutionChanges_Failures(t *testing.T) {
 
 	s.SubmitBLSToExecutionChanges(writer, request)
 	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	time.Sleep(10 * time.Millisecond) // Delay to allow the routine to start
 	require.StringContains(t, "One or more messages failed validation", writer.Body.String())
-	require.Eventually(t, func() bool {
-		return broadcaster.BroadcastCalled.Load() && len(broadcaster.BroadcastMessages)+1 == numValidators
-	}, time.Second, 10*time.Millisecond, "Broadcast should be called with expected messages")
+	assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
+	assert.Equal(t, numValidators, len(broadcaster.BroadcastMessages)+1)
 
 	poolChanges, err := s.BLSChangesPool.PendingBLSToExecChanges()
 	require.Equal(t, len(poolChanges)+1, len(signedChanges))

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -89,7 +89,13 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	}
 	// Set slot, graffiti, randao reveal, and parent root.
 	sBlk.SetSlot(req.Slot)
-	sBlk.SetGraffiti(req.Graffiti)
+	// Generate graffiti with client version info using flexible standard
+	if vs.GraffitiInfo != nil {
+		graffiti := vs.GraffitiInfo.GenerateGraffiti(req.Graffiti)
+		sBlk.SetGraffiti(graffiti[:])
+	} else {
+		sBlk.SetGraffiti(req.Graffiti)
+	}
 	sBlk.SetRandaoReveal(req.RandaoReveal)
 	sBlk.SetParentRoot(parentRoot[:])
 

beacon-chain/rpc/prysm/v1alpha1/validator/server.go

@@ -83,6 +83,7 @@ type Server struct {
 	ClockWaiter             startup.ClockWaiter
 	CoreService             *core.Service
 	AttestationStateFetcher blockchain.AttestationStateFetcher
+	GraffitiInfo            *execution.GraffitiInfo
 }
 
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.

beacon-chain/rpc/service.go

@@ -125,6 +125,7 @@ type Config struct {
 	TrackedValidatorsCache    *cache.TrackedValidatorsCache
 	PayloadIDCache            *cache.PayloadIDCache
 	LCStore                   *lightClient.Store
+	GraffitiInfo              *execution.GraffitiInfo
 }
 
 // NewService instantiates a new RPC service instance that will
@@ -256,6 +257,7 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		TrackedValidatorsCache:  s.cfg.TrackedValidatorsCache,
 		PayloadIDCache:          s.cfg.PayloadIDCache,
 		AttestationStateFetcher: s.cfg.AttestationReceiver,
+		GraffitiInfo:            s.cfg.GraffitiInfo,
 	}
 	s.validatorServer = validatorServer
 	nodeServer := &nodev1alpha1.Server{

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

@@ -102,7 +102,6 @@ go_test(
         "getters_test.go",
         "getters_validator_test.go",
         "getters_withdrawal_test.go",
-        "gloas_test.go",
         "hasher_test.go",
         "mvslice_fuzz_test.go",
         "proofs_test.go",
@@ -157,7 +156,6 @@ go_test(
         "@com_github_google_go_cmp//cmp:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
         "@org_golang_google_protobuf//testing/protocmp:go_default_library",
     ],

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

@@ -72,13 +72,11 @@ type BeaconState struct {
 
 	// Gloas fields
 	latestExecutionPayloadBid    *ethpb.ExecutionPayloadBid
-	builders                     []*ethpb.Builder
-	nextWithdrawalBuilderIndex   primitives.BuilderIndex
 	executionPayloadAvailability []byte
 	builderPendingPayments       []*ethpb.BuilderPendingPayment
 	builderPendingWithdrawals    []*ethpb.BuilderPendingWithdrawal
 	latestBlockHash              []byte
-	payloadExpectedWithdrawals   []*enginev1.Withdrawal
+	latestWithdrawalsRoot        []byte
 
 	id                    uint64
 	lock                  sync.RWMutex
@@ -136,13 +134,11 @@ type beaconStateMarshalable struct {
 	PendingConsolidations               []*ethpb.PendingConsolidation           `json:"pending_consolidations" yaml:"pending_consolidations"`
 	ProposerLookahead                   []primitives.ValidatorIndex             `json:"proposer_look_ahead" yaml:"proposer_look_ahead"`
 	LatestExecutionPayloadBid           *ethpb.ExecutionPayloadBid              `json:"latest_execution_payload_bid" yaml:"latest_execution_payload_bid"`
-	Builders                            []*ethpb.Builder                        `json:"builders" yaml:"builders"`
-	NextWithdrawalBuilderIndex          primitives.BuilderIndex                 `json:"next_withdrawal_builder_index" yaml:"next_withdrawal_builder_index"`
 	ExecutionPayloadAvailability        []byte                                  `json:"execution_payload_availability" yaml:"execution_payload_availability"`
 	BuilderPendingPayments              []*ethpb.BuilderPendingPayment          `json:"builder_pending_payments" yaml:"builder_pending_payments"`
 	BuilderPendingWithdrawals           []*ethpb.BuilderPendingWithdrawal       `json:"builder_pending_withdrawals" yaml:"builder_pending_withdrawals"`
 	LatestBlockHash                     []byte                                  `json:"latest_block_hash" yaml:"latest_block_hash"`
-	PayloadExpectedWithdrawals          []*enginev1.Withdrawal                  `json:"payload_expected_withdrawals" yaml:"payload_expected_withdrawals"`
+	LatestWithdrawalsRoot               []byte                                  `json:"latest_withdrawals_root" yaml:"latest_withdrawals_root"`
 }
 
 func (b *BeaconState) MarshalJSON() ([]byte, error) {
@@ -198,13 +194,11 @@ func (b *BeaconState) MarshalJSON() ([]byte, error) {
 		PendingConsolidations:               b.pendingConsolidations,
 		ProposerLookahead:                   b.proposerLookahead,
 		LatestExecutionPayloadBid:           b.latestExecutionPayloadBid,
-		Builders:                            b.builders,
-		NextWithdrawalBuilderIndex:          b.nextWithdrawalBuilderIndex,
 		ExecutionPayloadAvailability:        b.executionPayloadAvailability,
 		BuilderPendingPayments:              b.builderPendingPayments,
 		BuilderPendingWithdrawals:           b.builderPendingWithdrawals,
 		LatestBlockHash:                     b.latestBlockHash,
-		PayloadExpectedWithdrawals:          b.payloadExpectedWithdrawals,
+		LatestWithdrawalsRoot:               b.latestWithdrawalsRoot,
 	}
 	return json.Marshal(marshalable)
 }

beacon-chain/state/state-native/custom-types/state_roots.go

@@ -56,7 +56,9 @@ func (r StateRoots) MarshalSSZTo(dst []byte) ([]byte, error) {
 func (r StateRoots) MarshalSSZ() ([]byte, error) {
 	marshalled := make([]byte, fieldparams.StateRootsLength*32)
 	for i, r32 := range r {
-		copy(marshalled[i*32:(i+1)*32], r32[:])
+		for j, rr := range r32 {
+			marshalled[i*32+j] = rr
+		}
 	}
 	return marshalled, nil
 }

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

@@ -305,12 +305,10 @@ func (b *BeaconState) ToProtoUnsafe() any {
 			PendingConsolidations:         b.pendingConsolidations,
 			ProposerLookahead:             lookahead,
 			ExecutionPayloadAvailability:  b.executionPayloadAvailability,
-			Builders:                      b.builders,
-			NextWithdrawalBuilderIndex:    b.nextWithdrawalBuilderIndex,
 			BuilderPendingPayments:        b.builderPendingPayments,
 			BuilderPendingWithdrawals:     b.builderPendingWithdrawals,
 			LatestBlockHash:               b.latestBlockHash,
-			PayloadExpectedWithdrawals:    b.payloadExpectedWithdrawals,
+			LatestWithdrawalsRoot:         b.latestWithdrawalsRoot,
 		}
 	default:
 		return nil
@@ -609,12 +607,10 @@ func (b *BeaconState) ToProto() any {
 			PendingConsolidations:         b.pendingConsolidationsVal(),
 			ProposerLookahead:             lookahead,
 			ExecutionPayloadAvailability:  b.executionPayloadAvailabilityVal(),
-			Builders:                      b.buildersVal(),
-			NextWithdrawalBuilderIndex:    b.nextWithdrawalBuilderIndex,
 			BuilderPendingPayments:        b.builderPendingPaymentsVal(),
 			BuilderPendingWithdrawals:     b.builderPendingWithdrawalsVal(),
 			LatestBlockHash:               b.latestBlockHashVal(),
-			PayloadExpectedWithdrawals:    b.payloadExpectedWithdrawalsVal(),
+			LatestWithdrawalsRoot:         b.latestWithdrawalsRootVal(),
 		}
 	default:
 		return nil

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

@@ -1,7 +1,6 @@
 package state_native
 
 import (
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 )
 
@@ -48,22 +47,6 @@ func (b *BeaconState) builderPendingWithdrawalsVal() []*ethpb.BuilderPendingWith
 	return withdrawals
 }
 
-// buildersVal returns a copy of the builders registry.
-// This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) buildersVal() []*ethpb.Builder {
-	if b.builders == nil {
-		return nil
-	}
-
-	builders := make([]*ethpb.Builder, len(b.builders))
-	for i := range builders {
-		builder := b.builders[i]
-		builders[i] = ethpb.CopyBuilder(builder)
-	}
-
-	return builders
-}
-
 // latestBlockHashVal returns a copy of the latest block hash.
 // This assumes that a lock is already held on BeaconState.
 func (b *BeaconState) latestBlockHashVal() []byte {
@@ -77,17 +60,15 @@ func (b *BeaconState) latestBlockHashVal() []byte {
 	return hash
 }
 
-// payloadExpectedWithdrawalsVal returns a copy of the payload expected withdrawals.
+// latestWithdrawalsRootVal returns a copy of the latest withdrawals root.
 // This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) payloadExpectedWithdrawalsVal() []*enginev1.Withdrawal {
-	if b.payloadExpectedWithdrawals == nil {
+func (b *BeaconState) latestWithdrawalsRootVal() []byte {
+	if b.latestWithdrawalsRoot == nil {
 		return nil
 	}
 
-	withdrawals := make([]*enginev1.Withdrawal, len(b.payloadExpectedWithdrawals))
-	for i, withdrawal := range b.payloadExpectedWithdrawals {
-		withdrawals[i] = withdrawal.Copy()
-	}
+	root := make([]byte, len(b.latestWithdrawalsRoot))
+	copy(root, b.latestWithdrawalsRoot)
 
-	return withdrawals
+	return root
 }

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

@@ -1,43 +0,0 @@
-package state_native
-
-import (
-	"testing"
-
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBuildersVal(t *testing.T) {
-	st := &BeaconState{}
-
-	require.Nil(t, st.buildersVal())
-
-	st.builders = []*ethpb.Builder{
-		{Pubkey: []byte{0x01}, ExecutionAddress: []byte{0x02}, Balance: 3},
-		nil,
-	}
-
-	got := st.buildersVal()
-	require.Len(t, got, 2)
-	require.Nil(t, got[1])
-	require.Equal(t, st.builders[0], got[0])
-	require.NotSame(t, st.builders[0], got[0])
-}
-
-func TestPayloadExpectedWithdrawalsVal(t *testing.T) {
-	st := &BeaconState{}
-
-	require.Nil(t, st.payloadExpectedWithdrawalsVal())
-
-	st.payloadExpectedWithdrawals = []*enginev1.Withdrawal{
-		{Index: 1, ValidatorIndex: 2, Address: []byte{0x03}, Amount: 4},
-		nil,
-	}
-
-	got := st.payloadExpectedWithdrawalsVal()
-	require.Len(t, got, 2)
-	require.Nil(t, got[1])
-	require.Equal(t, st.payloadExpectedWithdrawals[0], got[0])
-	require.NotSame(t, st.payloadExpectedWithdrawals[0], got[0])
-}

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

@@ -342,15 +342,6 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 	}
 
 	if state.version >= version.Gloas {
-		buildersRoot, err := stateutil.BuildersRoot(state.builders)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute builders merkleization")
-		}
-		fieldRoots[types.Builders.RealPosition()] = buildersRoot[:]
-
-		nextWithdrawalBuilderIndexRoot := ssz.Uint64Root(uint64(state.nextWithdrawalBuilderIndex))
-		fieldRoots[types.NextWithdrawalBuilderIndex.RealPosition()] = nextWithdrawalBuilderIndexRoot[:]
-
 		epaRoot, err := stateutil.ExecutionPayloadAvailabilityRoot(state.executionPayloadAvailability)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not compute execution payload availability merkleization")
@@ -375,12 +366,8 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		lbhRoot := bytesutil.ToBytes32(state.latestBlockHash)
 		fieldRoots[types.LatestBlockHash.RealPosition()] = lbhRoot[:]
 
-		expectedWithdrawalsRoot, err := ssz.WithdrawalSliceRoot(state.payloadExpectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute payload expected withdrawals root")
-		}
-
-		fieldRoots[types.PayloadExpectedWithdrawals.RealPosition()] = expectedWithdrawalsRoot[:]
+		lwrRoot := bytesutil.ToBytes32(state.latestWithdrawalsRoot)
+		fieldRoots[types.LatestWithdrawalsRoot.RealPosition()] = lwrRoot[:]
 	}
 	return fieldRoots, nil
 }

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

@@ -120,13 +120,11 @@ var (
 	)
 
 	gloasAdditionalFields = []types.FieldIndex{
-		types.Builders,
-		types.NextWithdrawalBuilderIndex,
 		types.ExecutionPayloadAvailability,
 		types.BuilderPendingPayments,
 		types.BuilderPendingWithdrawals,
 		types.LatestBlockHash,
-		types.PayloadExpectedWithdrawals,
+		types.LatestWithdrawalsRoot,
 	}
 
 	gloasFields = slices.Concat(
@@ -147,7 +145,7 @@ const (
 	denebSharedFieldRefCount     = 7
 	electraSharedFieldRefCount   = 10
 	fuluSharedFieldRefCount      = 11
-	gloasSharedFieldRefCount     = 13 // Adds Builders + BuilderPendingWithdrawals to the shared-ref set and LatestExecutionPayloadHeader is removed
+	gloasSharedFieldRefCount     = 12 // Adds PendingBuilderWithdrawal to the shared-ref set and LatestExecutionPayloadHeader is removed
 )
 
 // InitializeFromProtoPhase0 the beacon state from a protobuf representation.
@@ -819,13 +817,11 @@ func InitializeFromProtoUnsafeGloas(st *ethpb.BeaconStateGloas) (state.BeaconSta
 		pendingConsolidations:         st.PendingConsolidations,
 		proposerLookahead:             proposerLookahead,
 		latestExecutionPayloadBid:     st.LatestExecutionPayloadBid,
-		builders:                      st.Builders,
-		nextWithdrawalBuilderIndex:    st.NextWithdrawalBuilderIndex,
 		executionPayloadAvailability:  st.ExecutionPayloadAvailability,
 		builderPendingPayments:        st.BuilderPendingPayments,
 		builderPendingWithdrawals:     st.BuilderPendingWithdrawals,
 		latestBlockHash:               st.LatestBlockHash,
-		payloadExpectedWithdrawals:    st.PayloadExpectedWithdrawals,
+		latestWithdrawalsRoot:         st.LatestWithdrawalsRoot,
 		dirtyFields:                   make(map[types.FieldIndex]bool, fieldCount),
 		dirtyIndices:                  make(map[types.FieldIndex][]uint64, fieldCount),
 		stateFieldLeaves:              make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
@@ -865,7 +861,6 @@ func InitializeFromProtoUnsafeGloas(st *ethpb.BeaconStateGloas) (state.BeaconSta
 	b.sharedFieldReferences[types.PendingPartialWithdrawals] = stateutil.NewRef(1)
 	b.sharedFieldReferences[types.PendingConsolidations] = stateutil.NewRef(1)
 	b.sharedFieldReferences[types.ProposerLookahead] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.Builders] = stateutil.NewRef(1)                  // New in Gloas.
 	b.sharedFieldReferences[types.BuilderPendingWithdrawals] = stateutil.NewRef(1) // New in Gloas.
 
 	state.Count.Inc()
@@ -937,7 +932,6 @@ func (b *BeaconState) Copy() state.BeaconState {
 		pendingDeposits:            b.pendingDeposits,
 		pendingPartialWithdrawals:  b.pendingPartialWithdrawals,
 		pendingConsolidations:      b.pendingConsolidations,
-		builders:                   b.builders,
 
 		// Everything else, too small to be concerned about, constant size.
 		genesisValidatorsRoot:               b.genesisValidatorsRoot,
@@ -954,12 +948,11 @@ func (b *BeaconState) Copy() state.BeaconState {
 		latestExecutionPayloadHeaderCapella: b.latestExecutionPayloadHeaderCapella.Copy(),
 		latestExecutionPayloadHeaderDeneb:   b.latestExecutionPayloadHeaderDeneb.Copy(),
 		latestExecutionPayloadBid:           b.latestExecutionPayloadBid.Copy(),
-		nextWithdrawalBuilderIndex:          b.nextWithdrawalBuilderIndex,
 		executionPayloadAvailability:        b.executionPayloadAvailabilityVal(),
 		builderPendingPayments:              b.builderPendingPaymentsVal(),
 		builderPendingWithdrawals:           b.builderPendingWithdrawalsVal(),
 		latestBlockHash:                     b.latestBlockHashVal(),
-		payloadExpectedWithdrawals:          b.payloadExpectedWithdrawalsVal(),
+		latestWithdrawalsRoot:               b.latestWithdrawalsRootVal(),
 
 		id: types.Enumerator.Inc(),
 
@@ -1335,10 +1328,6 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		return stateutil.ProposerLookaheadRoot(b.proposerLookahead)
 	case types.LatestExecutionPayloadBid:
 		return b.latestExecutionPayloadBid.HashTreeRoot()
-	case types.Builders:
-		return stateutil.BuildersRoot(b.builders)
-	case types.NextWithdrawalBuilderIndex:
-		return ssz.Uint64Root(uint64(b.nextWithdrawalBuilderIndex)), nil
 	case types.ExecutionPayloadAvailability:
 		return stateutil.ExecutionPayloadAvailabilityRoot(b.executionPayloadAvailability)
 
@@ -1348,8 +1337,8 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		return stateutil.BuilderPendingWithdrawalsRoot(b.builderPendingWithdrawals)
 	case types.LatestBlockHash:
 		return bytesutil.ToBytes32(b.latestBlockHash), nil
-	case types.PayloadExpectedWithdrawals:
-		return ssz.WithdrawalSliceRoot(b.payloadExpectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
+	case types.LatestWithdrawalsRoot:
+		return bytesutil.ToBytes32(b.latestWithdrawalsRoot), nil
 	}
 	return [32]byte{}, errors.New("invalid field index provided")
 }

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

@@ -116,10 +116,6 @@ func (f FieldIndex) String() string {
 		return "pendingConsolidations"
 	case ProposerLookahead:
 		return "proposerLookahead"
-	case Builders:
-		return "builders"
-	case NextWithdrawalBuilderIndex:
-		return "nextWithdrawalBuilderIndex"
 	case ExecutionPayloadAvailability:
 		return "executionPayloadAvailability"
 	case BuilderPendingPayments:
@@ -128,8 +124,8 @@ func (f FieldIndex) String() string {
 		return "builderPendingWithdrawals"
 	case LatestBlockHash:
 		return "latestBlockHash"
-	case PayloadExpectedWithdrawals:
-		return "payloadExpectedWithdrawals"
+	case LatestWithdrawalsRoot:
+		return "latestWithdrawalsRoot"
 	default:
 		return fmt.Sprintf("unknown field index number: %d", f)
 	}
@@ -215,20 +211,16 @@ func (f FieldIndex) RealPosition() int {
 		return 36
 	case ProposerLookahead:
 		return 37
-	case Builders:
-		return 38
-	case NextWithdrawalBuilderIndex:
-		return 39
 	case ExecutionPayloadAvailability:
-		return 40
+		return 38
 	case BuilderPendingPayments:
-		return 41
+		return 39
 	case BuilderPendingWithdrawals:
-		return 42
+		return 40
 	case LatestBlockHash:
-		return 43
-	case PayloadExpectedWithdrawals:
-		return 44
+		return 41
+	case LatestWithdrawalsRoot:
+		return 42
 	default:
 		return -1
 	}
@@ -295,13 +287,11 @@ const (
 	PendingPartialWithdrawals     // Electra: EIP-7251
 	PendingConsolidations         // Electra: EIP-7251
 	ProposerLookahead             // Fulu: EIP-7917
-	Builders                      // Gloas: EIP-7732
-	NextWithdrawalBuilderIndex    // Gloas: EIP-7732
 	ExecutionPayloadAvailability  // Gloas: EIP-7732
 	BuilderPendingPayments        // Gloas: EIP-7732
 	BuilderPendingWithdrawals     // Gloas: EIP-7732
 	LatestBlockHash               // Gloas: EIP-7732
-	PayloadExpectedWithdrawals    // Gloas: EIP-7732
+	LatestWithdrawalsRoot         // Gloas: EIP-7732
 )
 
 // Enumerator keeps track of the number of states created since the node's start.

beacon-chain/state/stateutil/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "block_header_root.go",
         "builder_pending_payments_root.go",
         "builder_pending_withdrawals_root.go",
-        "builders_root.go",
         "eth1_root.go",
         "execution_payload_availability_root.go",
         "field_root_attestation.go",

beacon-chain/state/stateutil/builders_root.go

@@ -1,12 +0,0 @@
-package stateutil
-
-import (
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-// BuildersRoot computes the SSZ root of a slice of Builder.
-func BuildersRoot(slice []*ethpb.Builder) ([32]byte, error) {
-	return ssz.SliceRoot(slice, uint64(fieldparams.BuilderRegistryLimit))
-}

beacon-chain/sync/custody.go

@@ -10,72 +10,20 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
 var nilFinalizedStateError = errors.New("finalized state is nil")
 
-func (s *Service) maintainCustodyInfo() error {
-	// Rationale of slot choice:
-	// - If syncing with an empty DB from genesis, then justifiedSlot = finalizedSlot = 0,
-	//   and the node starts to sync from slot 0 ==> Using justifiedSlot is correct.
-	// - If syncing with an empty DB from a checkpoint, then justifiedSlot = finalizedSlot = checkpointSlot,
-	//   and the node starts to sync from checkpointSlot ==> Using justifiedSlot is correct.
-	// - If syncing with a non-empty DB, then justifiedSlot > finalizedSlot,
-	//   and the node starts to sync from justifiedSlot + 1 ==> Using justifiedSlot + 1 is correct.
+func (s *Service) maintainCustodyInfo() {
 	const interval = 1 * time.Minute
 
-	finalizedCheckpoint, err := s.cfg.beaconDB.FinalizedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "finalized checkpoint")
-	}
-
-	if finalizedCheckpoint == nil {
-		return errors.New("finalized checkpoint is nil")
-	}
-
-	finalizedSlot, err := slots.EpochStart(finalizedCheckpoint.Epoch)
-	if err != nil {
-		return errors.Wrap(err, "epoch start for finalized slot")
-	}
-
-	justifiedCheckpoint, err := s.cfg.beaconDB.JustifiedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "justified checkpoint")
-	}
-
-	if justifiedCheckpoint == nil {
-		return errors.New("justified checkpoint is nil")
-	}
-
-	justifiedSlot, err := slots.EpochStart(justifiedCheckpoint.Epoch)
-	if err != nil {
-		return errors.Wrap(err, "epoch start for justified slot")
-	}
-
-	slot := justifiedSlot
-	if justifiedSlot > finalizedSlot {
-		slot++
-	}
-
-	earliestAvailableSlot, custodySubnetCount, err := s.updateCustodyInfoInDB(slot)
-	if err != nil {
-		return errors.Wrap(err, "could not get and save custody group count")
-	}
-
-	if _, _, err := s.cfg.p2p.UpdateCustodyInfo(earliestAvailableSlot, custodySubnetCount); err != nil {
-		return errors.Wrap(err, "update custody info")
-	}
-
 	async.RunEvery(s.ctx, interval, func() {
 		if err := s.updateCustodyInfoIfNeeded(); err != nil {
 			log.WithError(err).Error("Failed to update custody info")
 		}
 	})
-
-	return nil
 }
 
 func (s *Service) updateCustodyInfoIfNeeded() error {

beacon-chain/sync/rpc_status_test.go

@@ -12,7 +12,6 @@ import (
 	mock "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/kv"
-	dbTest "github.com/OffchainLabs/prysm/v7/beacon-chain/db/testing"
 	testingDB "github.com/OffchainLabs/prysm/v7/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers"
@@ -935,7 +934,6 @@ func TestStatusRPCRequest_BadPeerHandshake(t *testing.T) {
 	r := &Service{
 		cfg: &config{
 			p2p:           p1,
-			beaconDB:      dbTest.SetupDB(t),
 			chain:         chain,
 			stateNotifier: chain.StateNotifier(),
 			initialSync:   &mockSync.Sync{IsSyncing: false},

beacon-chain/sync/service.go

@@ -17,7 +17,6 @@ import (
 	blockfeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/block"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/execution"
@@ -34,11 +33,9 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/sync/backfill/coverage"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
 	lruwrpr "github.com/OffchainLabs/prysm/v7/cache/lru"
-	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	leakybucket "github.com/OffchainLabs/prysm/v7/container/leaky-bucket"
 	"github.com/OffchainLabs/prysm/v7/crypto/rand"
 	"github.com/OffchainLabs/prysm/v7/runtime"
@@ -278,6 +275,11 @@ func (s *Service) Start() {
 
 	s.processPendingBlocksQueue()
 	s.maintainPeerStatuses()
+
+	if params.FuluEnabled() {
+		s.maintainCustodyInfo()
+	}
+
 	s.resyncIfBehind()
 
 	// Update sync metrics.
@@ -285,15 +287,6 @@ func (s *Service) Start() {
 
 	// Prune data column cache periodically on finalization.
 	async.RunEvery(s.ctx, 30*time.Second, s.pruneDataColumnCache)
-
-	if !params.FuluEnabled() {
-		return
-	}
-
-	if err := s.maintainCustodyInfo(); err != nil {
-		log.WithError(err).Error("Failed to maintain custody info")
-	}
-
 }
 
 // Stop the regular sync service.
@@ -459,89 +452,6 @@ func (s *Service) waitForInitialSync(ctx context.Context) error {
 	}
 }
 
-// UpdateCustodyInfoInDB updates the custody information in the database.
-// It returns the (potentially updated) custody group count and the earliest available slot.
-func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot, uint64, error) {
-	isSupernode := flags.Get().Supernode
-	isSemiSupernode := flags.Get().SemiSupernode
-
-	cfg := params.BeaconConfig()
-	custodyRequirement := cfg.CustodyRequirement
-
-	// Check if the node was previously subscribed to all data subnets, and if so,
-	// store the new status accordingly.
-	wasSupernode, err := s.cfg.beaconDB.UpdateSubscribedToAllDataSubnets(s.ctx, isSupernode)
-	if err != nil {
-		return 0, 0, errors.Wrap(err, "update subscribed to all data subnets")
-	}
-
-	// Compute the target custody group count based on current flag configuration.
-	targetCustodyGroupCount := custodyRequirement
-
-	// Supernode: custody all groups (either currently set or previously enabled)
-	if isSupernode {
-		targetCustodyGroupCount = cfg.NumberOfCustodyGroups
-	}
-
-	// Semi-supernode: custody minimum needed for reconstruction, or custody requirement if higher
-	if isSemiSupernode {
-		semiSupernodeCustody, err := peerdas.MinimumCustodyGroupCountToReconstruct()
-		if err != nil {
-			return 0, 0, errors.Wrap(err, "minimum custody group count")
-		}
-
-		targetCustodyGroupCount = max(custodyRequirement, semiSupernodeCustody)
-	}
-
-	// Safely compute the fulu fork slot.
-	fuluForkSlot, err := fuluForkSlot()
-	if err != nil {
-		return 0, 0, errors.Wrap(err, "fulu fork slot")
-	}
-
-	// If slot is before the fulu fork slot, then use the earliest stored slot as the reference slot.
-	if slot < fuluForkSlot {
-		slot, err = s.cfg.beaconDB.EarliestSlot(s.ctx)
-		if err != nil {
-			return 0, 0, errors.Wrap(err, "earliest slot")
-		}
-	}
-
-	earliestAvailableSlot, actualCustodyGroupCount, err := s.cfg.beaconDB.UpdateCustodyInfo(s.ctx, slot, targetCustodyGroupCount)
-	if err != nil {
-		return 0, 0, errors.Wrap(err, "update custody info")
-	}
-
-	if isSupernode {
-		log.WithFields(logrus.Fields{
-			"current": actualCustodyGroupCount,
-			"target":  cfg.NumberOfCustodyGroups,
-		}).Info("Supernode mode enabled. Will custody all data columns going forward.")
-	}
-
-	if wasSupernode && !isSupernode {
-		log.Warningf("Because the `--%s` flag was previously used, the node will continue to act as a super node.", flags.Supernode.Name)
-	}
-
-	return earliestAvailableSlot, actualCustodyGroupCount, nil
-}
-
-func fuluForkSlot() (primitives.Slot, error) {
-	cfg := params.BeaconConfig()
-
-	fuluForkEpoch := cfg.FuluForkEpoch
-	if fuluForkEpoch == cfg.FarFutureEpoch {
-		return cfg.FarFutureSlot, nil
-	}
-
-	forkFuluSlot, err := slots.EpochStart(fuluForkEpoch)
-	if err != nil {
-		return 0, errors.Wrap(err, "epoch start")
-	}
-
-	return forkFuluSlot, nil
-}
-
 // Checker defines a struct which can verify whether a node is currently
 // synchronizing a chain with the rest of peers in the network.
 type Checker interface {

beacon-chain/sync/service_test.go

@@ -16,9 +16,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	mockSync "github.com/OffchainLabs/prysm/v7/beacon-chain/sync/initial-sync/testing"
-	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	leakybucket "github.com/OffchainLabs/prysm/v7/container/leaky-bucket"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
@@ -73,6 +70,7 @@ func TestSyncHandlers_WaitToSync(t *testing.T) {
 
 	topic := "/eth2/%x/beacon_block"
 	go r.startDiscoveryAndSubscriptions()
+	time.Sleep(100 * time.Millisecond)
 
 	var vr [32]byte
 	require.NoError(t, gs.SetClock(startup.NewClock(time.Now(), vr)))
@@ -85,11 +83,9 @@ func TestSyncHandlers_WaitToSync(t *testing.T) {
 	msg.Block.ParentRoot = util.Random32Bytes(t)
 	msg.Signature = sk.Sign([]byte("data")).Marshal()
 	p2p.ReceivePubSub(topic, msg)
-
-	// Wait for chainstart event to be processed
-	require.Eventually(t, func() bool {
-		return r.chainStarted.IsSet()
-	}, 5*time.Second, 50*time.Millisecond, "Did not receive chain start event.")
+	// wait for chainstart to be sent
+	time.Sleep(400 * time.Millisecond)
+	require.Equal(t, true, r.chainStarted.IsSet(), "Did not receive chain start event.")
 }
 
 func TestSyncHandlers_WaitForChainStart(t *testing.T) {
@@ -221,18 +217,20 @@ func TestSyncService_StopCleanly(t *testing.T) {
 	p2p.Digest, err = r.currentForkDigest()
 	require.NoError(t, err)
 
-	// Wait for chainstart and topics to be registered
-	require.Eventually(t, func() bool {
-		return r.chainStarted.IsSet() && len(r.cfg.p2p.PubSub().GetTopics()) > 0 && len(r.cfg.p2p.Host().Mux().Protocols()) > 0
-	}, 5*time.Second, 50*time.Millisecond, "Did not receive chain start event or topics not registered.")
+	// wait for chainstart to be sent
+	time.Sleep(2 * time.Second)
+	require.Equal(t, true, r.chainStarted.IsSet(), "Did not receive chain start event.")
+
+	require.NotEqual(t, 0, len(r.cfg.p2p.PubSub().GetTopics()))
+	require.NotEqual(t, 0, len(r.cfg.p2p.Host().Mux().Protocols()))
 
 	// Both pubsub and rpc topics should be unsubscribed.
 	require.NoError(t, r.Stop())
 
-	// Wait for pubsub topics to be deregistered.
-	require.Eventually(t, func() bool {
-		return len(r.cfg.p2p.PubSub().GetTopics()) == 0 && len(r.cfg.p2p.Host().Mux().Protocols()) == 0
-	}, 5*time.Second, 50*time.Millisecond, "Pubsub topics were not deregistered")
+	// Sleep to allow pubsub topics to be deregistered.
+	time.Sleep(1 * time.Second)
+	require.Equal(t, 0, len(r.cfg.p2p.PubSub().GetTopics()))
+	require.Equal(t, 0, len(r.cfg.p2p.Host().Mux().Protocols()))
 }
 
 func TestService_Stop_SendsGoodbyeMessages(t *testing.T) {
@@ -443,224 +441,3 @@ func TestService_Stop_ConcurrentGoodbyeMessages(t *testing.T) {
 
 	require.Equal(t, false, util.WaitTimeout(&wg, 2*time.Second))
 }
-
-func TestUpdateCustodyInfoInDB(t *testing.T) {
-	const (
-		fuluForkEpoch         = 10
-		custodyRequirement    = uint64(4)
-		earliestStoredSlot    = primitives.Slot(12)
-		numberOfCustodyGroups = uint64(64)
-	)
-
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.FuluForkEpoch = fuluForkEpoch
-	cfg.CustodyRequirement = custodyRequirement
-	cfg.NumberOfCustodyGroups = numberOfCustodyGroups
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := t.Context()
-	pbBlock := util.NewBeaconBlock()
-	pbBlock.Block.Slot = 12
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(pbBlock)
-	require.NoError(t, err)
-
-	roBlock, err := blocks.NewROBlock(signedBeaconBlock)
-	require.NoError(t, err)
-
-	t.Run("CGC increases before fulu", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		service := Service{cfg: &config{beaconDB: beaconDB}}
-		err = beaconDB.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Before Fulu
-		// -----------
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.Supernode = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(19)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-
-		// After Fulu
-		// ----------
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-	})
-
-	t.Run("CGC increases after fulu", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		service := Service{cfg: &config{beaconDB: beaconDB}}
-		err = beaconDB.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Before Fulu
-		// -----------
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		// After Fulu
-		// ----------
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.Supernode = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-	})
-
-	t.Run("Supernode downgrade prevented", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		service := Service{cfg: &config{beaconDB: beaconDB}}
-		err = beaconDB.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Enable supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.Supernode = true
-		flags.Init(gFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-
-		// Try to downgrade by removing flag
-		gFlags.Supernode = false
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// Should still be supernode
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc) // Still 64, not downgraded
-	})
-
-	t.Run("Semi-supernode downgrade prevented", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		service := Service{cfg: &config{beaconDB: beaconDB}}
-		err = beaconDB.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Enable semi-supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SemiSupernode = true
-		flags.Init(gFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
-		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
-
-		// Try to downgrade by removing flag
-		gFlags.SemiSupernode = false
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// UpdateCustodyInfo should prevent downgrade - custody count should remain at 64
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, semiSupernodeCustody, actualCgc) // Still 64 due to downgrade prevention by UpdateCustodyInfo
-	})
-
-	t.Run("Semi-supernode to supernode upgrade allowed", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		service := Service{cfg: &config{beaconDB: beaconDB}}
-		err = beaconDB.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Start with semi-supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SemiSupernode = true
-		flags.Init(gFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
-		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
-
-		// Upgrade to full supernode
-		gFlags.SemiSupernode = false
-		gFlags.Supernode = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// Should upgrade to full supernode
-		upgradeSlot := slot + 2
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(upgradeSlot)
-		require.NoError(t, err)
-		require.Equal(t, upgradeSlot, actualEas)           // Earliest slot updates when upgrading
-		require.Equal(t, numberOfCustodyGroups, actualCgc) // Upgraded to 128
-	})
-
-	t.Run("Semi-supernode with high validator requirements uses higher custody", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		service := Service{cfg: &config{beaconDB: beaconDB}}
-		err = beaconDB.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Enable semi-supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SemiSupernode = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// Mock a high custody requirement (simulating many validators)
-		// We need to override the custody requirement calculation
-		// For this test, we'll verify the logic by checking if custodyRequirement > 64
-		// Since custodyRequirement in minimalTestService is 4, we can't test the high case here
-		// This would require a different test setup with actual validators
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
-		// With low validator requirements (4), should use semi-supernode minimum (64)
-		require.Equal(t, semiSupernodeCustody, actualCgc)
-	})
-}

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -48,14 +48,7 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 		return errors.Wrap(err, "new ro block with root")
 	}
 
-	go func() {
-		if err := s.processSidecarsFromExecutionFromBlock(ctx, roBlock); err != nil {
-			log.WithError(err).WithFields(logrus.Fields{
-				"root": fmt.Sprintf("%#x", root),
-				"slot": block.Slot(),
-			}).Error("Failed to process sidecars from execution from block")
-		}
-	}()
+	go s.processSidecarsFromExecutionFromBlock(ctx, roBlock)
 
 	if err := s.cfg.chain.ReceiveBlock(ctx, signed, root, nil); err != nil {
 		if blockchain.IsInvalidBlock(err) {
@@ -76,37 +69,28 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 		}
 		return err
 	}
-
 	if err := s.processPendingAttsForBlock(ctx, root); err != nil {
 		return errors.Wrap(err, "process pending atts for block")
 	}
-
 	return nil
 }
 
 // processSidecarsFromExecutionFromBlock retrieves (if available) sidecars data from the execution client,
 // builds corresponding sidecars, save them to the storage, and broadcasts them over P2P if necessary.
-func (s *Service) processSidecarsFromExecutionFromBlock(ctx context.Context, roBlock blocks.ROBlock) error {
+func (s *Service) processSidecarsFromExecutionFromBlock(ctx context.Context, roBlock blocks.ROBlock) {
 	if roBlock.Version() >= version.Fulu {
 		if err := s.processDataColumnSidecarsFromExecution(ctx, peerdas.PopulateFromBlock(roBlock)); err != nil {
-			// Do not log if the context was cancelled on purpose.
-			// (Still log other context errors such as deadlines exceeded).
-			if errors.Is(err, context.Canceled) {
-				return nil
-			}
-
-			return errors.Wrap(err, "process data column sidecars from execution")
+			log.WithError(err).Error("Failed to process data column sidecars from execution")
+			return
 		}
 
-		return nil
+		return
 	}
 
 	if roBlock.Version() >= version.Deneb {
 		s.processBlobSidecarsFromExecution(ctx, roBlock)
-		return nil
+		return
 	}
-
-	return nil
 }
 
 // processBlobSidecarsFromExecution retrieves (if available) blob sidecars data from the execution client,
@@ -184,6 +168,7 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 	key := fmt.Sprintf("%#x", source.Root())
 	if _, err, _ := s.columnSidecarsExecSingleFlight.Do(key, func() (any, error) {
 		const delay = 250 * time.Millisecond
+		secondsPerHalfSlot := time.Duration(params.BeaconConfig().SecondsPerSlot/2) * time.Second
 
 		commitments, err := source.Commitments()
 		if err != nil {
@@ -201,6 +186,9 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 			return nil, errors.Wrap(err, "column indices to sample")
 		}
 
+		ctx, cancel := context.WithTimeout(ctx, secondsPerHalfSlot)
+		defer cancel()
+
 		log := log.WithFields(logrus.Fields{
 			"root":          fmt.Sprintf("%#x", source.Root()),
 			"slot":          source.Slot(),
@@ -221,11 +209,6 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 				return nil, nil
 			}
 
-			// Return if the context is done.
-			if ctx.Err() != nil {
-				return nil, ctx.Err()
-			}
-
 			if iteration == 0 {
 				dataColumnsRecoveredFromELAttempts.Inc()
 			}
@@ -237,10 +220,20 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 			}
 
 			// No sidecars are retrieved from the EL, retry later
-			constructedCount := uint64(len(constructedSidecars))
+			constructedSidecarCount = uint64(len(constructedSidecars))
+			if constructedSidecarCount == 0 {
+				if ctx.Err() != nil {
+					return nil, ctx.Err()
+				}
+
+				time.Sleep(delay)
+				continue
+			}
+
+			dataColumnsRecoveredFromELTotal.Inc()
 
 			// Boundary check.
-			if constructedSidecarCount > 0 && constructedSidecarCount != fieldparams.NumberOfColumns {
+			if constructedSidecarCount != fieldparams.NumberOfColumns {
 				return nil, errors.Errorf("reconstruct data column sidecars returned %d sidecars, expected %d - should never happen", constructedSidecarCount, fieldparams.NumberOfColumns)
 			}
 
@@ -249,24 +242,14 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 				return nil, errors.Wrap(err, "broadcast and receive unseen data column sidecars")
 			}
 
-			if constructedCount > 0 {
-				dataColumnsRecoveredFromELTotal.Inc()
+			log.WithFields(logrus.Fields{
+				"count":   len(unseenIndices),
+				"indices": helpers.SortedPrettySliceFromMap(unseenIndices),
+			}).Debug("Constructed data column sidecars from the execution client")
 
-				log.WithFields(logrus.Fields{
-					"root":          fmt.Sprintf("%#x", source.Root()),
-					"slot":          source.Slot(),
-					"proposerIndex": source.ProposerIndex(),
-					"iteration":     iteration,
-					"type":          source.Type(),
-					"count":         len(unseenIndices),
-					"indices":       helpers.SortedPrettySliceFromMap(unseenIndices),
-				}).Debug("Constructed data column sidecars from the execution client")
+			dataColumnSidecarsObtainedViaELCount.Observe(float64(len(unseenIndices)))
 
-				return nil, nil
-			}
-
-			// Wait before retrying.
-			time.Sleep(delay)
+			return nil, nil
 		}
 	}); err != nil {
 		return err
@@ -301,11 +284,6 @@ func (s *Service) broadcastAndReceiveUnseenDataColumnSidecars(
 		unseenIndices[sidecar.Index] = true
 	}
 
-	// Exit early if there are no nothing to broadcast or receive.
-	if len(unseenSidecars) == 0 {
-		return nil, nil
-	}
-
 	// Broadcast all the data column sidecars we reconstructed but did not see via gossip (non blocking).
 	if err := s.cfg.p2p.BroadcastDataColumnSidecars(ctx, unseenSidecars); err != nil {
 		return nil, errors.Wrap(err, "broadcast data column sidecars")

beacon-chain/sync/subscriber_beacon_blocks_test.go

@@ -194,8 +194,7 @@ func TestProcessSidecarsFromExecutionFromBlock(t *testing.T) {
 					},
 					seenBlobCache: lruwrpr.New(1),
 				}
-				err := s.processSidecarsFromExecutionFromBlock(t.Context(), roBlock)
-				require.NoError(t, err)
+				s.processSidecarsFromExecutionFromBlock(t.Context(), roBlock)
 				require.Equal(t, tt.expectedBlobCount, len(chainService.Blobs))
 			})
 		}
@@ -294,8 +293,7 @@ func TestProcessSidecarsFromExecutionFromBlock(t *testing.T) {
 				roBlock, err := blocks.NewROBlock(sb)
 				require.NoError(t, err)
 
-				err = s.processSidecarsFromExecutionFromBlock(t.Context(), roBlock)
-				require.NoError(t, err)
+				s.processSidecarsFromExecutionFromBlock(t.Context(), roBlock)
 				require.Equal(t, tt.expectedDataColumnCount, len(chainService.DataColumns))
 			})
 		}

beacon-chain/sync/subscriber_data_column_sidecar.go

@@ -25,12 +25,12 @@ func (s *Service) dataColumnSubscriber(ctx context.Context, msg proto.Message) e
 	}
 
 	if err := s.receiveDataColumnSidecar(ctx, sidecar); err != nil {
-		return wrapDataColumnError(sidecar, "receive data column sidecar", err)
+		return errors.Wrap(err, "receive data column sidecar")
 	}
 
 	wg.Go(func() error {
 		if err := s.processDataColumnSidecarsFromReconstruction(ctx, sidecar); err != nil {
-			return wrapDataColumnError(sidecar, "process data column sidecars from reconstruction", err)
+			return errors.Wrap(err, "process data column sidecars from reconstruction")
 		}
 
 		return nil
@@ -38,13 +38,7 @@ func (s *Service) dataColumnSubscriber(ctx context.Context, msg proto.Message) e
 
 	wg.Go(func() error {
 		if err := s.processDataColumnSidecarsFromExecution(ctx, peerdas.PopulateFromSidecar(sidecar)); err != nil {
-			if errors.Is(err, context.Canceled) {
-				// Do not log if the context was cancelled on purpose.
-				// (Still log other context errors such as deadlines exceeded).
-				return nil
-			}
-
-			return wrapDataColumnError(sidecar, "process data column sidecars from execution", err)
+			return errors.Wrap(err, "process data column sidecars from execution")
 		}
 
 		return nil
@@ -116,7 +110,3 @@ func (s *Service) allDataColumnSubnets(_ primitives.Slot) map[uint64]bool {
 
 	return allSubnets
 }
-
-func wrapDataColumnError(sidecar blocks.VerifiedRODataColumn, message string, err error) error {
-	return fmt.Errorf("%s - slot %d, root %s: %w", message, sidecar.SignedBlockHeader.Header.Slot, fmt.Sprintf("%#x", sidecar.BlockRoot()), err)
-}

beacon-chain/sync/validate_aggregate_proof_test.go

@@ -614,10 +614,11 @@ func TestVerifyIndexInCommittee_SeenAggregatorEpoch(t *testing.T) {
 		},
 	}
 
-	require.Eventually(t, func() bool {
-		res, _ := r.validateAggregateAndProof(t.Context(), "", msg)
-		return res != pubsub.ValidationAccept
-	}, time.Second, 10*time.Millisecond, "Expected validation to reject duplicate aggregate")
+	time.Sleep(10 * time.Millisecond) // Wait for cached value to pass through buffers.
+	if res, err := r.validateAggregateAndProof(t.Context(), "", msg); res == pubsub.ValidationAccept {
+		_ = err
+		t.Fatal("Validated status is true")
+	}
 }
 
 func TestValidateAggregateAndProof_BadBlock(t *testing.T) {

beacon-chain/sync/validate_beacon_blocks_test.go

@@ -992,6 +992,7 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 
 	// Mark the proposer/slot as seen
 	r.setSeenBlockIndexSlot(msg.Block.Slot, msg.Block.ProposerIndex)
+	time.Sleep(10 * time.Millisecond) // Wait for cached value to pass through buffers
 
 	// Prepare and validate the second message (clone)
 	buf := new(bytes.Buffer)
@@ -1009,11 +1010,9 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 	}
 
 	// Since this is not an equivocation (same signature), it should be ignored
-	// Wait for the cached value to propagate through buffers
-	require.Eventually(t, func() bool {
-		res, err := r.validateBeaconBlockPubSub(ctx, "", m)
-		return err == nil && res == pubsub.ValidationIgnore
-	}, time.Second, 10*time.Millisecond, "block with same signature should be ignored")
+	res, err := r.validateBeaconBlockPubSub(ctx, "", m)
+	assert.NoError(t, err)
+	assert.Equal(t, pubsub.ValidationIgnore, res, "block with same signature should be ignored")
 
 	// Verify no slashings were created
 	assert.Equal(t, 0, len(slashingPool.PendingPropSlashings), "Expected no slashings for same signature")

changelog/SashaMalysehko_fix-return-after-check.md

@@ -0,0 +1,3 @@
+## Fixed
+
+- Fix missing return after version header check in SubmitAttesterSlashingsV2.

changelog/Snezhkko_fix-type.md

@@ -0,0 +1,3 @@
+## Fixed
+
+- incorrect constructor return type [#16084](https://github.com/OffchainLabs/prysm/pull/16084)

changelog/aarsh-revert-autonatv2.md

@@ -0,0 +1,2 @@
+### Ignored
+- Reverts AutoNatV2 change introduced in https://github.com/OffchainLabs/prysm/pull/16100 as the libp2p upgrade fails inter-op testing.

changelog/avoid_kzg_send_after_context_cancel.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Prevent blocked sends to the KZG batch verifier when the caller context is already canceled, avoiding useless queueing and potential hangs.

changelog/bastin_fix-lcp2p-bug.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Fix the missing fork version object mapping for Fulu in light client p2p.

changelog/builder-index.md

@@ -0,0 +1,3 @@
+### Added
+
+- `primitives.BuilderIndex`: SSZ `uint64` wrapper for builder registry indices.

changelog/fix_kzg_batch_verifier_timeout_deadlock.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Fix deadlock in data column gossip KZG batch verification when a caller times out preventing result delivery.

changelog/james-prysm_align-atter-pool-apis.md

@@ -0,0 +1,3 @@
+### Changed
+
+- the /eth/v2/beacon/pool/attestations and /eth/v1/beacon/pool/sync_committees now returns a 503 error if the node is still syncing, the rest api is also working in a similar process to gRPC broadcasting immediately now.

changelog/james-prysm_fix-rest-replay-state.md

@@ -0,0 +1,3 @@
+### Fixed 
+
+- fixed replay state issue in rest api caused by attester and sync committee duties endpoints

changelog/james-prysm_is-ready.md

@@ -1,3 +0,0 @@
-### Changed
-
-- changed IsHealthy check to IsReady for validator client's interpretation from /eth/v1/node/health, 206 will now return false as the node is syncing. 

changelog/james-prysm_skip-e2e-slot1-check.md

@@ -0,0 +1,3 @@
+### Changed
+
+- e2e sync committee evaluator now skips the first slot after startup, we already skip the fork epoch for checks here, this skip only applies on startup, due to altair always from 0 and validators need to warm up.

changelog/jrhea_duplicate_tracer_provider_setting.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Don't call trace.WithMaxExportBatchSize(trace.DefaultMaxExportBatchSize) twice.

changelog/manu-agg.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Pending aggregates: When multiple aggregated attestations only differing by the aggregator index are in the pending queue, only process one of them.

changelog/manu-eas.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- When adding the `--[semi-]supernode` flag, update the ealiest available slot accordingly.

changelog/manu-remove-error-logs.md

@@ -0,0 +1,2 @@
+### Changed
+- `validateDataColumn`: Remove error logs.

changelog/manu-test-pr.md

@@ -0,0 +1,2 @@
+### Ignored
+- Added test requirement to `PULL_REQUEST_TEMPLATE.md`

changelog/manu_disable_get_blobs_v2.md

@@ -1,2 +0,0 @@
-### Added
-- `--disable-get-blobs-v2` flag.

changelog/manu_reconstruct-metrics.md

@@ -0,0 +1,7 @@
+### Added
+- prometheus histogram `cells_and_proofs_from_structured_computation_milliseconds` to track computation time for cells and proofs from structured blobs.
+- prometheus histogram `get_blobs_v2_latency_milliseconds` to track RPC latency for `getBlobsV2` calls to the execution layer.
+
+### Changed
+- Run `ComputeCellsAndProofsFromFlat` in parallel to improve performance when computing cells and proofs.
+- Run `ComputeCellsAndProofsFromStructured` in parallel to improve performance when computing cells and proofs.

changelog/marcopolo_aarshkshah1992_batch_publish_data_columns.md

@@ -1,3 +0,0 @@
-### Added
-
-- Batch publish data columns for faster data propogation.

changelog/potuz_check_twice_attseen.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Fixed possible race when validating two attestations at the same time. 

changelog/potuz_finalized_deproot.md

@@ -0,0 +1,3 @@
+### Added
+
+- Track the dependent root of the latest finalized checkpoint in forkchoice.

changelog/potuz_next_epoch_attributes.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Do not process slots and copy states for next epoch proposers after Fulu

changelog/potuz_return_indices_updateerr.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Do not error when committee has been computed correctly but updating the cache failed.

changelog/potuz_update_spectests.md

@@ -1,2 +0,0 @@
-### Added
-- Update spectests to v1.7.0-alpha.0

changelog/pvl-changelog-v7.1.2.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- Updated changelog for v7.1.2

changelog/pvl-v7.0.1.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Updated CHANGELOG.md for v7.0.1 patch release

changelog/pvl-v7.1.0.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Changelog for v7.1.0

changelog/pvl-v7.1.1.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- Added changelog for v7.1.1

changelog/pvl_fix-flaky-tests-polling.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Replaced `time.Sleep` with `require.Eventually` polling in tests to fix flaky behavior caused by race conditions between goroutines and assertions.

changelog/radek_httperror-analyzer.md

@@ -0,0 +1,3 @@
+### Added
+
+- Static analyzer that ensures each `httputil.HandleError` call is followed by a `return` statement.

changelog/radek_use-statefetch-error.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Use `WriteStateFetchError` in API handlers whenever possible. 

changelog/satushh-eth1copy.md

@@ -0,0 +1,3 @@
+### Removed
+
+- Unnecessary copy is removed from Eth1DataHasEnoughSupport

changelog/satushh-graffiti-impl.md

@@ -0,0 +1,3 @@
+### Added
+
+- Graffiti implementation based on the design doc. 

changelog/satushh-graffiti.md

@@ -0,0 +1,3 @@
+### Added
+
+- Proposal design document to implement graffiti. Currently it is empty by default and the idea is to have it of the form GE168dPR63af

changelog/satushh-migratetocold.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Optimise migratetocold by not doing brute force for loop

changelog/satushh-opt.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Performance improvement in state (MarshalSSZTo): use copy() instead of byte-by-byte loop which isn't required.

changelog/t_gloas-builders-registry.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added basic Gloas builder support (`Builder` message and `BeaconStateGloas` `builders`/`next_withdrawal_builder_index` fields)

cmd/beacon-chain/flags/base.go

@@ -356,9 +356,4 @@ var (
 		Usage: "A comma-separated list of exponents (of 2) in decreasing order, defining the state diff hierarchy levels. The last exponent must be greater than or equal to 5.",
 		Value: cli.NewIntSlice(21, 18, 16, 13, 11, 9, 5),
 	}
-	// DisableGetBlobsV2 disables the engine_getBlobsV2 usage.
-	DisableGetBlobsV2 = &cli.BoolFlag{
-		Name:  "disable-get-blobs-v2",
-		Usage: "Disables the engine_getBlobsV2 usage.",
-	}
 )

cmd/beacon-chain/flags/config.go

@@ -17,7 +17,6 @@ type GlobalFlags struct {
 	SubscribeToAllSubnets           bool
 	Supernode                       bool
 	SemiSupernode                   bool
-	DisableGetBlobsV2               bool
 	MinimumSyncPeers                int
 	MinimumPeersPerSubnet           int
 	MaxConcurrentDials              int
@@ -73,11 +72,6 @@ func ConfigureGlobalFlags(ctx *cli.Context) error {
 		cfg.SemiSupernode = true
 	}
 
-	if ctx.Bool(DisableGetBlobsV2.Name) {
-		log.Warning("Disabling `engine_getBlobsV2` API")
-		cfg.DisableGetBlobsV2 = true
-	}
-
 	// State-diff-exponents
 	cfg.StateDiffExponents = ctx.IntSlice(StateDiffExponents.Name)
 	if features.Get().EnableStateDiff {

cmd/beacon-chain/main.go

@@ -148,7 +148,6 @@ var appFlags = []cli.Flag{
 	flags.SlasherDirFlag,
 	flags.SlasherFlag,
 	flags.JwtId,
-	flags.DisableGetBlobsV2,
 	storage.BlobStoragePathFlag,
 	storage.DataColumnStoragePathFlag,
 	storage.BlobStorageLayout,

cmd/beacon-chain/usage.go

@@ -169,7 +169,6 @@ var appHelpFlagGroups = []flagGroup{
 			flags.ExecutionJWTSecretFlag,
 			flags.JwtId,
 			flags.InteropMockEth1DataVotesFlag,
-			flags.DisableGetBlobsV2,
 		},
 	},
 	{ // Flags relevant to configuring beacon chain monitoring.

config/fieldparams/mainnet.go

@@ -9,7 +9,6 @@ const (
 	RandaoMixesLength                     = 65536             // EPOCHS_PER_HISTORICAL_VECTOR
 	HistoricalRootsLength                 = 16777216          // HISTORICAL_ROOTS_LIMIT
 	ValidatorRegistryLimit                = 1099511627776     // VALIDATOR_REGISTRY_LIMIT
-	BuilderRegistryLimit                  = 1099511627776     // BUILDER_REGISTRY_LIMIT
 	Eth1DataVotesLength                   = 2048              // SLOTS_PER_ETH1_VOTING_PERIOD
 	PreviousEpochAttestationsLength       = 4096              // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
 	CurrentEpochAttestationsLength        = 4096              // MAX_ATTESTATIONS * SLOTS_PER_EPOCH

config/fieldparams/minimal.go

@@ -9,7 +9,6 @@ const (
 	RandaoMixesLength                     = 64                // EPOCHS_PER_HISTORICAL_VECTOR
 	HistoricalRootsLength                 = 16777216          // HISTORICAL_ROOTS_LIMIT
 	ValidatorRegistryLimit                = 1099511627776     // VALIDATOR_REGISTRY_LIMIT
-	BuilderRegistryLimit                  = 1099511627776     // BUILDER_REGISTRY_LIMIT
 	Eth1DataVotesLength                   = 32                // SLOTS_PER_ETH1_VOTING_PERIOD
 	PreviousEpochAttestationsLength       = 1024              // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
 	CurrentEpochAttestationsLength        = 1024              // MAX_ATTESTATIONS * SLOTS_PER_EPOCH

config/params/loader_test.go

@@ -55,8 +55,7 @@ var placeholderFields = []string{
 	"MAX_REQUEST_BLOB_SIDECARS_FULU",
 	"MAX_REQUEST_INCLUSION_LIST",
 	"MAX_REQUEST_PAYLOADS", // Compile time constant on BeaconBlockBody.ExecutionRequests
-	"MIN_BUILDER_WITHDRAWABILITY_DELAY",
-	"NUMBER_OF_COLUMNS", // Configured as a constant in config/fieldparams/mainnet.go
+	"NUMBER_OF_COLUMNS",    // Configured as a constant in config/fieldparams/mainnet.go
 	"PAYLOAD_ATTESTATION_DUE_BPS",
 	"PROPOSER_INCLUSION_LIST_CUTOFF",
 	"PROPOSER_INCLUSION_LIST_CUTOFF_BPS",

config/params/mainnet_config.go

@@ -206,7 +206,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	BeaconStateDenebFieldCount:     28,
 	BeaconStateElectraFieldCount:   37,
 	BeaconStateFuluFieldCount:      38,
-	BeaconStateGloasFieldCount:     45,
+	BeaconStateGloasFieldCount:     43,
 
 	// Slasher related values.
 	WeakSubjectivityPeriod:          54000,

consensus-types/blocks/getters_test.go

@@ -669,7 +669,6 @@ func hydrateBeaconBlockBodyGloas() *eth.BeaconBlockBodyGloas {
 				ParentBlockHash:        make([]byte, fieldparams.RootLength),
 				ParentBlockRoot:        make([]byte, fieldparams.RootLength),
 				BlockHash:              make([]byte, fieldparams.RootLength),
-				PrevRandao:             make([]byte, fieldparams.RootLength),
 				FeeRecipient:           make([]byte, 20),
 				BlobKzgCommitmentsRoot: make([]byte, fieldparams.RootLength),
 			},

monitoring/tracing/tracer.go

@@ -45,6 +45,7 @@ func Setup(ctx context.Context, serviceName, processName, endpoint string, sampl
 			exporter,
 			trace.WithMaxExportBatchSize(trace.DefaultMaxExportBatchSize),
 			trace.WithBatchTimeout(trace.DefaultScheduleDelay*time.Millisecond),
+			trace.WithMaxExportBatchSize(trace.DefaultMaxExportBatchSize),
 		),
 		trace.WithResource(
 			resource.NewWithAttributes(

proto/prysm/v1alpha1/cloners.go

@@ -35,21 +35,6 @@ func CopyValidator(val *Validator) *Validator {
 	}
 }
 
-// CopyBuilder copies the provided builder.
-func CopyBuilder(builder *Builder) *Builder {
-	if builder == nil {
-		return nil
-	}
-	return &Builder{
-		Pubkey:            bytesutil.SafeCopyBytes(builder.Pubkey),
-		Version:           bytesutil.SafeCopyBytes(builder.Version),
-		ExecutionAddress:  bytesutil.SafeCopyBytes(builder.ExecutionAddress),
-		Balance:           builder.Balance,
-		DepositEpoch:      builder.DepositEpoch,
-		WithdrawableEpoch: builder.WithdrawableEpoch,
-	}
-}
-
 // CopySyncCommitteeMessage copies the provided sync committee message object.
 func CopySyncCommitteeMessage(s *SyncCommitteeMessage) *SyncCommitteeMessage {
 	if s == nil {

proto/prysm/v1alpha1/cloners_test.go

@@ -1220,7 +1220,7 @@ func genExecutionPayloadBidGloas() *v1alpha1.ExecutionPayloadBid {
 		BlockHash:              bytes(32),
 		FeeRecipient:           bytes(20),
 		GasLimit:               rand.Uint64(),
-		BuilderIndex:           primitives.BuilderIndex(rand.Uint64()),
+		BuilderIndex:           primitives.ValidatorIndex(rand.Uint64()),
 		Slot:                   primitives.Slot(rand.Uint64()),
 		Value:                  primitives.Gwei(rand.Uint64()),
 		BlobKzgCommitmentsRoot: bytes(32),

proto/prysm/v1alpha1/gloas.go

@@ -13,13 +13,11 @@ func (header *ExecutionPayloadBid) Copy() *ExecutionPayloadBid {
 		ParentBlockHash:        bytesutil.SafeCopyBytes(header.ParentBlockHash),
 		ParentBlockRoot:        bytesutil.SafeCopyBytes(header.ParentBlockRoot),
 		BlockHash:              bytesutil.SafeCopyBytes(header.BlockHash),
-		PrevRandao:             bytesutil.SafeCopyBytes(header.PrevRandao),
 		FeeRecipient:           bytesutil.SafeCopyBytes(header.FeeRecipient),
 		GasLimit:               header.GasLimit,
 		BuilderIndex:           header.BuilderIndex,
 		Slot:                   header.Slot,
 		Value:                  header.Value,
-		ExecutionPayment:       header.ExecutionPayment,
 		BlobKzgCommitmentsRoot: bytesutil.SafeCopyBytes(header.BlobKzgCommitmentsRoot),
 	}
 }
@@ -30,9 +28,10 @@ func (withdrawal *BuilderPendingWithdrawal) Copy() *BuilderPendingWithdrawal {
 		return nil
 	}
 	return &BuilderPendingWithdrawal{
-		FeeRecipient: bytesutil.SafeCopyBytes(withdrawal.FeeRecipient),
-		Amount:       withdrawal.Amount,
-		BuilderIndex: withdrawal.BuilderIndex,
+		FeeRecipient:      bytesutil.SafeCopyBytes(withdrawal.FeeRecipient),
+		Amount:            withdrawal.Amount,
+		BuilderIndex:      withdrawal.BuilderIndex,
+		WithdrawableEpoch: withdrawal.WithdrawableEpoch,
 	}
 }
 

proto/prysm/v1alpha1/gloas.proto

@@ -26,37 +26,30 @@ option go_package = "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1;eth";
 //     parent_block_hash: Hash32
 //     parent_block_root: Root
 //     block_hash: Hash32
-//     prev_randao: Bytes32
 //     fee_recipient: ExecutionAddress
 //     gas_limit: uint64
-//     builder_index: BuilderIndex
+//     builder_index: ValidatorIndex
 //     slot: Slot
 //     value: Gwei
-//     execution_payment: Gwei
 //     blob_kzg_commitments_root: Root
 message ExecutionPayloadBid {
   bytes parent_block_hash = 1 [ (ethereum.eth.ext.ssz_size) = "32" ];
   bytes parent_block_root = 2 [ (ethereum.eth.ext.ssz_size) = "32" ];
   bytes block_hash = 3 [ (ethereum.eth.ext.ssz_size) = "32" ];
-  bytes prev_randao = 4 [ (ethereum.eth.ext.ssz_size) = "32" ];
-  bytes fee_recipient = 5 [ (ethereum.eth.ext.ssz_size) = "20" ];
-  uint64 gas_limit = 6;
-  uint64 builder_index = 7 [ (ethereum.eth.ext.cast_type) =
+  bytes fee_recipient = 4 [ (ethereum.eth.ext.ssz_size) = "20" ];
+  uint64 gas_limit = 5;
+  uint64 builder_index = 6 [ (ethereum.eth.ext.cast_type) =
   "github.com/OffchainLabs/prysm/v7/"
-      "consensus-types/primitives.BuilderIndex" ];
-  uint64 slot = 8 [
+      "consensus-types/primitives.ValidatorIndex" ];
+  uint64 slot = 7 [
     (ethereum.eth.ext.cast_type) =
         "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Slot"
   ];
-  uint64 value = 9 [
+  uint64 value = 8 [
     (ethereum.eth.ext.cast_type) =
         "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Gwei"
   ];
-  uint64 execution_payment = 10 [
-    (ethereum.eth.ext.cast_type) =
-        "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Gwei"
-  ];
-  bytes blob_kzg_commitments_root = 11 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes blob_kzg_commitments_root = 9 [ (ethereum.eth.ext.ssz_size) = "32" ];
 }
 
 // SignedExecutionPayloadBid wraps an execution payload bid with a signature.
@@ -192,15 +185,12 @@ message SignedBeaconBlockGloas {
 //     [All previous fields from earlier forks]
 //     # Replaced existing latest execution header position
 //     latest_execution_payload_bid: ExecutionPayloadBid
-//     builders: List[Builder, BUILDER_REGISTRY_LIMIT]
-//     # [New in Gloas:EIP7732]
-//     next_withdrawal_builder_index: BuilderIndex
-//     # [New in Gloas:EIP7732]
+//     # New fields in Gloas:EIP7732
 //     execution_payload_availability: Bitvector[SLOTS_PER_HISTORICAL_ROOT]
 //     builder_pending_payments: Vector[BuilderPendingPayment, 2 * SLOTS_PER_EPOCH]
 //     builder_pending_withdrawals: List[BuilderPendingWithdrawal, BUILDER_PENDING_WITHDRAWALS_LIMIT]
 //     latest_block_hash: Hash32
-//     payload_expected_withdrawals: List[Withdrawal, MAX_WITHDRAWALS_PER_PAYLOAD]
+//     latest_withdrawals_root: Root
 message BeaconStateGloas {
   // Versioning [1001-2000]
   uint64 genesis_time = 1001;
@@ -310,20 +300,13 @@ message BeaconStateGloas {
   [ (ethereum.eth.ext.ssz_size) = "proposer_lookahead_size" ];
 
   // Fields introduced in Gloas fork [14001-15000]
-  repeated Builder builders = 14001
-  [ (ethereum.eth.ext.ssz_max) = "builder_registry_limit" ];
-  uint64 next_withdrawal_builder_index = 14002
-  [ (ethereum.eth.ext.cast_type) =
-  "github.com/OffchainLabs/prysm/v7/consensus-types/"
-      "primitives.BuilderIndex" ];
-  bytes execution_payload_availability = 14003 [
+  bytes execution_payload_availability = 14001 [
     (ethereum.eth.ext.ssz_size) = "execution_payload_availability.size"
   ];
-  repeated BuilderPendingPayment builder_pending_payments = 14004 [(ethereum.eth.ext.ssz_size) = "builder_pending_payments.size"];
-  repeated BuilderPendingWithdrawal builder_pending_withdrawals = 14005 [(ethereum.eth.ext.ssz_max) = "1048576"];
-  bytes latest_block_hash = 14006 [ (ethereum.eth.ext.ssz_size) = "32" ];
-  repeated ethereum.engine.v1.Withdrawal payload_expected_withdrawals = 14007
-  [ (ethereum.eth.ext.ssz_max) = "withdrawal.size" ];
+  repeated BuilderPendingPayment builder_pending_payments = 14002 [(ethereum.eth.ext.ssz_size) = "builder_pending_payments.size"];
+  repeated BuilderPendingWithdrawal builder_pending_withdrawals = 14003 [(ethereum.eth.ext.ssz_max) = "1048576"];
+  bytes latest_block_hash = 14004 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes latest_withdrawals_root = 14005 [ (ethereum.eth.ext.ssz_size) = "32" ];
 }
 
 // BuilderPendingPayment represents a pending payment to a builder.
@@ -346,7 +329,8 @@ message BuilderPendingPayment {
 // class BuilderPendingWithdrawal(Container):
 //     fee_recipient: ExecutionAddress
 //     amount: Gwei
-//     builder_index: BuilderIndex
+//     builder_index: ValidatorIndex
+//     withdrawable_epoch: Epoch
 message BuilderPendingWithdrawal {
   bytes fee_recipient = 1 [ (ethereum.eth.ext.ssz_size) = "20" ];
   uint64 amount = 2 [
@@ -356,7 +340,11 @@ message BuilderPendingWithdrawal {
   uint64 builder_index = 3
   [ (ethereum.eth.ext.cast_type) =
   "github.com/OffchainLabs/prysm/v7/consensus-types/"
-      "primitives.BuilderIndex" ];
+      "primitives.ValidatorIndex" ];
+  uint64 withdrawable_epoch = 4 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Epoch"
+  ];
 }
 
 // DataColumnSidecarGloas represents a data column sidecar in the Gloas fork.
@@ -399,7 +387,7 @@ message DataColumnSidecarGloas {
 // class ExecutionPayloadEnvelope(Container):
 //     payload: ExecutionPayload
 //     execution_requests: ExecutionRequests
-//     builder_index: BuilderIndex
+//     builder_index: ValidatorIndex
 //     beacon_block_root: Root
 //     slot: Slot
 //     blob_kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
@@ -409,7 +397,7 @@ message ExecutionPayloadEnvelope {
   ethereum.engine.v1.ExecutionRequests execution_requests = 2;
   uint64 builder_index = 3 [ (ethereum.eth.ext.cast_type) =
   "github.com/OffchainLabs/prysm/v7/"
-      "consensus-types/primitives.BuilderIndex" ];
+      "consensus-types/primitives.ValidatorIndex" ];
   bytes beacon_block_root = 4 [ (ethereum.eth.ext.ssz_size) = "32" ];
   uint64 slot = 5 [
     (ethereum.eth.ext.cast_type) =
@@ -433,31 +421,3 @@ message SignedExecutionPayloadEnvelope {
   ExecutionPayloadEnvelope message = 1;
   bytes signature = 2 [ (ethereum.eth.ext.ssz_size) = "96" ];
 }
-
-// Builder represents a builder in the Gloas fork.
-//
-// Spec:
-// class Builder(Container):
-//     pubkey: BLSPubkey
-//     version: uint8
-//     execution_address: ExecutionAddress
-//     balance: Gwei
-//     deposit_epoch: Epoch
-//     withdrawable_epoch: Epoch
-message Builder {
-  bytes pubkey = 1 [ (ethereum.eth.ext.ssz_size) = "48" ];
-  bytes version = 2 [ (ethereum.eth.ext.ssz_size) = "1" ];
-  bytes execution_address = 3 [ (ethereum.eth.ext.ssz_size) = "20" ];
-  uint64 balance = 4 [
-    (ethereum.eth.ext.cast_type) =
-        "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Gwei"
-  ];
-  uint64 deposit_epoch = 5 [
-    (ethereum.eth.ext.cast_type) =
-        "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Epoch"
-  ];
-  uint64 withdrawable_epoch = 6 [
-    (ethereum.eth.ext.cast_type) =
-        "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Epoch"
-  ];
-}

proto/prysm/v1alpha1/gloas.ssz.go

@@ -37,36 +37,26 @@ func (e *ExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	}
 	dst = append(dst, e.BlockHash...)
 
-	// Field (3) 'PrevRandao'
-	if size := len(e.PrevRandao); size != 32 {
-		err = ssz.ErrBytesLengthFn("--.PrevRandao", size, 32)
-		return
-	}
-	dst = append(dst, e.PrevRandao...)
-
-	// Field (4) 'FeeRecipient'
+	// Field (3) 'FeeRecipient'
 	if size := len(e.FeeRecipient); size != 20 {
 		err = ssz.ErrBytesLengthFn("--.FeeRecipient", size, 20)
 		return
 	}
 	dst = append(dst, e.FeeRecipient...)
 
-	// Field (5) 'GasLimit'
+	// Field (4) 'GasLimit'
 	dst = ssz.MarshalUint64(dst, e.GasLimit)
 
-	// Field (6) 'BuilderIndex'
+	// Field (5) 'BuilderIndex'
 	dst = ssz.MarshalUint64(dst, uint64(e.BuilderIndex))
 
-	// Field (7) 'Slot'
+	// Field (6) 'Slot'
 	dst = ssz.MarshalUint64(dst, uint64(e.Slot))
 
-	// Field (8) 'Value'
+	// Field (7) 'Value'
 	dst = ssz.MarshalUint64(dst, uint64(e.Value))
 
-	// Field (9) 'ExecutionPayment'
-	dst = ssz.MarshalUint64(dst, uint64(e.ExecutionPayment))
-
-	// Field (10) 'BlobKzgCommitmentsRoot'
+	// Field (8) 'BlobKzgCommitmentsRoot'
 	if size := len(e.BlobKzgCommitmentsRoot); size != 32 {
 		err = ssz.ErrBytesLengthFn("--.BlobKzgCommitmentsRoot", size, 32)
 		return
@@ -80,7 +70,7 @@ func (e *ExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 func (e *ExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size != 220 {
+	if size != 180 {
 		return ssz.ErrSize
 	}
 
@@ -102,45 +92,36 @@ func (e *ExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	}
 	e.BlockHash = append(e.BlockHash, buf[64:96]...)
 
-	// Field (3) 'PrevRandao'
-	if cap(e.PrevRandao) == 0 {
-		e.PrevRandao = make([]byte, 0, len(buf[96:128]))
-	}
-	e.PrevRandao = append(e.PrevRandao, buf[96:128]...)
-
-	// Field (4) 'FeeRecipient'
+	// Field (3) 'FeeRecipient'
 	if cap(e.FeeRecipient) == 0 {
-		e.FeeRecipient = make([]byte, 0, len(buf[128:148]))
+		e.FeeRecipient = make([]byte, 0, len(buf[96:116]))
 	}
-	e.FeeRecipient = append(e.FeeRecipient, buf[128:148]...)
+	e.FeeRecipient = append(e.FeeRecipient, buf[96:116]...)
 
-	// Field (5) 'GasLimit'
-	e.GasLimit = ssz.UnmarshallUint64(buf[148:156])
+	// Field (4) 'GasLimit'
+	e.GasLimit = ssz.UnmarshallUint64(buf[116:124])
 
-	// Field (6) 'BuilderIndex'
-	e.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.BuilderIndex(ssz.UnmarshallUint64(buf[156:164]))
+	// Field (5) 'BuilderIndex'
+	e.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[124:132]))
 
-	// Field (7) 'Slot'
-	e.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[164:172]))
+	// Field (6) 'Slot'
+	e.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[132:140]))
 
-	// Field (8) 'Value'
-	e.Value = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[172:180]))
+	// Field (7) 'Value'
+	e.Value = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[140:148]))
 
-	// Field (9) 'ExecutionPayment'
-	e.ExecutionPayment = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[180:188]))
-
-	// Field (10) 'BlobKzgCommitmentsRoot'
+	// Field (8) 'BlobKzgCommitmentsRoot'
 	if cap(e.BlobKzgCommitmentsRoot) == 0 {
-		e.BlobKzgCommitmentsRoot = make([]byte, 0, len(buf[188:220]))
+		e.BlobKzgCommitmentsRoot = make([]byte, 0, len(buf[148:180]))
 	}
-	e.BlobKzgCommitmentsRoot = append(e.BlobKzgCommitmentsRoot, buf[188:220]...)
+	e.BlobKzgCommitmentsRoot = append(e.BlobKzgCommitmentsRoot, buf[148:180]...)
 
 	return err
 }
 
 // SizeSSZ returns the ssz encoded size in bytes for the ExecutionPayloadBid object
 func (e *ExecutionPayloadBid) SizeSSZ() (size int) {
-	size = 220
+	size = 180
 	return
 }
 
@@ -174,36 +155,26 @@ func (e *ExecutionPayloadBid) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	}
 	hh.PutBytes(e.BlockHash)
 
-	// Field (3) 'PrevRandao'
-	if size := len(e.PrevRandao); size != 32 {
-		err = ssz.ErrBytesLengthFn("--.PrevRandao", size, 32)
-		return
-	}
-	hh.PutBytes(e.PrevRandao)
-
-	// Field (4) 'FeeRecipient'
+	// Field (3) 'FeeRecipient'
 	if size := len(e.FeeRecipient); size != 20 {
 		err = ssz.ErrBytesLengthFn("--.FeeRecipient", size, 20)
 		return
 	}
 	hh.PutBytes(e.FeeRecipient)
 
-	// Field (5) 'GasLimit'
+	// Field (4) 'GasLimit'
 	hh.PutUint64(e.GasLimit)
 
-	// Field (6) 'BuilderIndex'
+	// Field (5) 'BuilderIndex'
 	hh.PutUint64(uint64(e.BuilderIndex))
 
-	// Field (7) 'Slot'
+	// Field (6) 'Slot'
 	hh.PutUint64(uint64(e.Slot))
 
-	// Field (8) 'Value'
+	// Field (7) 'Value'
 	hh.PutUint64(uint64(e.Value))
 
-	// Field (9) 'ExecutionPayment'
-	hh.PutUint64(uint64(e.ExecutionPayment))
-
-	// Field (10) 'BlobKzgCommitmentsRoot'
+	// Field (8) 'BlobKzgCommitmentsRoot'
 	if size := len(e.BlobKzgCommitmentsRoot); size != 32 {
 		err = ssz.ErrBytesLengthFn("--.BlobKzgCommitmentsRoot", size, 32)
 		return
@@ -245,7 +216,7 @@ func (s *SignedExecutionPayloadBid) MarshalSSZTo(buf []byte) (dst []byte, err er
 func (s *SignedExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size != 316 {
+	if size != 276 {
 		return ssz.ErrSize
 	}
 
@@ -253,22 +224,22 @@ func (s *SignedExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	if s.Message == nil {
 		s.Message = new(ExecutionPayloadBid)
 	}
-	if err = s.Message.UnmarshalSSZ(buf[0:220]); err != nil {
+	if err = s.Message.UnmarshalSSZ(buf[0:180]); err != nil {
 		return err
 	}
 
 	// Field (1) 'Signature'
 	if cap(s.Signature) == 0 {
-		s.Signature = make([]byte, 0, len(buf[220:316]))
+		s.Signature = make([]byte, 0, len(buf[180:276]))
 	}
-	s.Signature = append(s.Signature, buf[220:316]...)
+	s.Signature = append(s.Signature, buf[180:276]...)
 
 	return err
 }
 
 // SizeSSZ returns the ssz encoded size in bytes for the SignedExecutionPayloadBid object
 func (s *SignedExecutionPayloadBid) SizeSSZ() (size int) {
-	size = 316
+	size = 276
 	return
 }
 
@@ -742,7 +713,7 @@ func (b *BeaconBlockBodyGloas) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the BeaconBlockBodyGloas object to a target array
 func (b *BeaconBlockBodyGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(704)
+	offset := int(664)
 
 	// Field (0) 'RandaoReveal'
 	if size := len(b.RandaoReveal); size != 96 {
@@ -914,7 +885,7 @@ func (b *BeaconBlockBodyGloas) MarshalSSZTo(buf []byte) (dst []byte, err error)
 func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 704 {
+	if size < 664 {
 		return ssz.ErrSize
 	}
 
@@ -946,7 +917,7 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 		return ssz.ErrOffset
 	}
 
-	if o3 != 704 {
+	if o3 != 664 {
 		return ssz.ErrInvalidVariableOffset
 	}
 
@@ -987,12 +958,12 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 	if b.SignedExecutionPayloadBid == nil {
 		b.SignedExecutionPayloadBid = new(SignedExecutionPayloadBid)
 	}
-	if err = b.SignedExecutionPayloadBid.UnmarshalSSZ(buf[384:700]); err != nil {
+	if err = b.SignedExecutionPayloadBid.UnmarshalSSZ(buf[384:660]); err != nil {
 		return err
 	}
 
 	// Offset (11) 'PayloadAttestations'
-	if o11 = ssz.ReadOffset(buf[700:704]); o11 > size || o9 > o11 {
+	if o11 = ssz.ReadOffset(buf[660:664]); o11 > size || o9 > o11 {
 		return ssz.ErrOffset
 	}
 
@@ -1134,7 +1105,7 @@ func (b *BeaconBlockBodyGloas) UnmarshalSSZ(buf []byte) error {
 
 // SizeSSZ returns the ssz encoded size in bytes for the BeaconBlockBodyGloas object
 func (b *BeaconBlockBodyGloas) SizeSSZ() (size int) {
-	size = 704
+	size = 664
 
 	// Field (3) 'ProposerSlashings'
 	size += len(b.ProposerSlashings) * 416
@@ -1437,7 +1408,7 @@ func (b *BeaconStateGloas) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the BeaconStateGloas object to a target array
 func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(2741333)
+	offset := int(2741821)
 
 	// Field (0) 'GenesisTime'
 	dst = ssz.MarshalUint64(dst, b.GenesisTime)
@@ -1659,21 +1630,14 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		dst = ssz.MarshalUint64(dst, b.ProposerLookahead[ii])
 	}
 
-	// Offset (38) 'Builders'
-	dst = ssz.WriteOffset(dst, offset)
-	offset += len(b.Builders) * 93
-
-	// Field (39) 'NextWithdrawalBuilderIndex'
-	dst = ssz.MarshalUint64(dst, uint64(b.NextWithdrawalBuilderIndex))
-
-	// Field (40) 'ExecutionPayloadAvailability'
+	// Field (38) 'ExecutionPayloadAvailability'
 	if size := len(b.ExecutionPayloadAvailability); size != 1024 {
 		err = ssz.ErrBytesLengthFn("--.ExecutionPayloadAvailability", size, 1024)
 		return
 	}
 	dst = append(dst, b.ExecutionPayloadAvailability...)
 
-	// Field (41) 'BuilderPendingPayments'
+	// Field (39) 'BuilderPendingPayments'
 	if size := len(b.BuilderPendingPayments); size != 64 {
 		err = ssz.ErrVectorLengthFn("--.BuilderPendingPayments", size, 64)
 		return
@@ -1684,20 +1648,23 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		}
 	}
 
-	// Offset (42) 'BuilderPendingWithdrawals'
+	// Offset (40) 'BuilderPendingWithdrawals'
 	dst = ssz.WriteOffset(dst, offset)
-	offset += len(b.BuilderPendingWithdrawals) * 36
+	offset += len(b.BuilderPendingWithdrawals) * 44
 
-	// Field (43) 'LatestBlockHash'
+	// Field (41) 'LatestBlockHash'
 	if size := len(b.LatestBlockHash); size != 32 {
 		err = ssz.ErrBytesLengthFn("--.LatestBlockHash", size, 32)
 		return
 	}
 	dst = append(dst, b.LatestBlockHash...)
 
-	// Offset (44) 'PayloadExpectedWithdrawals'
-	dst = ssz.WriteOffset(dst, offset)
-	offset += len(b.PayloadExpectedWithdrawals) * 44
+	// Field (42) 'LatestWithdrawalsRoot'
+	if size := len(b.LatestWithdrawalsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.LatestWithdrawalsRoot", size, 32)
+		return
+	}
+	dst = append(dst, b.LatestWithdrawalsRoot...)
 
 	// Field (7) 'HistoricalRoots'
 	if size := len(b.HistoricalRoots); size > 16777216 {
@@ -1810,18 +1777,7 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		}
 	}
 
-	// Field (38) 'Builders'
-	if size := len(b.Builders); size > 1099511627776 {
-		err = ssz.ErrListTooBigFn("--.Builders", size, 1099511627776)
-		return
-	}
-	for ii := 0; ii < len(b.Builders); ii++ {
-		if dst, err = b.Builders[ii].MarshalSSZTo(dst); err != nil {
-			return
-		}
-	}
-
-	// Field (42) 'BuilderPendingWithdrawals'
+	// Field (40) 'BuilderPendingWithdrawals'
 	if size := len(b.BuilderPendingWithdrawals); size > 1048576 {
 		err = ssz.ErrListTooBigFn("--.BuilderPendingWithdrawals", size, 1048576)
 		return
@@ -1832,17 +1788,6 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		}
 	}
 
-	// Field (44) 'PayloadExpectedWithdrawals'
-	if size := len(b.PayloadExpectedWithdrawals); size > 16 {
-		err = ssz.ErrListTooBigFn("--.PayloadExpectedWithdrawals", size, 16)
-		return
-	}
-	for ii := 0; ii < len(b.PayloadExpectedWithdrawals); ii++ {
-		if dst, err = b.PayloadExpectedWithdrawals[ii].MarshalSSZTo(dst); err != nil {
-			return
-		}
-	}
-
 	return
 }
 
@@ -1850,12 +1795,12 @@ func (b *BeaconStateGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 2741333 {
+	if size < 2741821 {
 		return ssz.ErrSize
 	}
 
 	tail := buf
-	var o7, o9, o11, o12, o15, o16, o21, o27, o34, o35, o36, o38, o42, o44 uint64
+	var o7, o9, o11, o12, o15, o16, o21, o27, o34, o35, o36, o40 uint64
 
 	// Field (0) 'GenesisTime'
 	b.GenesisTime = ssz.UnmarshallUint64(buf[0:8])
@@ -1908,7 +1853,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 		return ssz.ErrOffset
 	}
 
-	if o7 != 2741333 {
+	if o7 != 2741821 {
 		return ssz.ErrInvalidVariableOffset
 	}
 
@@ -2018,100 +1963,93 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 	if b.LatestExecutionPayloadBid == nil {
 		b.LatestExecutionPayloadBid = new(ExecutionPayloadBid)
 	}
-	if err = b.LatestExecutionPayloadBid.UnmarshalSSZ(buf[2736629:2736849]); err != nil {
+	if err = b.LatestExecutionPayloadBid.UnmarshalSSZ(buf[2736629:2736809]); err != nil {
 		return err
 	}
 
 	// Field (25) 'NextWithdrawalIndex'
-	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736849:2736857])
+	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736809:2736817])
 
 	// Field (26) 'NextWithdrawalValidatorIndex'
-	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736857:2736865]))
+	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736817:2736825]))
 
 	// Offset (27) 'HistoricalSummaries'
-	if o27 = ssz.ReadOffset(buf[2736865:2736869]); o27 > size || o21 > o27 {
+	if o27 = ssz.ReadOffset(buf[2736825:2736829]); o27 > size || o21 > o27 {
 		return ssz.ErrOffset
 	}
 
 	// Field (28) 'DepositRequestsStartIndex'
-	b.DepositRequestsStartIndex = ssz.UnmarshallUint64(buf[2736869:2736877])
+	b.DepositRequestsStartIndex = ssz.UnmarshallUint64(buf[2736829:2736837])
 
 	// Field (29) 'DepositBalanceToConsume'
-	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736877:2736885]))
+	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736837:2736845]))
 
 	// Field (30) 'ExitBalanceToConsume'
-	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736885:2736893]))
+	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736845:2736853]))
 
 	// Field (31) 'EarliestExitEpoch'
-	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736893:2736901]))
+	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736853:2736861]))
 
 	// Field (32) 'ConsolidationBalanceToConsume'
-	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736901:2736909]))
+	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736861:2736869]))
 
 	// Field (33) 'EarliestConsolidationEpoch'
-	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736909:2736917]))
+	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736869:2736877]))
 
 	// Offset (34) 'PendingDeposits'
-	if o34 = ssz.ReadOffset(buf[2736917:2736921]); o34 > size || o27 > o34 {
+	if o34 = ssz.ReadOffset(buf[2736877:2736881]); o34 > size || o27 > o34 {
 		return ssz.ErrOffset
 	}
 
 	// Offset (35) 'PendingPartialWithdrawals'
-	if o35 = ssz.ReadOffset(buf[2736921:2736925]); o35 > size || o34 > o35 {
+	if o35 = ssz.ReadOffset(buf[2736881:2736885]); o35 > size || o34 > o35 {
 		return ssz.ErrOffset
 	}
 
 	// Offset (36) 'PendingConsolidations'
-	if o36 = ssz.ReadOffset(buf[2736925:2736929]); o36 > size || o35 > o36 {
+	if o36 = ssz.ReadOffset(buf[2736885:2736889]); o36 > size || o35 > o36 {
 		return ssz.ErrOffset
 	}
 
 	// Field (37) 'ProposerLookahead'
 	b.ProposerLookahead = ssz.ExtendUint64(b.ProposerLookahead, 64)
 	for ii := 0; ii < 64; ii++ {
-		b.ProposerLookahead[ii] = ssz.UnmarshallUint64(buf[2736929:2737441][ii*8 : (ii+1)*8])
+		b.ProposerLookahead[ii] = ssz.UnmarshallUint64(buf[2736889:2737401][ii*8 : (ii+1)*8])
 	}
 
-	// Offset (38) 'Builders'
-	if o38 = ssz.ReadOffset(buf[2737441:2737445]); o38 > size || o36 > o38 {
-		return ssz.ErrOffset
-	}
-
-	// Field (39) 'NextWithdrawalBuilderIndex'
-	b.NextWithdrawalBuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.BuilderIndex(ssz.UnmarshallUint64(buf[2737445:2737453]))
-
-	// Field (40) 'ExecutionPayloadAvailability'
+	// Field (38) 'ExecutionPayloadAvailability'
 	if cap(b.ExecutionPayloadAvailability) == 0 {
-		b.ExecutionPayloadAvailability = make([]byte, 0, len(buf[2737453:2738477]))
+		b.ExecutionPayloadAvailability = make([]byte, 0, len(buf[2737401:2738425]))
 	}
-	b.ExecutionPayloadAvailability = append(b.ExecutionPayloadAvailability, buf[2737453:2738477]...)
+	b.ExecutionPayloadAvailability = append(b.ExecutionPayloadAvailability, buf[2737401:2738425]...)
 
-	// Field (41) 'BuilderPendingPayments'
+	// Field (39) 'BuilderPendingPayments'
 	b.BuilderPendingPayments = make([]*BuilderPendingPayment, 64)
 	for ii := 0; ii < 64; ii++ {
 		if b.BuilderPendingPayments[ii] == nil {
 			b.BuilderPendingPayments[ii] = new(BuilderPendingPayment)
 		}
-		if err = b.BuilderPendingPayments[ii].UnmarshalSSZ(buf[2738477:2741293][ii*44 : (ii+1)*44]); err != nil {
+		if err = b.BuilderPendingPayments[ii].UnmarshalSSZ(buf[2738425:2741753][ii*52 : (ii+1)*52]); err != nil {
 			return err
 		}
 	}
 
-	// Offset (42) 'BuilderPendingWithdrawals'
-	if o42 = ssz.ReadOffset(buf[2741293:2741297]); o42 > size || o38 > o42 {
+	// Offset (40) 'BuilderPendingWithdrawals'
+	if o40 = ssz.ReadOffset(buf[2741753:2741757]); o40 > size || o36 > o40 {
 		return ssz.ErrOffset
 	}
 
-	// Field (43) 'LatestBlockHash'
+	// Field (41) 'LatestBlockHash'
 	if cap(b.LatestBlockHash) == 0 {
-		b.LatestBlockHash = make([]byte, 0, len(buf[2741297:2741329]))
+		b.LatestBlockHash = make([]byte, 0, len(buf[2741757:2741789]))
 	}
-	b.LatestBlockHash = append(b.LatestBlockHash, buf[2741297:2741329]...)
+	b.LatestBlockHash = append(b.LatestBlockHash, buf[2741757:2741789]...)
 
-	// Offset (44) 'PayloadExpectedWithdrawals'
-	if o44 = ssz.ReadOffset(buf[2741329:2741333]); o44 > size || o42 > o44 {
-		return ssz.ErrOffset
+	// Field (42) 'LatestWithdrawalsRoot'
+	if cap(b.LatestWithdrawalsRoot) == 0 {
+		b.LatestWithdrawalsRoot = make([]byte, 0, len(buf[2741789:2741821]))
 	}
+	b.LatestWithdrawalsRoot = append(b.LatestWithdrawalsRoot, buf[2741789:2741821]...)
 
 	// Field (7) 'HistoricalRoots'
 	{
@@ -2271,7 +2209,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 
 	// Field (36) 'PendingConsolidations'
 	{
-		buf = tail[o36:o38]
+		buf = tail[o36:o40]
 		num, err := ssz.DivideInt2(len(buf), 16, 262144)
 		if err != nil {
 			return err
@@ -2287,28 +2225,10 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 		}
 	}
 
-	// Field (38) 'Builders'
+	// Field (40) 'BuilderPendingWithdrawals'
 	{
-		buf = tail[o38:o42]
-		num, err := ssz.DivideInt2(len(buf), 93, 1099511627776)
-		if err != nil {
-			return err
-		}
-		b.Builders = make([]*Builder, num)
-		for ii := 0; ii < num; ii++ {
-			if b.Builders[ii] == nil {
-				b.Builders[ii] = new(Builder)
-			}
-			if err = b.Builders[ii].UnmarshalSSZ(buf[ii*93 : (ii+1)*93]); err != nil {
-				return err
-			}
-		}
-	}
-
-	// Field (42) 'BuilderPendingWithdrawals'
-	{
-		buf = tail[o42:o44]
-		num, err := ssz.DivideInt2(len(buf), 36, 1048576)
+		buf = tail[o40:]
+		num, err := ssz.DivideInt2(len(buf), 44, 1048576)
 		if err != nil {
 			return err
 		}
@@ -2317,25 +2237,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 			if b.BuilderPendingWithdrawals[ii] == nil {
 				b.BuilderPendingWithdrawals[ii] = new(BuilderPendingWithdrawal)
 			}
-			if err = b.BuilderPendingWithdrawals[ii].UnmarshalSSZ(buf[ii*36 : (ii+1)*36]); err != nil {
-				return err
-			}
-		}
-	}
-
-	// Field (44) 'PayloadExpectedWithdrawals'
-	{
-		buf = tail[o44:]
-		num, err := ssz.DivideInt2(len(buf), 44, 16)
-		if err != nil {
-			return err
-		}
-		b.PayloadExpectedWithdrawals = make([]*v1.Withdrawal, num)
-		for ii := 0; ii < num; ii++ {
-			if b.PayloadExpectedWithdrawals[ii] == nil {
-				b.PayloadExpectedWithdrawals[ii] = new(v1.Withdrawal)
-			}
-			if err = b.PayloadExpectedWithdrawals[ii].UnmarshalSSZ(buf[ii*44 : (ii+1)*44]); err != nil {
+			if err = b.BuilderPendingWithdrawals[ii].UnmarshalSSZ(buf[ii*44 : (ii+1)*44]); err != nil {
 				return err
 			}
 		}
@@ -2345,7 +2247,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 
 // SizeSSZ returns the ssz encoded size in bytes for the BeaconStateGloas object
 func (b *BeaconStateGloas) SizeSSZ() (size int) {
-	size = 2741333
+	size = 2741821
 
 	// Field (7) 'HistoricalRoots'
 	size += len(b.HistoricalRoots) * 32
@@ -2380,14 +2282,8 @@ func (b *BeaconStateGloas) SizeSSZ() (size int) {
 	// Field (36) 'PendingConsolidations'
 	size += len(b.PendingConsolidations) * 16
 
-	// Field (38) 'Builders'
-	size += len(b.Builders) * 93
-
-	// Field (42) 'BuilderPendingWithdrawals'
-	size += len(b.BuilderPendingWithdrawals) * 36
-
-	// Field (44) 'PayloadExpectedWithdrawals'
-	size += len(b.PayloadExpectedWithdrawals) * 44
+	// Field (40) 'BuilderPendingWithdrawals'
+	size += len(b.BuilderPendingWithdrawals) * 44
 
 	return
 }
@@ -2741,33 +2637,14 @@ func (b *BeaconStateGloas) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 		hh.Merkleize(subIndx)
 	}
 
-	// Field (38) 'Builders'
-	{
-		subIndx := hh.Index()
-		num := uint64(len(b.Builders))
-		if num > 1099511627776 {
-			err = ssz.ErrIncorrectListSize
-			return
-		}
-		for _, elem := range b.Builders {
-			if err = elem.HashTreeRootWith(hh); err != nil {
-				return
-			}
-		}
-		hh.MerkleizeWithMixin(subIndx, num, 1099511627776)
-	}
-
-	// Field (39) 'NextWithdrawalBuilderIndex'
-	hh.PutUint64(uint64(b.NextWithdrawalBuilderIndex))
-
-	// Field (40) 'ExecutionPayloadAvailability'
+	// Field (38) 'ExecutionPayloadAvailability'
 	if size := len(b.ExecutionPayloadAvailability); size != 1024 {
 		err = ssz.ErrBytesLengthFn("--.ExecutionPayloadAvailability", size, 1024)
 		return
 	}
 	hh.PutBytes(b.ExecutionPayloadAvailability)
 
-	// Field (41) 'BuilderPendingPayments'
+	// Field (39) 'BuilderPendingPayments'
 	{
 		subIndx := hh.Index()
 		for _, elem := range b.BuilderPendingPayments {
@@ -2778,7 +2655,7 @@ func (b *BeaconStateGloas) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 		hh.Merkleize(subIndx)
 	}
 
-	// Field (42) 'BuilderPendingWithdrawals'
+	// Field (40) 'BuilderPendingWithdrawals'
 	{
 		subIndx := hh.Index()
 		num := uint64(len(b.BuilderPendingWithdrawals))
@@ -2794,28 +2671,19 @@ func (b *BeaconStateGloas) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 		hh.MerkleizeWithMixin(subIndx, num, 1048576)
 	}
 
-	// Field (43) 'LatestBlockHash'
+	// Field (41) 'LatestBlockHash'
 	if size := len(b.LatestBlockHash); size != 32 {
 		err = ssz.ErrBytesLengthFn("--.LatestBlockHash", size, 32)
 		return
 	}
 	hh.PutBytes(b.LatestBlockHash)
 
-	// Field (44) 'PayloadExpectedWithdrawals'
-	{
-		subIndx := hh.Index()
-		num := uint64(len(b.PayloadExpectedWithdrawals))
-		if num > 16 {
-			err = ssz.ErrIncorrectListSize
-			return
-		}
-		for _, elem := range b.PayloadExpectedWithdrawals {
-			if err = elem.HashTreeRootWith(hh); err != nil {
-				return
-			}
-		}
-		hh.MerkleizeWithMixin(subIndx, num, 16)
+	// Field (42) 'LatestWithdrawalsRoot'
+	if size := len(b.LatestWithdrawalsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.LatestWithdrawalsRoot", size, 32)
+		return
 	}
+	hh.PutBytes(b.LatestWithdrawalsRoot)
 
 	hh.Merkleize(indx)
 	return
@@ -2848,7 +2716,7 @@ func (b *BuilderPendingPayment) MarshalSSZTo(buf []byte) (dst []byte, err error)
 func (b *BuilderPendingPayment) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size != 44 {
+	if size != 52 {
 		return ssz.ErrSize
 	}
 
@@ -2859,7 +2727,7 @@ func (b *BuilderPendingPayment) UnmarshalSSZ(buf []byte) error {
 	if b.Withdrawal == nil {
 		b.Withdrawal = new(BuilderPendingWithdrawal)
 	}
-	if err = b.Withdrawal.UnmarshalSSZ(buf[8:44]); err != nil {
+	if err = b.Withdrawal.UnmarshalSSZ(buf[8:52]); err != nil {
 		return err
 	}
 
@@ -2868,7 +2736,7 @@ func (b *BuilderPendingPayment) UnmarshalSSZ(buf []byte) error {
 
 // SizeSSZ returns the ssz encoded size in bytes for the BuilderPendingPayment object
 func (b *BuilderPendingPayment) SizeSSZ() (size int) {
-	size = 44
+	size = 52
 	return
 }
 
@@ -2915,6 +2783,9 @@ func (b *BuilderPendingWithdrawal) MarshalSSZTo(buf []byte) (dst []byte, err err
 	// Field (2) 'BuilderIndex'
 	dst = ssz.MarshalUint64(dst, uint64(b.BuilderIndex))
 
+	// Field (3) 'WithdrawableEpoch'
+	dst = ssz.MarshalUint64(dst, uint64(b.WithdrawableEpoch))
+
 	return
 }
 
@@ -2922,7 +2793,7 @@ func (b *BuilderPendingWithdrawal) MarshalSSZTo(buf []byte) (dst []byte, err err
 func (b *BuilderPendingWithdrawal) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size != 36 {
+	if size != 44 {
 		return ssz.ErrSize
 	}
 
@@ -2936,14 +2807,17 @@ func (b *BuilderPendingWithdrawal) UnmarshalSSZ(buf []byte) error {
 	b.Amount = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[20:28]))
 
 	// Field (2) 'BuilderIndex'
-	b.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.BuilderIndex(ssz.UnmarshallUint64(buf[28:36]))
+	b.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[28:36]))
+
+	// Field (3) 'WithdrawableEpoch'
+	b.WithdrawableEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
 
 	return err
 }
 
 // SizeSSZ returns the ssz encoded size in bytes for the BuilderPendingWithdrawal object
 func (b *BuilderPendingWithdrawal) SizeSSZ() (size int) {
-	size = 36
+	size = 44
 	return
 }
 
@@ -2969,6 +2843,9 @@ func (b *BuilderPendingWithdrawal) HashTreeRootWith(hh *ssz.Hasher) (err error)
 	// Field (2) 'BuilderIndex'
 	hh.PutUint64(uint64(b.BuilderIndex))
 
+	// Field (3) 'WithdrawableEpoch'
+	hh.PutUint64(uint64(b.WithdrawableEpoch))
+
 	hh.Merkleize(indx)
 	return
 }
@@ -3341,7 +3218,7 @@ func (e *ExecutionPayloadEnvelope) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (2) 'BuilderIndex'
-	e.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.BuilderIndex(ssz.UnmarshallUint64(buf[8:16]))
+	e.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (3) 'BeaconBlockRoot'
 	if cap(e.BeaconBlockRoot) == 0 {
@@ -3595,132 +3472,3 @@ func (s *SignedExecutionPayloadEnvelope) HashTreeRootWith(hh *ssz.Hasher) (err e
 	hh.Merkleize(indx)
 	return
 }
-
-// MarshalSSZ ssz marshals the Builder object
-func (b *Builder) MarshalSSZ() ([]byte, error) {
-	return ssz.MarshalSSZ(b)
-}
-
-// MarshalSSZTo ssz marshals the Builder object to a target array
-func (b *Builder) MarshalSSZTo(buf []byte) (dst []byte, err error) {
-	dst = buf
-
-	// Field (0) 'Pubkey'
-	if size := len(b.Pubkey); size != 48 {
-		err = ssz.ErrBytesLengthFn("--.Pubkey", size, 48)
-		return
-	}
-	dst = append(dst, b.Pubkey...)
-
-	// Field (1) 'Version'
-	if size := len(b.Version); size != 1 {
-		err = ssz.ErrBytesLengthFn("--.Version", size, 1)
-		return
-	}
-	dst = append(dst, b.Version...)
-
-	// Field (2) 'ExecutionAddress'
-	if size := len(b.ExecutionAddress); size != 20 {
-		err = ssz.ErrBytesLengthFn("--.ExecutionAddress", size, 20)
-		return
-	}
-	dst = append(dst, b.ExecutionAddress...)
-
-	// Field (3) 'Balance'
-	dst = ssz.MarshalUint64(dst, uint64(b.Balance))
-
-	// Field (4) 'DepositEpoch'
-	dst = ssz.MarshalUint64(dst, uint64(b.DepositEpoch))
-
-	// Field (5) 'WithdrawableEpoch'
-	dst = ssz.MarshalUint64(dst, uint64(b.WithdrawableEpoch))
-
-	return
-}
-
-// UnmarshalSSZ ssz unmarshals the Builder object
-func (b *Builder) UnmarshalSSZ(buf []byte) error {
-	var err error
-	size := uint64(len(buf))
-	if size != 93 {
-		return ssz.ErrSize
-	}
-
-	// Field (0) 'Pubkey'
-	if cap(b.Pubkey) == 0 {
-		b.Pubkey = make([]byte, 0, len(buf[0:48]))
-	}
-	b.Pubkey = append(b.Pubkey, buf[0:48]...)
-
-	// Field (1) 'Version'
-	if cap(b.Version) == 0 {
-		b.Version = make([]byte, 0, len(buf[48:49]))
-	}
-	b.Version = append(b.Version, buf[48:49]...)
-
-	// Field (2) 'ExecutionAddress'
-	if cap(b.ExecutionAddress) == 0 {
-		b.ExecutionAddress = make([]byte, 0, len(buf[49:69]))
-	}
-	b.ExecutionAddress = append(b.ExecutionAddress, buf[49:69]...)
-
-	// Field (3) 'Balance'
-	b.Balance = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[69:77]))
-
-	// Field (4) 'DepositEpoch'
-	b.DepositEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[77:85]))
-
-	// Field (5) 'WithdrawableEpoch'
-	b.WithdrawableEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[85:93]))
-
-	return err
-}
-
-// SizeSSZ returns the ssz encoded size in bytes for the Builder object
-func (b *Builder) SizeSSZ() (size int) {
-	size = 93
-	return
-}
-
-// HashTreeRoot ssz hashes the Builder object
-func (b *Builder) HashTreeRoot() ([32]byte, error) {
-	return ssz.HashWithDefaultHasher(b)
-}
-
-// HashTreeRootWith ssz hashes the Builder object with a hasher
-func (b *Builder) HashTreeRootWith(hh *ssz.Hasher) (err error) {
-	indx := hh.Index()
-
-	// Field (0) 'Pubkey'
-	if size := len(b.Pubkey); size != 48 {
-		err = ssz.ErrBytesLengthFn("--.Pubkey", size, 48)
-		return
-	}
-	hh.PutBytes(b.Pubkey)
-
-	// Field (1) 'Version'
-	if size := len(b.Version); size != 1 {
-		err = ssz.ErrBytesLengthFn("--.Version", size, 1)
-		return
-	}
-	hh.PutBytes(b.Version)
-
-	// Field (2) 'ExecutionAddress'
-	if size := len(b.ExecutionAddress); size != 20 {
-		err = ssz.ErrBytesLengthFn("--.ExecutionAddress", size, 20)
-		return
-	}
-	hh.PutBytes(b.ExecutionAddress)
-
-	// Field (3) 'Balance'
-	hh.PutUint64(uint64(b.Balance))
-
-	// Field (4) 'DepositEpoch'
-	hh.PutUint64(uint64(b.DepositEpoch))
-
-	// Field (5) 'WithdrawableEpoch'
-	hh.PutUint64(uint64(b.WithdrawableEpoch))
-
-	hh.Merkleize(indx)
-	return
-}