add it

* Check if validator exists when applying pending deposit

* Add test TestProcessPendingDepositsMultiplesSameDeposits

* keep a map of added pubkeys

---------

Co-authored-by: terence tsao <terence@prysmaticlabs.com>

.github/workflows/go.yml

@@ -54,7 +54,7 @@ jobs:
       - name: Golangci-lint
         uses: golangci/golangci-lint-action@v5
         with:
-          version: v1.55.2
+          version: v1.56.1
           args: --config=.golangci.yml --out-${NO_FUTURE}format colored-line-number
 
   build:

.golangci.yml

@@ -73,6 +73,7 @@ linters:
     - promlinter
     - protogetter
     - revive
+    - spancheck
     - staticcheck
     - stylecheck
     - tagalign

CHANGELOG.md

@@ -8,7 +8,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 
 ### Added
 
-- Electra EIP6110: Queue deposit [pr](https://github.com/prysmaticlabs/prysm/pull/14430)
+- Electra EIP6110: Queue deposit [pr](https://github.com/prysmaticlabs/prysm/pull/14430).
 - Add Bellatrix tests for light client functions.
 - Add Discovery Rebooter Feature.
 - Added GetBlockAttestationsV2 endpoint.
@@ -19,11 +19,15 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Added ListAttestationsV2 endpoint.
 - Add ability to rollback node's internal state during processing.
 - Change how unsafe protobuf state is created to prevent unnecessary copies.
-- Added benchmarks for process slots for Capella, Deneb, Electra
+- Added benchmarks for process slots for Capella, Deneb, Electra.
 - Add helper to cast bytes to string without allocating memory.
 - Added GetAggregatedAttestationV2 endpoint.
 - Added SubmitAttestationsV2 endpoint.
-- Validator REST mode Electra block support
+- Validator REST mode Electra block support.
+- Added validator index label to `validator_statuses` metric.
+- Added Validator REST mode use of Attestation V2 endpoints and Electra attestations.
+- PeerDAS: Added proto for `DataColumnIdentifier`, `DataColumnSidecar`, `DataColumnSidecarsByRangeRequest` and `MetadataV2`.
+- Better attestation packing for Electra. [PR](https://github.com/prysmaticlabs/prysm/pull/14534)
 
 ### Changed
 
@@ -51,9 +55,14 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Only Build the Protobuf state once during serialization.
 - Capella blocks are execution.
 - Fixed panic when http request to subscribe to event stream fails.
-- Return early for blob reconstructor during capella fork
-- Updated block endpoint from V1 to V2
+- Return early for blob reconstructor during capella fork.
+- Updated block endpoint from V1 to V2.
 - Rename instances of "deposit receipts" to "deposit requests".
+- Non-blocking payload attribute event handling in beacon api [pr](https://github.com/prysmaticlabs/prysm/pull/14644).
+- Updated light client protobufs. [PR](https://github.com/prysmaticlabs/prysm/pull/14650)
+- Added `Eth-Consensus-Version` header to `ListAttestationsV2` and `GetAggregateAttestationV2` endpoints.
+- Updated light client consensus types. [PR](https://github.com/prysmaticlabs/prysm/pull/14652)
+- Fixed pending deposits processing on Electra.
 
 ### Deprecated
 
@@ -80,6 +89,11 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - EIP7521 - Fixes withdrawal bug by accounting for pending partial withdrawals and deducting already withdrawn amounts from the sweep balance. [PR](https://github.com/prysmaticlabs/prysm/pull/14578)
 - unskip electra merkle spec test
 - Fix panic in validator REST mode when checking status after removing all keys
+- Fix panic on attestation interface since we call data before validation
+- corrects nil check on some interface attestation types
+- temporary solution to handling electra attesation and attester_slashing events. [pr](14655)
+- Diverse log improvements and comment additions.
+
 
 ### Security
 

beacon-chain/blockchain/execution_engine.go

@@ -6,8 +6,11 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -69,6 +72,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	if arg.attributes == nil {
 		arg.attributes = payloadattribute.EmptyWithVersion(headBlk.Version())
 	}
+	go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), arg)
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, arg.attributes)
 	if err != nil {
 		switch {
@@ -167,6 +171,38 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	return payloadID, nil
 }
 
+func firePayloadAttributesEvent(ctx context.Context, f event.SubscriberSender, cfg *fcuConfig) {
+	pidx, err := helpers.BeaconProposerIndex(ctx, cfg.headState)
+	if err != nil {
+		log.WithError(err).
+			WithField("head_root", cfg.headRoot[:]).
+			Error("Could not get proposer index for PayloadAttributes event")
+		return
+	}
+	evd := payloadattribute.EventData{
+		ProposerIndex:   pidx,
+		ProposalSlot:    cfg.headState.Slot(),
+		ParentBlockRoot: cfg.headRoot[:],
+		Attributer:      cfg.attributes,
+		HeadRoot:        cfg.headRoot,
+		HeadState:       cfg.headState,
+		HeadBlock:       cfg.headBlock,
+	}
+	if cfg.headBlock != nil && !cfg.headBlock.IsNil() {
+		headPayload, err := cfg.headBlock.Block().Body().Execution()
+		if err != nil {
+			log.WithError(err).Error("Could not get execution payload for head block")
+			return
+		}
+		evd.ParentBlockHash = headPayload.BlockHash()
+		evd.ParentBlockNumber = headPayload.BlockNumber()
+	}
+	f.Send(&feed.Event{
+		Type: statefeed.PayloadAttributes,
+		Data: evd,
+	})
+}
+
 // getPayloadHash returns the payload hash given the block root.
 // if the block is before bellatrix fork epoch, it returns the zero hash.
 func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, error) {

beacon-chain/blockchain/process_attestation_test.go

@@ -92,12 +92,12 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 		{
 			name:      "process nil attestation",
 			a:         nil,
-			wantedErr: "attestation can't be nil",
+			wantedErr: "attestation is nil",
 		},
 		{
 			name:      "process nil field (a.Data) in attestation",
 			a:         &ethpb.Attestation{},
-			wantedErr: "attestation's data can't be nil",
+			wantedErr: "attestation is nil",
 		},
 		{
 			name: "process nil field (a.Target) in attestation",

beacon-chain/blockchain/process_block.go

@@ -7,8 +7,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
-	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -620,9 +618,6 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if !s.inRegularSync() {
 		return
 	}
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.MissedSlot,
-	})
 	s.headLock.RLock()
 	headRoot := s.headRoot()
 	headState := s.headState(ctx)
@@ -650,6 +645,13 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	attribute := s.getPayloadAttribute(ctx, headState, s.CurrentSlot()+1, headRoot[:])
 	// return early if we are not proposing next slot
 	if attribute.IsEmpty() {
+		fcuArgs := &fcuConfig{
+			headState:  headState,
+			headRoot:   headRoot,
+			headBlock:  nil,
+			attributes: attribute,
+		}
+		go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), fcuArgs)
 		return
 	}
 

beacon-chain/core/blocks/attestation_test.go

@@ -448,6 +448,7 @@ func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
 			Target: &ethpb.Checkpoint{
 				Epoch: primitives.Epoch(i),
 			},
+			Source: &ethpb.Checkpoint{},
 		}
 	}
 
@@ -489,6 +490,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 				Target: &ethpb.Checkpoint{
 					Root: []byte{},
 				},
+				Source: &ethpb.Checkpoint{},
 			},
 			Signature:       sig.Marshal(),
 			AggregationBits: list,

beacon-chain/core/electra/deposits.go

@@ -386,8 +386,14 @@ func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState
 		return errors.Wrap(err, "batch signature verification failed")
 	}
 
+	pubKeyMap := make(map[[48]byte]struct{}, len(pendingDeposits))
+
 	// Process each deposit individually
 	for _, pendingDeposit := range pendingDeposits {
+		_, found := pubKeyMap[bytesutil.ToBytes48(pendingDeposit.PublicKey)]
+		if !found {
+			pubKeyMap[bytesutil.ToBytes48(pendingDeposit.PublicKey)] = struct{}{}
+		}
 		validSignature := allSignaturesVerified
 
 		// If batch verification failed, check the individual deposit signature
@@ -405,9 +411,16 @@ func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState
 
 		// Add validator to the registry if the signature is valid
 		if validSignature {
-			err = AddValidatorToRegistry(state, pendingDeposit.PublicKey, pendingDeposit.WithdrawalCredentials, pendingDeposit.Amount)
-			if err != nil {
-				return errors.Wrap(err, "failed to add validator to registry")
+			if found {
+				index, _ := state.ValidatorIndexByPubkey(bytesutil.ToBytes48(pendingDeposit.PublicKey))
+				if err := helpers.IncreaseBalance(state, index, pendingDeposit.Amount); err != nil {
+					return errors.Wrap(err, "could not increase balance")
+				}
+			} else {
+				err = AddValidatorToRegistry(state, pendingDeposit.PublicKey, pendingDeposit.WithdrawalCredentials, pendingDeposit.Amount)
+				if err != nil {
+					return errors.Wrap(err, "failed to add validator to registry")
+				}
 			}
 		}
 	}

beacon-chain/core/electra/deposits_test.go

@@ -22,6 +22,40 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
+func TestProcessPendingDepositsMultiplesSameDeposits(t *testing.T) {
+	st := stateWithActiveBalanceETH(t, 1000)
+	deps := make([]*eth.PendingDeposit, 2) // Make same deposit twice
+	validators := st.Validators()
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	for i := 0; i < len(deps); i += 1 {
+		wc := make([]byte, 32)
+		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		wc[31] = byte(i)
+		validators[i].PublicKey = sk.PublicKey().Marshal()
+		validators[i].WithdrawalCredentials = wc
+		deps[i] = stateTesting.GeneratePendingDeposit(t, sk, 32, bytesutil.ToBytes32(wc), 0)
+	}
+	require.NoError(t, st.SetPendingDeposits(deps))
+
+	err = electra.ProcessPendingDeposits(context.TODO(), st, 10000)
+	require.NoError(t, err)
+
+	val := st.Validators()
+	seenPubkeys := make(map[string]struct{})
+	for i := 0; i < len(val); i += 1 {
+		if len(val[i].PublicKey) == 0 {
+			continue
+		}
+		_, ok := seenPubkeys[string(val[i].PublicKey)]
+		if ok {
+			t.Fatalf("duplicated pubkeys")
+		} else {
+			seenPubkeys[string(val[i].PublicKey)] = struct{}{}
+		}
+	}
+}
+
 func TestProcessPendingDeposits(t *testing.T) {
 	tests := []struct {
 		name    string
@@ -285,7 +319,7 @@ func TestBatchProcessNewPendingDeposits(t *testing.T) {
 		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 		wc[31] = byte(0)
 		validDep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
-		invalidDep := &eth.PendingDeposit{}
+		invalidDep := &eth.PendingDeposit{PublicKey: make([]byte, 48)}
 		// have a combination of valid and invalid deposits
 		deps := []*eth.PendingDeposit{validDep, invalidDep}
 		require.NoError(t, electra.BatchProcessNewPendingDeposits(context.Background(), st, deps))

beacon-chain/core/feed/state/events.go

@@ -31,6 +31,8 @@ const (
 	LightClientFinalityUpdate
 	// LightClientOptimisticUpdate event
 	LightClientOptimisticUpdate
+	// PayloadAttributes events are fired upon a missed slot or new head.
+	PayloadAttributes
 )
 
 // BlockProcessedData is the data sent with BlockProcessed events.

beacon-chain/core/helpers/attestation.go

@@ -23,11 +23,8 @@ var (
 // Access to these nil fields will result in run time panic,
 // it is recommended to run these checks as first line of defense.
 func ValidateNilAttestation(attestation ethpb.Att) error {
-	if attestation == nil {
-		return errors.New("attestation can't be nil")
-	}
-	if attestation.GetData() == nil {
-		return errors.New("attestation's data can't be nil")
+	if attestation == nil || attestation.IsNil() {
+		return errors.New("attestation is nil")
 	}
 	if attestation.GetData().Source == nil {
 		return errors.New("attestation's source can't be nil")

beacon-chain/core/helpers/attestation_test.go

@@ -260,12 +260,12 @@ func TestValidateNilAttestation(t *testing.T) {
 		{
 			name:        "nil attestation",
 			attestation: nil,
-			errString:   "attestation can't be nil",
+			errString:   "attestation is nil",
 		},
 		{
 			name:        "nil attestation data",
 			attestation: &ethpb.Attestation{},
-			errString:   "attestation's data can't be nil",
+			errString:   "attestation is nil",
 		},
 		{
 			name: "nil attestation source",

beacon-chain/db/kv/blocks.go

@@ -23,10 +23,10 @@ import (
 	bolt "go.etcd.io/bbolt"
 )
 
-// used to represent errors for inconsistent slot ranges.
+// Used to represent errors for inconsistent slot ranges.
 var errInvalidSlotRange = errors.New("invalid end slot and start slot provided")
 
-// Block retrieval by root.
+// Block retrieval by root. Return nil if block is not found.
 func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.Block")
 	defer span.End()

beacon-chain/db/slasherkv/slasher.go

@@ -688,7 +688,7 @@ func decodeSlasherChunk(enc []byte) ([]uint16, error) {
 // Encode attestation record to bytes.
 // The output encoded attestation record consists in the signing root concatenated with the compressed attestation record.
 func encodeAttestationRecord(att *slashertypes.IndexedAttestationWrapper) ([]byte, error) {
-	if att == nil || att.IndexedAttestation == nil {
+	if att == nil || att.IndexedAttestation == nil || att.IndexedAttestation.IsNil() {
 		return []byte{}, errors.New("nil proposal record")
 	}
 

beacon-chain/forkchoice/doubly-linked-tree/reorg_late_blocks.go

@@ -53,7 +53,7 @@ func (f *ForkChoice) ShouldOverrideFCU() (override bool) {
 	// Only reorg blocks that arrive late
 	early, err := head.arrivedEarly(f.store.genesisTime)
 	if err != nil {
-		log.WithError(err).Error("could not check if block arrived early")
+		log.WithError(err).Error("Could not check if block arrived early")
 		return
 	}
 	if early {

beacon-chain/node/node.go

@@ -192,20 +192,13 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 	beacon.verifyInitWaiter = verification.NewInitializerWaiter(
 		beacon.clockWaiter, forkchoice.NewROForkChoice(beacon.forkChoicer), beacon.stateGen)
 
-	pa := peers.NewAssigner(beacon.fetchP2P().Peers(), beacon.forkChoicer)
-
 	beacon.BackfillOpts = append(
 		beacon.BackfillOpts,
 		backfill.WithVerifierWaiter(beacon.verifyInitWaiter),
 		backfill.WithInitSyncWaiter(initSyncWaiter(ctx, beacon.initialSyncComplete)),
 	)
 
-	bf, err := backfill.NewService(ctx, bfs, beacon.BlobStorage, beacon.clockWaiter, beacon.fetchP2P(), pa, beacon.BackfillOpts...)
-	if err != nil {
-		return nil, errors.Wrap(err, "error initializing backfill service")
-	}
-
-	if err := registerServices(cliCtx, beacon, synchronizer, bf, bfs); err != nil {
+	if err := registerServices(cliCtx, beacon, synchronizer, bfs); err != nil {
 		return nil, errors.Wrap(err, "could not register services")
 	}
 
@@ -292,11 +285,6 @@ func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress s
 		return nil, errors.Wrap(err, "could not start slashing DB")
 	}
 
-	log.Debugln("Registering P2P Service")
-	if err := beacon.registerP2P(cliCtx); err != nil {
-		return nil, errors.Wrap(err, "could not register P2P service")
-	}
-
 	bfs, err := backfill.NewUpdater(ctx, beacon.db)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not create backfill updater")
@@ -315,9 +303,15 @@ func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress s
 	return bfs, nil
 }
 
-func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *startup.ClockSynchronizer, bf *backfill.Service, bfs *backfill.Store) error {
-	if err := beacon.services.RegisterService(bf); err != nil {
-		return errors.Wrap(err, "could not register backfill service")
+func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *startup.ClockSynchronizer, bfs *backfill.Store) error {
+	log.Debugln("Registering P2P Service")
+	if err := beacon.registerP2P(cliCtx); err != nil {
+		return errors.Wrap(err, "could not register P2P service")
+	}
+
+	log.Debugln("Registering Backfill Service")
+	if err := beacon.RegisterBackfillService(cliCtx, bfs); err != nil {
+		return errors.Wrap(err, "could not register Back Fill service")
 	}
 
 	log.Debugln("Registering POW Chain Service")
@@ -1136,6 +1130,16 @@ func (b *BeaconNode) registerBuilderService(cliCtx *cli.Context) error {
 	return b.services.RegisterService(svc)
 }
 
+func (b *BeaconNode) RegisterBackfillService(cliCtx *cli.Context, bfs *backfill.Store) error {
+	pa := peers.NewAssigner(b.fetchP2P().Peers(), b.forkChoicer)
+	bf, err := backfill.NewService(cliCtx.Context, bfs, b.BlobStorage, b.clockWaiter, b.fetchP2P(), pa, b.BackfillOpts...)
+	if err != nil {
+		return errors.Wrap(err, "error initializing backfill service")
+	}
+
+	return b.services.RegisterService(bf)
+}
+
 func hasNetworkFlag(cliCtx *cli.Context) bool {
 	for _, flag := range features.NetworkFlags {
 		for _, name := range flag.Names() {

beacon-chain/operations/attestations/kv/aggregated_test.go

@@ -49,12 +49,12 @@ func TestKV_Aggregated_SaveAggregatedAttestation(t *testing.T) {
 		{
 			name:          "nil attestation",
 			att:           nil,
-			wantErrString: "attestation can't be nil",
+			wantErrString: "attestation is nil",
 		},
 		{
 			name:          "nil attestation data",
 			att:           &ethpb.Attestation{},
-			wantErrString: "attestation's data can't be nil",
+			wantErrString: "attestation is nil",
 		},
 		{
 			name: "not aggregated",
@@ -206,7 +206,7 @@ func TestKV_Aggregated_AggregatedAttestations(t *testing.T) {
 func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
 	t.Run("nil attestation", func(t *testing.T) {
 		cache := NewAttCaches()
-		assert.ErrorContains(t, "attestation can't be nil", cache.DeleteAggregatedAttestation(nil))
+		assert.ErrorContains(t, "attestation is nil", cache.DeleteAggregatedAttestation(nil))
 		att := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10101}, Data: &ethpb.AttestationData{Slot: 2}})
 		assert.NoError(t, cache.DeleteAggregatedAttestation(att))
 	})
@@ -288,7 +288,7 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
 			name:  "nil attestation",
 			input: nil,
 			want:  false,
-			err:   errors.New("can't be nil"),
+			err:   errors.New("is nil"),
 		},
 		{
 			name: "nil attestation data",
@@ -296,7 +296,7 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
 				AggregationBits: bitfield.Bitlist{0b1111},
 			},
 			want: false,
-			err:  errors.New("can't be nil"),
+			err:  errors.New("is nil"),
 		},
 		{
 			name: "empty cache aggregated",

beacon-chain/operations/attestations/kv/block.go

@@ -8,7 +8,7 @@ import (
 
 // SaveBlockAttestation saves an block attestation in cache.
 func (c *AttCaches) SaveBlockAttestation(att ethpb.Att) error {
-	if att == nil {
+	if att == nil || att.IsNil() {
 		return nil
 	}
 
@@ -53,10 +53,9 @@ func (c *AttCaches) BlockAttestations() []ethpb.Att {
 
 // DeleteBlockAttestation deletes a block attestation in cache.
 func (c *AttCaches) DeleteBlockAttestation(att ethpb.Att) error {
-	if att == nil {
+	if att == nil || att.IsNil() {
 		return nil
 	}
-
 	id, err := attestation.NewId(att, attestation.Data)
 	if err != nil {
 		return errors.Wrap(err, "could not create attestation ID")

beacon-chain/operations/attestations/kv/forkchoice.go

@@ -8,7 +8,7 @@ import (
 
 // SaveForkchoiceAttestation saves an forkchoice attestation in cache.
 func (c *AttCaches) SaveForkchoiceAttestation(att ethpb.Att) error {
-	if att == nil {
+	if att == nil || att.IsNil() {
 		return nil
 	}
 
@@ -50,7 +50,7 @@ func (c *AttCaches) ForkchoiceAttestations() []ethpb.Att {
 
 // DeleteForkchoiceAttestation deletes a forkchoice attestation in cache.
 func (c *AttCaches) DeleteForkchoiceAttestation(att ethpb.Att) error {
-	if att == nil {
+	if att == nil || att.IsNil() {
 		return nil
 	}
 

beacon-chain/operations/attestations/kv/unaggregated.go

@@ -14,7 +14,7 @@ import (
 
 // SaveUnaggregatedAttestation saves an unaggregated attestation in cache.
 func (c *AttCaches) SaveUnaggregatedAttestation(att ethpb.Att) error {
-	if att == nil {
+	if att == nil || att.IsNil() {
 		return nil
 	}
 	if helpers.IsAggregated(att) {
@@ -130,9 +130,10 @@ func (c *AttCaches) UnaggregatedAttestationsBySlotIndexElectra(
 
 // DeleteUnaggregatedAttestation deletes the unaggregated attestations in cache.
 func (c *AttCaches) DeleteUnaggregatedAttestation(att ethpb.Att) error {
-	if att == nil {
+	if att == nil || att.IsNil() {
 		return nil
 	}
+
 	if helpers.IsAggregated(att) {
 		return errors.New("attestation is aggregated")
 	}
@@ -161,7 +162,7 @@ func (c *AttCaches) DeleteSeenUnaggregatedAttestations() (int, error) {
 
 	count := 0
 	for r, att := range c.unAggregatedAtt {
-		if att == nil || helpers.IsAggregated(att) {
+		if att == nil || att.IsNil() || helpers.IsAggregated(att) {
 			continue
 		}
 		if seen, err := c.hasSeenBit(att); err == nil && seen {

beacon-chain/operations/attestations/mock/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations/mock",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/operations/attestations:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
     ],

beacon-chain/operations/attestations/mock/mock.go

@@ -3,13 +3,17 @@ package mock
 import (
 	"context"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
+var _ attestations.Pool = &PoolMock{}
+
 // PoolMock --
 type PoolMock struct {
-	AggregatedAtts []*ethpb.Attestation
+	AggregatedAtts   []ethpb.Att
+	UnaggregatedAtts []ethpb.Att
 }
 
 // AggregateUnaggregatedAttestations --
@@ -23,18 +27,18 @@ func (*PoolMock) AggregateUnaggregatedAttestationsBySlotIndex(_ context.Context,
 }
 
 // SaveAggregatedAttestation --
-func (*PoolMock) SaveAggregatedAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) SaveAggregatedAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 
 // SaveAggregatedAttestations --
-func (m *PoolMock) SaveAggregatedAttestations(atts []*ethpb.Attestation) error {
+func (m *PoolMock) SaveAggregatedAttestations(atts []ethpb.Att) error {
 	m.AggregatedAtts = append(m.AggregatedAtts, atts...)
 	return nil
 }
 
 // AggregatedAttestations --
-func (m *PoolMock) AggregatedAttestations() []*ethpb.Attestation {
+func (m *PoolMock) AggregatedAttestations() []ethpb.Att {
 	return m.AggregatedAtts
 }
 
@@ -43,13 +47,18 @@ func (*PoolMock) AggregatedAttestationsBySlotIndex(_ context.Context, _ primitiv
 	panic("implement me")
 }
 
+// AggregatedAttestationsBySlotIndexElectra --
+func (*PoolMock) AggregatedAttestationsBySlotIndexElectra(_ context.Context, _ primitives.Slot, _ primitives.CommitteeIndex) []*ethpb.AttestationElectra {
+	panic("implement me")
+}
+
 // DeleteAggregatedAttestation --
-func (*PoolMock) DeleteAggregatedAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) DeleteAggregatedAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 
 // HasAggregatedAttestation --
-func (*PoolMock) HasAggregatedAttestation(_ *ethpb.Attestation) (bool, error) {
+func (*PoolMock) HasAggregatedAttestation(_ ethpb.Att) (bool, error) {
 	panic("implement me")
 }
 
@@ -59,18 +68,19 @@ func (*PoolMock) AggregatedAttestationCount() int {
 }
 
 // SaveUnaggregatedAttestation --
-func (*PoolMock) SaveUnaggregatedAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) SaveUnaggregatedAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 
 // SaveUnaggregatedAttestations --
-func (*PoolMock) SaveUnaggregatedAttestations(_ []*ethpb.Attestation) error {
-	panic("implement me")
+func (m *PoolMock) SaveUnaggregatedAttestations(atts []ethpb.Att) error {
+	m.UnaggregatedAtts = append(m.UnaggregatedAtts, atts...)
+	return nil
 }
 
 // UnaggregatedAttestations --
-func (*PoolMock) UnaggregatedAttestations() ([]*ethpb.Attestation, error) {
-	panic("implement me")
+func (m *PoolMock) UnaggregatedAttestations() ([]ethpb.Att, error) {
+	return m.UnaggregatedAtts, nil
 }
 
 // UnaggregatedAttestationsBySlotIndex --
@@ -78,8 +88,13 @@ func (*PoolMock) UnaggregatedAttestationsBySlotIndex(_ context.Context, _ primit
 	panic("implement me")
 }
 
+// UnaggregatedAttestationsBySlotIndexElectra --
+func (*PoolMock) UnaggregatedAttestationsBySlotIndexElectra(_ context.Context, _ primitives.Slot, _ primitives.CommitteeIndex) []*ethpb.AttestationElectra {
+	panic("implement me")
+}
+
 // DeleteUnaggregatedAttestation --
-func (*PoolMock) DeleteUnaggregatedAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) DeleteUnaggregatedAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 
@@ -94,42 +109,42 @@ func (*PoolMock) UnaggregatedAttestationCount() int {
 }
 
 // SaveBlockAttestation --
-func (*PoolMock) SaveBlockAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) SaveBlockAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 
 // SaveBlockAttestations --
-func (*PoolMock) SaveBlockAttestations(_ []*ethpb.Attestation) error {
+func (*PoolMock) SaveBlockAttestations(_ []ethpb.Att) error {
 	panic("implement me")
 }
 
 // BlockAttestations --
-func (*PoolMock) BlockAttestations() []*ethpb.Attestation {
+func (*PoolMock) BlockAttestations() []ethpb.Att {
 	panic("implement me")
 }
 
 // DeleteBlockAttestation --
-func (*PoolMock) DeleteBlockAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) DeleteBlockAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 
 // SaveForkchoiceAttestation --
-func (*PoolMock) SaveForkchoiceAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) SaveForkchoiceAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 
 // SaveForkchoiceAttestations --
-func (*PoolMock) SaveForkchoiceAttestations(_ []*ethpb.Attestation) error {
+func (*PoolMock) SaveForkchoiceAttestations(_ []ethpb.Att) error {
 	panic("implement me")
 }
 
 // ForkchoiceAttestations --
-func (*PoolMock) ForkchoiceAttestations() []*ethpb.Attestation {
+func (*PoolMock) ForkchoiceAttestations() []ethpb.Att {
 	panic("implement me")
 }
 
 // DeleteForkchoiceAttestation --
-func (*PoolMock) DeleteForkchoiceAttestation(_ *ethpb.Attestation) error {
+func (*PoolMock) DeleteForkchoiceAttestation(_ ethpb.Att) error {
 	panic("implement me")
 }
 

beacon-chain/p2p/BUILD.bazel

@@ -75,6 +75,8 @@ go_library(
         "//runtime/version:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_btcsuite_btcd_btcec_v2//:go_default_library",
+        "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/discover:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",

beacon-chain/p2p/pubsub.go

@@ -165,14 +165,14 @@ func (s *Service) pubsubOptions() []pubsub.Option {
 func parsePeersEnr(peers []string) ([]peer.AddrInfo, error) {
 	addrs, err := PeersFromStringAddrs(peers)
 	if err != nil {
-		return nil, fmt.Errorf("Cannot convert peers raw ENRs into multiaddresses: %w", err)
+		return nil, fmt.Errorf("cannot convert peers raw ENRs into multiaddresses: %w", err)
 	}
 	if len(addrs) == 0 {
-		return nil, fmt.Errorf("Converting peers raw ENRs into multiaddresses resulted in an empty list")
+		return nil, fmt.Errorf("converting peers raw ENRs into multiaddresses resulted in an empty list")
 	}
 	directAddrInfos, err := peer.AddrInfosFromP2pAddrs(addrs...)
 	if err != nil {
-		return nil, fmt.Errorf("Cannot convert peers multiaddresses into AddrInfos: %w", err)
+		return nil, fmt.Errorf("cannot convert peers multiaddresses into AddrInfos: %w", err)
 	}
 	return directAddrInfos, nil
 }

beacon-chain/p2p/testing/fuzz_p2p.go

@@ -27,148 +27,148 @@ func NewFuzzTestP2P() *FakeP2P {
 }
 
 // Encoding -- fake.
-func (_ *FakeP2P) Encoding() encoder.NetworkEncoding {
+func (*FakeP2P) Encoding() encoder.NetworkEncoding {
 	return &encoder.SszNetworkEncoder{}
 }
 
 // AddConnectionHandler -- fake.
-func (_ *FakeP2P) AddConnectionHandler(_, _ func(ctx context.Context, id peer.ID) error) {
+func (*FakeP2P) AddConnectionHandler(_, _ func(ctx context.Context, id peer.ID) error) {
 
 }
 
 // AddDisconnectionHandler -- fake.
-func (_ *FakeP2P) AddDisconnectionHandler(_ func(ctx context.Context, id peer.ID) error) {
+func (*FakeP2P) AddDisconnectionHandler(_ func(ctx context.Context, id peer.ID) error) {
 }
 
 // AddPingMethod -- fake.
-func (_ *FakeP2P) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {
+func (*FakeP2P) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {
 
 }
 
 // PeerID -- fake.
-func (_ *FakeP2P) PeerID() peer.ID {
+func (*FakeP2P) PeerID() peer.ID {
 	return "fake"
 }
 
 // ENR returns the enr of the local peer.
-func (_ *FakeP2P) ENR() *enr.Record {
+func (*FakeP2P) ENR() *enr.Record {
 	return new(enr.Record)
 }
 
 // DiscoveryAddresses -- fake
-func (_ *FakeP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
+func (*FakeP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	return nil, nil
 }
 
 // FindPeersWithSubnet mocks the p2p func.
-func (_ *FakeP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
+func (*FakeP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
 	return false, nil
 }
 
 // RefreshENR mocks the p2p func.
-func (_ *FakeP2P) RefreshENR() {}
+func (*FakeP2P) RefreshENR() {}
 
 // LeaveTopic -- fake.
-func (_ *FakeP2P) LeaveTopic(_ string) error {
+func (*FakeP2P) LeaveTopic(_ string) error {
 	return nil
 }
 
 // Metadata -- fake.
-func (_ *FakeP2P) Metadata() metadata.Metadata {
+func (*FakeP2P) Metadata() metadata.Metadata {
 	return nil
 }
 
 // Peers -- fake.
-func (_ *FakeP2P) Peers() *peers.Status {
+func (*FakeP2P) Peers() *peers.Status {
 	return nil
 }
 
 // PublishToTopic -- fake.
-func (_ *FakeP2P) PublishToTopic(_ context.Context, _ string, _ []byte, _ ...pubsub.PubOpt) error {
+func (*FakeP2P) PublishToTopic(_ context.Context, _ string, _ []byte, _ ...pubsub.PubOpt) error {
 	return nil
 }
 
 // Send -- fake.
-func (_ *FakeP2P) Send(_ context.Context, _ interface{}, _ string, _ peer.ID) (network.Stream, error) {
+func (*FakeP2P) Send(_ context.Context, _ interface{}, _ string, _ peer.ID) (network.Stream, error) {
 	return nil, nil
 }
 
 // PubSub -- fake.
-func (_ *FakeP2P) PubSub() *pubsub.PubSub {
+func (*FakeP2P) PubSub() *pubsub.PubSub {
 	return nil
 }
 
 // MetadataSeq -- fake.
-func (_ *FakeP2P) MetadataSeq() uint64 {
+func (*FakeP2P) MetadataSeq() uint64 {
 	return 0
 }
 
 // SetStreamHandler -- fake.
-func (_ *FakeP2P) SetStreamHandler(_ string, _ network.StreamHandler) {
+func (*FakeP2P) SetStreamHandler(_ string, _ network.StreamHandler) {
 
 }
 
 // SubscribeToTopic -- fake.
-func (_ *FakeP2P) SubscribeToTopic(_ string, _ ...pubsub.SubOpt) (*pubsub.Subscription, error) {
+func (*FakeP2P) SubscribeToTopic(_ string, _ ...pubsub.SubOpt) (*pubsub.Subscription, error) {
 	return nil, nil
 }
 
 // JoinTopic -- fake.
-func (_ *FakeP2P) JoinTopic(_ string, _ ...pubsub.TopicOpt) (*pubsub.Topic, error) {
+func (*FakeP2P) JoinTopic(_ string, _ ...pubsub.TopicOpt) (*pubsub.Topic, error) {
 	return nil, nil
 }
 
 // Host -- fake.
-func (_ *FakeP2P) Host() host.Host {
+func (*FakeP2P) Host() host.Host {
 	return nil
 }
 
 // Disconnect -- fake.
-func (_ *FakeP2P) Disconnect(_ peer.ID) error {
+func (*FakeP2P) Disconnect(_ peer.ID) error {
 	return nil
 }
 
 // Broadcast -- fake.
-func (_ *FakeP2P) Broadcast(_ context.Context, _ proto.Message) error {
+func (*FakeP2P) Broadcast(_ context.Context, _ proto.Message) error {
 	return nil
 }
 
 // BroadcastAttestation -- fake.
-func (_ *FakeP2P) BroadcastAttestation(_ context.Context, _ uint64, _ ethpb.Att) error {
+func (*FakeP2P) BroadcastAttestation(_ context.Context, _ uint64, _ ethpb.Att) error {
 	return nil
 }
 
 // BroadcastSyncCommitteeMessage -- fake.
-func (_ *FakeP2P) BroadcastSyncCommitteeMessage(_ context.Context, _ uint64, _ *ethpb.SyncCommitteeMessage) error {
+func (*FakeP2P) BroadcastSyncCommitteeMessage(_ context.Context, _ uint64, _ *ethpb.SyncCommitteeMessage) error {
 	return nil
 }
 
 // BroadcastBlob -- fake.
-func (_ *FakeP2P) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.BlobSidecar) error {
+func (*FakeP2P) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.BlobSidecar) error {
 	return nil
 }
 
 // InterceptPeerDial -- fake.
-func (_ *FakeP2P) InterceptPeerDial(peer.ID) (allow bool) {
+func (*FakeP2P) InterceptPeerDial(peer.ID) (allow bool) {
 	return true
 }
 
 // InterceptAddrDial -- fake.
-func (_ *FakeP2P) InterceptAddrDial(peer.ID, multiaddr.Multiaddr) (allow bool) {
+func (*FakeP2P) InterceptAddrDial(peer.ID, multiaddr.Multiaddr) (allow bool) {
 	return true
 }
 
 // InterceptAccept -- fake.
-func (_ *FakeP2P) InterceptAccept(_ network.ConnMultiaddrs) (allow bool) {
+func (*FakeP2P) InterceptAccept(_ network.ConnMultiaddrs) (allow bool) {
 	return true
 }
 
 // InterceptSecured -- fake.
-func (_ *FakeP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiaddrs) (allow bool) {
+func (*FakeP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiaddrs) (allow bool) {
 	return true
 }
 
 // InterceptUpgraded -- fake.
-func (_ *FakeP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
+func (*FakeP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
 	return true, 0
 }

beacon-chain/p2p/testing/mock_host.go

@@ -18,12 +18,12 @@ type MockHost struct {
 }
 
 // ID --
-func (_ *MockHost) ID() peer.ID {
+func (*MockHost) ID() peer.ID {
 	return ""
 }
 
 // Peerstore --
-func (_ *MockHost) Peerstore() peerstore.Peerstore {
+func (*MockHost) Peerstore() peerstore.Peerstore {
 	return nil
 }
 
@@ -33,46 +33,46 @@ func (m *MockHost) Addrs() []ma.Multiaddr {
 }
 
 // Network --
-func (_ *MockHost) Network() network.Network {
+func (*MockHost) Network() network.Network {
 	return nil
 }
 
 // Mux --
-func (_ *MockHost) Mux() protocol.Switch {
+func (*MockHost) Mux() protocol.Switch {
 	return nil
 }
 
 // Connect --
-func (_ *MockHost) Connect(_ context.Context, _ peer.AddrInfo) error {
+func (*MockHost) Connect(_ context.Context, _ peer.AddrInfo) error {
 	return nil
 }
 
 // SetStreamHandler --
-func (_ *MockHost) SetStreamHandler(_ protocol.ID, _ network.StreamHandler) {}
+func (*MockHost) SetStreamHandler(_ protocol.ID, _ network.StreamHandler) {}
 
 // SetStreamHandlerMatch --
-func (_ *MockHost) SetStreamHandlerMatch(protocol.ID, func(id protocol.ID) bool, network.StreamHandler) {
+func (*MockHost) SetStreamHandlerMatch(protocol.ID, func(id protocol.ID) bool, network.StreamHandler) {
 }
 
 // RemoveStreamHandler --
-func (_ *MockHost) RemoveStreamHandler(_ protocol.ID) {}
+func (*MockHost) RemoveStreamHandler(_ protocol.ID) {}
 
 // NewStream --
-func (_ *MockHost) NewStream(_ context.Context, _ peer.ID, _ ...protocol.ID) (network.Stream, error) {
+func (*MockHost) NewStream(_ context.Context, _ peer.ID, _ ...protocol.ID) (network.Stream, error) {
 	return nil, nil
 }
 
 // Close --
-func (_ *MockHost) Close() error {
+func (*MockHost) Close() error {
 	return nil
 }
 
 // ConnManager --
-func (_ *MockHost) ConnManager() connmgr.ConnManager {
+func (*MockHost) ConnManager() connmgr.ConnManager {
 	return nil
 }
 
 // EventBus --
-func (_ *MockHost) EventBus() event.Bus {
+func (*MockHost) EventBus() event.Bus {
 	return nil
 }

beacon-chain/p2p/utils.go

@@ -12,10 +12,15 @@ import (
 	"path"
 	"time"
 
+	"github.com/btcsuite/btcd/btcec/v2"
+	gCrypto "github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/libp2p/go-libp2p/core/crypto"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/wrapper"
 	ecdsaprysm "github.com/prysmaticlabs/prysm/v5/crypto/ecdsa"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
@@ -62,6 +67,7 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 	}
 
 	if defaultKeysExist {
+		log.WithField("filePath", defaultKeyPath).Info("Reading static P2P private key from a file. To generate a new random private key at every start, please remove this file.")
 		return privKeyFromFile(defaultKeyPath)
 	}
 
@@ -71,8 +77,8 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 		return nil, err
 	}
 
-	// If the StaticPeerID flag is not set, return the private key.
-	if !cfg.StaticPeerID {
+	// If the StaticPeerID flag is not set and if peerDAS is not enabled, return the private key.
+	if !(cfg.StaticPeerID || params.PeerDASEnabled()) {
 		return ecdsaprysm.ConvertFromInterfacePrivKey(priv)
 	}
 
@@ -89,7 +95,7 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 		return nil, err
 	}
 
-	log.Info("Wrote network key to file")
+	log.WithField("path", defaultKeyPath).Info("Wrote network key to file")
 	// Read the key from the defaultKeyPath file just written
 	// for the strongest guarantee that the next start will be the same as this one.
 	return privKeyFromFile(defaultKeyPath)
@@ -173,3 +179,27 @@ func verifyConnectivity(addr string, port uint, protocol string) {
 		}
 	}
 }
+
+// ConvertPeerIDToNodeID converts a peer ID (libp2p) to a node ID (devp2p).
+func ConvertPeerIDToNodeID(pid peer.ID) (enode.ID, error) {
+	// Retrieve the public key object of the peer under "crypto" form.
+	pubkeyObjCrypto, err := pid.ExtractPublicKey()
+	if err != nil {
+		return [32]byte{}, errors.Wrapf(err, "extract public key from peer ID `%s`", pid)
+	}
+
+	// Extract the bytes representation of the public key.
+	compressedPubKeyBytes, err := pubkeyObjCrypto.Raw()
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "public key raw")
+	}
+
+	// Retrieve the public key object of the peer under "SECP256K1" form.
+	pubKeyObjSecp256k1, err := btcec.ParsePubKey(compressedPubKeyBytes)
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "parse public key")
+	}
+
+	newPubkey := &ecdsa.PublicKey{Curve: gCrypto.S256(), X: pubKeyObjSecp256k1.X(), Y: pubKeyObjSecp256k1.Y()}
+	return enode.PubkeyToIDV4(newPubkey), nil
+}

beacon-chain/p2p/utils_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -64,3 +65,19 @@ func TestSerializeENR(t *testing.T) {
 		assert.ErrorContains(t, "could not serialize nil record", err)
 	})
 }
+
+func TestConvertPeerIDToNodeID(t *testing.T) {
+	const (
+		peerIDStr         = "16Uiu2HAmRrhnqEfybLYimCiAYer2AtZKDGamQrL1VwRCyeh2YiFc"
+		expectedNodeIDStr = "eed26c5d2425ab95f57246a5dca87317c41cacee4bcafe8bbe57e5965527c290"
+	)
+
+	peerID, err := peer.Decode(peerIDStr)
+	require.NoError(t, err)
+
+	actualNodeID, err := ConvertPeerIDToNodeID(peerID)
+	require.NoError(t, err)
+
+	actualNodeIDStr := actualNodeID.String()
+	require.Equal(t, expectedNodeIDStr, actualNodeIDStr)
+}

beacon-chain/rpc/core/validator.go

@@ -381,21 +381,12 @@ func (s *Service) SubmitSignedAggregateSelectionProof(
 	ctx, span := trace.StartSpan(ctx, "coreService.SubmitSignedAggregateSelectionProof")
 	defer span.End()
 
-	if agg == nil {
+	if agg == nil || agg.IsNil() {
 		return &RpcError{Err: errors.New("signed aggregate request can't be nil"), Reason: BadRequest}
 	}
 	attAndProof := agg.AggregateAttestationAndProof()
-	if attAndProof == nil {
-		return &RpcError{Err: errors.New("signed aggregate request can't be nil"), Reason: BadRequest}
-	}
 	att := attAndProof.AggregateVal()
-	if att == nil {
-		return &RpcError{Err: errors.New("signed aggregate request can't be nil"), Reason: BadRequest}
-	}
 	data := att.GetData()
-	if data == nil {
-		return &RpcError{Err: errors.New("signed aggregate request can't be nil"), Reason: BadRequest}
-	}
 	emptySig := make([]byte, fieldparams.BLSSignatureLength)
 	if bytes.Equal(agg.GetSignature(), emptySig) || bytes.Equal(attAndProof.GetSelectionProof(), emptySig) {
 		return &RpcError{Err: errors.New("signed signatures can't be zero hashes"), Reason: BadRequest}

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

@@ -149,6 +149,7 @@ func (s *Server) ListAttestationsV2(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	w.Header().Set(api.VersionHeader, version.String(headState.Version()))
 	httputil.WriteJson(w, &structs.ListAttestationsResponse{
 		Version: version.String(headState.Version()),
 		Data:    attsData,

beacon-chain/rpc/eth/config/handlers_test.go

@@ -79,6 +79,7 @@ func TestGetSpec(t *testing.T) {
 	config.DenebForkEpoch = 105
 	config.ElectraForkVersion = []byte("ElectraForkVersion")
 	config.ElectraForkEpoch = 107
+	config.Eip7594ForkEpoch = 109
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
 	config.GenesisDelay = 24
@@ -189,7 +190,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 155, len(data))
+	assert.Equal(t, 156, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -267,6 +268,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x"+hex.EncodeToString([]byte("ElectraForkVersion")), v)
 			case "ELECTRA_FORK_EPOCH":
 				assert.Equal(t, "107", v)
+			case "EIP7594_FORK_EPOCH":
+				assert.Equal(t, "109", v)
 			case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":
 				assert.Equal(t, "1000", v)
 			case "BLS_WITHDRAWAL_PREFIX":

beacon-chain/rpc/eth/events/BUILD.bazel

@@ -19,11 +19,12 @@ go_library(
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/payload-attribute:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -52,6 +53,7 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/payload-attribute:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

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

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"strconv"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -18,11 +19,12 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	chaintime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
+	engine "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -31,6 +33,7 @@ import (
 )
 
 const DefaultEventFeedDepth = 1000
+const payloadAttributeTimeout = 2 * time.Second
 
 const (
 	InvalidTopic = "__invalid__"
@@ -89,12 +92,12 @@ var opsFeedEventTopics = map[feed.EventType]string{
 
 var stateFeedEventTopics = map[feed.EventType]string{
 	statefeed.NewHead:                     HeadTopic,
-	statefeed.MissedSlot:                  PayloadAttributesTopic,
 	statefeed.FinalizedCheckpoint:         FinalizedCheckpointTopic,
 	statefeed.LightClientFinalityUpdate:   LightClientFinalityUpdateTopic,
 	statefeed.LightClientOptimisticUpdate: LightClientOptimisticUpdateTopic,
 	statefeed.Reorg:                       ChainReorgTopic,
 	statefeed.BlockProcessed:              BlockTopic,
+	statefeed.PayloadAttributes:           PayloadAttributesTopic,
 }
 
 var topicsForStateFeed = topicsForFeed(stateFeedEventTopics)
@@ -418,10 +421,9 @@ func topicForEvent(event *feed.Event) string {
 		return ChainReorgTopic
 	case *statefeed.BlockProcessedData:
 		return BlockTopic
+	case payloadattribute.EventData:
+		return PayloadAttributesTopic
 	default:
-		if event.Type == statefeed.MissedSlot {
-			return PayloadAttributesTopic
-		}
 		return InvalidTopic
 	}
 }
@@ -431,31 +433,17 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi
 	if !topics.requested(eventName) {
 		return nil, errNotRequested
 	}
-	if eventName == PayloadAttributesTopic {
-		return s.currentPayloadAttributes(ctx)
-	}
 	if event == nil || event.Data == nil {
 		return nil, errors.New("event or event data is nil")
 	}
 	switch v := event.Data.(type) {
+	case payloadattribute.EventData:
+		return s.payloadAttributesReader(ctx, v)
 	case *ethpb.EventHead:
 		// The head event is a special case because, if the client requested the payload attributes topic,
 		// we send two event messages in reaction; the head event and the payload attributes.
-		headReader := func() io.Reader {
-			return jsonMarshalReader(eventName, structs.HeadEventFromV1(v))
-		}
-		// Don't do the expensive attr lookup unless the client requested it.
-		if !topics.requested(PayloadAttributesTopic) {
-			return headReader, nil
-		}
-		// Since payload attributes could change before the outbox is written, we need to do a blocking operation to
-		// get the current payload attributes right here.
-		attrReader, err := s.currentPayloadAttributes(ctx)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get payload attributes for head event")
-		}
 		return func() io.Reader {
-			return io.MultiReader(headReader(), attrReader())
+			return jsonMarshalReader(eventName, structs.HeadEventFromV1(v))
 		}, nil
 	case *operation.AggregatedAttReceivedData:
 		return func() io.Reader {
@@ -463,14 +451,20 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi
 			return jsonMarshalReader(eventName, att)
 		}, nil
 	case *operation.UnAggregatedAttReceivedData:
-		att, ok := v.Attestation.(*eth.Attestation)
-		if !ok {
+		switch att := v.Attestation.(type) {
+		case *eth.Attestation:
+			return func() io.Reader {
+				att := structs.AttFromConsensus(att)
+				return jsonMarshalReader(eventName, att)
+			}, nil
+		case *eth.AttestationElectra:
+			return func() io.Reader {
+				att := structs.AttElectraFromConsensus(att)
+				return jsonMarshalReader(eventName, att)
+			}, nil
+		default:
 			return nil, errors.Wrapf(errUnhandledEventData, "Unexpected type %T for the .Attestation field of UnAggregatedAttReceivedData", v.Attestation)
 		}
-		return func() io.Reader {
-			att := structs.AttFromConsensus(att)
-			return jsonMarshalReader(eventName, att)
-		}, nil
 	case *operation.ExitReceivedData:
 		return func() io.Reader {
 			return jsonMarshalReader(eventName, structs.SignedExitFromConsensus(v.Exit))
@@ -495,13 +489,18 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi
 			})
 		}, nil
 	case *operation.AttesterSlashingReceivedData:
-		slashing, ok := v.AttesterSlashing.(*eth.AttesterSlashing)
-		if !ok {
+		switch slashing := v.AttesterSlashing.(type) {
+		case *eth.AttesterSlashing:
+			return func() io.Reader {
+				return jsonMarshalReader(eventName, structs.AttesterSlashingFromConsensus(slashing))
+			}, nil
+		case *eth.AttesterSlashingElectra:
+			return func() io.Reader {
+				return jsonMarshalReader(eventName, structs.AttesterSlashingElectraFromConsensus(slashing))
+			}, nil
+		default:
 			return nil, errors.Wrapf(errUnhandledEventData, "Unexpected type %T for the .AttesterSlashing field of AttesterSlashingReceivedData", v.AttesterSlashing)
 		}
-		return func() io.Reader {
-			return jsonMarshalReader(eventName, structs.AttesterSlashingFromConsensus(slashing))
-		}, nil
 	case *operation.ProposerSlashingReceivedData:
 		return func() io.Reader {
 			return jsonMarshalReader(eventName, structs.ProposerSlashingFromConsensus(v.ProposerSlashing))
@@ -556,115 +555,202 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi
 	}
 }
 
-// This event stream is intended to be used by builders and relays.
-// Parent fields are based on state at N_{current_slot}, while the rest of fields are based on state of N_{current_slot + 1}
-func (s *Server) currentPayloadAttributes(ctx context.Context) (lazyReader, error) {
-	headRoot, err := s.HeadFetcher.HeadRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get head root")
-	}
-	st, err := s.HeadFetcher.HeadState(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get head state")
-	}
-	// advance the head state
-	headState, err := transition.ProcessSlotsIfPossible(ctx, st, s.ChainInfoFetcher.CurrentSlot()+1)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not advance head state")
+var errUnsupportedPayloadAttribute = errors.New("cannot compute payload attributes pre-Bellatrix")
+
+func (s *Server) computePayloadAttributes(ctx context.Context, ev payloadattribute.EventData) (payloadattribute.Attributer, error) {
+	v := ev.HeadState.Version()
+	if v < version.Bellatrix {
+		return nil, errors.Wrapf(errUnsupportedPayloadAttribute, "%s is not supported", version.String(v))
 	}
 
-	headBlock, err := s.HeadFetcher.HeadBlock(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get head block")
-	}
-
-	headPayload, err := headBlock.Block().Body().Execution()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution payload")
-	}
-
-	t, err := slots.ToTime(headState.GenesisTime(), headState.Slot())
+	t, err := slots.ToTime(ev.HeadState.GenesisTime(), ev.HeadState.Slot())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get head state slot time")
 	}
-
-	prevRando, err := helpers.RandaoMix(headState, chaintime.CurrentEpoch(headState))
+	timestamp := uint64(t.Unix())
+	prevRando, err := helpers.RandaoMix(ev.HeadState, chaintime.CurrentEpoch(ev.HeadState))
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get head state randao mix")
 	}
-
-	proposerIndex, err := helpers.BeaconProposerIndex(ctx, headState)
+	proposerIndex, err := helpers.BeaconProposerIndex(ctx, ev.HeadState)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get head state proposer index")
 	}
-	feeRecipient := params.BeaconConfig().DefaultFeeRecipient.Bytes()
+	feeRecpt := params.BeaconConfig().DefaultFeeRecipient.Bytes()
 	tValidator, exists := s.TrackedValidatorsCache.Validator(proposerIndex)
 	if exists {
-		feeRecipient = tValidator.FeeRecipient[:]
-	}
-	var attributes interface{}
-	switch headState.Version() {
-	case version.Bellatrix:
-		attributes = &structs.PayloadAttributesV1{
-			Timestamp:             fmt.Sprintf("%d", t.Unix()),
-			PrevRandao:            hexutil.Encode(prevRando),
-			SuggestedFeeRecipient: hexutil.Encode(feeRecipient),
-		}
-	case version.Capella:
-		withdrawals, _, err := headState.ExpectedWithdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get head state expected withdrawals")
-		}
-		attributes = &structs.PayloadAttributesV2{
-			Timestamp:             fmt.Sprintf("%d", t.Unix()),
-			PrevRandao:            hexutil.Encode(prevRando),
-			SuggestedFeeRecipient: hexutil.Encode(feeRecipient),
-			Withdrawals:           structs.WithdrawalsFromConsensus(withdrawals),
-		}
-	case version.Deneb, version.Electra:
-		withdrawals, _, err := headState.ExpectedWithdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get head state expected withdrawals")
-		}
-		parentRoot, err := headBlock.Block().HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get head block root")
-		}
-		attributes = &structs.PayloadAttributesV3{
-			Timestamp:             fmt.Sprintf("%d", t.Unix()),
-			PrevRandao:            hexutil.Encode(prevRando),
-			SuggestedFeeRecipient: hexutil.Encode(feeRecipient),
-			Withdrawals:           structs.WithdrawalsFromConsensus(withdrawals),
-			ParentBeaconBlockRoot: hexutil.Encode(parentRoot[:]),
-		}
-	default:
-		return nil, errors.Wrapf(err, "Payload version %s is not supported", version.String(headState.Version()))
+		feeRecpt = tValidator.FeeRecipient[:]
 	}
 
-	attributesBytes, err := json.Marshal(attributes)
-	if err != nil {
-		return nil, errors.Wrap(err, "errors marshaling payload attributes to json")
-	}
-	eventData := structs.PayloadAttributesEventData{
-		ProposerIndex:     fmt.Sprintf("%d", proposerIndex),
-		ProposalSlot:      fmt.Sprintf("%d", headState.Slot()),
-		ParentBlockNumber: fmt.Sprintf("%d", headPayload.BlockNumber()),
-		ParentBlockRoot:   hexutil.Encode(headRoot),
-		ParentBlockHash:   hexutil.Encode(headPayload.BlockHash()),
-		PayloadAttributes: attributesBytes,
-	}
-	eventDataBytes, err := json.Marshal(eventData)
-	if err != nil {
-		return nil, errors.Wrap(err, "errors marshaling payload attributes event data to json")
-	}
-	return func() io.Reader {
-		return jsonMarshalReader(PayloadAttributesTopic, &structs.PayloadAttributesEvent{
-			Version: version.String(headState.Version()),
-			Data:    eventDataBytes,
+	if v == version.Bellatrix {
+		return payloadattribute.New(&engine.PayloadAttributes{
+			Timestamp:             timestamp,
+			PrevRandao:            prevRando,
+			SuggestedFeeRecipient: feeRecpt,
 		})
+	}
+
+	w, _, err := ev.HeadState.ExpectedWithdrawals()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get withdrawals from head state")
+	}
+	if v == version.Capella {
+		return payloadattribute.New(&engine.PayloadAttributesV2{
+			Timestamp:             timestamp,
+			PrevRandao:            prevRando,
+			SuggestedFeeRecipient: feeRecpt,
+			Withdrawals:           w,
+		})
+	}
+
+	pr, err := ev.HeadBlock.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute head block root")
+	}
+	return payloadattribute.New(&engine.PayloadAttributesV3{
+		Timestamp:             timestamp,
+		PrevRandao:            prevRando,
+		SuggestedFeeRecipient: feeRecpt,
+		Withdrawals:           w,
+		ParentBeaconBlockRoot: pr[:],
+	})
+}
+
+type asyncPayloadAttrData struct {
+	data    json.RawMessage
+	version string
+	err     error
+}
+
+func (s *Server) fillEventData(ctx context.Context, ev payloadattribute.EventData) (payloadattribute.EventData, error) {
+	if ev.HeadBlock == nil || ev.HeadBlock.IsNil() {
+		hb, err := s.HeadFetcher.HeadBlock(ctx)
+		if err != nil {
+			return ev, errors.Wrap(err, "Could not look up head block")
+		}
+		root, err := hb.Block().HashTreeRoot()
+		if err != nil {
+			return ev, errors.Wrap(err, "Could not compute head block root")
+		}
+		if ev.HeadRoot != root {
+			return ev, errors.Wrap(err, "head root changed before payload attribute event handler execution")
+		}
+		ev.HeadBlock = hb
+		payload, err := hb.Block().Body().Execution()
+		if err != nil {
+			return ev, errors.Wrap(err, "Could not get execution payload for head block")
+		}
+		ev.ParentBlockHash = payload.BlockHash()
+		ev.ParentBlockNumber = payload.BlockNumber()
+	}
+
+	attr := ev.Attributer
+	if attr == nil || attr.IsEmpty() {
+		attr, err := s.computePayloadAttributes(ctx, ev)
+		if err != nil {
+			return ev, errors.Wrap(err, "Could not compute payload attributes")
+		}
+		ev.Attributer = attr
+	}
+	return ev, nil
+}
+
+// This event stream is intended to be used by builders and relays.
+// Parent fields are based on state at N_{current_slot}, while the rest of fields are based on state of N_{current_slot + 1}
+func (s *Server) payloadAttributesReader(ctx context.Context, ev payloadattribute.EventData) (lazyReader, error) {
+	ctx, cancel := context.WithTimeout(ctx, payloadAttributeTimeout)
+	edc := make(chan asyncPayloadAttrData)
+	go func() {
+		d := asyncPayloadAttrData{
+			version: version.String(ev.HeadState.Version()),
+		}
+
+		defer func() {
+			edc <- d
+		}()
+		ev, err := s.fillEventData(ctx, ev)
+		if err != nil {
+			d.err = errors.Wrap(err, "Could not fill event data")
+			return
+		}
+		attributesBytes, err := marshalAttributes(ev.Attributer)
+		if err != nil {
+			d.err = errors.Wrap(err, "errors marshaling payload attributes to json")
+			return
+		}
+		d.data, d.err = json.Marshal(structs.PayloadAttributesEventData{
+			ProposerIndex:     strconv.FormatUint(uint64(ev.ProposerIndex), 10),
+			ProposalSlot:      strconv.FormatUint(uint64(ev.ProposalSlot), 10),
+			ParentBlockNumber: strconv.FormatUint(ev.ParentBlockNumber, 10),
+			ParentBlockRoot:   hexutil.Encode(ev.ParentBlockRoot),
+			ParentBlockHash:   hexutil.Encode(ev.ParentBlockHash),
+			PayloadAttributes: attributesBytes,
+		})
+		if d.err != nil {
+			d.err = errors.Wrap(d.err, "errors marshaling payload attributes event data to json")
+		}
+	}()
+	return func() io.Reader {
+		defer cancel()
+		select {
+		case <-ctx.Done():
+			log.WithError(ctx.Err()).Warn("Context canceled while waiting for payload attributes event data")
+			return nil
+		case ed := <-edc:
+			if ed.err != nil {
+				log.WithError(ed.err).Warn("Error while marshaling payload attributes event data")
+				return nil
+			}
+			return jsonMarshalReader(PayloadAttributesTopic, &structs.PayloadAttributesEvent{
+				Version: ed.version,
+				Data:    ed.data,
+			})
+		}
 	}, nil
 }
 
+func marshalAttributes(attr payloadattribute.Attributer) ([]byte, error) {
+	v := attr.Version()
+	if v < version.Bellatrix {
+		return nil, errors.Wrapf(errUnsupportedPayloadAttribute, "Payload version %s is not supported", version.String(v))
+	}
+
+	timestamp := strconv.FormatUint(attr.Timestamp(), 10)
+	prevRandao := hexutil.Encode(attr.PrevRandao())
+	feeRecpt := hexutil.Encode(attr.SuggestedFeeRecipient())
+	if v == version.Bellatrix {
+		return json.Marshal(&structs.PayloadAttributesV1{
+			Timestamp:             timestamp,
+			PrevRandao:            prevRandao,
+			SuggestedFeeRecipient: feeRecpt,
+		})
+	}
+	w, err := attr.Withdrawals()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get withdrawals from payload attributes event")
+	}
+	withdrawals := structs.WithdrawalsFromConsensus(w)
+	if v == version.Capella {
+		return json.Marshal(&structs.PayloadAttributesV2{
+			Timestamp:             timestamp,
+			PrevRandao:            prevRandao,
+			SuggestedFeeRecipient: feeRecpt,
+			Withdrawals:           withdrawals,
+		})
+	}
+	parentRoot, err := attr.ParentBeaconBlockRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get parent beacon block root from payload attributes event")
+	}
+	return json.Marshal(&structs.PayloadAttributesV3{
+		Timestamp:             timestamp,
+		PrevRandao:            prevRandao,
+		SuggestedFeeRecipient: feeRecpt,
+		Withdrawals:           withdrawals,
+		ParentBeaconBlockRoot: hexutil.Encode(parentRoot),
+	})
+}
+
 func newStreamingResponseController(rw http.ResponseWriter, timeout time.Duration) *streamingResponseWriterController {
 	rc := http.NewResponseController(rw)
 	return &streamingResponseWriterController{

beacon-chain/rpc/eth/events/events_test.go

@@ -21,6 +21,7 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -489,7 +490,21 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 				require.NoError(t, err)
 				request := topics.testHttpRequest(testSync.ctx, t)
 				w := NewStreamingResponseWriterRecorder(testSync.ctx)
-				events := []*feed.Event{&feed.Event{Type: statefeed.MissedSlot}}
+				events := []*feed.Event{
+					&feed.Event{
+						Type: statefeed.PayloadAttributes,
+						Data: payloadattribute.EventData{
+							ProposerIndex:     0,
+							ProposalSlot:      0,
+							ParentBlockNumber: 0,
+							ParentBlockRoot:   make([]byte, 32),
+							ParentBlockHash:   make([]byte, 32),
+							HeadState:         st,
+							HeadBlock:         b,
+							HeadRoot:          [fieldparams.RootLength]byte{},
+						},
+					},
+				}
 
 				go func() {
 					s.StreamEvents(w, request)

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

@@ -75,7 +75,7 @@ func (s *Server) GetAggregateAttestation(w http.ResponseWriter, r *http.Request)
 
 // GetAggregateAttestationV2 aggregates all attestations matching the given attestation data root and slot, returning the aggregated result.
 func (s *Server) GetAggregateAttestationV2(w http.ResponseWriter, r *http.Request) {
-	_, span := trace.StartSpan(r.Context(), "validator.GetAggregateAttestationV2")
+	ctx, span := trace.StartSpan(r.Context(), "validator.GetAggregateAttestationV2")
 	defer span.End()
 
 	_, attDataRoot, ok := shared.HexFromQuery(w, r, "attestation_data_root", fieldparams.RootLength, true)
@@ -123,6 +123,12 @@ func (s *Server) GetAggregateAttestationV2(w http.ResponseWriter, r *http.Reques
 		}
 		resp.Data = data
 	}
+	headState, err := s.ChainInfoFetcher.HeadStateReadOnly(ctx)
+	if err != nil {
+		httputil.HandleError(w, "Could not get head state: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set(api.VersionHeader, version.String(headState.Version()))
 	httputil.WriteJson(w, resp)
 }
 

beacon-chain/rpc/eth/validator/handlers_test.go

@@ -262,7 +262,10 @@ func TestGetAggregateAttestation(t *testing.T) {
 		require.NoError(t, pool.SaveAggregatedAttestations([]ethpbalpha.Att{aggSlot1_Root1_1, aggSlot1_Root1_2, aggSlot1_Root2, aggSlot2}), "Failed to save aggregated attestations")
 		agg := pool.AggregatedAttestations()
 		require.Equal(t, 4, len(agg), "Expected 4 aggregated attestations")
+		bs, err := util.NewBeaconState()
+		require.NoError(t, err)
 		s := &Server{
+			ChainInfoFetcher: &mockChain.ChainService{State: bs},
 			AttestationsPool: pool,
 		}
 		t.Run("non-matching attestation request", func(t *testing.T) {

beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel

@@ -212,7 +212,9 @@ go_test(
     embed = [":go_default_library"],
     eth_network = "minimal",
     tags = ["minimal"],
-    deps = common_deps,
+    deps = common_deps + [
+        "//beacon-chain/operations/attestations/mock:go_default_library",
+    ],
 )
 
 go_test(

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

@@ -339,7 +339,7 @@ func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.Signe
 
 	sidecars, err := unblindBlobsSidecars(copiedBlock, bundle)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "unblind sidecars failed")
+		return nil, nil, errors.Wrap(err, "unblind blobs sidecars: commitment value doesn't match block")
 	}
 
 	return copiedBlock, sidecars, nil

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

@@ -91,14 +91,7 @@ func (vs *Server) packAttestations(ctx context.Context, latestState state.Beacon
 
 	var attsForInclusion proposerAtts
 	if postElectra {
-		// TODO: hack for Electra devnet-1, take only one aggregate per ID
-		// (which essentially means one aggregate for an attestation_data+committee combination
-		topAggregates := make([]ethpb.Att, 0)
-		for _, v := range attsById {
-			topAggregates = append(topAggregates, v[0])
-		}
-
-		attsForInclusion, err = computeOnChainAggregate(topAggregates)
+		attsForInclusion, err = onChainAggregates(attsById)
 		if err != nil {
 			return nil, err
 		}
@@ -113,14 +106,68 @@ func (vs *Server) packAttestations(ctx context.Context, latestState state.Beacon
 	if err != nil {
 		return nil, err
 	}
-	sorted, err := deduped.sort()
-	if err != nil {
-		return nil, err
+
+	var sorted proposerAtts
+	if postElectra {
+		sorted, err = deduped.sortOnChainAggregates()
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		sorted, err = deduped.sort()
+		if err != nil {
+			return nil, err
+		}
 	}
+
 	atts = sorted.limitToMaxAttestations()
 	return vs.filterAttestationBySignature(ctx, atts, latestState)
 }
 
+func onChainAggregates(attsById map[attestation.Id][]ethpb.Att) (proposerAtts, error) {
+	var result proposerAtts
+	var err error
+
+	// When constructing on-chain aggregates, we want to combine the most profitable
+	// aggregate for each ID, then the second most profitable, and so on and so forth.
+	// Because of this we sort attestations at the beginning.
+	for id, as := range attsById {
+		attsById[id], err = proposerAtts(as).sort()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// We construct the first on-chain aggregate by taking the first aggregate for each ID.
+	// We construct the second on-chain aggregate by taking the second aggregate for each ID.
+	// We continue doing this until we run out of aggregates.
+	idx := 0
+	for {
+		topAggregates := make([]ethpb.Att, 0, len(attsById))
+		for _, as := range attsById {
+			// In case there are no more aggregates for an ID, we skip that ID.
+			if len(as) > idx {
+				topAggregates = append(topAggregates, as[idx])
+			}
+		}
+
+		// Once there are no more aggregates for any ID, we are done.
+		if len(topAggregates) == 0 {
+			break
+		}
+
+		onChainAggs, err := computeOnChainAggregate(topAggregates)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, onChainAggs...)
+
+		idx++
+	}
+
+	return result, nil
+}
+
 // filter separates attestation list into two groups: valid and invalid attestations.
 // The first group passes the all the required checks for attestation to be considered for proposing.
 // And attestations from the second group should be deleted.
@@ -223,6 +270,14 @@ func (a proposerAtts) sort() (proposerAtts, error) {
 	return a.sortBySlotAndCommittee()
 }
 
+func (a proposerAtts) sortOnChainAggregates() (proposerAtts, error) {
+	if len(a) < 2 {
+		return a, nil
+	}
+
+	return a.sortByProfitabilityUsingMaxCover()
+}
+
 // Separate attestations by slot, as slot number takes higher precedence when sorting.
 // Also separate by committee index because maxcover will prefer attestations for the same
 // committee with disjoint bits over attestations for different committees with overlapping
@@ -231,7 +286,6 @@ func (a proposerAtts) sortBySlotAndCommittee() (proposerAtts, error) {
 	type slotAtts struct {
 		candidates map[primitives.CommitteeIndex]proposerAtts
 		selected   map[primitives.CommitteeIndex]proposerAtts
-		leftover   map[primitives.CommitteeIndex]proposerAtts
 	}
 
 	var slots []primitives.Slot
@@ -250,7 +304,6 @@ func (a proposerAtts) sortBySlotAndCommittee() (proposerAtts, error) {
 	var err error
 	for _, sa := range attsBySlot {
 		sa.selected = make(map[primitives.CommitteeIndex]proposerAtts)
-		sa.leftover = make(map[primitives.CommitteeIndex]proposerAtts)
 		for ci, committeeAtts := range sa.candidates {
 			sa.selected[ci], err = committeeAtts.sortByProfitabilityUsingMaxCover_committeeAwarePacking()
 			if err != nil {
@@ -266,9 +319,6 @@ func (a proposerAtts) sortBySlotAndCommittee() (proposerAtts, error) {
 	for _, slot := range slots {
 		sortedAtts = append(sortedAtts, sortSlotAttestations(attsBySlot[slot].selected)...)
 	}
-	for _, slot := range slots {
-		sortedAtts = append(sortedAtts, sortSlotAttestations(attsBySlot[slot].leftover)...)
-	}
 
 	return sortedAtts, nil
 }
@@ -287,15 +337,11 @@ func (a proposerAtts) sortByProfitabilityUsingMaxCover_committeeAwarePacking() (
 			return nil, err
 		}
 	}
-	// Add selected candidates on top, those that are not selected - append at bottom.
 	selectedKeys, _, err := aggregation.MaxCover(candidates, len(candidates), true /* allowOverlaps */)
 	if err != nil {
 		log.WithError(err).Debug("MaxCover aggregation failed")
 		return a, nil
 	}
-
-	// Pick selected attestations first, leftover attestations will be appended at the end.
-	// Both lists will be sorted by number of bits set.
 	selected := make(proposerAtts, selectedKeys.Count())
 	for i, key := range selectedKeys.BitIndices() {
 		selected[i] = a[key]

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

@@ -13,6 +13,9 @@ import (
 // computeOnChainAggregate constructs a final aggregate form a list of network aggregates with equal attestation data.
 // It assumes that each network aggregate has exactly one committee bit set.
 //
+// Our implementation allows to pass aggregates for different attestation data, in which case the function will return
+// one final aggregate per attestation data.
+//
 // Spec definition:
 //
 //	def compute_on_chain_aggregate(network_aggregates: Sequence[Attestation]) -> Attestation:

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

@@ -3,16 +3,21 @@ package validator
 import (
 	"bytes"
 	"context"
+	"math/rand"
 	"sort"
+	"strconv"
 	"testing"
 
 	"github.com/prysmaticlabs/go-bitfield"
 	chainMock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations/mock"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls/blst"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -680,6 +685,212 @@ func Test_packAttestations(t *testing.T) {
 	})
 }
 
+func Test_packAttestations_ElectraOnChainAggregates(t *testing.T) {
+	ctx := context.Background()
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.ElectraForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
+
+	key, err := blst.RandKey()
+	require.NoError(t, err)
+	sig := key.Sign([]byte{'X'})
+
+	cb0 := primitives.NewAttestationCommitteeBits()
+	cb0.SetBitAt(0, true)
+	cb1 := primitives.NewAttestationCommitteeBits()
+	cb1.SetBitAt(1, true)
+
+	data0 := util.HydrateAttestationData(&ethpb.AttestationData{BeaconBlockRoot: bytesutil.PadTo([]byte{'0'}, 32)})
+	data1 := util.HydrateAttestationData(&ethpb.AttestationData{BeaconBlockRoot: bytesutil.PadTo([]byte{'1'}, 32)})
+
+	// Glossary:
+	// - Single Aggregate: aggregate with exactly one committee bit set, from which an On-Chain Aggregate is constructed
+	// - On-Chain Aggregate: final aggregate packed into a block
+	//
+	// We construct the following number of single aggregates:
+	// - data_root_0 and committee_index_0: 3 single aggregates
+	// - data_root_0 and committee_index_1: 2 single aggregates
+	// - data_root_1 and committee_index_0: 1 single aggregate
+	// - data_root_1 and committee_index_1: 3 single aggregates
+	//
+	// Because the function tries to aggregate attestations, we have to create attestations which are not aggregatable
+	// and are not redundant when using MaxCover.
+	// The function should also sort attestation by ID before computing the On-Chain Aggregate, so we want unsorted aggregation bits
+	// to test the sorting part.
+	//
+	// The result should be the following six on-chain aggregates:
+	// - for data_root_0 combining the most profitable aggregate for each committee
+	// - for data_root_0 combining the second most profitable aggregate for each committee
+	// - for data_root_0 constructed from the single aggregate at index 2 for committee_index_0
+	// - for data_root_1 combining the most profitable aggregate for each committee
+	// - for data_root_1 constructed from the single aggregate at index 1 for committee_index_1
+	// - for data_root_1 constructed from the single aggregate at index 2 for committee_index_1
+
+	d0_c0_a1 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1000011},
+		CommitteeBits:   cb0,
+		Data:            data0,
+		Signature:       sig.Marshal(),
+	}
+	d0_c0_a2 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1100101},
+		CommitteeBits:   cb0,
+		Data:            data0,
+		Signature:       sig.Marshal(),
+	}
+	d0_c0_a3 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1111000},
+		CommitteeBits:   cb0,
+		Data:            data0,
+		Signature:       sig.Marshal(),
+	}
+	d0_c1_a1 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1111100},
+		CommitteeBits:   cb1,
+		Data:            data0,
+		Signature:       sig.Marshal(),
+	}
+	d0_c1_a2 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1001111},
+		CommitteeBits:   cb1,
+		Data:            data0,
+		Signature:       sig.Marshal(),
+	}
+	d1_c0_a1 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1111111},
+		CommitteeBits:   cb0,
+		Data:            data1,
+		Signature:       sig.Marshal(),
+	}
+	d1_c1_a1 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1000011},
+		CommitteeBits:   cb1,
+		Data:            data1,
+		Signature:       sig.Marshal(),
+	}
+	d1_c1_a2 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1100101},
+		CommitteeBits:   cb1,
+		Data:            data1,
+		Signature:       sig.Marshal(),
+	}
+	d1_c1_a3 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b1111000},
+		CommitteeBits:   cb1,
+		Data:            data1,
+		Signature:       sig.Marshal(),
+	}
+
+	pool := &mock.PoolMock{}
+	require.NoError(t, pool.SaveAggregatedAttestations([]ethpb.Att{d0_c0_a1, d0_c0_a2, d0_c0_a3, d0_c1_a1, d0_c1_a2, d1_c0_a1, d1_c1_a1, d1_c1_a2, d1_c1_a3}))
+	slot := primitives.Slot(1)
+	s := &Server{AttPool: pool, HeadFetcher: &chainMock.ChainService{}, TimeFetcher: &chainMock.ChainService{Slot: &slot}}
+
+	// We need the correct number of validators so that there are at least 2 committees per slot
+	// and each committee has exactly 6 validators (this is because we have 6 aggregation bits).
+	st, _ := util.DeterministicGenesisStateElectra(t, 192)
+
+	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))
+
+	atts, err := s.packAttestations(ctx, st, params.BeaconConfig().SlotsPerEpoch)
+	require.NoError(t, err)
+	require.Equal(t, 6, len(atts))
+	assert.Equal(t, true,
+		atts[0].GetAggregationBits().Count() >= atts[1].GetAggregationBits().Count() &&
+			atts[1].GetAggregationBits().Count() >= atts[2].GetAggregationBits().Count() &&
+			atts[2].GetAggregationBits().Count() >= atts[3].GetAggregationBits().Count() &&
+			atts[3].GetAggregationBits().Count() >= atts[4].GetAggregationBits().Count() &&
+			atts[4].GetAggregationBits().Count() >= atts[5].GetAggregationBits().Count(),
+		"on-chain aggregates are not sorted by aggregation bit count",
+	)
+
+	t.Run("slot takes precedence", func(t *testing.T) {
+		moreRecentAtt := &ethpb.AttestationElectra{
+			AggregationBits: bitfield.Bitlist{0b1100000}, // we set only one bit for committee_index_0
+			CommitteeBits:   cb1,
+			Data:            util.HydrateAttestationData(&ethpb.AttestationData{Slot: 1, BeaconBlockRoot: bytesutil.PadTo([]byte{'0'}, 32)}),
+			Signature:       sig.Marshal(),
+		}
+		require.NoError(t, pool.SaveUnaggregatedAttestations([]ethpb.Att{moreRecentAtt}))
+		atts, err = s.packAttestations(ctx, st, params.BeaconConfig().SlotsPerEpoch)
+		require.NoError(t, err)
+		require.Equal(t, 7, len(atts))
+		assert.Equal(t, true, atts[0].GetData().Slot == 1)
+	})
+}
+
+func Benchmark_packAttestations_Electra(b *testing.B) {
+	ctx := context.Background()
+
+	params.SetupTestConfigCleanup(b)
+	cfg := params.MainnetConfig().Copy()
+	cfg.ElectraForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
+
+	valCount := uint64(1048576)
+	committeeCount := helpers.SlotCommitteeCount(valCount)
+	valsPerCommittee := valCount / committeeCount / uint64(params.BeaconConfig().SlotsPerEpoch)
+
+	st, _ := util.DeterministicGenesisStateElectra(b, valCount)
+
+	key, err := blst.RandKey()
+	require.NoError(b, err)
+	sig := key.Sign([]byte{'X'})
+
+	r := rand.New(rand.NewSource(123))
+
+	var atts []ethpb.Att
+	for c := uint64(0); c < committeeCount; c++ {
+		for a := uint64(0); a < params.BeaconConfig().TargetAggregatorsPerCommittee; a++ {
+			cb := primitives.NewAttestationCommitteeBits()
+			cb.SetBitAt(c, true)
+
+			var att *ethpb.AttestationElectra
+			// Last two aggregators send aggregates for some random block root with only a few bits set.
+			if a >= params.BeaconConfig().TargetAggregatorsPerCommittee-2 {
+				root := bytesutil.PadTo([]byte("root_"+strconv.Itoa(r.Intn(100))), 32)
+				att = &ethpb.AttestationElectra{
+					Data:            util.HydrateAttestationData(&ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch - 1, BeaconBlockRoot: root}),
+					AggregationBits: bitfield.NewBitlist(valsPerCommittee),
+					CommitteeBits:   cb,
+					Signature:       sig.Marshal(),
+				}
+				for bit := uint64(0); bit < valsPerCommittee; bit++ {
+					att.AggregationBits.SetBitAt(bit, r.Intn(100) < 2) // 2% that the bit is set
+				}
+			} else {
+				att = &ethpb.AttestationElectra{
+					Data:            util.HydrateAttestationData(&ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch - 1, BeaconBlockRoot: bytesutil.PadTo([]byte("root"), 32)}),
+					AggregationBits: bitfield.NewBitlist(valsPerCommittee),
+					CommitteeBits:   cb,
+					Signature:       sig.Marshal(),
+				}
+				for bit := uint64(0); bit < valsPerCommittee; bit++ {
+					att.AggregationBits.SetBitAt(bit, r.Intn(100) < 98) // 98% that the bit is set
+				}
+			}
+
+			atts = append(atts, att)
+		}
+	}
+
+	pool := &mock.PoolMock{}
+	require.NoError(b, pool.SaveAggregatedAttestations(atts))
+
+	slot := primitives.Slot(1)
+	s := &Server{AttPool: pool, HeadFetcher: &chainMock.ChainService{}, TimeFetcher: &chainMock.ChainService{Slot: &slot}}
+
+	require.NoError(b, st.SetSlot(params.BeaconConfig().SlotsPerEpoch))
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err = s.packAttestations(ctx, st, params.BeaconConfig().SlotsPerEpoch+1)
+		require.NoError(b, err)
+	}
+}
+
 func Test_limitToMaxAttestations(t *testing.T) {
 	t.Run("Phase 0", func(t *testing.T) {
 		atts := make([]ethpb.Att, params.BeaconConfig().MaxAttestations+1)

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

@@ -54,7 +54,7 @@ func (vs *Server) eth1DataMajorityVote(ctx context.Context, beaconState state.Be
 	// by ETH1_FOLLOW_DISTANCE. The head state should maintain the same ETH1Data until this condition has passed, so
 	// trust the existing head for the right eth1 vote until we can get a meaningful value from the deposit contract.
 	if latestValidTime < genesisTime+followDistanceSeconds {
-		log.WithField("genesisTime", genesisTime).WithField("latestValidTime", latestValidTime).Warn("voting period before genesis + follow distance, using eth1data from head")
+		log.WithField("genesisTime", genesisTime).WithField("latestValidTime", latestValidTime).Warn("Voting period before genesis + follow distance, using eth1data from head")
 		return vs.HeadFetcher.HeadETH1Data(), nil
 	}
 

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

@@ -84,7 +84,6 @@ func (vs *Server) getLocalPayloadFromEngine(
 	}
 	setFeeRecipientIfBurnAddress(&val)
 
-	var err error
 	if ok && payloadId != [8]byte{} {
 		// Payload ID is cache hit. Return the cached payload ID.
 		var pid primitives.PayloadID
@@ -102,7 +101,7 @@ func (vs *Server) getLocalPayloadFromEngine(
 			return nil, errors.Wrap(err, "could not get cached payload from execution client")
 		}
 	}
-	log.WithFields(logFields).Debug("payload ID cache miss")
+	log.WithFields(logFields).Debug("Payload ID cache miss")
 	parentHash, err := vs.getParentBlockHash(ctx, st, slot)
 	switch {
 	case errors.Is(err, errActivationNotReached) || errors.Is(err, errNoTerminalBlockHash):
@@ -191,7 +190,7 @@ func (vs *Server) getLocalPayloadFromEngine(
 	}
 
 	warnIfFeeRecipientDiffers(val.FeeRecipient[:], res.ExecutionData.FeeRecipient())
-	log.WithField("value", res.Bid).Debug("received execution payload from local engine")
+	log.WithField("value", res.Bid).Debug("Received execution payload from local engine")
 	return res, nil
 }
 

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

@@ -912,7 +912,7 @@ func TestProposer_ProposeBlock_OK(t *testing.T) {
 				return &ethpb.GenericSignedBeaconBlock{Block: blk}
 			},
 			useBuilder: true,
-			err:        "unblind sidecars failed: commitment value doesn't match block",
+			err:        "unblind blobs sidecars: commitment value doesn't match block",
 		},
 		{
 			name: "electra block no blob",

beacon-chain/slasher/helpers.go

@@ -97,10 +97,7 @@ func (s *Service) filterAttestations(
 // detection (except for the genesis epoch).
 func validateAttestationIntegrity(att ethpb.IndexedAtt) bool {
 	// If an attestation is malformed, we drop it.
-	if att == nil ||
-		att.GetData() == nil ||
-		att.GetData().Source == nil ||
-		att.GetData().Target == nil {
+	if att == nil || att.IsNil() || att.GetData().Source == nil || att.GetData().Target == nil {
 		return false
 	}
 

beacon-chain/sync/backfill/blobs.go

@@ -107,7 +107,7 @@ type blobBatchVerifier struct {
 
 func (bbv *blobBatchVerifier) newVerifier(rb blocks.ROBlob) verification.BlobVerifier {
 	m := bbv.verifiers[rb.BlockRoot()]
-	m[rb.Index] = bbv.newBlobVerifier(rb, verification.BackfillSidecarRequirements)
+	m[rb.Index] = bbv.newBlobVerifier(rb, verification.BackfillBlobSidecarRequirements)
 	bbv.verifiers[rb.BlockRoot()] = m
 	return m[rb.Index]
 }

beacon-chain/sync/fork_watcher_test.go

@@ -388,6 +388,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) {
 	}
 }
 
+// oneEpoch returns the duration of one epoch.
 func oneEpoch() time.Duration {
 	return time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot)) * time.Second
 }

beacon-chain/sync/initial-sync/round_robin.go

@@ -172,7 +172,7 @@ func (s *Service) processFetchedDataRegSync(
 	if len(bwb) == 0 {
 		return
 	}
-	bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.InitsyncSidecarRequirements)
+	bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.InitsyncBlobSidecarRequirements)
 	avs := das.NewLazilyPersistentStore(s.cfg.BlobStorage, bv)
 	batchFields := logrus.Fields{
 		"firstSlot":        data.bwb[0].Block.Block().Slot(),
@@ -331,7 +331,7 @@ func (s *Service) processBatchedBlocks(ctx context.Context, genesis time.Time,
 			errParentDoesNotExist, first.Block().ParentRoot(), first.Block().Slot())
 	}
 
-	bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.InitsyncSidecarRequirements)
+	bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.InitsyncBlobSidecarRequirements)
 	avs := das.NewLazilyPersistentStore(s.cfg.BlobStorage, bv)
 	s.logBatchSyncStatus(genesis, first, len(bwb))
 	for _, bb := range bwb {

beacon-chain/sync/initial-sync/service.go

@@ -340,7 +340,7 @@ func (s *Service) fetchOriginBlobs(pids []peer.ID) error {
 		if len(sidecars) != len(req) {
 			continue
 		}
-		bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.InitsyncSidecarRequirements)
+		bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.InitsyncBlobSidecarRequirements)
 		avs := das.NewLazilyPersistentStore(s.cfg.BlobStorage, bv)
 		current := s.clock.CurrentSlot()
 		if err := avs.Persist(current, sidecars...); err != nil {

beacon-chain/sync/initial-sync/service_test.go

@@ -495,8 +495,8 @@ func TestOriginOutsideRetention(t *testing.T) {
 	bdb := dbtest.SetupDB(t)
 	genesis := time.Unix(0, 0)
 	secsPerEpoch := params.BeaconConfig().SecondsPerSlot * uint64(params.BeaconConfig().SlotsPerEpoch)
-	retentionSeconds := time.Second * time.Duration(uint64(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest+1)*secsPerEpoch)
-	outsideRetention := genesis.Add(retentionSeconds)
+	retentionPeriod := time.Second * time.Duration(uint64(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest+1)*secsPerEpoch)
+	outsideRetention := genesis.Add(retentionPeriod)
 	now := func() time.Time {
 		return outsideRetention
 	}

beacon-chain/sync/pending_blocks_queue.go

@@ -315,7 +315,7 @@ func (s *Service) sendBatchRootRequest(ctx context.Context, roots [][32]byte, ra
 		if uint64(len(roots)) > maxReqBlock {
 			req = roots[:maxReqBlock]
 		}
-		if err := s.sendRecentBeaconBlocksRequest(ctx, &req, pid); err != nil {
+		if err := s.sendBeaconBlocksRequest(ctx, &req, pid); err != nil {
 			tracing.AnnotateError(span, err)
 			log.WithError(err).Debug("Could not send recent block request")
 		}

beacon-chain/sync/rpc_beacon_blocks_by_range.go

@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"github.com/sirupsen/logrus"
 )
 
 // beaconBlocksByRangeRPCHandler looks up the request blocks from the database from a given start block.
@@ -26,15 +27,23 @@ func (s *Service) beaconBlocksByRangeRPCHandler(ctx context.Context, msg interfa
 	defer cancel()
 	SetRPCStreamDeadlines(stream)
 
+	remotePeer := stream.Conn().RemotePeer()
+
 	m, ok := msg.(*pb.BeaconBlocksByRangeRequest)
 	if !ok {
 		return errors.New("message is not type *pb.BeaconBlockByRangeRequest")
 	}
-	log.WithField("startSlot", m.StartSlot).WithField("count", m.Count).Debug("Serving block by range request")
+
+	log.WithFields(logrus.Fields{
+		"startSlot": m.StartSlot,
+		"count":     m.Count,
+		"peer":      remotePeer,
+	}).Debug("Serving block by range request")
+
 	rp, err := validateRangeRequest(m, s.cfg.clock.CurrentSlot())
 	if err != nil {
 		s.writeErrorResponseToStream(responseCodeInvalidRequest, err.Error(), stream)
-		s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(stream.Conn().RemotePeer())
+		s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(remotePeer)
 		tracing.AnnotateError(span, err)
 		return err
 	}
@@ -50,12 +59,12 @@ func (s *Service) beaconBlocksByRangeRPCHandler(ctx context.Context, msg interfa
 	if err != nil {
 		return err
 	}
-	remainingBucketCapacity := blockLimiter.Remaining(stream.Conn().RemotePeer().String())
+	remainingBucketCapacity := blockLimiter.Remaining(remotePeer.String())
 	span.SetAttributes(
 		trace.Int64Attribute("start", int64(rp.start)), // lint:ignore uintcast -- This conversion is OK for tracing.
 		trace.Int64Attribute("end", int64(rp.end)),     // lint:ignore uintcast -- This conversion is OK for tracing.
 		trace.Int64Attribute("count", int64(m.Count)),
-		trace.StringAttribute("peer", stream.Conn().RemotePeer().String()),
+		trace.StringAttribute("peer", remotePeer.String()),
 		trace.Int64Attribute("remaining_capacity", remainingBucketCapacity),
 	)
 
@@ -82,12 +91,19 @@ func (s *Service) beaconBlocksByRangeRPCHandler(ctx context.Context, msg interfa
 		}
 		rpcBlocksByRangeResponseLatency.Observe(float64(time.Since(batchStart).Milliseconds()))
 	}
+
 	if err := batch.error(); err != nil {
-		log.WithError(err).Debug("error in BlocksByRange batch")
-		s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
+		log.WithError(err).Debug("Serving block by range request - BlocksByRange batch")
+
+		// If a rate limit is hit, it means an error response has already been sent and the stream has been closed.
+		if !errors.Is(err, p2ptypes.ErrRateLimited) {
+			s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
+		}
+
 		tracing.AnnotateError(span, err)
 		return err
 	}
+
 	closeStream(stream, log)
 	return nil
 }

beacon-chain/sync/rpc_beacon_blocks_by_root.go

@@ -20,9 +20,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
-// sendRecentBeaconBlocksRequest sends a recent beacon blocks request to a peer to get
+// sendBeaconBlocksRequest sends a recent beacon blocks request to a peer to get
 // those corresponding blocks from that peer.
-func (s *Service) sendRecentBeaconBlocksRequest(ctx context.Context, requests *types.BeaconBlockByRootsReq, id peer.ID) error {
+func (s *Service) sendBeaconBlocksRequest(ctx context.Context, requests *types.BeaconBlockByRootsReq, id peer.ID) error {
 	ctx, cancel := context.WithTimeout(ctx, respTimeout)
 	defer cancel()
 
@@ -151,7 +151,7 @@ func (s *Service) sendAndSaveBlobSidecars(ctx context.Context, request types.Blo
 	if len(sidecars) != len(request) {
 		return fmt.Errorf("received %d blob sidecars, expected %d for RPC", len(sidecars), len(request))
 	}
-	bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.PendingQueueSidecarRequirements)
+	bv := verification.NewBlobBatchVerifier(s.newBlobVerifier, verification.PendingQueueBlobSidecarRequirements)
 	for _, sidecar := range sidecars {
 		if err := verify.BlobAlignsWithBlock(sidecar, RoBlock); err != nil {
 			return err

beacon-chain/sync/rpc_beacon_blocks_by_root_test.go

@@ -253,7 +253,7 @@ func TestRecentBeaconBlocks_RPCRequestSent(t *testing.T) {
 	})
 
 	p1.Connect(p2)
-	require.NoError(t, r.sendRecentBeaconBlocksRequest(context.Background(), &expectedRoots, p2.PeerID()))
+	require.NoError(t, r.sendBeaconBlocksRequest(context.Background(), &expectedRoots, p2.PeerID()))
 
 	if util.WaitTimeout(&wg, 1*time.Second) {
 		t.Fatal("Did not receive stream within 1 sec")
@@ -328,7 +328,7 @@ func TestRecentBeaconBlocks_RPCRequestSent_IncorrectRoot(t *testing.T) {
 	})
 
 	p1.Connect(p2)
-	require.ErrorContains(t, "received unexpected block with root", r.sendRecentBeaconBlocksRequest(context.Background(), &expectedRoots, p2.PeerID()))
+	require.ErrorContains(t, "received unexpected block with root", r.sendBeaconBlocksRequest(context.Background(), &expectedRoots, p2.PeerID()))
 }
 
 func TestRecentBeaconBlocksRPCHandler_HandleZeroBlocks(t *testing.T) {

beacon-chain/sync/rpc_blob_sidecars_by_range.go

@@ -99,6 +99,7 @@ func (s *Service) blobSidecarsByRangeRPCHandler(ctx context.Context, msg interfa
 	}
 
 	var batch blockBatch
+
 	wQuota := params.BeaconConfig().MaxRequestBlobSidecars
 	for batch, ok = batcher.next(ctx, stream); ok; batch, ok = batcher.next(ctx, stream) {
 		batchStart := time.Now()
@@ -114,7 +115,12 @@ func (s *Service) blobSidecarsByRangeRPCHandler(ctx context.Context, msg interfa
 	}
 	if err := batch.error(); err != nil {
 		log.WithError(err).Debug("error in BlobSidecarsByRange batch")
-		s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
+
+		// If a rate limit is hit, it means an error response has already been sent and the stream has been closed.
+		if !errors.Is(err, p2ptypes.ErrRateLimited) {
+			s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
+		}
+
 		tracing.AnnotateError(span, err)
 		return err
 	}

beacon-chain/sync/rpc_ping.go

@@ -2,12 +2,12 @@ package sync
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strings"
 
 	libp2pcore "github.com/libp2p/go-libp2p/core"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	p2ptypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -16,127 +16,191 @@ import (
 )
 
 // pingHandler reads the incoming ping rpc message from the peer.
+// If the peer's sequence number is higher than the one stored locally,
+// a METADATA request is sent to the peer to retrieve and update the latest metadata.
+// Note: This function is misnamed, as it performs more than just reading a ping message.
 func (s *Service) pingHandler(_ context.Context, msg interface{}, stream libp2pcore.Stream) error {
 	SetRPCStreamDeadlines(stream)
 
+	// Convert the message to SSW Uint64 type.
 	m, ok := msg.(*primitives.SSZUint64)
 	if !ok {
 		return fmt.Errorf("wrong message type for ping, got %T, wanted *uint64", msg)
 	}
+
+	// Validate the incoming request regarding rate limiting.
 	if err := s.rateLimiter.validateRequest(stream, 1); err != nil {
-		return err
+		return errors.Wrap(err, "validate request")
 	}
+
 	s.rateLimiter.add(stream, 1)
-	valid, err := s.validateSequenceNum(*m, stream.Conn().RemotePeer())
+
+	// Retrieve the peer ID.
+	peerID := stream.Conn().RemotePeer()
+
+	// Check if the peer sequence number is higher than the one we have in our store.
+	valid, err := s.validateSequenceNum(*m, peerID)
 	if err != nil {
 		// Descore peer for giving us a bad sequence number.
 		if errors.Is(err, p2ptypes.ErrInvalidSequenceNum) {
-			s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(stream.Conn().RemotePeer())
+			s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(peerID)
 			s.writeErrorResponseToStream(responseCodeInvalidRequest, p2ptypes.ErrInvalidSequenceNum.Error(), stream)
 		}
-		return err
+
+		return errors.Wrap(err, "validate sequence number")
 	}
+
+	// We can already prepare a success response to the peer.
 	if _, err := stream.Write([]byte{responseCodeSuccess}); err != nil {
-		return err
+		return errors.Wrap(err, "write response")
 	}
-	sq := primitives.SSZUint64(s.cfg.p2p.MetadataSeq())
-	if _, err := s.cfg.p2p.Encoding().EncodeWithMaxLength(stream, &sq); err != nil {
+
+	// Retrieve our own sequence number.
+	seqNumber := s.cfg.p2p.MetadataSeq()
+
+	// SSZ encode our sequence number.
+	seqNumberSSZ := primitives.SSZUint64(seqNumber)
+
+	// Send our sequence number back to the peer.
+	if _, err := s.cfg.p2p.Encoding().EncodeWithMaxLength(stream, &seqNumberSSZ); err != nil {
 		return err
 	}
 
 	closeStream(stream, log)
 
 	if valid {
-		// If the sequence number was valid we're done.
+		// If the peer's sequence numberwas valid we're done.
 		return nil
 	}
 
-	// The sequence number was not valid.  Start our own ping back to the peer.
+	// The peer's sequence number was not valid. We ask the peer for its metadata.
 	go func() {
-		// New context so the calling function doesn't cancel on us.
+		// Define a new context so the calling function doesn't cancel on us.
 		ctx, cancel := context.WithTimeout(context.Background(), ttfbTimeout)
 		defer cancel()
-		md, err := s.sendMetaDataRequest(ctx, stream.Conn().RemotePeer())
+
+		// Send a METADATA request to the peer.
+		peerMetadata, err := s.sendMetaDataRequest(ctx, peerID)
 		if err != nil {
 			// We cannot compare errors directly as the stream muxer error
 			// type isn't compatible with the error we have, so a direct
 			// equality checks fails.
 			if !strings.Contains(err.Error(), p2ptypes.ErrIODeadline.Error()) {
-				log.WithField("peer", stream.Conn().RemotePeer()).WithError(err).Debug("Could not send metadata request")
+				log.WithField("peer", peerID).WithError(err).Debug("Could not send metadata request")
 			}
+
 			return
 		}
-		// update metadata if there is no error
-		s.cfg.p2p.Peers().SetMetadata(stream.Conn().RemotePeer(), md)
+
+		// Update peer's metadata.
+		s.cfg.p2p.Peers().SetMetadata(peerID, peerMetadata)
 	}()
 
 	return nil
 }
 
-func (s *Service) sendPingRequest(ctx context.Context, id peer.ID) error {
+// sendPingRequest first sends a PING request to the peer.
+// If the peer responds with a sequence number higher than latest one for it we have in our store,
+// then this function sends a METADATA request to the peer, and stores the metadata received.
+// This function is actually poorly named, since it does more than just sending a ping request.
+func (s *Service) sendPingRequest(ctx context.Context, peerID peer.ID) error {
 	ctx, cancel := context.WithTimeout(ctx, respTimeout)
 	defer cancel()
 
-	metadataSeq := primitives.SSZUint64(s.cfg.p2p.MetadataSeq())
-	topic, err := p2p.TopicFromMessage(p2p.PingMessageName, slots.ToEpoch(s.cfg.clock.CurrentSlot()))
+	// Get the current epoch.
+	currentSlot := s.cfg.clock.CurrentSlot()
+	currentEpoch := slots.ToEpoch(currentSlot)
+
+	// SSZ encode our metadata sequence number.
+	metadataSeq := s.cfg.p2p.MetadataSeq()
+	encodedMetadataSeq := primitives.SSZUint64(metadataSeq)
+
+	// Get the PING topic for the current epoch.
+	topic, err := p2p.TopicFromMessage(p2p.PingMessageName, currentEpoch)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "topic from message")
 	}
-	stream, err := s.cfg.p2p.Send(ctx, &metadataSeq, topic, id)
+
+	// Send the PING request to the peer.
+	stream, err := s.cfg.p2p.Send(ctx, &encodedMetadataSeq, topic, peerID)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "send ping request")
 	}
-	currentTime := time.Now()
 	defer closeStream(stream, log)
 
+	startTime := time.Now()
+
+	// Read the response from the peer.
 	code, errMsg, err := ReadStatusCode(stream, s.cfg.p2p.Encoding())
 	if err != nil {
-		return err
+		return errors.Wrap(err, "read status code")
 	}
-	// Records the latency of the ping request for that peer.
-	s.cfg.p2p.Host().Peerstore().RecordLatency(id, time.Now().Sub(currentTime))
 
+	// Record the latency of the ping request for that peer.
+	s.cfg.p2p.Host().Peerstore().RecordLatency(peerID, time.Now().Sub(startTime))
+
+	// If the peer responded with an error, increment the bad responses scorer.
 	if code != 0 {
-		s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(stream.Conn().RemotePeer())
-		return errors.New(errMsg)
+		s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(peerID)
+		return errors.Errorf("code: %d - %s", code, errMsg)
 	}
+
+	// Decode the sequence number from the peer.
 	msg := new(primitives.SSZUint64)
 	if err := s.cfg.p2p.Encoding().DecodeWithMaxLength(stream, msg); err != nil {
-		return err
+		return errors.Wrap(err, "decode sequence number")
 	}
-	valid, err := s.validateSequenceNum(*msg, stream.Conn().RemotePeer())
+
+	// Determine if the peer's sequence number returned by the peer is higher than the one we have in our store.
+	valid, err := s.validateSequenceNum(*msg, peerID)
 	if err != nil {
 		// Descore peer for giving us a bad sequence number.
 		if errors.Is(err, p2ptypes.ErrInvalidSequenceNum) {
-			s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(stream.Conn().RemotePeer())
+			s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(peerID)
 		}
-		return err
+
+		return errors.Wrap(err, "validate sequence number")
 	}
+
+	// The sequence number have in our store for this peer is the same as the one returned by the peer, all good.
 	if valid {
 		return nil
 	}
-	md, err := s.sendMetaDataRequest(ctx, stream.Conn().RemotePeer())
+
+	// We need to send a METADATA request to the peer to get its latest metadata.
+	md, err := s.sendMetaDataRequest(ctx, peerID)
 	if err != nil {
-		// do not increment bad responses, as its
-		// already done in the request method.
-		return err
+		// do not increment bad responses, as its already done in the request method.
+		return errors.Wrap(err, "send metadata request")
 	}
-	s.cfg.p2p.Peers().SetMetadata(stream.Conn().RemotePeer(), md)
+
+	// Update the metadata for the peer.
+	s.cfg.p2p.Peers().SetMetadata(peerID, md)
+
 	return nil
 }
 
-// validates the peer's sequence number.
+// validateSequenceNum validates the peer's sequence number.
+// - If the peer's sequence number is greater than the sequence number we have in our store for the peer, return false.
+// - If the peer's sequence number is equal to the sequence number we have in our store for the peer, return true.
+// - If the peer's sequence number is less than the sequence number we have in our store for the peer, return an error.
 func (s *Service) validateSequenceNum(seq primitives.SSZUint64, id peer.ID) (bool, error) {
+	// Retrieve the metadata for the peer we got in our store.
 	md, err := s.cfg.p2p.Peers().Metadata(id)
 	if err != nil {
-		return false, err
+		return false, errors.Wrap(err, "get metadata")
 	}
+
+	// If we have no metadata for the peer, return false.
 	if md == nil || md.IsNil() {
 		return false, nil
 	}
-	// Return error on invalid sequence number.
+
+	// The peer's sequence number must be less than or equal to the sequence number we have in our store.
 	if md.SequenceNumber() > uint64(seq) {
 		return false, p2ptypes.ErrInvalidSequenceNum
 	}
+
+	// Return true if the peer's sequence number is equal to the sequence number we have in our store.
 	return md.SequenceNumber() == uint64(seq), nil
 }

beacon-chain/sync/rpc_send_request.go

@@ -19,7 +19,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
@@ -49,7 +48,7 @@ type BeaconBlockProcessor func(block interfaces.ReadOnlySignedBeaconBlock) error
 // SendBeaconBlocksByRangeRequest sends BeaconBlocksByRange and returns fetched blocks, if any.
 func SendBeaconBlocksByRangeRequest(
 	ctx context.Context, tor blockchain.TemporalOracle, p2pProvider p2p.SenderEncoder, pid peer.ID,
-	req *pb.BeaconBlocksByRangeRequest, blockProcessor BeaconBlockProcessor,
+	req *ethpb.BeaconBlocksByRangeRequest, blockProcessor BeaconBlockProcessor,
 ) ([]interfaces.ReadOnlySignedBeaconBlock, error) {
 	topic, err := p2p.TopicFromMessage(p2p.BeaconBlocksByRangeMessageName, slots.ToEpoch(tor.CurrentSlot()))
 	if err != nil {
@@ -155,7 +154,7 @@ func SendBeaconBlocksByRootRequest(
 	return blocks, nil
 }
 
-func SendBlobsByRangeRequest(ctx context.Context, tor blockchain.TemporalOracle, p2pApi p2p.SenderEncoder, pid peer.ID, ctxMap ContextByteVersions, req *pb.BlobSidecarsByRangeRequest, bvs ...BlobResponseValidation) ([]blocks.ROBlob, error) {
+func SendBlobsByRangeRequest(ctx context.Context, tor blockchain.TemporalOracle, p2pApi p2p.SenderEncoder, pid peer.ID, ctxMap ContextByteVersions, req *ethpb.BlobSidecarsByRangeRequest, bvs ...BlobResponseValidation) ([]blocks.ROBlob, error) {
 	topic, err := p2p.TopicFromMessage(p2p.BlobSidecarsByRangeName, slots.ToEpoch(tor.CurrentSlot()))
 	if err != nil {
 		return nil, err
@@ -298,7 +297,7 @@ func blobValidatorFromRootReq(req *p2ptypes.BlobSidecarsByRootReq) BlobResponseV
 	}
 }
 
-func blobValidatorFromRangeReq(req *pb.BlobSidecarsByRangeRequest) BlobResponseValidation {
+func blobValidatorFromRangeReq(req *ethpb.BlobSidecarsByRangeRequest) BlobResponseValidation {
 	end := req.StartSlot + primitives.Slot(req.Count)
 	return func(sc blocks.ROBlob) error {
 		if sc.Slot() < req.StartSlot || sc.Slot() >= end {

beacon-chain/sync/service.go

@@ -15,6 +15,8 @@ import (
 	"github.com/libp2p/go-libp2p/core/peer"
 	gcache "github.com/patrickmn/go-cache"
 	"github.com/pkg/errors"
+	"github.com/trailofbits/go-mutexasserts"
+
 	"github.com/prysmaticlabs/prysm/v5/async"
 	"github.com/prysmaticlabs/prysm/v5/async/abool"
 	"github.com/prysmaticlabs/prysm/v5/async/event"
@@ -44,22 +46,24 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/runtime"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"github.com/trailofbits/go-mutexasserts"
 )
 
 var _ runtime.Service = (*Service)(nil)
 
-const rangeLimit uint64 = 1024
-const seenBlockSize = 1000
-const seenBlobSize = seenBlockSize * 4 // Each block can have max 4 blobs. Worst case 164kB for cache.
-const seenUnaggregatedAttSize = 20000
-const seenAggregatedAttSize = 16384
-const seenSyncMsgSize = 1000         // Maximum of 512 sync committee members, 1000 is a safe amount.
-const seenSyncContributionSize = 512 // Maximum of SYNC_COMMITTEE_SIZE as specified by the spec.
-const seenExitSize = 100
-const seenProposerSlashingSize = 100
-const badBlockSize = 1000
-const syncMetricsInterval = 10 * time.Second
+const (
+	rangeLimit               uint64 = 1024
+	seenBlockSize                   = 1000
+	seenBlobSize                    = seenBlockSize * 6   // Each block can have max 6 blobs.
+	seenDataColumnSize              = seenBlockSize * 128 // Each block can have max 128 data columns.
+	seenUnaggregatedAttSize         = 20000
+	seenAggregatedAttSize           = 16384
+	seenSyncMsgSize                 = 1000 // Maximum of 512 sync committee members, 1000 is a safe amount.
+	seenSyncContributionSize        = 512  // Maximum of SYNC_COMMITTEE_SIZE as specified by the spec.
+	seenExitSize                    = 100
+	seenProposerSlashingSize        = 100
+	badBlockSize                    = 1000
+	syncMetricsInterval             = 10 * time.Second
+)
 
 var (
 	// Seconds in one epoch.
@@ -162,18 +166,18 @@ type Service struct {
 
 // NewService initializes new regular sync service.
 func NewService(ctx context.Context, opts ...Option) *Service {
-	c := gcache.New(pendingBlockExpTime /* exp time */, 0 /* disable janitor */)
 	ctx, cancel := context.WithCancel(ctx)
 	r := &Service{
 		ctx:                  ctx,
 		cancel:               cancel,
 		chainStarted:         abool.New(),
 		cfg:                  &config{clock: startup.NewClock(time.Unix(0, 0), [32]byte{})},
-		slotToPendingBlocks:  c,
+		slotToPendingBlocks:  gcache.New(pendingBlockExpTime /* exp time */, 0 /* disable janitor */),
 		seenPendingBlocks:    make(map[[32]byte]bool),
 		blkRootToPendingAtts: make(map[[32]byte][]ethpb.SignedAggregateAttAndProof),
 		signatureChan:        make(chan *signatureVerifier, verifierLimit),
 	}
+
 	for _, opt := range opts {
 		if err := opt(r); err != nil {
 			return nil
@@ -224,7 +228,7 @@ func (s *Service) Start() {
 	s.newBlobVerifier = newBlobVerifierFromInitializer(v)
 
 	go s.verifierRoutine()
-	go s.registerHandlers()
+	go s.startTasksPostInitialSync()
 
 	s.cfg.p2p.AddConnectionHandler(s.reValidatePeer, s.sendGoodbye)
 	s.cfg.p2p.AddDisconnectionHandler(func(_ context.Context, _ peer.ID) error {
@@ -315,23 +319,31 @@ func (s *Service) waitForChainStart() {
 	s.markForChainStart()
 }
 
-func (s *Service) registerHandlers() {
+func (s *Service) startTasksPostInitialSync() {
+	// Wait for the chain to start.
 	s.waitForChainStart()
+
 	select {
 	case <-s.initialSyncComplete:
-		// Register respective pubsub handlers at state synced event.
-		digest, err := s.currentForkDigest()
+		// Compute the current epoch.
+		currentSlot := slots.CurrentSlot(uint64(s.cfg.clock.GenesisTime().Unix()))
+		currentEpoch := slots.ToEpoch(currentSlot)
+
+		// Compute the current fork forkDigest.
+		forkDigest, err := s.currentForkDigest()
 		if err != nil {
 			log.WithError(err).Error("Could not retrieve current fork digest")
 			return
 		}
-		currentEpoch := slots.ToEpoch(slots.CurrentSlot(uint64(s.cfg.clock.GenesisTime().Unix())))
-		s.registerSubscribers(currentEpoch, digest)
+
+		// Register respective pubsub handlers at state synced event.
+		s.registerSubscribers(currentEpoch, forkDigest)
+
+		// Start the fork watcher.
 		go s.forkWatcher()
-		return
+
 	case <-s.ctx.Done():
 		log.Debug("Context closed, exiting goroutine")
-		return
 	}
 }
 

beacon-chain/sync/service_test.go

@@ -62,7 +62,7 @@ func TestSyncHandlers_WaitToSync(t *testing.T) {
 	}
 
 	topic := "/eth2/%x/beacon_block"
-	go r.registerHandlers()
+	go r.startTasksPostInitialSync()
 	time.Sleep(100 * time.Millisecond)
 
 	var vr [32]byte
@@ -143,7 +143,7 @@ func TestSyncHandlers_WaitTillSynced(t *testing.T) {
 
 	syncCompleteCh := make(chan bool)
 	go func() {
-		r.registerHandlers()
+		r.startTasksPostInitialSync()
 		syncCompleteCh <- true
 	}()
 
@@ -200,7 +200,7 @@ func TestSyncService_StopCleanly(t *testing.T) {
 		initialSyncComplete: make(chan struct{}),
 	}
 
-	go r.registerHandlers()
+	go r.startTasksPostInitialSync()
 	var vr [32]byte
 	require.NoError(t, gs.SetClock(startup.NewClock(time.Now(), vr)))
 	r.waitForChainStart()

beacon-chain/sync/subscriber_blob_sidecar.go

@@ -13,7 +13,7 @@ import (
 func (s *Service) blobSubscriber(ctx context.Context, msg proto.Message) error {
 	b, ok := msg.(blocks.VerifiedROBlob)
 	if !ok {
-		return fmt.Errorf("message was not type blocks.ROBlob, type=%T", msg)
+		return fmt.Errorf("message was not type blocks.VerifiedROBlob, type=%T", msg)
 	}
 
 	return s.subscribeBlob(ctx, b)

beacon-chain/sync/validate_aggregate_proof.go

@@ -57,11 +57,10 @@ func (s *Service) validateAggregateAndProof(ctx context.Context, pid peer.ID, ms
 	}
 
 	aggregate := m.AggregateAttestationAndProof().AggregateVal()
-	data := aggregate.GetData()
-
 	if err := helpers.ValidateNilAttestation(aggregate); err != nil {
 		return pubsub.ValidationReject, err
 	}
+	data := aggregate.GetData()
 	// Do not process slot 0 aggregates.
 	if data.Slot == 0 {
 		return pubsub.ValidationIgnore, nil
@@ -118,6 +117,9 @@ func (s *Service) validateAggregateAndProof(ctx context.Context, pid peer.ID, ms
 	if seen {
 		return pubsub.ValidationIgnore, nil
 	}
+
+	// Verify the block being voted on is in the beacon chain.
+	// If not, store this attestation in the map of pending attestations.
 	if !s.validateBlockInAttestation(ctx, m) {
 		return pubsub.ValidationIgnore, nil
 	}
@@ -223,6 +225,8 @@ func (s *Service) validateAggregatedAtt(ctx context.Context, signed ethpb.Signed
 	return s.validateWithBatchVerifier(ctx, "aggregate", set)
 }
 
+// validateBlocksInAttestation checks if the block being voted on is in the beaconDB.
+// If not, it store this attestation in the map of pending attestations.
 func (s *Service) validateBlockInAttestation(ctx context.Context, satt ethpb.SignedAggregateAttAndProof) bool {
 	// Verify the block being voted and the processed state is in beaconDB. The block should have passed validation if it's in the beaconDB.
 	blockRoot := bytesutil.ToBytes32(satt.AggregateAttestationAndProof().AggregateVal().GetData().BeaconBlockRoot)

beacon-chain/sync/validate_beacon_attestation.go

@@ -62,12 +62,11 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 	if !ok {
 		return pubsub.ValidationReject, errWrongMessage
 	}
-
-	data := att.GetData()
-
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return pubsub.ValidationReject, err
 	}
+	data := att.GetData()
+
 	// Do not process slot 0 attestations.
 	if data.Slot == 0 {
 		return pubsub.ValidationIgnore, nil

beacon-chain/sync/validate_beacon_blocks.go

@@ -211,11 +211,16 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 
 	// Log the arrival time of the accepted block
 	graffiti := blk.Block().Body().Graffiti()
+	exec, err := blk.Block().Body().Execution()
+	if err != nil {
+		log.WithError(err)
+	}
 	startTime, err := slots.ToTime(genesisTime, blk.Block().Slot())
 	logFields := logrus.Fields{
 		"blockSlot":     blk.Block().Slot(),
 		"proposerIndex": blk.Block().ProposerIndex(),
 		"graffiti":      string(graffiti[:]),
+		"extraData":     string(exec.ExtraData()),
 	}
 	if err != nil {
 		log.WithError(err).WithFields(logFields).Warn("Received block, could not report timing information.")

beacon-chain/sync/validate_blob.go

@@ -51,7 +51,7 @@ func (s *Service) validateBlob(ctx context.Context, pid peer.ID, msg *pubsub.Mes
 	if err != nil {
 		return pubsub.ValidationReject, errors.Wrap(err, "roblob conversion failure")
 	}
-	vf := s.newBlobVerifier(blob, verification.GossipSidecarRequirements)
+	vf := s.newBlobVerifier(blob, verification.GossipBlobSidecarRequirements)
 
 	if err := vf.BlobIndexInBounds(); err != nil {
 		return pubsub.ValidationReject, err

beacon-chain/verification/BUILD.bazel

@@ -10,6 +10,7 @@ go_library(
         "fake.go",
         "initializer.go",
         "interface.go",
+        "log.go",
         "metrics.go",
         "mock.go",
         "result.go",

beacon-chain/verification/batch_test.go

@@ -169,7 +169,7 @@ func TestBatchVerifier(t *testing.T) {
 			blk, blbs := c.bandb(t, c.nblobs)
 			reqs := c.reqs
 			if reqs == nil {
-				reqs = InitsyncSidecarRequirements
+				reqs = InitsyncBlobSidecarRequirements
 			}
 			bbv := NewBlobBatchVerifier(c.nv(), reqs)
 			if c.cv == nil {

beacon-chain/verification/blob.go

@@ -2,6 +2,7 @@ package verification
 
 import (
 	"context"
+	goError "errors"
 
 	"github.com/pkg/errors"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
@@ -12,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/runtime/logging"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -29,7 +29,7 @@ const (
 	RequireSidecarProposerExpected
 )
 
-var allSidecarRequirements = []Requirement{
+var allBlobSidecarRequirements = []Requirement{
 	RequireBlobIndexInBounds,
 	RequireNotFromFutureSlot,
 	RequireSlotAboveFinalized,
@@ -43,21 +43,21 @@ var allSidecarRequirements = []Requirement{
 	RequireSidecarProposerExpected,
 }
 
-// GossipSidecarRequirements defines the set of requirements that BlobSidecars received on gossip
+// GossipBlobSidecarRequirements defines the set of requirements that BlobSidecars received on gossip
 // must satisfy in order to upgrade an ROBlob to a VerifiedROBlob.
-var GossipSidecarRequirements = requirementList(allSidecarRequirements).excluding()
+var GossipBlobSidecarRequirements = requirementList(allBlobSidecarRequirements).excluding()
 
-// SpectestSidecarRequirements is used by the forkchoice spectests when verifying blobs used in the on_block tests.
+// SpectestBlobSidecarRequirements is used by the forkchoice spectests when verifying blobs used in the on_block tests.
 // The only requirements we exclude for these tests are the parent validity and seen tests, as these are specific to
 // gossip processing and require the bad block cache that we only use there.
-var SpectestSidecarRequirements = requirementList(GossipSidecarRequirements).excluding(
+var SpectestBlobSidecarRequirements = requirementList(GossipBlobSidecarRequirements).excluding(
 	RequireSidecarParentSeen, RequireSidecarParentValid)
 
-// InitsyncSidecarRequirements is the list of verification requirements to be used by the init-sync service
+// InitsyncBlobSidecarRequirements is the list of verification requirements to be used by the init-sync service
 // for batch-mode syncing. Because we only perform batch verification as part of the IsDataAvailable method
 // for blobs after the block has been verified, and the blobs to be verified are keyed in the cache by the
 // block root, the list of required verifications is much shorter than gossip.
-var InitsyncSidecarRequirements = requirementList(GossipSidecarRequirements).excluding(
+var InitsyncBlobSidecarRequirements = requirementList(GossipBlobSidecarRequirements).excluding(
 	RequireNotFromFutureSlot,
 	RequireSlotAboveFinalized,
 	RequireSidecarParentSeen,
@@ -71,36 +71,16 @@ var InitsyncSidecarRequirements = requirementList(GossipSidecarRequirements).exc
 // execution layer mempool. Only the KZG proof verification is required.
 var ELMemPoolRequirements = []Requirement{RequireSidecarKzgProofVerified}
 
-// BackfillSidecarRequirements is the same as InitsyncSidecarRequirements.
-var BackfillSidecarRequirements = requirementList(InitsyncSidecarRequirements).excluding()
+// BackfillBlobSidecarRequirements is the same as InitsyncBlobSidecarRequirements.
+var BackfillBlobSidecarRequirements = requirementList(InitsyncBlobSidecarRequirements).excluding()
 
-// PendingQueueSidecarRequirements is the same as InitsyncSidecarRequirements, used by the pending blocks queue.
-var PendingQueueSidecarRequirements = requirementList(InitsyncSidecarRequirements).excluding()
+// PendingQueueBlobSidecarRequirements is the same as InitsyncBlobSidecarRequirements, used by the pending blocks queue.
+var PendingQueueBlobSidecarRequirements = requirementList(InitsyncBlobSidecarRequirements).excluding()
 
 var (
 	ErrBlobInvalid = errors.New("blob failed verification")
 	// ErrBlobIndexInvalid means RequireBlobIndexInBounds failed.
-	ErrBlobIndexInvalid = errors.Wrap(ErrBlobInvalid, "incorrect blob sidecar index")
-	// ErrFromFutureSlot means RequireSlotNotTooEarly failed.
-	ErrFromFutureSlot = errors.Wrap(ErrBlobInvalid, "slot is too far in the future")
-	// ErrSlotNotAfterFinalized means RequireSlotAboveFinalized failed.
-	ErrSlotNotAfterFinalized = errors.Wrap(ErrBlobInvalid, "slot <= finalized checkpoint")
-	// ErrInvalidProposerSignature means RequireValidProposerSignature failed.
-	ErrInvalidProposerSignature = errors.Wrap(ErrBlobInvalid, "proposer signature could not be verified")
-	// ErrSidecarParentNotSeen means RequireSidecarParentSeen failed.
-	ErrSidecarParentNotSeen = errors.Wrap(ErrBlobInvalid, "parent root has not been seen")
-	// ErrSidecarParentInvalid means RequireSidecarParentValid failed.
-	ErrSidecarParentInvalid = errors.Wrap(ErrBlobInvalid, "parent block is not valid")
-	// ErrSlotNotAfterParent means RequireSidecarParentSlotLower failed.
-	ErrSlotNotAfterParent = errors.Wrap(ErrBlobInvalid, "slot <= slot")
-	// ErrSidecarNotFinalizedDescendent means RequireSidecarDescendsFromFinalized failed.
-	ErrSidecarNotFinalizedDescendent = errors.Wrap(ErrBlobInvalid, "blob parent is not descended from the finalized block")
-	// ErrSidecarInclusionProofInvalid means RequireSidecarInclusionProven failed.
-	ErrSidecarInclusionProofInvalid = errors.Wrap(ErrBlobInvalid, "sidecar inclusion proof verification failed")
-	// ErrSidecarKzgProofInvalid means RequireSidecarKzgProofVerified failed.
-	ErrSidecarKzgProofInvalid = errors.Wrap(ErrBlobInvalid, "sidecar kzg commitment proof verification failed")
-	// ErrSidecarUnexpectedProposer means RequireSidecarProposerExpected failed.
-	ErrSidecarUnexpectedProposer = errors.Wrap(ErrBlobInvalid, "sidecar was not proposed by the expected proposer_index")
+	ErrBlobIndexInvalid = errors.New("incorrect blob sidecar index")
 )
 
 type ROBlobVerifier struct {
@@ -149,7 +129,7 @@ func (bv *ROBlobVerifier) BlobIndexInBounds() (err error) {
 	defer bv.recordResult(RequireBlobIndexInBounds, &err)
 	if bv.blob.Index >= fieldparams.MaxBlobsPerBlock {
 		log.WithFields(logging.BlobFields(bv.blob)).Debug("Sidecar index >= MAX_BLOBS_PER_BLOCK")
-		return ErrBlobIndexInvalid
+		return blobErrBuilder(ErrBlobIndexInvalid)
 	}
 	return nil
 }
@@ -168,7 +148,7 @@ func (bv *ROBlobVerifier) NotFromFutureSlot() (err error) {
 	// If the system time is still before earliestStart, we consider the blob from a future slot and return an error.
 	if bv.clock.Now().Before(earliestStart) {
 		log.WithFields(logging.BlobFields(bv.blob)).Debug("sidecar slot is too far in the future")
-		return ErrFromFutureSlot
+		return blobErrBuilder(ErrFromFutureSlot)
 	}
 	return nil
 }
@@ -181,11 +161,11 @@ func (bv *ROBlobVerifier) SlotAboveFinalized() (err error) {
 	fcp := bv.fc.FinalizedCheckpoint()
 	fSlot, err := slots.EpochStart(fcp.Epoch)
 	if err != nil {
-		return errors.Wrapf(ErrSlotNotAfterFinalized, "error computing epoch start slot for finalized checkpoint (%d) %s", fcp.Epoch, err.Error())
+		return errors.Wrapf(blobErrBuilder(ErrSlotNotAfterFinalized), "error computing epoch start slot for finalized checkpoint (%d) %s", fcp.Epoch, err.Error())
 	}
 	if bv.blob.Slot() <= fSlot {
 		log.WithFields(logging.BlobFields(bv.blob)).Debug("sidecar slot is not after finalized checkpoint")
-		return ErrSlotNotAfterFinalized
+		return blobErrBuilder(ErrSlotNotAfterFinalized)
 	}
 	return nil
 }
@@ -203,7 +183,7 @@ func (bv *ROBlobVerifier) ValidProposerSignature(ctx context.Context) (err error
 		if err != nil {
 			log.WithFields(logging.BlobFields(bv.blob)).WithError(err).Debug("reusing failed proposer signature validation from cache")
 			blobVerificationProposerSignatureCache.WithLabelValues("hit-invalid").Inc()
-			return ErrInvalidProposerSignature
+			return blobErrBuilder(ErrInvalidProposerSignature)
 		}
 		return nil
 	}
@@ -213,12 +193,12 @@ func (bv *ROBlobVerifier) ValidProposerSignature(ctx context.Context) (err error
 	parent, err := bv.parentState(ctx)
 	if err != nil {
 		log.WithFields(logging.BlobFields(bv.blob)).WithError(err).Debug("could not replay parent state for blob signature verification")
-		return ErrInvalidProposerSignature
+		return blobErrBuilder(ErrInvalidProposerSignature)
 	}
 	// Full verification, which will subsequently be cached for anything sharing the signature cache.
 	if err = bv.sc.VerifySignature(sd, parent); err != nil {
 		log.WithFields(logging.BlobFields(bv.blob)).WithError(err).Debug("signature verification failed")
-		return ErrInvalidProposerSignature
+		return blobErrBuilder(ErrInvalidProposerSignature)
 	}
 	return nil
 }
@@ -235,7 +215,7 @@ func (bv *ROBlobVerifier) SidecarParentSeen(parentSeen func([32]byte) bool) (err
 		return nil
 	}
 	log.WithFields(logging.BlobFields(bv.blob)).Debug("parent root has not been seen")
-	return ErrSidecarParentNotSeen
+	return blobErrBuilder(ErrSidecarParentNotSeen)
 }
 
 // SidecarParentValid represents the spec verification:
@@ -244,7 +224,7 @@ func (bv *ROBlobVerifier) SidecarParentValid(badParent func([32]byte) bool) (err
 	defer bv.recordResult(RequireSidecarParentValid, &err)
 	if badParent != nil && badParent(bv.blob.ParentRoot()) {
 		log.WithFields(logging.BlobFields(bv.blob)).Debug("parent root is invalid")
-		return ErrSidecarParentInvalid
+		return blobErrBuilder(ErrSidecarParentInvalid)
 	}
 	return nil
 }
@@ -255,10 +235,10 @@ func (bv *ROBlobVerifier) SidecarParentSlotLower() (err error) {
 	defer bv.recordResult(RequireSidecarParentSlotLower, &err)
 	parentSlot, err := bv.fc.Slot(bv.blob.ParentRoot())
 	if err != nil {
-		return errors.Wrap(ErrSlotNotAfterParent, "parent root not in forkchoice")
+		return errors.Wrap(blobErrBuilder(ErrSlotNotAfterParent), "parent root not in forkchoice")
 	}
 	if parentSlot >= bv.blob.Slot() {
-		return ErrSlotNotAfterParent
+		return blobErrBuilder(ErrSlotNotAfterParent)
 	}
 	return nil
 }
@@ -270,7 +250,7 @@ func (bv *ROBlobVerifier) SidecarDescendsFromFinalized() (err error) {
 	defer bv.recordResult(RequireSidecarDescendsFromFinalized, &err)
 	if !bv.fc.HasNode(bv.blob.ParentRoot()) {
 		log.WithFields(logging.BlobFields(bv.blob)).Debug("parent root not in forkchoice")
-		return ErrSidecarNotFinalizedDescendent
+		return blobErrBuilder(ErrSidecarNotFinalizedDescendent)
 	}
 	return nil
 }
@@ -281,7 +261,7 @@ func (bv *ROBlobVerifier) SidecarInclusionProven() (err error) {
 	defer bv.recordResult(RequireSidecarInclusionProven, &err)
 	if err = blocks.VerifyKZGInclusionProof(bv.blob); err != nil {
 		log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("sidecar inclusion proof verification failed")
-		return ErrSidecarInclusionProofInvalid
+		return blobErrBuilder(ErrSidecarInclusionProofInvalid)
 	}
 	return nil
 }
@@ -293,7 +273,7 @@ func (bv *ROBlobVerifier) SidecarKzgProofVerified() (err error) {
 	defer bv.recordResult(RequireSidecarKzgProofVerified, &err)
 	if err = bv.verifyBlobCommitment(bv.blob); err != nil {
 		log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("kzg commitment proof verification failed")
-		return ErrSidecarKzgProofInvalid
+		return blobErrBuilder(ErrSidecarKzgProofInvalid)
 	}
 	return nil
 }
@@ -311,7 +291,7 @@ func (bv *ROBlobVerifier) SidecarProposerExpected(ctx context.Context) (err erro
 	}
 	r, err := bv.fc.TargetRootForEpoch(bv.blob.ParentRoot(), e)
 	if err != nil {
-		return ErrSidecarUnexpectedProposer
+		return blobErrBuilder(ErrSidecarUnexpectedProposer)
 	}
 	c := &forkchoicetypes.Checkpoint{Root: r, Epoch: e}
 	idx, cached := bv.pc.Proposer(c, bv.blob.Slot())
@@ -319,19 +299,19 @@ func (bv *ROBlobVerifier) SidecarProposerExpected(ctx context.Context) (err erro
 		pst, err := bv.parentState(ctx)
 		if err != nil {
 			log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("state replay to parent_root failed")
-			return ErrSidecarUnexpectedProposer
+			return blobErrBuilder(ErrSidecarUnexpectedProposer)
 		}
 		idx, err = bv.pc.ComputeProposer(ctx, bv.blob.ParentRoot(), bv.blob.Slot(), pst)
 		if err != nil {
 			log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("error computing proposer index from parent state")
-			return ErrSidecarUnexpectedProposer
+			return blobErrBuilder(ErrSidecarUnexpectedProposer)
 		}
 	}
 	if idx != bv.blob.ProposerIndex() {
-		log.WithError(ErrSidecarUnexpectedProposer).
+		log.WithError(blobErrBuilder(ErrSidecarUnexpectedProposer)).
 			WithFields(logging.BlobFields(bv.blob)).WithField("expectedProposer", idx).
 			Debug("unexpected blob proposer")
-		return ErrSidecarUnexpectedProposer
+		return blobErrBuilder(ErrSidecarUnexpectedProposer)
 	}
 	return nil
 }
@@ -357,3 +337,7 @@ func blobToSignatureData(b blocks.ROBlob) SignatureData {
 		Slot:      b.Slot(),
 	}
 }
+
+func blobErrBuilder(baseErr error) error {
+	return goError.Join(ErrBlobInvalid, baseErr)
+}

beacon-chain/verification/blob_test.go

@@ -27,13 +27,13 @@ func TestBlobIndexInBounds(t *testing.T) {
 	_, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 0, 1)
 	b := blobs[0]
 	// set Index to a value that is out of bounds
-	v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.NoError(t, v.BlobIndexInBounds())
 	require.Equal(t, true, v.results.executed(RequireBlobIndexInBounds))
 	require.NoError(t, v.results.result(RequireBlobIndexInBounds))
 
 	b.Index = fieldparams.MaxBlobsPerBlock
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.ErrorIs(t, v.BlobIndexInBounds(), ErrBlobIndexInvalid)
 	require.Equal(t, true, v.results.executed(RequireBlobIndexInBounds))
 	require.NotNil(t, v.results.result(RequireBlobIndexInBounds))
@@ -52,7 +52,7 @@ func TestSlotNotTooEarly(t *testing.T) {
 	// This clock will give a current slot of 1 on the nose
 	happyClock := startup.NewClock(genesis, [32]byte{}, startup.WithNower(func() time.Time { return now }))
 	ini := Initializer{shared: &sharedResources{clock: happyClock}}
-	v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.NoError(t, v.NotFromFutureSlot())
 	require.Equal(t, true, v.results.executed(RequireNotFromFutureSlot))
 	require.NoError(t, v.results.result(RequireNotFromFutureSlot))
@@ -61,7 +61,7 @@ func TestSlotNotTooEarly(t *testing.T) {
 	// but still in the previous slot.
 	closeClock := startup.NewClock(genesis, [32]byte{}, startup.WithNower(func() time.Time { return now.Add(-1 * params.BeaconConfig().MaximumGossipClockDisparityDuration() / 2) }))
 	ini = Initializer{shared: &sharedResources{clock: closeClock}}
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.NoError(t, v.NotFromFutureSlot())
 
 	// This clock will give a current slot of 0, with now coming more than max clock disparity before slot 1
@@ -69,7 +69,7 @@ func TestSlotNotTooEarly(t *testing.T) {
 	dispClock := startup.NewClock(genesis, [32]byte{}, startup.WithNower(func() time.Time { return disparate }))
 	// Set up initializer to use the clock that will set now to a little to far before slot 1
 	ini = Initializer{shared: &sharedResources{clock: dispClock}}
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.ErrorIs(t, v.NotFromFutureSlot(), ErrFromFutureSlot)
 	require.Equal(t, true, v.results.executed(RequireNotFromFutureSlot))
 	require.NotNil(t, v.results.result(RequireNotFromFutureSlot))
@@ -114,7 +114,7 @@ func TestSlotAboveFinalized(t *testing.T) {
 			_, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 0, 1)
 			b := blobs[0]
 			b.SignedBlockHeader.Header.Slot = c.slot
-			v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+			v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 			err := v.SlotAboveFinalized()
 			require.Equal(t, true, v.results.executed(RequireSlotAboveFinalized))
 			if c.err == nil {
@@ -146,7 +146,7 @@ func TestValidProposerSignature_Cached(t *testing.T) {
 		},
 	}
 	ini := Initializer{shared: &sharedResources{sc: sc, sr: &mockStateByRooter{sbr: sbrErrorIfCalled(t)}}}
-	v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.NoError(t, v.ValidProposerSignature(ctx))
 	require.Equal(t, true, v.results.executed(RequireValidProposerSignature))
 	require.NoError(t, v.results.result(RequireValidProposerSignature))
@@ -159,7 +159,7 @@ func TestValidProposerSignature_Cached(t *testing.T) {
 		return true, errors.New("derp")
 	}
 	ini = Initializer{shared: &sharedResources{sc: sc, sr: &mockStateByRooter{sbr: sbrErrorIfCalled(t)}}}
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.ErrorIs(t, v.ValidProposerSignature(ctx), ErrInvalidProposerSignature)
 	require.Equal(t, true, v.results.executed(RequireValidProposerSignature))
 	require.NotNil(t, v.results.result(RequireValidProposerSignature))
@@ -182,14 +182,14 @@ func TestValidProposerSignature_CacheMiss(t *testing.T) {
 		},
 	}
 	ini := Initializer{shared: &sharedResources{sc: sc, sr: sbrForValOverride(b.ProposerIndex(), &ethpb.Validator{})}}
-	v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.NoError(t, v.ValidProposerSignature(ctx))
 	require.Equal(t, true, v.results.executed(RequireValidProposerSignature))
 	require.NoError(t, v.results.result(RequireValidProposerSignature))
 
 	// simulate state not found
 	ini = Initializer{shared: &sharedResources{sc: sc, sr: sbrNotFound(t, expectedSd.Parent)}}
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.ErrorIs(t, v.ValidProposerSignature(ctx), ErrInvalidProposerSignature)
 	require.Equal(t, true, v.results.executed(RequireValidProposerSignature))
 	require.NotNil(t, v.results.result(RequireValidProposerSignature))
@@ -206,7 +206,7 @@ func TestValidProposerSignature_CacheMiss(t *testing.T) {
 		},
 	}
 	ini = Initializer{shared: &sharedResources{sc: sc, sr: sbr}}
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 
 	// make sure all the histories are clean before calling the method
 	// so we don't get polluted by previous usages
@@ -255,14 +255,14 @@ func TestSidecarParentSeen(t *testing.T) {
 
 	t.Run("happy path", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{fc: fcHas}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.NoError(t, v.SidecarParentSeen(nil))
 		require.Equal(t, true, v.results.executed(RequireSidecarParentSeen))
 		require.NoError(t, v.results.result(RequireSidecarParentSeen))
 	})
 	t.Run("HasNode false, no badParent cb, expected error", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{fc: fcLacks}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarParentSeen(nil), ErrSidecarParentNotSeen)
 		require.Equal(t, true, v.results.executed(RequireSidecarParentSeen))
 		require.NotNil(t, v.results.result(RequireSidecarParentSeen))
@@ -270,14 +270,14 @@ func TestSidecarParentSeen(t *testing.T) {
 
 	t.Run("HasNode false, badParent true", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{fc: fcLacks}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.NoError(t, v.SidecarParentSeen(badParentCb(t, b.ParentRoot(), true)))
 		require.Equal(t, true, v.results.executed(RequireSidecarParentSeen))
 		require.NoError(t, v.results.result(RequireSidecarParentSeen))
 	})
 	t.Run("HasNode false, badParent false", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{fc: fcLacks}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarParentSeen(badParentCb(t, b.ParentRoot(), false)), ErrSidecarParentNotSeen)
 		require.Equal(t, true, v.results.executed(RequireSidecarParentSeen))
 		require.NotNil(t, v.results.result(RequireSidecarParentSeen))
@@ -289,14 +289,14 @@ func TestSidecarParentValid(t *testing.T) {
 	b := blobs[0]
 	t.Run("parent valid", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.NoError(t, v.SidecarParentValid(badParentCb(t, b.ParentRoot(), false)))
 		require.Equal(t, true, v.results.executed(RequireSidecarParentValid))
 		require.NoError(t, v.results.result(RequireSidecarParentValid))
 	})
 	t.Run("parent not valid", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarParentValid(badParentCb(t, b.ParentRoot(), true)), ErrSidecarParentInvalid)
 		require.Equal(t, true, v.results.executed(RequireSidecarParentValid))
 		require.NotNil(t, v.results.result(RequireSidecarParentValid))
@@ -340,7 +340,7 @@ func TestSidecarParentSlotLower(t *testing.T) {
 				}
 				return c.fcSlot, c.fcErr
 			}}}}
-			v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+			v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 			err := v.SidecarParentSlotLower()
 			require.Equal(t, true, v.results.executed(RequireSidecarParentSlotLower))
 			if c.err == nil {
@@ -364,7 +364,7 @@ func TestSidecarDescendsFromFinalized(t *testing.T) {
 			}
 			return false
 		}}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarDescendsFromFinalized(), ErrSidecarNotFinalizedDescendent)
 		require.Equal(t, true, v.results.executed(RequireSidecarDescendsFromFinalized))
 		require.NotNil(t, v.results.result(RequireSidecarDescendsFromFinalized))
@@ -376,7 +376,7 @@ func TestSidecarDescendsFromFinalized(t *testing.T) {
 			}
 			return true
 		}}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.NoError(t, v.SidecarDescendsFromFinalized())
 		require.Equal(t, true, v.results.executed(RequireSidecarDescendsFromFinalized))
 		require.NoError(t, v.results.result(RequireSidecarDescendsFromFinalized))
@@ -389,7 +389,7 @@ func TestSidecarInclusionProven(t *testing.T) {
 	b := blobs[0]
 
 	ini := Initializer{}
-	v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.NoError(t, v.SidecarInclusionProven())
 	require.Equal(t, true, v.results.executed(RequireSidecarInclusionProven))
 	require.NoError(t, v.results.result(RequireSidecarInclusionProven))
@@ -397,7 +397,7 @@ func TestSidecarInclusionProven(t *testing.T) {
 	// Invert bits of the first byte of the body root to mess up the proof
 	byte0 := b.SignedBlockHeader.Header.BodyRoot[0]
 	b.SignedBlockHeader.Header.BodyRoot[0] = byte0 ^ 255
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.ErrorIs(t, v.SidecarInclusionProven(), ErrSidecarInclusionProofInvalid)
 	require.Equal(t, true, v.results.executed(RequireSidecarInclusionProven))
 	require.NotNil(t, v.results.result(RequireSidecarInclusionProven))
@@ -409,7 +409,7 @@ func TestSidecarInclusionProvenElectra(t *testing.T) {
 	b := blobs[0]
 
 	ini := Initializer{}
-	v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.NoError(t, v.SidecarInclusionProven())
 	require.Equal(t, true, v.results.executed(RequireSidecarInclusionProven))
 	require.NoError(t, v.results.result(RequireSidecarInclusionProven))
@@ -417,7 +417,7 @@ func TestSidecarInclusionProvenElectra(t *testing.T) {
 	// Invert bits of the first byte of the body root to mess up the proof
 	byte0 := b.SignedBlockHeader.Header.BodyRoot[0]
 	b.SignedBlockHeader.Header.BodyRoot[0] = byte0 ^ 255
-	v = ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v = ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 	require.ErrorIs(t, v.SidecarInclusionProven(), ErrSidecarInclusionProofInvalid)
 	require.Equal(t, true, v.results.executed(RequireSidecarInclusionProven))
 	require.NotNil(t, v.results.result(RequireSidecarInclusionProven))
@@ -452,21 +452,21 @@ func TestSidecarProposerExpected(t *testing.T) {
 	b := blobs[0]
 	t.Run("cached, matches", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{pc: &mockProposerCache{ProposerCB: pcReturnsIdx(b.ProposerIndex())}, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.NoError(t, v.SidecarProposerExpected(ctx))
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NoError(t, v.results.result(RequireSidecarProposerExpected))
 	})
 	t.Run("cached, does not match", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{pc: &mockProposerCache{ProposerCB: pcReturnsIdx(b.ProposerIndex() + 1)}, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarProposerExpected(ctx), ErrSidecarUnexpectedProposer)
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NotNil(t, v.results.result(RequireSidecarProposerExpected))
 	})
 	t.Run("not cached, state lookup failure", func(t *testing.T) {
 		ini := Initializer{shared: &sharedResources{sr: sbrNotFound(t, b.ParentRoot()), pc: &mockProposerCache{ProposerCB: pcReturnsNotFound()}, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarProposerExpected(ctx), ErrSidecarUnexpectedProposer)
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NotNil(t, v.results.result(RequireSidecarProposerExpected))
@@ -475,14 +475,14 @@ func TestSidecarProposerExpected(t *testing.T) {
 	t.Run("not cached, proposer matches", func(t *testing.T) {
 		pc := &mockProposerCache{
 			ProposerCB: pcReturnsNotFound(),
-			ComputeProposerCB: func(ctx context.Context, root [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error) {
+			ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
 				require.Equal(t, b.ParentRoot(), root)
 				require.Equal(t, b.Slot(), slot)
 				return b.ProposerIndex(), nil
 			},
 		}
 		ini := Initializer{shared: &sharedResources{sr: sbrForValOverride(b.ProposerIndex(), &ethpb.Validator{}), pc: pc, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.NoError(t, v.SidecarProposerExpected(ctx))
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NoError(t, v.results.result(RequireSidecarProposerExpected))
@@ -490,14 +490,14 @@ func TestSidecarProposerExpected(t *testing.T) {
 	t.Run("not cached, proposer does not match", func(t *testing.T) {
 		pc := &mockProposerCache{
 			ProposerCB: pcReturnsNotFound(),
-			ComputeProposerCB: func(ctx context.Context, root [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error) {
+			ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
 				require.Equal(t, b.ParentRoot(), root)
 				require.Equal(t, b.Slot(), slot)
 				return b.ProposerIndex() + 1, nil
 			},
 		}
 		ini := Initializer{shared: &sharedResources{sr: sbrForValOverride(b.ProposerIndex(), &ethpb.Validator{}), pc: pc, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarProposerExpected(ctx), ErrSidecarUnexpectedProposer)
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NotNil(t, v.results.result(RequireSidecarProposerExpected))
@@ -505,14 +505,14 @@ func TestSidecarProposerExpected(t *testing.T) {
 	t.Run("not cached, ComputeProposer fails", func(t *testing.T) {
 		pc := &mockProposerCache{
 			ProposerCB: pcReturnsNotFound(),
-			ComputeProposerCB: func(ctx context.Context, root [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error) {
+			ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
 				require.Equal(t, b.ParentRoot(), root)
 				require.Equal(t, b.Slot(), slot)
 				return 0, errors.New("ComputeProposer failed")
 			},
 		}
 		ini := Initializer{shared: &sharedResources{sr: sbrForValOverride(b.ProposerIndex(), &ethpb.Validator{}), pc: pc, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarProposerExpected(ctx), ErrSidecarUnexpectedProposer)
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NotNil(t, v.results.result(RequireSidecarProposerExpected))
@@ -523,7 +523,7 @@ func TestRequirementSatisfaction(t *testing.T) {
 	_, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 1)
 	b := blobs[0]
 	ini := Initializer{}
-	v := ini.NewBlobVerifier(b, GossipSidecarRequirements)
+	v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 
 	_, err := v.VerifiedROBlob()
 	require.ErrorIs(t, err, ErrBlobInvalid)
@@ -537,7 +537,7 @@ func TestRequirementSatisfaction(t *testing.T) {
 	}
 
 	// satisfy everything through the backdoor and ensure we get the verified ro blob at the end
-	for _, r := range GossipSidecarRequirements {
+	for _, r := range GossipBlobSidecarRequirements {
 		v.results.record(r, nil)
 	}
 	require.Equal(t, true, v.results.allSatisfied())

beacon-chain/verification/cache.go

@@ -17,7 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/network/forks"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	log "github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -50,8 +50,8 @@ type SignatureData struct {
 	Slot      primitives.Slot
 }
 
-func (d SignatureData) logFields() log.Fields {
-	return log.Fields{
+func (d SignatureData) logFields() logrus.Fields {
+	return logrus.Fields{
 		"root":       fmt.Sprintf("%#x", d.Root),
 		"parentRoot": fmt.Sprintf("%#x", d.Parent),
 		"signature":  fmt.Sprintf("%#x", d.Signature),

beacon-chain/verification/error.go

@@ -2,8 +2,40 @@ package verification
 
 import "github.com/pkg/errors"
 
-// ErrMissingVerification indicates that the given verification function was never performed on the value.
-var ErrMissingVerification = errors.New("verification was not performed for requirement")
+var (
+	// ErrFromFutureSlot means RequireSlotNotTooEarly failed.
+	ErrFromFutureSlot = errors.New("slot is too far in the future")
+
+	// ErrSlotNotAfterFinalized means RequireSlotAboveFinalized failed.
+	ErrSlotNotAfterFinalized = errors.New("slot <= finalized checkpoint")
+
+	// ErrInvalidProposerSignature means RequireValidProposerSignature failed.
+	ErrInvalidProposerSignature = errors.New("proposer signature could not be verified")
+
+	// ErrSidecarParentNotSeen means RequireSidecarParentSeen failed.
+	ErrSidecarParentNotSeen = errors.New("parent root has not been seen")
+
+	// ErrSidecarParentInvalid means RequireSidecarParentValid failed.
+	ErrSidecarParentInvalid = errors.New("parent block is not valid")
+
+	// ErrSlotNotAfterParent means RequireSidecarParentSlotLower failed.
+	ErrSlotNotAfterParent = errors.New("slot <= slot")
+
+	// ErrSidecarNotFinalizedDescendent means RequireSidecarDescendsFromFinalized failed.
+	ErrSidecarNotFinalizedDescendent = errors.New("parent is not descended from the finalized block")
+
+	// ErrSidecarInclusionProofInvalid means RequireSidecarInclusionProven failed.
+	ErrSidecarInclusionProofInvalid = errors.New("sidecar inclusion proof verification failed")
+
+	// ErrSidecarKzgProofInvalid means RequireSidecarKzgProofVerified failed.
+	ErrSidecarKzgProofInvalid = errors.New("sidecar kzg commitment proof verification failed")
+
+	// ErrSidecarUnexpectedProposer means RequireSidecarProposerExpected failed.
+	ErrSidecarUnexpectedProposer = errors.New("sidecar was not proposed by the expected proposer_index")
+
+	// ErrMissingVerification indicates that the given verification function was never performed on the value.
+	ErrMissingVerification = errors.New("verification was not performed for requirement")
+)
 
 // VerificationMultiError is a custom error that can be used to access individual verification failures.
 type VerificationMultiError struct {

beacon-chain/verification/log.go

@@ -0,0 +1,5 @@
+package verification
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "verification")

beacon-chain/verification/result_test.go

@@ -39,7 +39,7 @@ func TestResultList(t *testing.T) {
 func TestExportedBlobSanityCheck(t *testing.T) {
 	// make sure all requirement lists contain the bare minimum checks
 	sanity := []Requirement{RequireValidProposerSignature, RequireSidecarKzgProofVerified, RequireBlobIndexInBounds, RequireSidecarInclusionProven}
-	reqs := [][]Requirement{GossipSidecarRequirements, SpectestSidecarRequirements, InitsyncSidecarRequirements, BackfillSidecarRequirements, PendingQueueSidecarRequirements}
+	reqs := [][]Requirement{GossipBlobSidecarRequirements, SpectestBlobSidecarRequirements, InitsyncBlobSidecarRequirements, BackfillBlobSidecarRequirements, PendingQueueBlobSidecarRequirements}
 	for i := range reqs {
 		r := reqs[i]
 		reqMap := make(map[Requirement]struct{})
@@ -51,13 +51,13 @@ func TestExportedBlobSanityCheck(t *testing.T) {
 			require.Equal(t, true, ok)
 		}
 	}
-	require.DeepEqual(t, allSidecarRequirements, GossipSidecarRequirements)
+	require.DeepEqual(t, allBlobSidecarRequirements, GossipBlobSidecarRequirements)
 }
 
 func TestAllBlobRequirementsHaveStrings(t *testing.T) {
 	var derp Requirement = math.MaxInt
 	require.Equal(t, unknownRequirementName, derp.String())
-	for i := range allSidecarRequirements {
-		require.NotEqual(t, unknownRequirementName, allSidecarRequirements[i].String())
+	for i := range allBlobSidecarRequirements {
+		require.NotEqual(t, unknownRequirementName, allBlobSidecarRequirements[i].String())
 	}
 }

config/fieldparams/mainnet.go

@@ -37,6 +37,7 @@ const (
 	SyncCommitteeBranchDepth              = 5             // SyncCommitteeBranchDepth defines the number of leaves in a merkle proof of a sync committee.
 	SyncCommitteeBranchDepthElectra       = 6             // SyncCommitteeBranchDepthElectra defines the number of leaves in a merkle proof of a sync committee.
 	FinalityBranchDepth                   = 6             // FinalityBranchDepth defines the number of leaves in a merkle proof of the finalized checkpoint root.
+	FinalityBranchDepthElectra            = 7             // FinalityBranchDepthElectra defines the number of leaves in a merkle proof of the finalized checkpoint root.
 	PendingDepositsLimit                  = 134217728     // Maximum number of pending balance deposits in the beacon state.
 	PendingPartialWithdrawalsLimit        = 134217728     // Maximum number of pending partial withdrawals in the beacon state.
 	PendingConsolidationsLimit            = 262144        // Maximum number of pending consolidations in the beacon state.

config/fieldparams/minimal.go

@@ -37,6 +37,7 @@ const (
 	SyncCommitteeBranchDepth              = 5             // SyncCommitteeBranchDepth defines the number of leaves in a merkle proof of a sync committee.
 	SyncCommitteeBranchDepthElectra       = 6             // SyncCommitteeBranchDepthElectra defines the number of leaves in a merkle proof of a sync committee.
 	FinalityBranchDepth                   = 6             // FinalityBranchDepth defines the number of leaves in a merkle proof of the finalized checkpoint root.
+	FinalityBranchDepthElectra            = 7             // FinalityBranchDepthElectra defines the number of leaves in a merkle proof of the finalized checkpoint root.
 	PendingDepositsLimit                  = 134217728     // Maximum number of pending balance deposits in the beacon state.
 	PendingPartialWithdrawalsLimit        = 64            // Maximum number of pending partial withdrawals in the beacon state.
 	PendingConsolidationsLimit            = 64            // Maximum number of pending consolidations in the beacon state.

config/params/config.go

@@ -166,6 +166,7 @@ type BeaconChainConfig struct {
 	DenebForkEpoch       primitives.Epoch `yaml:"DENEB_FORK_EPOCH" spec:"true"`       // DenebForkEpoch is used to represent the assigned fork epoch for deneb.
 	ElectraForkVersion   []byte           `yaml:"ELECTRA_FORK_VERSION" spec:"true"`   // ElectraForkVersion is used to represent the fork version for electra.
 	ElectraForkEpoch     primitives.Epoch `yaml:"ELECTRA_FORK_EPOCH" spec:"true"`     // ElectraForkEpoch is used to represent the assigned fork epoch for electra.
+	Eip7594ForkEpoch     primitives.Epoch `yaml:"EIP7594_FORK_EPOCH" spec:"true"`     // EIP7594ForkEpoch is used to represent the assigned fork epoch for peer das.
 
 	ForkVersionSchedule map[[fieldparams.VersionLength]byte]primitives.Epoch // Schedule of fork epochs by version.
 	ForkVersionNames    map[[fieldparams.VersionLength]byte]string           // Human-readable names of fork versions.
@@ -255,6 +256,13 @@ type BeaconChainConfig struct {
 	MaxDepositRequestsPerPayload          uint64 `yaml:"MAX_DEPOSIT_REQUESTS_PER_PAYLOAD" spec:"true"`           // MaxDepositRequestsPerPayload is the maximum number of execution layer deposits in each payload
 	UnsetDepositRequestsStartIndex        uint64 `yaml:"UNSET_DEPOSIT_REQUESTS_START_INDEX" spec:"true"`         // UnsetDepositRequestsStartIndex is used to check the start index for eip6110
 
+	// PeerDAS Values
+	SamplesPerSlot                        uint64           `yaml:"SAMPLES_PER_SLOT"`                             // SamplesPerSlot refers to the number of random samples a node queries per slot.
+	CustodyRequirement                    uint64           `yaml:"CUSTODY_REQUIREMENT"`                          // CustodyRequirement refers to the minimum amount of subnets a peer must custody and serve samples from.
+	MinEpochsForDataColumnSidecarsRequest primitives.Epoch `yaml:"MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS"` // MinEpochsForDataColumnSidecarsRequest is the minimum number of epochs the node will keep the data columns for.
+	MaxCellsInExtendedMatrix              uint64           `yaml:"MAX_CELLS_IN_EXTENDED_MATRIX" spec:"true"`     // MaxCellsInExtendedMatrix is the full data of one-dimensional erasure coding extended blobs (in row major format).
+	NumberOfColumns                       uint64           `yaml:"NUMBER_OF_COLUMNS" spec:"true"`                // NumberOfColumns in the extended data matrix.
+
 	// Networking Specific Parameters
 	GossipMaxSize                   uint64          `yaml:"GOSSIP_MAX_SIZE" spec:"true"`                    // GossipMaxSize is the maximum allowed size of uncompressed gossip messages.
 	MaxChunkSize                    uint64          `yaml:"MAX_CHUNK_SIZE" spec:"true"`                     // MaxChunkSize is the maximum allowed size of uncompressed req/resp chunked responses.
@@ -272,10 +280,6 @@ type BeaconChainConfig struct {
 	AttestationSubnetPrefixBits     uint64          `yaml:"ATTESTATION_SUBNET_PREFIX_BITS" spec:"true"`     // AttestationSubnetPrefixBits is defined as (ceillog2(ATTESTATION_SUBNET_COUNT) + ATTESTATION_SUBNET_EXTRA_BITS).
 	SubnetsPerNode                  uint64          `yaml:"SUBNETS_PER_NODE" spec:"true"`                   // SubnetsPerNode is the number of long-lived subnets a beacon node should be subscribed to.
 	NodeIdBits                      uint64          `yaml:"NODE_ID_BITS" spec:"true"`                       // NodeIdBits defines the bit length of a node id.
-
-	// PeerDAS
-	NumberOfColumns          uint64 `yaml:"NUMBER_OF_COLUMNS" spec:"true"`            // NumberOfColumns in the extended data matrix.
-	MaxCellsInExtendedMatrix uint64 `yaml:"MAX_CELLS_IN_EXTENDED_MATRIX" spec:"true"` // MaxCellsInExtendedMatrix is the full data of one-dimensional erasure coding extended blobs (in row major format).
 }
 
 // InitializeForkSchedule initializes the schedules forks baked into the config.
@@ -360,6 +364,12 @@ func DenebEnabled() bool {
 	return BeaconConfig().DenebForkEpoch < math.MaxUint64
 }
 
+// PeerDASEnabled centralizes the check to determine if code paths
+// that are specific to peerdas should be allowed to execute.
+func PeerDASEnabled() bool {
+	return BeaconConfig().Eip7594ForkEpoch < math.MaxUint64
+}
+
 // WithinDAPeriod checks if the block epoch is within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS of the given current epoch.
 func WithinDAPeriod(block, current primitives.Epoch) bool {
 	return block+BeaconConfig().MinEpochsForBlobsSidecarsRequest >= current

config/params/loader_test.go

@@ -25,12 +25,10 @@ import (
 // IMPORTANT: Use one field per line and sort these alphabetically to reduce conflicts.
 var placeholderFields = []string{
 	"BYTES_PER_LOGS_BLOOM", // Compile time constant on ExecutionPayload.logs_bloom.
-	"CUSTODY_REQUIREMENT",
 	"EIP6110_FORK_EPOCH",
 	"EIP6110_FORK_VERSION",
 	"EIP7002_FORK_EPOCH",
 	"EIP7002_FORK_VERSION",
-	"EIP7594_FORK_EPOCH",
 	"EIP7594_FORK_VERSION",
 	"EIP7732_FORK_EPOCH",
 	"EIP7732_FORK_VERSION",
@@ -43,7 +41,6 @@ var placeholderFields = []string{
 	"MAX_REQUEST_PAYLOADS",           // Compile time constant on BeaconBlockBody.ExecutionRequests
 	"MAX_TRANSACTIONS_PER_PAYLOAD",   // Compile time constant on ExecutionPayload.transactions.
 	"REORG_HEAD_WEIGHT_THRESHOLD",
-	"SAMPLES_PER_SLOT",
 	"TARGET_NUMBER_OF_PEERS",
 	"UPDATE_TIMEOUT",
 	"WHISK_EPOCHS_PER_SHUFFLING_PHASE",

config/params/mainnet_config.go

@@ -216,6 +216,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	DenebForkEpoch:       mainnetDenebForkEpoch,
 	ElectraForkVersion:   []byte{5, 0, 0, 0},
 	ElectraForkEpoch:     mainnetElectraForkEpoch,
+	Eip7594ForkEpoch:     math.MaxUint64,
 
 	// New values introduced in Altair hard fork 1.
 	// Participation flag indices.
@@ -295,8 +296,11 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	UnsetDepositRequestsStartIndex:        math.MaxUint64,
 
 	// PeerDAS
-	NumberOfColumns:          128,
-	MaxCellsInExtendedMatrix: 768,
+	NumberOfColumns:                       128,
+	MaxCellsInExtendedMatrix:              768,
+	SamplesPerSlot:                        8,
+	CustodyRequirement:                    4,
+	MinEpochsForDataColumnSidecarsRequest: 4096,
 
 	// Values related to networking parameters.
 	GossipMaxSize:                   10 * 1 << 20, // 10 MiB

consensus-types/interfaces/light_client.go

@@ -5,15 +5,18 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"google.golang.org/protobuf/proto"
 )
 
 type LightClientExecutionBranch = [fieldparams.ExecutionBranchDepth][fieldparams.RootLength]byte
 type LightClientSyncCommitteeBranch = [fieldparams.SyncCommitteeBranchDepth][fieldparams.RootLength]byte
 type LightClientSyncCommitteeBranchElectra = [fieldparams.SyncCommitteeBranchDepthElectra][fieldparams.RootLength]byte
 type LightClientFinalityBranch = [fieldparams.FinalityBranchDepth][fieldparams.RootLength]byte
+type LightClientFinalityBranchElectra = [fieldparams.FinalityBranchDepthElectra][fieldparams.RootLength]byte
 
 type LightClientHeader interface {
 	ssz.Marshaler
+	Proto() proto.Message
 	Version() int
 	Beacon() *pb.BeaconBlockHeader
 	Execution() (ExecutionData, error)
@@ -31,29 +34,41 @@ type LightClientBootstrap interface {
 
 type LightClientUpdate interface {
 	ssz.Marshaler
+	Proto() proto.Message
 	Version() int
 	AttestedHeader() LightClientHeader
+	SetAttestedHeader(header LightClientHeader) error
 	NextSyncCommittee() *pb.SyncCommittee
+	SetNextSyncCommittee(sc *pb.SyncCommittee)
 	NextSyncCommitteeBranch() (LightClientSyncCommitteeBranch, error)
+	SetNextSyncCommitteeBranch(branch [][]byte) error
 	NextSyncCommitteeBranchElectra() (LightClientSyncCommitteeBranchElectra, error)
 	FinalizedHeader() LightClientHeader
-	FinalityBranch() LightClientFinalityBranch
+	SetFinalizedHeader(header LightClientHeader) error
+	FinalityBranch() (LightClientFinalityBranch, error)
+	FinalityBranchElectra() (LightClientFinalityBranchElectra, error)
+	SetFinalityBranch(branch [][]byte) error
 	SyncAggregate() *pb.SyncAggregate
+	SetSyncAggregate(sa *pb.SyncAggregate)
 	SignatureSlot() primitives.Slot
+	SetSignatureSlot(slot primitives.Slot)
 }
 
 type LightClientFinalityUpdate interface {
 	ssz.Marshaler
+	Proto() proto.Message
 	Version() int
 	AttestedHeader() LightClientHeader
 	FinalizedHeader() LightClientHeader
-	FinalityBranch() LightClientFinalityBranch
+	FinalityBranch() (LightClientFinalityBranch, error)
+	FinalityBranchElectra() (LightClientFinalityBranchElectra, error)
 	SyncAggregate() *pb.SyncAggregate
 	SignatureSlot() primitives.Slot
 }
 
 type LightClientOptimisticUpdate interface {
 	ssz.Marshaler
+	Proto() proto.Message
 	Version() int
 	AttestedHeader() LightClientHeader
 	SyncAggregate() *pb.SyncAggregate

consensus-types/light-client/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//config/fieldparams:go_default_library",
+        "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
@@ -21,6 +22,7 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

consensus-types/light-client/bootstrap.go

@@ -41,7 +41,7 @@ func NewWrappedBootstrapAltair(p *pb.LightClientBootstrapAltair) (interfaces.Lig
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderAltair(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}
@@ -105,7 +105,7 @@ func NewWrappedBootstrapCapella(p *pb.LightClientBootstrapCapella) (interfaces.L
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderCapella(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}
@@ -169,7 +169,7 @@ func NewWrappedBootstrapDeneb(p *pb.LightClientBootstrapDeneb) (interfaces.Light
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderDeneb(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}
@@ -233,7 +233,7 @@ func NewWrappedBootstrapElectra(p *pb.LightClientBootstrapElectra) (interfaces.L
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderDeneb(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}

consensus-types/light-client/finality_update.go

@@ -23,11 +23,72 @@ func NewWrappedFinalityUpdate(m proto.Message) (interfaces.LightClientFinalityUp
 		return NewWrappedFinalityUpdateCapella(t)
 	case *pb.LightClientFinalityUpdateDeneb:
 		return NewWrappedFinalityUpdateDeneb(t)
+	case *pb.LightClientFinalityUpdateElectra:
+		return NewWrappedFinalityUpdateElectra(t)
 	default:
 		return nil, fmt.Errorf("cannot construct light client finality update from type %T", t)
 	}
 }
 
+func NewFinalityUpdateFromUpdate(update interfaces.LightClientUpdate) (interfaces.LightClientFinalityUpdate, error) {
+	switch t := update.(type) {
+	case *updateAltair:
+		return &finalityUpdateAltair{
+			p: &pb.LightClientFinalityUpdateAltair{
+				AttestedHeader:  t.p.AttestedHeader,
+				FinalizedHeader: t.p.FinalizedHeader,
+				FinalityBranch:  t.p.FinalityBranch,
+				SyncAggregate:   t.p.SyncAggregate,
+				SignatureSlot:   t.p.SignatureSlot,
+			},
+			attestedHeader:  t.attestedHeader,
+			finalizedHeader: t.finalizedHeader,
+			finalityBranch:  t.finalityBranch,
+		}, nil
+	case *updateCapella:
+		return &finalityUpdateCapella{
+			p: &pb.LightClientFinalityUpdateCapella{
+				AttestedHeader:  t.p.AttestedHeader,
+				FinalizedHeader: t.p.FinalizedHeader,
+				FinalityBranch:  t.p.FinalityBranch,
+				SyncAggregate:   t.p.SyncAggregate,
+				SignatureSlot:   t.p.SignatureSlot,
+			},
+			attestedHeader:  t.attestedHeader,
+			finalizedHeader: t.finalizedHeader,
+			finalityBranch:  t.finalityBranch,
+		}, nil
+	case *updateDeneb:
+		return &finalityUpdateDeneb{
+			p: &pb.LightClientFinalityUpdateDeneb{
+				AttestedHeader:  t.p.AttestedHeader,
+				FinalizedHeader: t.p.FinalizedHeader,
+				FinalityBranch:  t.p.FinalityBranch,
+				SyncAggregate:   t.p.SyncAggregate,
+				SignatureSlot:   t.p.SignatureSlot,
+			},
+			attestedHeader:  t.attestedHeader,
+			finalizedHeader: t.finalizedHeader,
+			finalityBranch:  t.finalityBranch,
+		}, nil
+	case *updateElectra:
+		return &finalityUpdateElectra{
+			p: &pb.LightClientFinalityUpdateElectra{
+				AttestedHeader:  t.p.AttestedHeader,
+				FinalizedHeader: t.p.FinalizedHeader,
+				FinalityBranch:  t.p.FinalityBranch,
+				SyncAggregate:   t.p.SyncAggregate,
+				SignatureSlot:   t.p.SignatureSlot,
+			},
+			attestedHeader:  t.attestedHeader,
+			finalizedHeader: t.finalizedHeader,
+			finalityBranch:  t.finalityBranch,
+		}, nil
+	default:
+		return nil, fmt.Errorf("unsupported type %T", t)
+	}
+}
+
 type finalityUpdateAltair struct {
 	p               *pb.LightClientFinalityUpdateAltair
 	attestedHeader  interfaces.LightClientHeader
@@ -41,11 +102,11 @@ func NewWrappedFinalityUpdateAltair(p *pb.LightClientFinalityUpdateAltair) (inte
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	attestedHeader, err := NewWrappedHeaderAltair(p.AttestedHeader)
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
 	if err != nil {
 		return nil, err
 	}
-	finalizedHeader, err := NewWrappedHeaderAltair(p.FinalizedHeader)
+	finalizedHeader, err := NewWrappedHeader(p.FinalizedHeader)
 	if err != nil {
 		return nil, err
 	}
@@ -78,6 +139,10 @@ func (u *finalityUpdateAltair) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
+func (u *finalityUpdateAltair) Proto() proto.Message {
+	return u.p
+}
+
 func (u *finalityUpdateAltair) Version() int {
 	return version.Altair
 }
@@ -90,8 +155,12 @@ func (u *finalityUpdateAltair) FinalizedHeader() interfaces.LightClientHeader {
 	return u.finalizedHeader
 }
 
-func (u *finalityUpdateAltair) FinalityBranch() interfaces.LightClientFinalityBranch {
-	return u.finalityBranch
+func (u *finalityUpdateAltair) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return u.finalityBranch, nil
+}
+
+func (u *finalityUpdateAltair) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return interfaces.LightClientFinalityBranchElectra{}, consensustypes.ErrNotSupported("FinalityBranchElectra", u.Version())
 }
 
 func (u *finalityUpdateAltair) SyncAggregate() *pb.SyncAggregate {
@@ -115,11 +184,11 @@ func NewWrappedFinalityUpdateCapella(p *pb.LightClientFinalityUpdateCapella) (in
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	attestedHeader, err := NewWrappedHeaderCapella(p.AttestedHeader)
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
 	if err != nil {
 		return nil, err
 	}
-	finalizedHeader, err := NewWrappedHeaderCapella(p.FinalizedHeader)
+	finalizedHeader, err := NewWrappedHeader(p.FinalizedHeader)
 	if err != nil {
 		return nil, err
 	}
@@ -152,6 +221,10 @@ func (u *finalityUpdateCapella) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
+func (u *finalityUpdateCapella) Proto() proto.Message {
+	return u.p
+}
+
 func (u *finalityUpdateCapella) Version() int {
 	return version.Capella
 }
@@ -164,8 +237,12 @@ func (u *finalityUpdateCapella) FinalizedHeader() interfaces.LightClientHeader {
 	return u.finalizedHeader
 }
 
-func (u *finalityUpdateCapella) FinalityBranch() interfaces.LightClientFinalityBranch {
-	return u.finalityBranch
+func (u *finalityUpdateCapella) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return u.finalityBranch, nil
+}
+
+func (u *finalityUpdateCapella) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return interfaces.LightClientFinalityBranchElectra{}, consensustypes.ErrNotSupported("FinalityBranchElectra", u.Version())
 }
 
 func (u *finalityUpdateCapella) SyncAggregate() *pb.SyncAggregate {
@@ -189,11 +266,11 @@ func NewWrappedFinalityUpdateDeneb(p *pb.LightClientFinalityUpdateDeneb) (interf
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	attestedHeader, err := NewWrappedHeaderDeneb(p.AttestedHeader)
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
 	if err != nil {
 		return nil, err
 	}
-	finalizedHeader, err := NewWrappedHeaderDeneb(p.FinalizedHeader)
+	finalizedHeader, err := NewWrappedHeader(p.FinalizedHeader)
 	if err != nil {
 		return nil, err
 	}
@@ -226,6 +303,10 @@ func (u *finalityUpdateDeneb) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
+func (u *finalityUpdateDeneb) Proto() proto.Message {
+	return u.p
+}
+
 func (u *finalityUpdateDeneb) Version() int {
 	return version.Deneb
 }
@@ -238,8 +319,12 @@ func (u *finalityUpdateDeneb) FinalizedHeader() interfaces.LightClientHeader {
 	return u.finalizedHeader
 }
 
-func (u *finalityUpdateDeneb) FinalityBranch() interfaces.LightClientFinalityBranch {
-	return u.finalityBranch
+func (u *finalityUpdateDeneb) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return u.finalityBranch, nil
+}
+
+func (u *finalityUpdateDeneb) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return interfaces.LightClientFinalityBranchElectra{}, consensustypes.ErrNotSupported("FinalityBranchElectra", u.Version())
 }
 
 func (u *finalityUpdateDeneb) SyncAggregate() *pb.SyncAggregate {
@@ -249,3 +334,86 @@ func (u *finalityUpdateDeneb) SyncAggregate() *pb.SyncAggregate {
 func (u *finalityUpdateDeneb) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
+
+type finalityUpdateElectra struct {
+	p               *pb.LightClientFinalityUpdateElectra
+	attestedHeader  interfaces.LightClientHeader
+	finalizedHeader interfaces.LightClientHeader
+	finalityBranch  interfaces.LightClientFinalityBranchElectra
+}
+
+var _ interfaces.LightClientFinalityUpdate = &finalityUpdateElectra{}
+
+func NewWrappedFinalityUpdateElectra(p *pb.LightClientFinalityUpdateElectra) (interfaces.LightClientFinalityUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeader(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	finalityBranch, err := createBranch[interfaces.LightClientFinalityBranchElectra](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepthElectra,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &finalityUpdateElectra{
+		p:               p,
+		attestedHeader:  attestedHeader,
+		finalizedHeader: finalizedHeader,
+		finalityBranch:  finalityBranch,
+	}, nil
+}
+
+func (u *finalityUpdateElectra) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *finalityUpdateElectra) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *finalityUpdateElectra) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *finalityUpdateElectra) Proto() proto.Message {
+	return u.p
+}
+
+func (u *finalityUpdateElectra) Version() int {
+	return version.Electra
+}
+
+func (u *finalityUpdateElectra) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *finalityUpdateElectra) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *finalityUpdateElectra) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return interfaces.LightClientFinalityBranch{}, consensustypes.ErrNotSupported("FinalityBranch", u.Version())
+}
+
+func (u *finalityUpdateElectra) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return u.finalityBranch, nil
+}
+
+func (u *finalityUpdateElectra) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *finalityUpdateElectra) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}

consensus-types/light-client/header.go

@@ -4,11 +4,13 @@ import (
 	"fmt"
 
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -22,6 +24,9 @@ func NewWrappedHeader(m proto.Message) (interfaces.LightClientHeader, error) {
 	case *pb.LightClientHeaderCapella:
 		return NewWrappedHeaderCapella(t)
 	case *pb.LightClientHeaderDeneb:
+		if slots.ToEpoch(t.Beacon.Slot) >= params.BeaconConfig().ElectraForkEpoch {
+			return NewWrappedHeaderElectra(t)
+		}
 		return NewWrappedHeaderDeneb(t)
 	default:
 		return nil, fmt.Errorf("cannot construct light client header from type %T", t)
@@ -53,6 +58,10 @@ func (h *headerAltair) SizeSSZ() int {
 	return h.p.SizeSSZ()
 }
 
+func (h *headerAltair) Proto() proto.Message {
+	return h.p
+}
+
 func (h *headerAltair) Version() int {
 	return version.Altair
 }
@@ -62,11 +71,11 @@ func (h *headerAltair) Beacon() *pb.BeaconBlockHeader {
 }
 
 func (h *headerAltair) Execution() (interfaces.ExecutionData, error) {
-	return nil, consensustypes.ErrNotSupported("Execution", version.Altair)
+	return nil, consensustypes.ErrNotSupported("Execution", h.Version())
 }
 
 func (h *headerAltair) ExecutionBranch() (interfaces.LightClientExecutionBranch, error) {
-	return interfaces.LightClientExecutionBranch{}, consensustypes.ErrNotSupported("ExecutionBranch", version.Altair)
+	return interfaces.LightClientExecutionBranch{}, consensustypes.ErrNotSupported("ExecutionBranch", h.Version())
 }
 
 type headerCapella struct {
@@ -114,6 +123,10 @@ func (h *headerCapella) SizeSSZ() int {
 	return h.p.SizeSSZ()
 }
 
+func (h *headerCapella) Proto() proto.Message {
+	return h.p
+}
+
 func (h *headerCapella) Version() int {
 	return version.Capella
 }
@@ -175,6 +188,10 @@ func (h *headerDeneb) SizeSSZ() int {
 	return h.p.SizeSSZ()
 }
 
+func (h *headerDeneb) Proto() proto.Message {
+	return h.p
+}
+
 func (h *headerDeneb) Version() int {
 	return version.Deneb
 }
@@ -190,3 +207,68 @@ func (h *headerDeneb) Execution() (interfaces.ExecutionData, error) {
 func (h *headerDeneb) ExecutionBranch() (interfaces.LightClientExecutionBranch, error) {
 	return h.executionBranch, nil
 }
+
+type headerElectra struct {
+	p               *pb.LightClientHeaderDeneb
+	execution       interfaces.ExecutionData
+	executionBranch interfaces.LightClientExecutionBranch
+}
+
+var _ interfaces.LightClientHeader = &headerElectra{}
+
+func NewWrappedHeaderElectra(p *pb.LightClientHeaderDeneb) (interfaces.LightClientHeader, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	execution, err := blocks.WrappedExecutionPayloadHeaderDeneb(p.Execution)
+	if err != nil {
+		return nil, err
+	}
+
+	branch, err := createBranch[interfaces.LightClientExecutionBranch](
+		"execution",
+		p.ExecutionBranch,
+		fieldparams.ExecutionBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &headerElectra{
+		p:               p,
+		execution:       execution,
+		executionBranch: branch,
+	}, nil
+}
+
+func (h *headerElectra) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *headerElectra) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *headerElectra) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *headerElectra) Proto() proto.Message {
+	return h.p
+}
+
+func (h *headerElectra) Version() int {
+	return version.Electra
+}
+
+func (h *headerElectra) Beacon() *pb.BeaconBlockHeader {
+	return h.p.Beacon
+}
+
+func (h *headerElectra) Execution() (interfaces.ExecutionData, error) {
+	return h.execution, nil
+}
+
+func (h *headerElectra) ExecutionBranch() (interfaces.LightClientExecutionBranch, error) {
+	return h.executionBranch, nil
+}

consensus-types/light-client/helpers.go

@@ -4,12 +4,11 @@ import (
 	"fmt"
 
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 )
 
 type branchConstraint interface {
-	~interfaces.LightClientExecutionBranch | ~interfaces.LightClientSyncCommitteeBranch | ~interfaces.LightClientFinalityBranch
+	[4][fieldparams.RootLength]byte | [5][fieldparams.RootLength]byte | [6][fieldparams.RootLength]byte | [7][fieldparams.RootLength]byte
 }
 
 func createBranch[T branchConstraint](name string, input [][]byte, depth int) (T, error) {

consensus-types/light-client/optimistic_update.go

@@ -27,12 +27,55 @@ func NewWrappedOptimisticUpdate(m proto.Message) (interfaces.LightClientOptimist
 	}
 }
 
-type OptimisticUpdateAltair struct {
+func NewOptimisticUpdateFromUpdate(update interfaces.LightClientUpdate) (interfaces.LightClientOptimisticUpdate, error) {
+	switch t := update.(type) {
+	case *updateAltair:
+		return &optimisticUpdateAltair{
+			p: &pb.LightClientOptimisticUpdateAltair{
+				AttestedHeader: t.p.AttestedHeader,
+				SyncAggregate:  t.p.SyncAggregate,
+				SignatureSlot:  t.p.SignatureSlot,
+			},
+			attestedHeader: t.attestedHeader,
+		}, nil
+	case *updateCapella:
+		return &optimisticUpdateCapella{
+			p: &pb.LightClientOptimisticUpdateCapella{
+				AttestedHeader: t.p.AttestedHeader,
+				SyncAggregate:  t.p.SyncAggregate,
+				SignatureSlot:  t.p.SignatureSlot,
+			},
+			attestedHeader: t.attestedHeader,
+		}, nil
+	case *updateDeneb:
+		return &optimisticUpdateDeneb{
+			p: &pb.LightClientOptimisticUpdateDeneb{
+				AttestedHeader: t.p.AttestedHeader,
+				SyncAggregate:  t.p.SyncAggregate,
+				SignatureSlot:  t.p.SignatureSlot,
+			},
+			attestedHeader: t.attestedHeader,
+		}, nil
+	case *updateElectra:
+		return &optimisticUpdateDeneb{
+			p: &pb.LightClientOptimisticUpdateDeneb{
+				AttestedHeader: t.p.AttestedHeader,
+				SyncAggregate:  t.p.SyncAggregate,
+				SignatureSlot:  t.p.SignatureSlot,
+			},
+			attestedHeader: t.attestedHeader,
+		}, nil
+	default:
+		return nil, fmt.Errorf("unsupported type %T", t)
+	}
+}
+
+type optimisticUpdateAltair struct {
 	p              *pb.LightClientOptimisticUpdateAltair
 	attestedHeader interfaces.LightClientHeader
 }
 
-var _ interfaces.LightClientOptimisticUpdate = &OptimisticUpdateAltair{}
+var _ interfaces.LightClientOptimisticUpdate = &optimisticUpdateAltair{}
 
 func NewWrappedOptimisticUpdateAltair(p *pb.LightClientOptimisticUpdateAltair) (interfaces.LightClientOptimisticUpdate, error) {
 	if p == nil {
@@ -43,46 +86,50 @@ func NewWrappedOptimisticUpdateAltair(p *pb.LightClientOptimisticUpdateAltair) (
 		return nil, err
 	}
 
-	return &OptimisticUpdateAltair{
+	return &optimisticUpdateAltair{
 		p:              p,
 		attestedHeader: attestedHeader,
 	}, nil
 }
 
-func (u *OptimisticUpdateAltair) MarshalSSZTo(dst []byte) ([]byte, error) {
+func (u *optimisticUpdateAltair) MarshalSSZTo(dst []byte) ([]byte, error) {
 	return u.p.MarshalSSZTo(dst)
 }
 
-func (u *OptimisticUpdateAltair) MarshalSSZ() ([]byte, error) {
+func (u *optimisticUpdateAltair) MarshalSSZ() ([]byte, error) {
 	return u.p.MarshalSSZ()
 }
 
-func (u *OptimisticUpdateAltair) SizeSSZ() int {
+func (u *optimisticUpdateAltair) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
-func (u *OptimisticUpdateAltair) Version() int {
+func (u *optimisticUpdateAltair) Proto() proto.Message {
+	return u.p
+}
+
+func (u *optimisticUpdateAltair) Version() int {
 	return version.Altair
 }
 
-func (u *OptimisticUpdateAltair) AttestedHeader() interfaces.LightClientHeader {
+func (u *optimisticUpdateAltair) AttestedHeader() interfaces.LightClientHeader {
 	return u.attestedHeader
 }
 
-func (u *OptimisticUpdateAltair) SyncAggregate() *pb.SyncAggregate {
+func (u *optimisticUpdateAltair) SyncAggregate() *pb.SyncAggregate {
 	return u.p.SyncAggregate
 }
 
-func (u *OptimisticUpdateAltair) SignatureSlot() primitives.Slot {
+func (u *optimisticUpdateAltair) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
 
-type OptimisticUpdateCapella struct {
+type optimisticUpdateCapella struct {
 	p              *pb.LightClientOptimisticUpdateCapella
 	attestedHeader interfaces.LightClientHeader
 }
 
-var _ interfaces.LightClientOptimisticUpdate = &OptimisticUpdateCapella{}
+var _ interfaces.LightClientOptimisticUpdate = &optimisticUpdateCapella{}
 
 func NewWrappedOptimisticUpdateCapella(p *pb.LightClientOptimisticUpdateCapella) (interfaces.LightClientOptimisticUpdate, error) {
 	if p == nil {
@@ -93,46 +140,50 @@ func NewWrappedOptimisticUpdateCapella(p *pb.LightClientOptimisticUpdateCapella)
 		return nil, err
 	}
 
-	return &OptimisticUpdateCapella{
+	return &optimisticUpdateCapella{
 		p:              p,
 		attestedHeader: attestedHeader,
 	}, nil
 }
 
-func (u *OptimisticUpdateCapella) MarshalSSZTo(dst []byte) ([]byte, error) {
+func (u *optimisticUpdateCapella) MarshalSSZTo(dst []byte) ([]byte, error) {
 	return u.p.MarshalSSZTo(dst)
 }
 
-func (u *OptimisticUpdateCapella) MarshalSSZ() ([]byte, error) {
+func (u *optimisticUpdateCapella) MarshalSSZ() ([]byte, error) {
 	return u.p.MarshalSSZ()
 }
 
-func (u *OptimisticUpdateCapella) SizeSSZ() int {
+func (u *optimisticUpdateCapella) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
-func (u *OptimisticUpdateCapella) Version() int {
+func (u *optimisticUpdateCapella) Proto() proto.Message {
+	return u.p
+}
+
+func (u *optimisticUpdateCapella) Version() int {
 	return version.Capella
 }
 
-func (u *OptimisticUpdateCapella) AttestedHeader() interfaces.LightClientHeader {
+func (u *optimisticUpdateCapella) AttestedHeader() interfaces.LightClientHeader {
 	return u.attestedHeader
 }
 
-func (u *OptimisticUpdateCapella) SyncAggregate() *pb.SyncAggregate {
+func (u *optimisticUpdateCapella) SyncAggregate() *pb.SyncAggregate {
 	return u.p.SyncAggregate
 }
 
-func (u *OptimisticUpdateCapella) SignatureSlot() primitives.Slot {
+func (u *optimisticUpdateCapella) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
 
-type OptimisticUpdateDeneb struct {
+type optimisticUpdateDeneb struct {
 	p              *pb.LightClientOptimisticUpdateDeneb
 	attestedHeader interfaces.LightClientHeader
 }
 
-var _ interfaces.LightClientOptimisticUpdate = &OptimisticUpdateDeneb{}
+var _ interfaces.LightClientOptimisticUpdate = &optimisticUpdateDeneb{}
 
 func NewWrappedOptimisticUpdateDeneb(p *pb.LightClientOptimisticUpdateDeneb) (interfaces.LightClientOptimisticUpdate, error) {
 	if p == nil {
@@ -143,36 +194,40 @@ func NewWrappedOptimisticUpdateDeneb(p *pb.LightClientOptimisticUpdateDeneb) (in
 		return nil, err
 	}
 
-	return &OptimisticUpdateDeneb{
+	return &optimisticUpdateDeneb{
 		p:              p,
 		attestedHeader: attestedHeader,
 	}, nil
 }
 
-func (u *OptimisticUpdateDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+func (u *optimisticUpdateDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
 	return u.p.MarshalSSZTo(dst)
 }
 
-func (u *OptimisticUpdateDeneb) MarshalSSZ() ([]byte, error) {
+func (u *optimisticUpdateDeneb) MarshalSSZ() ([]byte, error) {
 	return u.p.MarshalSSZ()
 }
 
-func (u *OptimisticUpdateDeneb) SizeSSZ() int {
+func (u *optimisticUpdateDeneb) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
-func (u *OptimisticUpdateDeneb) Version() int {
+func (u *optimisticUpdateDeneb) Proto() proto.Message {
+	return u.p
+}
+
+func (u *optimisticUpdateDeneb) Version() int {
 	return version.Deneb
 }
 
-func (u *OptimisticUpdateDeneb) AttestedHeader() interfaces.LightClientHeader {
+func (u *optimisticUpdateDeneb) AttestedHeader() interfaces.LightClientHeader {
 	return u.attestedHeader
 }
 
-func (u *OptimisticUpdateDeneb) SyncAggregate() *pb.SyncAggregate {
+func (u *optimisticUpdateDeneb) SyncAggregate() *pb.SyncAggregate {
 	return u.p.SyncAggregate
 }
 
-func (u *OptimisticUpdateDeneb) SignatureSlot() primitives.Slot {
+func (u *optimisticUpdateDeneb) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }

consensus-types/light-client/update.go

@@ -23,11 +23,17 @@ func NewWrappedUpdate(m proto.Message) (interfaces.LightClientUpdate, error) {
 		return NewWrappedUpdateCapella(t)
 	case *pb.LightClientUpdateDeneb:
 		return NewWrappedUpdateDeneb(t)
+	case *pb.LightClientUpdateElectra:
+		return NewWrappedUpdateElectra(t)
 	default:
 		return nil, fmt.Errorf("cannot construct light client update from type %T", t)
 	}
 }
 
+// In addition to the proto object being wrapped, we store some fields that have to be
+// constructed from the proto, so that we don't have to reconstruct them every time
+// in getters.
+
 type updateAltair struct {
 	p                       *pb.LightClientUpdateAltair
 	attestedHeader          interfaces.LightClientHeader
@@ -42,14 +48,20 @@ func NewWrappedUpdateAltair(p *pb.LightClientUpdateAltair) (interfaces.LightClie
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	attestedHeader, err := NewWrappedHeaderAltair(p.AttestedHeader)
+
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
 	if err != nil {
 		return nil, err
 	}
-	finalizedHeader, err := NewWrappedHeaderAltair(p.FinalizedHeader)
-	if err != nil {
-		return nil, err
+
+	var finalizedHeader interfaces.LightClientHeader
+	if p.FinalizedHeader != nil {
+		finalizedHeader, err = NewWrappedHeader(p.FinalizedHeader)
+		if err != nil {
+			return nil, err
+		}
 	}
+
 	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
 		"sync committee",
 		p.NextSyncCommitteeBranch,
@@ -88,6 +100,10 @@ func (u *updateAltair) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
+func (u *updateAltair) Proto() proto.Message {
+	return u.p
+}
+
 func (u *updateAltair) Version() int {
 	return version.Altair
 }
@@ -96,14 +112,40 @@ func (u *updateAltair) AttestedHeader() interfaces.LightClientHeader {
 	return u.attestedHeader
 }
 
+func (u *updateAltair) SetAttestedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderAltair)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderAltair{})
+	}
+	u.p.AttestedHeader = proto
+	u.attestedHeader = header
+	return nil
+}
+
 func (u *updateAltair) NextSyncCommittee() *pb.SyncCommittee {
 	return u.p.NextSyncCommittee
 }
 
+func (u *updateAltair) SetNextSyncCommittee(sc *pb.SyncCommittee) {
+	u.p.NextSyncCommittee = sc
+}
+
 func (u *updateAltair) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
 	return u.nextSyncCommitteeBranch, nil
 }
 
+func (u *updateAltair) SetNextSyncCommitteeBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientSyncCommitteeBranch]("sync committee", branch, fieldparams.SyncCommitteeBranchDepth)
+	if err != nil {
+		return err
+	}
+	u.nextSyncCommitteeBranch = b
+
+	u.p.NextSyncCommitteeBranch = branch
+
+	return nil
+}
+
 func (u *updateAltair) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
 	return [6][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranchElectra", version.Altair)
 }
@@ -112,18 +154,53 @@ func (u *updateAltair) FinalizedHeader() interfaces.LightClientHeader {
 	return u.finalizedHeader
 }
 
-func (u *updateAltair) FinalityBranch() interfaces.LightClientFinalityBranch {
-	return u.finalityBranch
+func (u *updateAltair) SetFinalizedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderAltair)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderAltair{})
+	}
+	u.p.FinalizedHeader = proto
+	u.finalizedHeader = header
+	return nil
+}
+
+func (u *updateAltair) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return u.finalityBranch, nil
+}
+
+func (u *updateAltair) SetFinalityBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientFinalityBranch]("finality", branch, fieldparams.FinalityBranchDepth)
+	if err != nil {
+		return err
+	}
+	u.finalityBranch = b
+	u.p.FinalityBranch = branch
+	return nil
+}
+
+func (u *updateAltair) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return interfaces.LightClientFinalityBranchElectra{}, consensustypes.ErrNotSupported("FinalityBranchElectra", version.Altair)
 }
 
 func (u *updateAltair) SyncAggregate() *pb.SyncAggregate {
 	return u.p.SyncAggregate
 }
 
+func (u *updateAltair) SetSyncAggregate(sa *pb.SyncAggregate) {
+	u.p.SyncAggregate = sa
+}
+
 func (u *updateAltair) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
 
+func (u *updateAltair) SetSignatureSlot(slot primitives.Slot) {
+	u.p.SignatureSlot = slot
+}
+
+// In addition to the proto object being wrapped, we store some fields that have to be
+// constructed from the proto, so that we don't have to reconstruct them every time
+// in getters.
 type updateCapella struct {
 	p                       *pb.LightClientUpdateCapella
 	attestedHeader          interfaces.LightClientHeader
@@ -138,14 +215,20 @@ func NewWrappedUpdateCapella(p *pb.LightClientUpdateCapella) (interfaces.LightCl
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	attestedHeader, err := NewWrappedHeaderCapella(p.AttestedHeader)
+
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
 	if err != nil {
 		return nil, err
 	}
-	finalizedHeader, err := NewWrappedHeaderCapella(p.FinalizedHeader)
-	if err != nil {
-		return nil, err
+
+	var finalizedHeader interfaces.LightClientHeader
+	if p.FinalizedHeader != nil {
+		finalizedHeader, err = NewWrappedHeader(p.FinalizedHeader)
+		if err != nil {
+			return nil, err
+		}
 	}
+
 	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
 		"sync committee",
 		p.NextSyncCommitteeBranch,
@@ -184,6 +267,10 @@ func (u *updateCapella) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
+func (u *updateCapella) Proto() proto.Message {
+	return u.p
+}
+
 func (u *updateCapella) Version() int {
 	return version.Capella
 }
@@ -192,14 +279,40 @@ func (u *updateCapella) AttestedHeader() interfaces.LightClientHeader {
 	return u.attestedHeader
 }
 
+func (u *updateCapella) SetAttestedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderCapella)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderCapella{})
+	}
+	u.p.AttestedHeader = proto
+	u.attestedHeader = header
+	return nil
+}
+
 func (u *updateCapella) NextSyncCommittee() *pb.SyncCommittee {
 	return u.p.NextSyncCommittee
 }
 
+func (u *updateCapella) SetNextSyncCommittee(sc *pb.SyncCommittee) {
+	u.p.NextSyncCommittee = sc
+}
+
 func (u *updateCapella) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
 	return u.nextSyncCommitteeBranch, nil
 }
 
+func (u *updateCapella) SetNextSyncCommitteeBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientSyncCommitteeBranch]("sync committee", branch, fieldparams.SyncCommitteeBranchDepth)
+	if err != nil {
+		return err
+	}
+	u.nextSyncCommitteeBranch = b
+
+	u.p.NextSyncCommitteeBranch = branch
+
+	return nil
+}
+
 func (u *updateCapella) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
 	return [6][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranchElectra", version.Capella)
 }
@@ -208,18 +321,53 @@ func (u *updateCapella) FinalizedHeader() interfaces.LightClientHeader {
 	return u.finalizedHeader
 }
 
-func (u *updateCapella) FinalityBranch() interfaces.LightClientFinalityBranch {
-	return u.finalityBranch
+func (u *updateCapella) SetFinalizedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderCapella)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderCapella{})
+	}
+	u.p.FinalizedHeader = proto
+	u.finalizedHeader = header
+	return nil
+}
+
+func (u *updateCapella) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return u.finalityBranch, nil
+}
+
+func (u *updateCapella) SetFinalityBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientFinalityBranch]("finality", branch, fieldparams.FinalityBranchDepth)
+	if err != nil {
+		return err
+	}
+	u.finalityBranch = b
+	u.p.FinalityBranch = branch
+	return nil
+}
+
+func (u *updateCapella) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return interfaces.LightClientFinalityBranchElectra{}, consensustypes.ErrNotSupported("FinalityBranchElectra", u.Version())
 }
 
 func (u *updateCapella) SyncAggregate() *pb.SyncAggregate {
 	return u.p.SyncAggregate
 }
 
+func (u *updateCapella) SetSyncAggregate(sa *pb.SyncAggregate) {
+	u.p.SyncAggregate = sa
+}
+
 func (u *updateCapella) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
 
+func (u *updateCapella) SetSignatureSlot(slot primitives.Slot) {
+	u.p.SignatureSlot = slot
+}
+
+// In addition to the proto object being wrapped, we store some fields that have to be
+// constructed from the proto, so that we don't have to reconstruct them every time
+// in getters.
 type updateDeneb struct {
 	p                       *pb.LightClientUpdateDeneb
 	attestedHeader          interfaces.LightClientHeader
@@ -234,14 +382,20 @@ func NewWrappedUpdateDeneb(p *pb.LightClientUpdateDeneb) (interfaces.LightClient
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	attestedHeader, err := NewWrappedHeaderDeneb(p.AttestedHeader)
+
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
 	if err != nil {
 		return nil, err
 	}
-	finalizedHeader, err := NewWrappedHeaderDeneb(p.FinalizedHeader)
-	if err != nil {
-		return nil, err
+
+	var finalizedHeader interfaces.LightClientHeader
+	if p.FinalizedHeader != nil {
+		finalizedHeader, err = NewWrappedHeader(p.FinalizedHeader)
+		if err != nil {
+			return nil, err
+		}
 	}
+
 	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
 		"sync committee",
 		p.NextSyncCommitteeBranch,
@@ -280,6 +434,10 @@ func (u *updateDeneb) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
+func (u *updateDeneb) Proto() proto.Message {
+	return u.p
+}
+
 func (u *updateDeneb) Version() int {
 	return version.Deneb
 }
@@ -288,14 +446,40 @@ func (u *updateDeneb) AttestedHeader() interfaces.LightClientHeader {
 	return u.attestedHeader
 }
 
+func (u *updateDeneb) SetAttestedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderDeneb)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderDeneb{})
+	}
+	u.p.AttestedHeader = proto
+	u.attestedHeader = header
+	return nil
+}
+
 func (u *updateDeneb) NextSyncCommittee() *pb.SyncCommittee {
 	return u.p.NextSyncCommittee
 }
 
+func (u *updateDeneb) SetNextSyncCommittee(sc *pb.SyncCommittee) {
+	u.p.NextSyncCommittee = sc
+}
+
 func (u *updateDeneb) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
 	return u.nextSyncCommitteeBranch, nil
 }
 
+func (u *updateDeneb) SetNextSyncCommitteeBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientSyncCommitteeBranch]("sync committee", branch, fieldparams.SyncCommitteeBranchDepth)
+	if err != nil {
+		return err
+	}
+	u.nextSyncCommitteeBranch = b
+
+	u.p.NextSyncCommitteeBranch = branch
+
+	return nil
+}
+
 func (u *updateDeneb) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
 	return [6][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranchElectra", version.Deneb)
 }
@@ -304,24 +488,59 @@ func (u *updateDeneb) FinalizedHeader() interfaces.LightClientHeader {
 	return u.finalizedHeader
 }
 
-func (u *updateDeneb) FinalityBranch() interfaces.LightClientFinalityBranch {
-	return u.finalityBranch
+func (u *updateDeneb) SetFinalizedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderDeneb)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderDeneb{})
+	}
+	u.p.FinalizedHeader = proto
+	u.finalizedHeader = header
+	return nil
+}
+
+func (u *updateDeneb) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return u.finalityBranch, nil
+}
+
+func (u *updateDeneb) SetFinalityBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientFinalityBranch]("finality", branch, fieldparams.FinalityBranchDepth)
+	if err != nil {
+		return err
+	}
+	u.finalityBranch = b
+	u.p.FinalityBranch = branch
+	return nil
+}
+
+func (u *updateDeneb) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return interfaces.LightClientFinalityBranchElectra{}, consensustypes.ErrNotSupported("FinalityBranchElectra", u.Version())
 }
 
 func (u *updateDeneb) SyncAggregate() *pb.SyncAggregate {
 	return u.p.SyncAggregate
 }
 
+func (u *updateDeneb) SetSyncAggregate(sa *pb.SyncAggregate) {
+	u.p.SyncAggregate = sa
+}
+
 func (u *updateDeneb) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
 
+func (u *updateDeneb) SetSignatureSlot(slot primitives.Slot) {
+	u.p.SignatureSlot = slot
+}
+
+// In addition to the proto object being wrapped, we store some fields that have to be
+// constructed from the proto, so that we don't have to reconstruct them every time
+// in getters.
 type updateElectra struct {
 	p                       *pb.LightClientUpdateElectra
 	attestedHeader          interfaces.LightClientHeader
 	nextSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranchElectra
 	finalizedHeader         interfaces.LightClientHeader
-	finalityBranch          interfaces.LightClientFinalityBranch
+	finalityBranch          interfaces.LightClientFinalityBranchElectra
 }
 
 var _ interfaces.LightClientUpdate = &updateElectra{}
@@ -330,14 +549,20 @@ func NewWrappedUpdateElectra(p *pb.LightClientUpdateElectra) (interfaces.LightCl
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	attestedHeader, err := NewWrappedHeaderDeneb(p.AttestedHeader)
+
+	attestedHeader, err := NewWrappedHeader(p.AttestedHeader)
 	if err != nil {
 		return nil, err
 	}
-	finalizedHeader, err := NewWrappedHeaderDeneb(p.FinalizedHeader)
-	if err != nil {
-		return nil, err
+
+	var finalizedHeader interfaces.LightClientHeader
+	if p.FinalizedHeader != nil {
+		finalizedHeader, err = NewWrappedHeader(p.FinalizedHeader)
+		if err != nil {
+			return nil, err
+		}
 	}
+
 	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranchElectra](
 		"sync committee",
 		p.NextSyncCommitteeBranch,
@@ -346,10 +571,11 @@ func NewWrappedUpdateElectra(p *pb.LightClientUpdateElectra) (interfaces.LightCl
 	if err != nil {
 		return nil, err
 	}
-	finalityBranch, err := createBranch[interfaces.LightClientFinalityBranch](
+
+	finalityBranch, err := createBranch[interfaces.LightClientFinalityBranchElectra](
 		"finality",
 		p.FinalityBranch,
-		fieldparams.FinalityBranchDepth,
+		fieldparams.FinalityBranchDepthElectra,
 	)
 	if err != nil {
 		return nil, err
@@ -376,6 +602,10 @@ func (u *updateElectra) SizeSSZ() int {
 	return u.p.SizeSSZ()
 }
 
+func (u *updateElectra) Proto() proto.Message {
+	return u.p
+}
+
 func (u *updateElectra) Version() int {
 	return version.Electra
 }
@@ -384,14 +614,40 @@ func (u *updateElectra) AttestedHeader() interfaces.LightClientHeader {
 	return u.attestedHeader
 }
 
+func (u *updateElectra) SetAttestedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderDeneb)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderDeneb{})
+	}
+	u.p.AttestedHeader = proto
+	u.attestedHeader = header
+	return nil
+}
+
 func (u *updateElectra) NextSyncCommittee() *pb.SyncCommittee {
 	return u.p.NextSyncCommittee
 }
 
+func (u *updateElectra) SetNextSyncCommittee(sc *pb.SyncCommittee) {
+	u.p.NextSyncCommittee = sc
+}
+
 func (u *updateElectra) NextSyncCommitteeBranch() (interfaces.LightClientSyncCommitteeBranch, error) {
 	return [5][32]byte{}, consensustypes.ErrNotSupported("NextSyncCommitteeBranch", version.Electra)
 }
 
+func (u *updateElectra) SetNextSyncCommitteeBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientSyncCommitteeBranchElectra]("sync committee", branch, fieldparams.SyncCommitteeBranchDepthElectra)
+	if err != nil {
+		return err
+	}
+	u.nextSyncCommitteeBranch = b
+
+	u.p.NextSyncCommitteeBranch = branch
+
+	return nil
+}
+
 func (u *updateElectra) NextSyncCommitteeBranchElectra() (interfaces.LightClientSyncCommitteeBranchElectra, error) {
 	return u.nextSyncCommitteeBranch, nil
 }
@@ -400,14 +656,46 @@ func (u *updateElectra) FinalizedHeader() interfaces.LightClientHeader {
 	return u.finalizedHeader
 }
 
-func (u *updateElectra) FinalityBranch() interfaces.LightClientFinalityBranch {
-	return u.finalityBranch
+func (u *updateElectra) SetFinalizedHeader(header interfaces.LightClientHeader) error {
+	proto, ok := header.Proto().(*pb.LightClientHeaderDeneb)
+	if !ok {
+		return fmt.Errorf("header type %T is not %T", proto, &pb.LightClientHeaderDeneb{})
+	}
+	u.p.FinalizedHeader = proto
+	u.finalizedHeader = header
+	return nil
+}
+
+func (u *updateElectra) FinalityBranch() (interfaces.LightClientFinalityBranch, error) {
+	return interfaces.LightClientFinalityBranch{}, consensustypes.ErrNotSupported("FinalityBranch", u.Version())
+}
+
+func (u *updateElectra) SetFinalityBranch(branch [][]byte) error {
+	b, err := createBranch[interfaces.LightClientFinalityBranchElectra]("finality", branch, fieldparams.FinalityBranchDepthElectra)
+	if err != nil {
+		return err
+	}
+	u.finalityBranch = b
+	u.p.FinalityBranch = branch
+	return nil
+}
+
+func (u *updateElectra) FinalityBranchElectra() (interfaces.LightClientFinalityBranchElectra, error) {
+	return u.finalityBranch, nil
 }
 
 func (u *updateElectra) SyncAggregate() *pb.SyncAggregate {
 	return u.p.SyncAggregate
 }
 
+func (u *updateElectra) SetSyncAggregate(sa *pb.SyncAggregate) {
+	u.p.SyncAggregate = sa
+}
+
 func (u *updateElectra) SignatureSlot() primitives.Slot {
 	return u.p.SignatureSlot
 }
+
+func (u *updateElectra) SetSignatureSlot(slot primitives.Slot) {
+	u.p.SignatureSlot = slot
+}

consensus-types/payload-attribute/BUILD.bazel

@@ -10,8 +10,12 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/state:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

consensus-types/payload-attribute/getters.go

@@ -38,6 +38,16 @@ func (a *data) Withdrawals() ([]*enginev1.Withdrawal, error) {
 	return a.withdrawals, nil
 }
 
+func (a *data) ParentBeaconBlockRoot() ([]byte, error) {
+	if len(a.parentBeaconBlockRoot) == 0 {
+		return nil, errNoParentRoot
+	}
+	if a.version < version.Deneb {
+		return nil, consensus_types.ErrNotSupported("ParentBeaconBlockRoot", a.version)
+	}
+	return a.parentBeaconBlockRoot, nil
+}
+
 // PbV1 returns the payload attribute in version 1.
 func (a *data) PbV1() (*enginev1.PayloadAttributes, error) {
 	if a == nil {
@@ -97,6 +107,9 @@ func (a *data) PbV3() (*enginev1.PayloadAttributesV3, error) {
 
 // IsEmpty returns whether the given payload attribute is empty
 func (a *data) IsEmpty() bool {
+	if a == nil {
+		return true
+	}
 	if len(a.PrevRandao()) != 0 {
 		return false
 	}

consensus-types/payload-attribute/interface.go

@@ -10,6 +10,7 @@ type Attributer interface {
 	Timestamp() uint64
 	SuggestedFeeRecipient() []byte
 	Withdrawals() ([]*enginev1.Withdrawal, error)
+	ParentBeaconBlockRoot() ([]byte, error)
 	PbV1() (*enginev1.PayloadAttributes, error)
 	PbV2() (*enginev1.PayloadAttributesV2, error)
 	PbV3() (*enginev1.PayloadAttributesV3, error)

consensus-types/payload-attribute/types.go

@@ -2,7 +2,11 @@ package payloadattribute
 
 import (
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
@@ -23,6 +27,7 @@ type data struct {
 var (
 	errNilPayloadAttribute         = errors.New("received nil payload attribute")
 	errUnsupportedPayloadAttribute = errors.New("unsupported payload attribute")
+	errNoParentRoot                = errors.New("parent root is empty")
 )
 
 // New returns a new payload attribute with the given input object.
@@ -89,3 +94,16 @@ func initPayloadAttributeFromV3(a *enginev1.PayloadAttributesV3) (Attributer, er
 		parentBeaconBlockRoot: a.ParentBeaconBlockRoot,
 	}, nil
 }
+
+// EventData holds the values for a PayloadAttributes event.
+type EventData struct {
+	ProposerIndex     primitives.ValidatorIndex
+	ProposalSlot      primitives.Slot
+	ParentBlockNumber uint64
+	ParentBlockRoot   []byte
+	ParentBlockHash   []byte
+	Attributer        Attributer
+	HeadState         state.BeaconState
+	HeadBlock         interfaces.ReadOnlySignedBeaconBlock
+	HeadRoot          [field_params.RootLength]byte
+}

proto/prysm/v1alpha1/BUILD.bazel

@@ -81,11 +81,11 @@ ssz_altair_objs = [
     "BeaconBlockBodyAltair",
     "BeaconStateAltair",
     "ContributionAndProof",
-    "LightClientBootstrapAltair",
-    "LightClientFinalityUpdateAltair",
     "LightClientHeaderAltair",
-    "LightClientOptimisticUpdateAltair",
+    "LightClientBootstrapAltair",
     "LightClientUpdateAltair",
+    "LightClientFinalityUpdateAltair",
+    "LightClientOptimisticUpdateAltair",
     "SignedBeaconBlockAltair",
     "SignedContributionAndProof",
     "SyncAggregate",
@@ -115,11 +115,11 @@ ssz_capella_objs = [
     "BlindedBeaconBlockCapella",
     "BuilderBidCapella",
     "HistoricalSummary",
-    "LightClientBootstrapCapella",
-    "LightClientFinalityUpdateCapella",
     "LightClientHeaderCapella",
-    "LightClientOptimisticUpdateCapella",
+    "LightClientBootstrapCapella",
     "LightClientUpdateCapella",
+    "LightClientFinalityUpdateCapella",
+    "LightClientOptimisticUpdateCapella",
     "SignedBLSToExecutionChange",
     "SignedBeaconBlockCapella",
     "SignedBlindedBeaconBlockCapella",
@@ -137,11 +137,11 @@ ssz_deneb_objs = [
     "BlobSidecar",
     "BlobSidecars",
     "BuilderBidDeneb",
-    "LightClientBootstrapDeneb",
-    "LightClientFinalityUpdateDeneb",
     "LightClientHeaderDeneb",
-    "LightClientOptimisticUpdateDeneb",
+    "LightClientBootstrapDeneb",
     "LightClientUpdateDeneb",
+    "LightClientFinalityUpdateDeneb",
+    "LightClientOptimisticUpdateDeneb",
     "SignedBeaconBlockContentsDeneb",
     "SignedBeaconBlockDeneb",
     "SignedBlindedBeaconBlockDeneb",
@@ -151,16 +151,18 @@ ssz_electra_objs = [
     "AggregateAttestationAndProofElectra",
     "AttestationElectra",
     "AttesterSlashingElectra",
+    "BeaconBlockElectra",
     "BeaconBlockBodyElectra",
     "BeaconBlockContentsElectra",
-    "BeaconBlockElectra",
     "BeaconStateElectra",
     "BlindedBeaconBlockBodyElectra",
     "BlindedBeaconBlockElectra",
     "Consolidation",
     "IndexedAttestationElectra",
+    "LightClientHeaderElectra",
     "LightClientBootstrapElectra",
     "LightClientUpdateElectra",
+    "LightClientFinalityUpdateElectra",
     "PendingDeposit",
     "PendingDeposits",
     "PendingConsolidation",
@@ -172,6 +174,11 @@ ssz_electra_objs = [
     "SignedConsolidation",
 ]
 
+ssz_fulu_objs = [
+    "DataColumnIdentifier",
+    "DataColumnSidecar",
+]
+
 ssz_gen_marshal(
     name = "ssz_generated_phase0",
     out = "phase0.ssz.go",
@@ -249,6 +256,19 @@ ssz_gen_marshal(
     objs = ssz_electra_objs,
 )
 
+ssz_gen_marshal(
+    name = "ssz_generated_fulu",
+    out = "fulu.ssz.go",
+    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs + ssz_capella_objs + ssz_deneb_objs + ssz_electra_objs,
+    go_proto = ":go_proto",
+    includes = [
+        "//consensus-types/primitives:go_default_library",
+        "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
+    ],
+    objs = ssz_fulu_objs,
+)
+
 ssz_gen_marshal(
     name = "ssz_generated_non_core",
     out = "non-core.ssz.go",
@@ -261,8 +281,10 @@ ssz_gen_marshal(
     objs = [
         "BeaconBlocksByRangeRequest",
         "BlobSidecarsByRangeRequest",
+        "DataColumnSidecarsByRangeRequest",
         "MetaDataV0",
         "MetaDataV1",
+        "MetaDataV2",
         "SignedValidatorRegistrationV1",
         "ValidatorRegistrationV1",
         "BuilderBid",
@@ -311,6 +333,7 @@ go_library(
         ":ssz_generated_capella",  # keep
         ":ssz_generated_deneb",  # keep
         ":ssz_generated_electra",  # keep
+        ":ssz_generated_fulu",  # keep
         ":ssz_generated_non_core",  # keep
         ":ssz_generated_phase0",  # keep
     ],
@@ -352,6 +375,7 @@ ssz_proto_files(
         "beacon_state.proto",
         "blobs.proto",
         "light_client.proto",
+        "data_columns.proto",
         "sync_committee.proto",
         "withdrawals.proto",
     ],

proto/prysm/v1alpha1/attestation.go

@@ -25,6 +25,7 @@ type Att interface {
 	CommitteeBitsVal() bitfield.Bitfield
 	GetSignature() []byte
 	GetCommitteeIndex() (primitives.CommitteeIndex, error)
+	IsNil() bool
 }
 
 // IndexedAtt defines common functionality for all indexed attestation types.
@@ -37,6 +38,7 @@ type IndexedAtt interface {
 	GetAttestingIndices() []uint64
 	GetData() *AttestationData
 	GetSignature() []byte
+	IsNil() bool
 }
 
 // SignedAggregateAttAndProof defines common functionality for all signed aggregate attestation types.
@@ -48,6 +50,7 @@ type SignedAggregateAttAndProof interface {
 	Version() int
 	AggregateAttestationAndProof() AggregateAttAndProof
 	GetSignature() []byte
+	IsNil() bool
 }
 
 // AggregateAttAndProof defines common functionality for all aggregate attestation types.
@@ -60,6 +63,7 @@ type AggregateAttAndProof interface {
 	GetAggregatorIndex() primitives.ValidatorIndex
 	AggregateVal() Att
 	GetSelectionProof() []byte
+	IsNil() bool
 }
 
 // AttSlashing defines common functionality for all attestation slashing types.
@@ -71,6 +75,7 @@ type AttSlashing interface {
 	Version() int
 	FirstAttestation() IndexedAtt
 	SecondAttestation() IndexedAtt
+	IsNil() bool
 }
 
 // Copy --
@@ -103,20 +108,25 @@ func (a *Attestation) Version() int {
 	return version.Phase0
 }
 
+// IsNil --
+func (a *Attestation) IsNil() bool {
+	return a == nil || a.Data == nil
+}
+
 // Clone --
 func (a *Attestation) Clone() Att {
 	return a.Copy()
 }
 
 // Copy --
-func (att *Attestation) Copy() *Attestation {
-	if att == nil {
+func (a *Attestation) Copy() *Attestation {
+	if a == nil {
 		return nil
 	}
 	return &Attestation{
-		AggregationBits: bytesutil.SafeCopyBytes(att.AggregationBits),
-		Data:            att.Data.Copy(),
-		Signature:       bytesutil.SafeCopyBytes(att.Signature),
+		AggregationBits: bytesutil.SafeCopyBytes(a.AggregationBits),
+		Data:            a.Data.Copy(),
+		Signature:       bytesutil.SafeCopyBytes(a.Signature),
 	}
 }
 
@@ -140,6 +150,11 @@ func (a *PendingAttestation) Version() int {
 	return version.Phase0
 }
 
+// IsNil --
+func (a *PendingAttestation) IsNil() bool {
+	return a == nil || a.Data == nil
+}
+
 // Clone --
 func (a *PendingAttestation) Clone() Att {
 	return a.Copy()
@@ -181,21 +196,26 @@ func (a *AttestationElectra) Version() int {
 	return version.Electra
 }
 
+// IsNil --
+func (a *AttestationElectra) IsNil() bool {
+	return a == nil || a.Data == nil
+}
+
 // Clone --
 func (a *AttestationElectra) Clone() Att {
 	return a.Copy()
 }
 
 // Copy --
-func (att *AttestationElectra) Copy() *AttestationElectra {
-	if att == nil {
+func (a *AttestationElectra) Copy() *AttestationElectra {
+	if a == nil {
 		return nil
 	}
 	return &AttestationElectra{
-		AggregationBits: bytesutil.SafeCopyBytes(att.AggregationBits),
-		CommitteeBits:   bytesutil.SafeCopyBytes(att.CommitteeBits),
-		Data:            att.Data.Copy(),
-		Signature:       bytesutil.SafeCopyBytes(att.Signature),
+		AggregationBits: bytesutil.SafeCopyBytes(a.AggregationBits),
+		CommitteeBits:   bytesutil.SafeCopyBytes(a.CommitteeBits),
+		Data:            a.Data.Copy(),
+		Signature:       bytesutil.SafeCopyBytes(a.Signature),
 	}
 }
 
@@ -227,40 +247,50 @@ func (a *IndexedAttestation) Version() int {
 	return version.Phase0
 }
 
+// IsNil --
+func (a *IndexedAttestation) IsNil() bool {
+	return a == nil || a.Data == nil
+}
+
 // Version --
 func (a *IndexedAttestationElectra) Version() int {
 	return version.Electra
 }
 
+// IsNil --
+func (a *IndexedAttestationElectra) IsNil() bool {
+	return a == nil || a.Data == nil
+}
+
 // Copy --
-func (indexedAtt *IndexedAttestation) Copy() *IndexedAttestation {
+func (a *IndexedAttestation) Copy() *IndexedAttestation {
 	var indices []uint64
-	if indexedAtt == nil {
+	if a == nil {
 		return nil
-	} else if indexedAtt.AttestingIndices != nil {
-		indices = make([]uint64, len(indexedAtt.AttestingIndices))
-		copy(indices, indexedAtt.AttestingIndices)
+	} else if a.AttestingIndices != nil {
+		indices = make([]uint64, len(a.AttestingIndices))
+		copy(indices, a.AttestingIndices)
 	}
 	return &IndexedAttestation{
 		AttestingIndices: indices,
-		Data:             indexedAtt.Data.Copy(),
-		Signature:        bytesutil.SafeCopyBytes(indexedAtt.Signature),
+		Data:             a.Data.Copy(),
+		Signature:        bytesutil.SafeCopyBytes(a.Signature),
 	}
 }
 
 // Copy --
-func (indexedAtt *IndexedAttestationElectra) Copy() *IndexedAttestationElectra {
+func (a *IndexedAttestationElectra) Copy() *IndexedAttestationElectra {
 	var indices []uint64
-	if indexedAtt == nil {
+	if a == nil {
 		return nil
-	} else if indexedAtt.AttestingIndices != nil {
-		indices = make([]uint64, len(indexedAtt.AttestingIndices))
-		copy(indices, indexedAtt.AttestingIndices)
+	} else if a.AttestingIndices != nil {
+		indices = make([]uint64, len(a.AttestingIndices))
+		copy(indices, a.AttestingIndices)
 	}
 	return &IndexedAttestationElectra{
 		AttestingIndices: indices,
-		Data:             indexedAtt.Data.Copy(),
-		Signature:        bytesutil.SafeCopyBytes(indexedAtt.Signature),
+		Data:             a.Data.Copy(),
+		Signature:        bytesutil.SafeCopyBytes(a.Signature),
 	}
 }
 
@@ -269,6 +299,13 @@ func (a *AttesterSlashing) Version() int {
 	return version.Phase0
 }
 
+// IsNil --
+func (a *AttesterSlashing) IsNil() bool {
+	return a == nil ||
+		a.Attestation_1 == nil || a.Attestation_1.IsNil() ||
+		a.Attestation_2 == nil || a.Attestation_2.IsNil()
+}
+
 // FirstAttestation --
 func (a *AttesterSlashing) FirstAttestation() IndexedAtt {
 	return a.Attestation_1
@@ -284,6 +321,13 @@ func (a *AttesterSlashingElectra) Version() int {
 	return version.Electra
 }
 
+// IsNil --
+func (a *AttesterSlashingElectra) IsNil() bool {
+	return a == nil ||
+		a.Attestation_1 == nil || a.Attestation_1.IsNil() ||
+		a.Attestation_2 == nil || a.Attestation_2.IsNil()
+}
+
 // FirstAttestation --
 func (a *AttesterSlashingElectra) FirstAttestation() IndexedAtt {
 	return a.Attestation_1
@@ -320,6 +364,11 @@ func (a *AggregateAttestationAndProof) Version() int {
 	return version.Phase0
 }
 
+// IsNil --
+func (a *AggregateAttestationAndProof) IsNil() bool {
+	return a == nil || a.Aggregate == nil || a.Aggregate.IsNil()
+}
+
 // AggregateVal --
 func (a *AggregateAttestationAndProof) AggregateVal() Att {
 	return a.Aggregate
@@ -330,6 +379,11 @@ func (a *AggregateAttestationAndProofElectra) Version() int {
 	return version.Electra
 }
 
+// IsNil --
+func (a *AggregateAttestationAndProofElectra) IsNil() bool {
+	return a == nil || a.Aggregate == nil || a.Aggregate.IsNil()
+}
+
 // AggregateVal --
 func (a *AggregateAttestationAndProofElectra) AggregateVal() Att {
 	return a.Aggregate
@@ -340,6 +394,11 @@ func (a *SignedAggregateAttestationAndProof) Version() int {
 	return version.Phase0
 }
 
+// IsNil --
+func (a *SignedAggregateAttestationAndProof) IsNil() bool {
+	return a == nil || a.Message == nil || a.Message.IsNil()
+}
+
 // AggregateAttestationAndProof --
 func (a *SignedAggregateAttestationAndProof) AggregateAttestationAndProof() AggregateAttAndProof {
 	return a.Message
@@ -350,6 +409,11 @@ func (a *SignedAggregateAttestationAndProofElectra) Version() int {
 	return version.Electra
 }
 
+// IsNil --
+func (a *SignedAggregateAttestationAndProofElectra) IsNil() bool {
+	return a == nil || a.Message == nil || a.Message.IsNil()
+}
+
 // AggregateAttestationAndProof --
 func (a *SignedAggregateAttestationAndProofElectra) AggregateAttestationAndProof() AggregateAttAndProof {
 	return a.Message

proto/prysm/v1alpha1/attestation/attestation_utils.go

@@ -39,7 +39,7 @@ import (
 //	     data=attestation.data,
 //	     signature=attestation.signature,
 //	 )
-func ConvertToIndexed(ctx context.Context, attestation ethpb.Att, committees ...[]primitives.ValidatorIndex) (ethpb.IndexedAtt, error) {
+func ConvertToIndexed(_ context.Context, attestation ethpb.Att, committees ...[]primitives.ValidatorIndex) (ethpb.IndexedAtt, error) {
 	attIndices, err := AttestingIndices(attestation, committees...)
 	if err != nil {
 		return nil, err
@@ -185,12 +185,10 @@ func IsValidAttestationIndices(ctx context.Context, indexedAttestation ethpb.Ind
 	_, span := trace.StartSpan(ctx, "attestationutil.IsValidAttestationIndices")
 	defer span.End()
 
-	if indexedAttestation == nil ||
-		indexedAttestation.GetData() == nil ||
-		indexedAttestation.GetData().Target == nil ||
-		indexedAttestation.GetAttestingIndices() == nil {
+	if indexedAttestation == nil || indexedAttestation.IsNil() || indexedAttestation.GetData().Target == nil || indexedAttestation.GetData().Source == nil {
 		return errors.New("nil or missing indexed attestation data")
 	}
+
 	indices := indexedAttestation.GetAttestingIndices()
 	if len(indices) == 0 {
 		return errors.New("expected non-empty attesting indices")

proto/prysm/v1alpha1/attestation/attestation_utils_test.go

@@ -106,10 +106,11 @@ func TestIsValidAttestationIndices(t *testing.T) {
 			att: &eth.IndexedAttestation{
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
-			wantedErr: "nil or missing indexed attestation data",
+			wantedErr: "expected non-empty attesting indices",
 		},
 		{
 			name: "Indices should be non-empty",
@@ -117,6 +118,7 @@ func TestIsValidAttestationIndices(t *testing.T) {
 				AttestingIndices: []uint64{},
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
@@ -128,6 +130,7 @@ func TestIsValidAttestationIndices(t *testing.T) {
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
@@ -139,6 +142,7 @@ func TestIsValidAttestationIndices(t *testing.T) {
 				AttestingIndices: []uint64{3, 2, 1},
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
@@ -150,6 +154,7 @@ func TestIsValidAttestationIndices(t *testing.T) {
 				AttestingIndices: []uint64{1, 2, 3},
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
@@ -160,6 +165,7 @@ func TestIsValidAttestationIndices(t *testing.T) {
 				AttestingIndices: []uint64{1, 2},
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
@@ -170,6 +176,7 @@ func TestIsValidAttestationIndices(t *testing.T) {
 				AttestingIndices: []uint64{1},
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
@@ -180,6 +187,7 @@ func TestIsValidAttestationIndices(t *testing.T) {
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee*params.BeaconConfig().MaxCommitteesPerSlot+1),
 				Data: &eth.AttestationData{
 					Target: &eth.Checkpoint{},
+					Source: &eth.Checkpoint{},
 				},
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
 			},
@@ -218,6 +226,7 @@ func BenchmarkIsValidAttestationIndices(b *testing.B) {
 		AttestingIndices: indices,
 		Data: &eth.AttestationData{
 			Target: &eth.Checkpoint{},
+			Source: &eth.Checkpoint{},
 		},
 		Signature: make([]byte, fieldparams.BLSSignatureLength),
 	}

proto/prysm/v1alpha1/data_columns.pb.go

@@ -0,0 +1,299 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.31.0
+// 	protoc        v4.25.1
+// source: proto/prysm/v1alpha1/data_columns.proto
+
+package eth
+
+import (
+	reflect "reflect"
+	sync "sync"
+
+	_ "github.com/prysmaticlabs/prysm/v5/proto/eth/ext"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type DataColumnSidecar struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ColumnIndex                  uint64                   `protobuf:"varint,1,opt,name=column_index,json=columnIndex,proto3" json:"column_index,omitempty"`
+	DataColumn                   [][]byte                 `protobuf:"bytes,2,rep,name=data_column,json=dataColumn,proto3" json:"data_column,omitempty" ssz-max:"4096" ssz-size:"?,2048"`
+	KzgCommitments               [][]byte                 `protobuf:"bytes,3,rep,name=kzg_commitments,json=kzgCommitments,proto3" json:"kzg_commitments,omitempty" ssz-max:"4096" ssz-size:"?,48"`
+	KzgProof                     [][]byte                 `protobuf:"bytes,4,rep,name=kzg_proof,json=kzgProof,proto3" json:"kzg_proof,omitempty" ssz-max:"4096" ssz-size:"?,48"`
+	SignedBlockHeader            *SignedBeaconBlockHeader `protobuf:"bytes,5,opt,name=signed_block_header,json=signedBlockHeader,proto3" json:"signed_block_header,omitempty"`
+	KzgCommitmentsInclusionProof [][]byte                 `protobuf:"bytes,6,rep,name=kzg_commitments_inclusion_proof,json=kzgCommitmentsInclusionProof,proto3" json:"kzg_commitments_inclusion_proof,omitempty" ssz-size:"4,32"`
+}
+
+func (x *DataColumnSidecar) Reset() {
+	*x = DataColumnSidecar{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DataColumnSidecar) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DataColumnSidecar) ProtoMessage() {}
+
+func (x *DataColumnSidecar) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DataColumnSidecar.ProtoReflect.Descriptor instead.
+func (*DataColumnSidecar) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *DataColumnSidecar) GetColumnIndex() uint64 {
+	if x != nil {
+		return x.ColumnIndex
+	}
+	return 0
+}
+
+func (x *DataColumnSidecar) GetDataColumn() [][]byte {
+	if x != nil {
+		return x.DataColumn
+	}
+	return nil
+}
+
+func (x *DataColumnSidecar) GetKzgCommitments() [][]byte {
+	if x != nil {
+		return x.KzgCommitments
+	}
+	return nil
+}
+
+func (x *DataColumnSidecar) GetKzgProof() [][]byte {
+	if x != nil {
+		return x.KzgProof
+	}
+	return nil
+}
+
+func (x *DataColumnSidecar) GetSignedBlockHeader() *SignedBeaconBlockHeader {
+	if x != nil {
+		return x.SignedBlockHeader
+	}
+	return nil
+}
+
+func (x *DataColumnSidecar) GetKzgCommitmentsInclusionProof() [][]byte {
+	if x != nil {
+		return x.KzgCommitmentsInclusionProof
+	}
+	return nil
+}
+
+type DataColumnIdentifier struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	BlockRoot   []byte `protobuf:"bytes,1,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty" ssz-size:"32"`
+	ColumnIndex uint64 `protobuf:"varint,2,opt,name=column_index,json=columnIndex,proto3" json:"column_index,omitempty"`
+}
+
+func (x *DataColumnIdentifier) Reset() {
+	*x = DataColumnIdentifier{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DataColumnIdentifier) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DataColumnIdentifier) ProtoMessage() {}
+
+func (x *DataColumnIdentifier) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DataColumnIdentifier.ProtoReflect.Descriptor instead.
+func (*DataColumnIdentifier) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *DataColumnIdentifier) GetBlockRoot() []byte {
+	if x != nil {
+		return x.BlockRoot
+	}
+	return nil
+}
+
+func (x *DataColumnIdentifier) GetColumnIndex() uint64 {
+	if x != nil {
+		return x.ColumnIndex
+	}
+	return 0
+}
+
+var File_proto_prysm_v1alpha1_data_columns_proto protoreflect.FileDescriptor
+
+var file_proto_prysm_v1alpha1_data_columns_proto_rawDesc = []byte{
+	0x0a, 0x27, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75,
+	0x6d, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x65, 0x74, 0x68, 0x65, 0x72,
+	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
+	0x1a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x65, 0x78, 0x74, 0x2f,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70,
+	0x68, 0x61, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x86, 0x03, 0x0a, 0x11, 0x44, 0x61, 0x74, 0x61, 0x43,
+	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x53, 0x69, 0x64, 0x65, 0x63, 0x61, 0x72, 0x12, 0x21, 0x0a, 0x0c,
+	0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12,
+	0x33, 0x0a, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x0c, 0x42, 0x12, 0x8a, 0xb5, 0x18, 0x06, 0x3f, 0x2c, 0x32, 0x30, 0x34, 0x38,
+	0x92, 0xb5, 0x18, 0x04, 0x34, 0x30, 0x39, 0x36, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f,
+	0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x39, 0x0a, 0x0f, 0x6b, 0x7a, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d,
+	0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x10, 0x8a,
+	0xb5, 0x18, 0x04, 0x3f, 0x2c, 0x34, 0x38, 0x92, 0xb5, 0x18, 0x04, 0x34, 0x30, 0x39, 0x36, 0x52,
+	0x0e, 0x6b, 0x7a, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12,
+	0x2d, 0x0a, 0x09, 0x6b, 0x7a, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x04, 0x20, 0x03,
+	0x28, 0x0c, 0x42, 0x10, 0x8a, 0xb5, 0x18, 0x04, 0x3f, 0x2c, 0x34, 0x38, 0x92, 0xb5, 0x18, 0x04,
+	0x34, 0x30, 0x39, 0x36, 0x52, 0x08, 0x6b, 0x7a, 0x67, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x5e,
+	0x0a, 0x13, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68,
+	0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x74,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
+	0x68, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e,
+	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x11, 0x73, 0x69, 0x67,
+	0x6e, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x4f,
+	0x0a, 0x1f, 0x6b, 0x7a, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74,
+	0x73, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f,
+	0x66, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x08, 0x8a, 0xb5, 0x18, 0x04, 0x34, 0x2c, 0x33,
+	0x32, 0x52, 0x1c, 0x6b, 0x7a, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74,
+	0x73, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22,
+	0x60, 0x0a, 0x14, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x49, 0x64, 0x65,
+	0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x25, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+	0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18,
+	0x02, 0x33, 0x32, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x21,
+	0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x49, 0x6e, 0x64, 0x65,
+	0x78, 0x42, 0x9b, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
+	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42,
+	0x10, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
+	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
+	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79,
+	0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa,
+	0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x76,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65,
+	0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_proto_prysm_v1alpha1_data_columns_proto_rawDescOnce sync.Once
+	file_proto_prysm_v1alpha1_data_columns_proto_rawDescData = file_proto_prysm_v1alpha1_data_columns_proto_rawDesc
+)
+
+func file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP() []byte {
+	file_proto_prysm_v1alpha1_data_columns_proto_rawDescOnce.Do(func() {
+		file_proto_prysm_v1alpha1_data_columns_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_prysm_v1alpha1_data_columns_proto_rawDescData)
+	})
+	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescData
+}
+
+var file_proto_prysm_v1alpha1_data_columns_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_proto_prysm_v1alpha1_data_columns_proto_goTypes = []interface{}{
+	(*DataColumnSidecar)(nil),       // 0: ethereum.eth.v1alpha1.DataColumnSidecar
+	(*DataColumnIdentifier)(nil),    // 1: ethereum.eth.v1alpha1.DataColumnIdentifier
+	(*SignedBeaconBlockHeader)(nil), // 2: ethereum.eth.v1alpha1.SignedBeaconBlockHeader
+}
+var file_proto_prysm_v1alpha1_data_columns_proto_depIdxs = []int32{
+	2, // 0: ethereum.eth.v1alpha1.DataColumnSidecar.signed_block_header:type_name -> ethereum.eth.v1alpha1.SignedBeaconBlockHeader
+	1, // [1:1] is the sub-list for method output_type
+	1, // [1:1] is the sub-list for method input_type
+	1, // [1:1] is the sub-list for extension type_name
+	1, // [1:1] is the sub-list for extension extendee
+	0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_proto_prysm_v1alpha1_data_columns_proto_init() }
+func file_proto_prysm_v1alpha1_data_columns_proto_init() {
+	if File_proto_prysm_v1alpha1_data_columns_proto != nil {
+		return
+	}
+	file_proto_prysm_v1alpha1_beacon_block_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DataColumnSidecar); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DataColumnIdentifier); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_proto_prysm_v1alpha1_data_columns_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_proto_prysm_v1alpha1_data_columns_proto_goTypes,
+		DependencyIndexes: file_proto_prysm_v1alpha1_data_columns_proto_depIdxs,
+		MessageInfos:      file_proto_prysm_v1alpha1_data_columns_proto_msgTypes,
+	}.Build()
+	File_proto_prysm_v1alpha1_data_columns_proto = out.File
+	file_proto_prysm_v1alpha1_data_columns_proto_rawDesc = nil
+	file_proto_prysm_v1alpha1_data_columns_proto_goTypes = nil
+	file_proto_prysm_v1alpha1_data_columns_proto_depIdxs = nil
+}

proto/prysm/v1alpha1/data_columns.proto

@@ -0,0 +1,41 @@
+// Copyright 2024 Offchain Labs.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+syntax = "proto3";
+
+package ethereum.eth.v1alpha1;
+
+import "proto/eth/ext/options.proto";
+import "proto/prysm/v1alpha1/beacon_block.proto";
+
+option csharp_namespace = "Ethereum.Eth.v1alpha1";
+option go_package = "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1;eth";
+option java_multiple_files = true;
+option java_outer_classname = "DataColumnsProto";
+option java_package = "org.ethereum.eth.v1alpha1";
+option php_namespace = "Ethereum\\Eth\\v1alpha1";
+
+
+message DataColumnSidecar {
+  uint64 column_index = 1;
+  repeated bytes data_column = 2 [(ethereum.eth.ext.ssz_size) = "?,bytes_per_cell.size", (ethereum.eth.ext.ssz_max)  = "max_blob_commitments.size"];
+  repeated bytes kzg_commitments = 3 [(ethereum.eth.ext.ssz_size) = "?,48", (ethereum.eth.ext.ssz_max)  = "max_blob_commitments.size"];
+  repeated bytes kzg_proof = 4 [(ethereum.eth.ext.ssz_size) = "?,48", (ethereum.eth.ext.ssz_max)  = "max_blob_commitments.size"];
+  SignedBeaconBlockHeader signed_block_header = 5;
+  repeated bytes kzg_commitments_inclusion_proof = 6  [(ethereum.eth.ext.ssz_size) = "kzg_commitments_inclusion_proof_depth.size,32"];
+}
+
+message DataColumnIdentifier {
+  bytes block_root = 1 [(ethereum.eth.ext.ssz_size) = "32"];
+  uint64 column_index = 2;
+}

proto/prysm/v1alpha1/electra.ssz.go

@@ -1,5 +1,5 @@
 // Code generated by fastssz. DO NOT EDIT.
-// Hash: 5ca1c2c4e61b47b1f8185b3e9c477ae280f82e1483b88d4e11fa214452da5117
+// Hash: bce36d386a65c91018c9a1edaacd2ed0f09cc4dce59fdc5f014fbd9e05bfee77
 package eth
 
 import (
@@ -4410,7 +4410,7 @@ func (l *LightClientUpdateElectra) MarshalSSZ() ([]byte, error) {
 // MarshalSSZTo ssz marshals the LightClientUpdateElectra object to a target array
 func (l *LightClientUpdateElectra) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 	dst = buf
-	offset := int(25184)
+	offset := int(25216)
 
 	// Offset (0) 'AttestedHeader'
 	dst = ssz.WriteOffset(dst, offset)
@@ -4448,11 +4448,11 @@ func (l *LightClientUpdateElectra) MarshalSSZTo(buf []byte) (dst []byte, err err
 	offset += l.FinalizedHeader.SizeSSZ()
 
 	// Field (4) 'FinalityBranch'
-	if size := len(l.FinalityBranch); size != 6 {
-		err = ssz.ErrVectorLengthFn("--.FinalityBranch", size, 6)
+	if size := len(l.FinalityBranch); size != 7 {
+		err = ssz.ErrVectorLengthFn("--.FinalityBranch", size, 7)
 		return
 	}
-	for ii := 0; ii < 6; ii++ {
+	for ii := 0; ii < 7; ii++ {
 		if size := len(l.FinalityBranch[ii]); size != 32 {
 			err = ssz.ErrBytesLengthFn("--.FinalityBranch[ii]", size, 32)
 			return
@@ -4488,7 +4488,7 @@ func (l *LightClientUpdateElectra) MarshalSSZTo(buf []byte) (dst []byte, err err
 func (l *LightClientUpdateElectra) UnmarshalSSZ(buf []byte) error {
 	var err error
 	size := uint64(len(buf))
-	if size < 25184 {
+	if size < 25216 {
 		return ssz.ErrSize
 	}
 
@@ -4500,7 +4500,7 @@ func (l *LightClientUpdateElectra) UnmarshalSSZ(buf []byte) error {
 		return ssz.ErrOffset
 	}
 
-	if o0 != 25184 {
+	if o0 != 25216 {
 		return ssz.ErrInvalidVariableOffset
 	}
 
@@ -4527,24 +4527,24 @@ func (l *LightClientUpdateElectra) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'FinalityBranch'
-	l.FinalityBranch = make([][]byte, 6)
-	for ii := 0; ii < 6; ii++ {
+	l.FinalityBranch = make([][]byte, 7)
+	for ii := 0; ii < 7; ii++ {
 		if cap(l.FinalityBranch[ii]) == 0 {
-			l.FinalityBranch[ii] = make([]byte, 0, len(buf[24824:25016][ii*32:(ii+1)*32]))
+			l.FinalityBranch[ii] = make([]byte, 0, len(buf[24824:25048][ii*32:(ii+1)*32]))
 		}
-		l.FinalityBranch[ii] = append(l.FinalityBranch[ii], buf[24824:25016][ii*32:(ii+1)*32]...)
+		l.FinalityBranch[ii] = append(l.FinalityBranch[ii], buf[24824:25048][ii*32:(ii+1)*32]...)
 	}
 
 	// Field (5) 'SyncAggregate'
 	if l.SyncAggregate == nil {
 		l.SyncAggregate = new(SyncAggregate)
 	}
-	if err = l.SyncAggregate.UnmarshalSSZ(buf[25016:25176]); err != nil {
+	if err = l.SyncAggregate.UnmarshalSSZ(buf[25048:25208]); err != nil {
 		return err
 	}
 
 	// Field (6) 'SignatureSlot'
-	l.SignatureSlot = github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25176:25184]))
+	l.SignatureSlot = github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25208:25216]))
 
 	// Field (0) 'AttestedHeader'
 	{
@@ -4572,7 +4572,7 @@ func (l *LightClientUpdateElectra) UnmarshalSSZ(buf []byte) error {
 
 // SizeSSZ returns the ssz encoded size in bytes for the LightClientUpdateElectra object
 func (l *LightClientUpdateElectra) SizeSSZ() (size int) {
-	size = 25184
+	size = 25216
 
 	// Field (0) 'AttestedHeader'
 	if l.AttestedHeader == nil {
@@ -4632,8 +4632,8 @@ func (l *LightClientUpdateElectra) HashTreeRootWith(hh *ssz.Hasher) (err error)
 
 	// Field (4) 'FinalityBranch'
 	{
-		if size := len(l.FinalityBranch); size != 6 {
-			err = ssz.ErrVectorLengthFn("--.FinalityBranch", size, 6)
+		if size := len(l.FinalityBranch); size != 7 {
+			err = ssz.ErrVectorLengthFn("--.FinalityBranch", size, 7)
 			return
 		}
 		subIndx := hh.Index()
@@ -4658,3 +4658,245 @@ func (l *LightClientUpdateElectra) HashTreeRootWith(hh *ssz.Hasher) (err error)
 	hh.Merkleize(indx)
 	return
 }
+
+// MarshalSSZ ssz marshals the LightClientFinalityUpdateElectra object
+func (l *LightClientFinalityUpdateElectra) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(l)
+}
+
+// MarshalSSZTo ssz marshals the LightClientFinalityUpdateElectra object to a target array
+func (l *LightClientFinalityUpdateElectra) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(180)
+
+	// Offset (0) 'AttestedHeader'
+	dst = ssz.WriteOffset(dst, offset)
+	if l.AttestedHeader == nil {
+		l.AttestedHeader = new(LightClientHeaderDeneb)
+	}
+	offset += l.AttestedHeader.SizeSSZ()
+
+	// Offset (1) 'FinalizedHeader'
+	dst = ssz.WriteOffset(dst, offset)
+	if l.FinalizedHeader == nil {
+		l.FinalizedHeader = new(LightClientHeaderDeneb)
+	}
+	offset += l.FinalizedHeader.SizeSSZ()
+
+	// Offset (2) 'FinalityBranch'
+	dst = ssz.WriteOffset(dst, offset)
+	for ii := 0; ii < len(l.FinalityBranch); ii++ {
+		offset += 4
+		offset += len(l.FinalityBranch[ii])
+	}
+
+	// Field (3) 'SyncAggregate'
+	if l.SyncAggregate == nil {
+		l.SyncAggregate = new(SyncAggregate)
+	}
+	if dst, err = l.SyncAggregate.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (4) 'SignatureSlot'
+	dst = ssz.MarshalUint64(dst, uint64(l.SignatureSlot))
+
+	// Field (0) 'AttestedHeader'
+	if dst, err = l.AttestedHeader.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (1) 'FinalizedHeader'
+	if dst, err = l.FinalizedHeader.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (2) 'FinalityBranch'
+	if size := len(l.FinalityBranch); size > 7 {
+		err = ssz.ErrListTooBigFn("--.FinalityBranch", size, 7)
+		return
+	}
+	{
+		offset = 4 * len(l.FinalityBranch)
+		for ii := 0; ii < len(l.FinalityBranch); ii++ {
+			dst = ssz.WriteOffset(dst, offset)
+			offset += len(l.FinalityBranch[ii])
+		}
+	}
+	for ii := 0; ii < len(l.FinalityBranch); ii++ {
+		if size := len(l.FinalityBranch[ii]); size > 32 {
+			err = ssz.ErrBytesLengthFn("--.FinalityBranch[ii]", size, 32)
+			return
+		}
+		dst = append(dst, l.FinalityBranch[ii]...)
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the LightClientFinalityUpdateElectra object
+func (l *LightClientFinalityUpdateElectra) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 180 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o0, o1, o2 uint64
+
+	// Offset (0) 'AttestedHeader'
+	if o0 = ssz.ReadOffset(buf[0:4]); o0 > size {
+		return ssz.ErrOffset
+	}
+
+	if o0 != 180 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Offset (1) 'FinalizedHeader'
+	if o1 = ssz.ReadOffset(buf[4:8]); o1 > size || o0 > o1 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (2) 'FinalityBranch'
+	if o2 = ssz.ReadOffset(buf[8:12]); o2 > size || o1 > o2 {
+		return ssz.ErrOffset
+	}
+
+	// Field (3) 'SyncAggregate'
+	if l.SyncAggregate == nil {
+		l.SyncAggregate = new(SyncAggregate)
+	}
+	if err = l.SyncAggregate.UnmarshalSSZ(buf[12:172]); err != nil {
+		return err
+	}
+
+	// Field (4) 'SignatureSlot'
+	l.SignatureSlot = github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[172:180]))
+
+	// Field (0) 'AttestedHeader'
+	{
+		buf = tail[o0:o1]
+		if l.AttestedHeader == nil {
+			l.AttestedHeader = new(LightClientHeaderDeneb)
+		}
+		if err = l.AttestedHeader.UnmarshalSSZ(buf); err != nil {
+			return err
+		}
+	}
+
+	// Field (1) 'FinalizedHeader'
+	{
+		buf = tail[o1:o2]
+		if l.FinalizedHeader == nil {
+			l.FinalizedHeader = new(LightClientHeaderDeneb)
+		}
+		if err = l.FinalizedHeader.UnmarshalSSZ(buf); err != nil {
+			return err
+		}
+	}
+
+	// Field (2) 'FinalityBranch'
+	{
+		buf = tail[o2:]
+		num, err := ssz.DecodeDynamicLength(buf, 7)
+		if err != nil {
+			return err
+		}
+		l.FinalityBranch = make([][]byte, num)
+		err = ssz.UnmarshalDynamic(buf, num, func(indx int, buf []byte) (err error) {
+			if len(buf) > 32 {
+				return ssz.ErrBytesLength
+			}
+			if cap(l.FinalityBranch[indx]) == 0 {
+				l.FinalityBranch[indx] = make([]byte, 0, len(buf))
+			}
+			l.FinalityBranch[indx] = append(l.FinalityBranch[indx], buf...)
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the LightClientFinalityUpdateElectra object
+func (l *LightClientFinalityUpdateElectra) SizeSSZ() (size int) {
+	size = 180
+
+	// Field (0) 'AttestedHeader'
+	if l.AttestedHeader == nil {
+		l.AttestedHeader = new(LightClientHeaderDeneb)
+	}
+	size += l.AttestedHeader.SizeSSZ()
+
+	// Field (1) 'FinalizedHeader'
+	if l.FinalizedHeader == nil {
+		l.FinalizedHeader = new(LightClientHeaderDeneb)
+	}
+	size += l.FinalizedHeader.SizeSSZ()
+
+	// Field (2) 'FinalityBranch'
+	for ii := 0; ii < len(l.FinalityBranch); ii++ {
+		size += 4
+		size += len(l.FinalityBranch[ii])
+	}
+
+	return
+}
+
+// HashTreeRoot ssz hashes the LightClientFinalityUpdateElectra object
+func (l *LightClientFinalityUpdateElectra) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(l)
+}
+
+// HashTreeRootWith ssz hashes the LightClientFinalityUpdateElectra object with a hasher
+func (l *LightClientFinalityUpdateElectra) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'AttestedHeader'
+	if err = l.AttestedHeader.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (1) 'FinalizedHeader'
+	if err = l.FinalizedHeader.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (2) 'FinalityBranch'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(l.FinalityBranch))
+		if num > 7 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range l.FinalityBranch {
+			{
+				elemIndx := hh.Index()
+				byteLen := uint64(len(elem))
+				if byteLen > 32 {
+					err = ssz.ErrIncorrectListSize
+					return
+				}
+				hh.AppendBytes32(elem)
+				hh.MerkleizeWithMixin(elemIndx, byteLen, (32+31)/32)
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 7)
+	}
+
+	// Field (3) 'SyncAggregate'
+	if err = l.SyncAggregate.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (4) 'SignatureSlot'
+	hh.PutUint64(uint64(l.SignatureSlot))
+
+	hh.Merkleize(indx)
+	return
+}

proto/prysm/v1alpha1/fulu.ssz.go

@@ -0,0 +1,377 @@
+// Code generated by fastssz. DO NOT EDIT.
+// Hash: 4a3e60c60f0d0729fe9feb7ebc13fa7a8dda757273542e39821ecbd42fe1422d
+package eth
+
+import (
+	ssz "github.com/prysmaticlabs/fastssz"
+)
+
+// MarshalSSZ ssz marshals the DataColumnSidecar object
+func (d *DataColumnSidecar) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(d)
+}
+
+// MarshalSSZTo ssz marshals the DataColumnSidecar object to a target array
+func (d *DataColumnSidecar) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(356)
+
+	// Field (0) 'ColumnIndex'
+	dst = ssz.MarshalUint64(dst, d.ColumnIndex)
+
+	// Offset (1) 'DataColumn'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(d.DataColumn) * 2048
+
+	// Offset (2) 'KzgCommitments'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(d.KzgCommitments) * 48
+
+	// Offset (3) 'KzgProof'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(d.KzgProof) * 48
+
+	// Field (4) 'SignedBlockHeader'
+	if d.SignedBlockHeader == nil {
+		d.SignedBlockHeader = new(SignedBeaconBlockHeader)
+	}
+	if dst, err = d.SignedBlockHeader.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (5) 'KzgCommitmentsInclusionProof'
+	if size := len(d.KzgCommitmentsInclusionProof); size != 4 {
+		err = ssz.ErrVectorLengthFn("--.KzgCommitmentsInclusionProof", size, 4)
+		return
+	}
+	for ii := 0; ii < 4; ii++ {
+		if size := len(d.KzgCommitmentsInclusionProof[ii]); size != 32 {
+			err = ssz.ErrBytesLengthFn("--.KzgCommitmentsInclusionProof[ii]", size, 32)
+			return
+		}
+		dst = append(dst, d.KzgCommitmentsInclusionProof[ii]...)
+	}
+
+	// Field (1) 'DataColumn'
+	if size := len(d.DataColumn); size > 4096 {
+		err = ssz.ErrListTooBigFn("--.DataColumn", size, 4096)
+		return
+	}
+	for ii := 0; ii < len(d.DataColumn); ii++ {
+		if size := len(d.DataColumn[ii]); size != 2048 {
+			err = ssz.ErrBytesLengthFn("--.DataColumn[ii]", size, 2048)
+			return
+		}
+		dst = append(dst, d.DataColumn[ii]...)
+	}
+
+	// Field (2) 'KzgCommitments'
+	if size := len(d.KzgCommitments); size > 4096 {
+		err = ssz.ErrListTooBigFn("--.KzgCommitments", size, 4096)
+		return
+	}
+	for ii := 0; ii < len(d.KzgCommitments); ii++ {
+		if size := len(d.KzgCommitments[ii]); size != 48 {
+			err = ssz.ErrBytesLengthFn("--.KzgCommitments[ii]", size, 48)
+			return
+		}
+		dst = append(dst, d.KzgCommitments[ii]...)
+	}
+
+	// Field (3) 'KzgProof'
+	if size := len(d.KzgProof); size > 4096 {
+		err = ssz.ErrListTooBigFn("--.KzgProof", size, 4096)
+		return
+	}
+	for ii := 0; ii < len(d.KzgProof); ii++ {
+		if size := len(d.KzgProof[ii]); size != 48 {
+			err = ssz.ErrBytesLengthFn("--.KzgProof[ii]", size, 48)
+			return
+		}
+		dst = append(dst, d.KzgProof[ii]...)
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the DataColumnSidecar object
+func (d *DataColumnSidecar) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 356 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o1, o2, o3 uint64
+
+	// Field (0) 'ColumnIndex'
+	d.ColumnIndex = ssz.UnmarshallUint64(buf[0:8])
+
+	// Offset (1) 'DataColumn'
+	if o1 = ssz.ReadOffset(buf[8:12]); o1 > size {
+		return ssz.ErrOffset
+	}
+
+	if o1 != 356 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Offset (2) 'KzgCommitments'
+	if o2 = ssz.ReadOffset(buf[12:16]); o2 > size || o1 > o2 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (3) 'KzgProof'
+	if o3 = ssz.ReadOffset(buf[16:20]); o3 > size || o2 > o3 {
+		return ssz.ErrOffset
+	}
+
+	// Field (4) 'SignedBlockHeader'
+	if d.SignedBlockHeader == nil {
+		d.SignedBlockHeader = new(SignedBeaconBlockHeader)
+	}
+	if err = d.SignedBlockHeader.UnmarshalSSZ(buf[20:228]); err != nil {
+		return err
+	}
+
+	// Field (5) 'KzgCommitmentsInclusionProof'
+	d.KzgCommitmentsInclusionProof = make([][]byte, 4)
+	for ii := 0; ii < 4; ii++ {
+		if cap(d.KzgCommitmentsInclusionProof[ii]) == 0 {
+			d.KzgCommitmentsInclusionProof[ii] = make([]byte, 0, len(buf[228:356][ii*32:(ii+1)*32]))
+		}
+		d.KzgCommitmentsInclusionProof[ii] = append(d.KzgCommitmentsInclusionProof[ii], buf[228:356][ii*32:(ii+1)*32]...)
+	}
+
+	// Field (1) 'DataColumn'
+	{
+		buf = tail[o1:o2]
+		num, err := ssz.DivideInt2(len(buf), 2048, 4096)
+		if err != nil {
+			return err
+		}
+		d.DataColumn = make([][]byte, num)
+		for ii := 0; ii < num; ii++ {
+			if cap(d.DataColumn[ii]) == 0 {
+				d.DataColumn[ii] = make([]byte, 0, len(buf[ii*2048:(ii+1)*2048]))
+			}
+			d.DataColumn[ii] = append(d.DataColumn[ii], buf[ii*2048:(ii+1)*2048]...)
+		}
+	}
+
+	// Field (2) 'KzgCommitments'
+	{
+		buf = tail[o2:o3]
+		num, err := ssz.DivideInt2(len(buf), 48, 4096)
+		if err != nil {
+			return err
+		}
+		d.KzgCommitments = make([][]byte, num)
+		for ii := 0; ii < num; ii++ {
+			if cap(d.KzgCommitments[ii]) == 0 {
+				d.KzgCommitments[ii] = make([]byte, 0, len(buf[ii*48:(ii+1)*48]))
+			}
+			d.KzgCommitments[ii] = append(d.KzgCommitments[ii], buf[ii*48:(ii+1)*48]...)
+		}
+	}
+
+	// Field (3) 'KzgProof'
+	{
+		buf = tail[o3:]
+		num, err := ssz.DivideInt2(len(buf), 48, 4096)
+		if err != nil {
+			return err
+		}
+		d.KzgProof = make([][]byte, num)
+		for ii := 0; ii < num; ii++ {
+			if cap(d.KzgProof[ii]) == 0 {
+				d.KzgProof[ii] = make([]byte, 0, len(buf[ii*48:(ii+1)*48]))
+			}
+			d.KzgProof[ii] = append(d.KzgProof[ii], buf[ii*48:(ii+1)*48]...)
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the DataColumnSidecar object
+func (d *DataColumnSidecar) SizeSSZ() (size int) {
+	size = 356
+
+	// Field (1) 'DataColumn'
+	size += len(d.DataColumn) * 2048
+
+	// Field (2) 'KzgCommitments'
+	size += len(d.KzgCommitments) * 48
+
+	// Field (3) 'KzgProof'
+	size += len(d.KzgProof) * 48
+
+	return
+}
+
+// HashTreeRoot ssz hashes the DataColumnSidecar object
+func (d *DataColumnSidecar) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(d)
+}
+
+// HashTreeRootWith ssz hashes the DataColumnSidecar object with a hasher
+func (d *DataColumnSidecar) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'ColumnIndex'
+	hh.PutUint64(d.ColumnIndex)
+
+	// Field (1) 'DataColumn'
+	{
+		if size := len(d.DataColumn); size > 4096 {
+			err = ssz.ErrListTooBigFn("--.DataColumn", size, 4096)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range d.DataColumn {
+			if len(i) != 2048 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.PutBytes(i)
+		}
+
+		numItems := uint64(len(d.DataColumn))
+		hh.MerkleizeWithMixin(subIndx, numItems, 4096)
+	}
+
+	// Field (2) 'KzgCommitments'
+	{
+		if size := len(d.KzgCommitments); size > 4096 {
+			err = ssz.ErrListTooBigFn("--.KzgCommitments", size, 4096)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range d.KzgCommitments {
+			if len(i) != 48 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.PutBytes(i)
+		}
+
+		numItems := uint64(len(d.KzgCommitments))
+		hh.MerkleizeWithMixin(subIndx, numItems, 4096)
+	}
+
+	// Field (3) 'KzgProof'
+	{
+		if size := len(d.KzgProof); size > 4096 {
+			err = ssz.ErrListTooBigFn("--.KzgProof", size, 4096)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range d.KzgProof {
+			if len(i) != 48 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.PutBytes(i)
+		}
+
+		numItems := uint64(len(d.KzgProof))
+		hh.MerkleizeWithMixin(subIndx, numItems, 4096)
+	}
+
+	// Field (4) 'SignedBlockHeader'
+	if err = d.SignedBlockHeader.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (5) 'KzgCommitmentsInclusionProof'
+	{
+		if size := len(d.KzgCommitmentsInclusionProof); size != 4 {
+			err = ssz.ErrVectorLengthFn("--.KzgCommitmentsInclusionProof", size, 4)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range d.KzgCommitmentsInclusionProof {
+			if len(i) != 32 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.Append(i)
+		}
+		hh.Merkleize(subIndx)
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
+// MarshalSSZ ssz marshals the DataColumnIdentifier object
+func (d *DataColumnIdentifier) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(d)
+}
+
+// MarshalSSZTo ssz marshals the DataColumnIdentifier object to a target array
+func (d *DataColumnIdentifier) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+
+	// Field (0) 'BlockRoot'
+	if size := len(d.BlockRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockRoot", size, 32)
+		return
+	}
+	dst = append(dst, d.BlockRoot...)
+
+	// Field (1) 'ColumnIndex'
+	dst = ssz.MarshalUint64(dst, d.ColumnIndex)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the DataColumnIdentifier object
+func (d *DataColumnIdentifier) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size != 40 {
+		return ssz.ErrSize
+	}
+
+	// Field (0) 'BlockRoot'
+	if cap(d.BlockRoot) == 0 {
+		d.BlockRoot = make([]byte, 0, len(buf[0:32]))
+	}
+	d.BlockRoot = append(d.BlockRoot, buf[0:32]...)
+
+	// Field (1) 'ColumnIndex'
+	d.ColumnIndex = ssz.UnmarshallUint64(buf[32:40])
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the DataColumnIdentifier object
+func (d *DataColumnIdentifier) SizeSSZ() (size int) {
+	size = 40
+	return
+}
+
+// HashTreeRoot ssz hashes the DataColumnIdentifier object
+func (d *DataColumnIdentifier) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(d)
+}
+
+// HashTreeRootWith ssz hashes the DataColumnIdentifier object with a hasher
+func (d *DataColumnIdentifier) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'BlockRoot'
+	if size := len(d.BlockRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockRoot", size, 32)
+		return
+	}
+	hh.PutBytes(d.BlockRoot)
+
+	// Field (1) 'ColumnIndex'
+	hh.PutUint64(d.ColumnIndex)
+
+	hh.Merkleize(indx)
+	return
+}

proto/prysm/v1alpha1/light_client.pb.go

@@ -743,7 +743,7 @@ type LightClientUpdateElectra struct {
 	NextSyncCommittee       *SyncCommittee                                                    `protobuf:"bytes,2,opt,name=next_sync_committee,json=nextSyncCommittee,proto3" json:"next_sync_committee,omitempty"`
 	NextSyncCommitteeBranch [][]byte                                                          `protobuf:"bytes,3,rep,name=next_sync_committee_branch,json=nextSyncCommitteeBranch,proto3" json:"next_sync_committee_branch,omitempty" ssz-size:"6,32"`
 	FinalizedHeader         *LightClientHeaderDeneb                                           `protobuf:"bytes,4,opt,name=finalized_header,json=finalizedHeader,proto3" json:"finalized_header,omitempty"`
-	FinalityBranch          [][]byte                                                          `protobuf:"bytes,5,rep,name=finality_branch,json=finalityBranch,proto3" json:"finality_branch,omitempty" ssz-size:"6,32"`
+	FinalityBranch          [][]byte                                                          `protobuf:"bytes,5,rep,name=finality_branch,json=finalityBranch,proto3" json:"finality_branch,omitempty" ssz-size:"7,32"`
 	SyncAggregate           *SyncAggregate                                                    `protobuf:"bytes,6,opt,name=sync_aggregate,json=syncAggregate,proto3" json:"sync_aggregate,omitempty"`
 	SignatureSlot           github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot `protobuf:"varint,7,opt,name=signature_slot,json=signatureSlot,proto3" json:"signature_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"`
 }
@@ -1066,6 +1066,85 @@ func (x *LightClientFinalityUpdateDeneb) GetSignatureSlot() github_com_prysmatic
 	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
 }
 
+type LightClientFinalityUpdateElectra struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	AttestedHeader  *LightClientHeaderDeneb                                           `protobuf:"bytes,1,opt,name=attested_header,json=attestedHeader,proto3" json:"attested_header,omitempty"`
+	FinalizedHeader *LightClientHeaderDeneb                                           `protobuf:"bytes,2,opt,name=finalized_header,json=finalizedHeader,proto3" json:"finalized_header,omitempty"`
+	FinalityBranch  [][]byte                                                          `protobuf:"bytes,3,rep,name=finality_branch,json=finalityBranch,proto3" json:"finality_branch,omitempty" ssz-max:"7,32"`
+	SyncAggregate   *SyncAggregate                                                    `protobuf:"bytes,4,opt,name=sync_aggregate,json=syncAggregate,proto3" json:"sync_aggregate,omitempty"`
+	SignatureSlot   github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot `protobuf:"varint,5,opt,name=signature_slot,json=signatureSlot,proto3" json:"signature_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"`
+}
+
+func (x *LightClientFinalityUpdateElectra) Reset() {
+	*x = LightClientFinalityUpdateElectra{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *LightClientFinalityUpdateElectra) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LightClientFinalityUpdateElectra) ProtoMessage() {}
+
+func (x *LightClientFinalityUpdateElectra) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use LightClientFinalityUpdateElectra.ProtoReflect.Descriptor instead.
+func (*LightClientFinalityUpdateElectra) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *LightClientFinalityUpdateElectra) GetAttestedHeader() *LightClientHeaderDeneb {
+	if x != nil {
+		return x.AttestedHeader
+	}
+	return nil
+}
+
+func (x *LightClientFinalityUpdateElectra) GetFinalizedHeader() *LightClientHeaderDeneb {
+	if x != nil {
+		return x.FinalizedHeader
+	}
+	return nil
+}
+
+func (x *LightClientFinalityUpdateElectra) GetFinalityBranch() [][]byte {
+	if x != nil {
+		return x.FinalityBranch
+	}
+	return nil
+}
+
+func (x *LightClientFinalityUpdateElectra) GetSyncAggregate() *SyncAggregate {
+	if x != nil {
+		return x.SyncAggregate
+	}
+	return nil
+}
+
+func (x *LightClientFinalityUpdateElectra) GetSignatureSlot() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot {
+	if x != nil {
+		return x.SignatureSlot
+	}
+	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
+}
+
 type LightClientOptimisticUpdateAltair struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1079,7 +1158,7 @@ type LightClientOptimisticUpdateAltair struct {
 func (x *LightClientOptimisticUpdateAltair) Reset() {
 	*x = LightClientOptimisticUpdateAltair{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[14]
+		mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[15]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1092,7 +1171,7 @@ func (x *LightClientOptimisticUpdateAltair) String() string {
 func (*LightClientOptimisticUpdateAltair) ProtoMessage() {}
 
 func (x *LightClientOptimisticUpdateAltair) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[14]
+	mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[15]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1105,7 +1184,7 @@ func (x *LightClientOptimisticUpdateAltair) ProtoReflect() protoreflect.Message
 
 // Deprecated: Use LightClientOptimisticUpdateAltair.ProtoReflect.Descriptor instead.
 func (*LightClientOptimisticUpdateAltair) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP(), []int{14}
+	return file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP(), []int{15}
 }
 
 func (x *LightClientOptimisticUpdateAltair) GetAttestedHeader() *LightClientHeaderAltair {
@@ -1142,7 +1221,7 @@ type LightClientOptimisticUpdateCapella struct {
 func (x *LightClientOptimisticUpdateCapella) Reset() {
 	*x = LightClientOptimisticUpdateCapella{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[15]
+		mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[16]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1155,7 +1234,7 @@ func (x *LightClientOptimisticUpdateCapella) String() string {
 func (*LightClientOptimisticUpdateCapella) ProtoMessage() {}
 
 func (x *LightClientOptimisticUpdateCapella) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[15]
+	mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[16]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1168,7 +1247,7 @@ func (x *LightClientOptimisticUpdateCapella) ProtoReflect() protoreflect.Message
 
 // Deprecated: Use LightClientOptimisticUpdateCapella.ProtoReflect.Descriptor instead.
 func (*LightClientOptimisticUpdateCapella) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP(), []int{15}
+	return file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP(), []int{16}
 }
 
 func (x *LightClientOptimisticUpdateCapella) GetAttestedHeader() *LightClientHeaderCapella {
@@ -1205,7 +1284,7 @@ type LightClientOptimisticUpdateDeneb struct {
 func (x *LightClientOptimisticUpdateDeneb) Reset() {
 	*x = LightClientOptimisticUpdateDeneb{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[16]
+		mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1218,7 +1297,7 @@ func (x *LightClientOptimisticUpdateDeneb) String() string {
 func (*LightClientOptimisticUpdateDeneb) ProtoMessage() {}
 
 func (x *LightClientOptimisticUpdateDeneb) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[16]
+	mi := &file_proto_prysm_v1alpha1_light_client_proto_msgTypes[17]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1231,7 +1310,7 @@ func (x *LightClientOptimisticUpdateDeneb) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LightClientOptimisticUpdateDeneb.ProtoReflect.Descriptor instead.
 func (*LightClientOptimisticUpdateDeneb) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP(), []int{16}
+	return file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP(), []int{17}
 }
 
 func (x *LightClientOptimisticUpdateDeneb) GetAttestedHeader() *LightClientHeaderDeneb {
@@ -1511,7 +1590,7 @@ var file_proto_prysm_v1alpha1_light_client_proto_rawDesc = []byte{
 	0x72, 0x44, 0x65, 0x6e, 0x65, 0x62, 0x52, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65,
 	0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c,
 	0x69, 0x74, 0x79, 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c,
-	0x42, 0x08, 0x8a, 0xb5, 0x18, 0x04, 0x36, 0x2c, 0x33, 0x32, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61,
+	0x42, 0x08, 0x8a, 0xb5, 0x18, 0x04, 0x37, 0x2c, 0x33, 0x32, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61,
 	0x6c, 0x69, 0x74, 0x79, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x4b, 0x0a, 0x0e, 0x73, 0x79,
 	0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01,
 	0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
@@ -1609,76 +1688,104 @@ var file_proto_prysm_v1alpha1_light_client_proto_rawDesc = []byte{
 	0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73,
 	0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69,
 	0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74,
-	0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0xb7, 0x02, 0x0a, 0x21, 0x4c, 0x69, 0x67, 0x68,
-	0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69,
-	0x63, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x6c, 0x74, 0x61, 0x69, 0x72, 0x12, 0x57, 0x0a,
-	0x0f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
-	0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c,
-	0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72,
-	0x41, 0x6c, 0x74, 0x61, 0x69, 0x72, 0x52, 0x0e, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64,
-	0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x4b, 0x0a, 0x0e, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x61,
-	0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24,
+	0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0xc2, 0x03, 0x0a, 0x20, 0x4c, 0x69, 0x67, 0x68,
+	0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x55,
+	0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x61, 0x12, 0x56, 0x0a, 0x0f,
+	0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
+	0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69,
+	0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x44,
+	0x65, 0x6e, 0x65, 0x62, 0x52, 0x0e, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x48, 0x65,
+	0x61, 0x64, 0x65, 0x72, 0x12, 0x58, 0x0a, 0x10, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65,
+	0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d,
 	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
-	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65,
-	0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67,
-	0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
-	0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18,
-	0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73,
-	0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f,
-	0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70,
-	0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c,
-	0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f,
-	0x74, 0x22, 0xb9, 0x02, 0x0a, 0x22, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, 0x74,
-	0x65, 0x43, 0x61, 0x70, 0x65, 0x6c, 0x6c, 0x61, 0x12, 0x58, 0x0a, 0x0f, 0x61, 0x74, 0x74, 0x65,
-	0x73, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x2f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68,
-	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43,
-	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x43, 0x61, 0x70, 0x65, 0x6c,
-	0x6c, 0x61, 0x52, 0x0e, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64,
-	0x65, 0x72, 0x12, 0x4b, 0x0a, 0x0e, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65,
-	0x67, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65,
-	0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12,
-	0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x73, 0x6c, 0x6f,
-	0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74,
-	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69,
-	0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63,
-	0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70,
-	0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0d,
-	0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0xb5, 0x02,
-	0x0a, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4f, 0x70, 0x74,
-	0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x44, 0x65, 0x6e,
-	0x65, 0x62, 0x12, 0x56, 0x0a, 0x0f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x68,
-	0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x65, 0x74,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65,
+	0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x65, 0x6e, 0x65, 0x62, 0x52, 0x0f, 0x66,
+	0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x31,
+	0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x63,
+	0x68, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x08, 0x92, 0xb5, 0x18, 0x04, 0x37, 0x2c, 0x33,
+	0x32, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x42, 0x72, 0x61, 0x6e, 0x63,
+	0x68, 0x12, 0x4b, 0x0a, 0x0e, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67,
+	0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65,
+	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x52,
+	0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x6c,
+	0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x73, 0x6c, 0x6f, 0x74,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63,
+	0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f,
+	0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72,
+	0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0d, 0x73,
+	0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0xb7, 0x02, 0x0a,
+	0x21, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69,
+	0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x6c, 0x74, 0x61,
+	0x69, 0x72, 0x12, 0x57, 0x0a, 0x0f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x68,
+	0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x74,
 	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
 	0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x48,
-	0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x65, 0x6e, 0x65, 0x62, 0x52, 0x0e, 0x61, 0x74, 0x74, 0x65,
-	0x73, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x4b, 0x0a, 0x0e, 0x73, 0x79,
-	0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
-	0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41,
-	0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67,
-	0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61,
-	0x74, 0x75, 0x72, 0x65, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42,
-	0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
-	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
-	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73,
-	0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65,
-	0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
-	0x65, 0x53, 0x6c, 0x6f, 0x74, 0x42, 0x99, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
-	0x68, 0x61, 0x31, 0x42, 0x10, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74,
-	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62,
-	0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74,
-	0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68,
-	0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
-	0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x65, 0x61, 0x64, 0x65, 0x72, 0x41, 0x6c, 0x74, 0x61, 0x69, 0x72, 0x52, 0x0e, 0x61, 0x74, 0x74,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x4b, 0x0a, 0x0e, 0x73,
+	0x79, 0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
+	0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63,
+	0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41,
+	0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e,
+	0x61, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04,
+	0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
+	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70,
+	0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75,
+	0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76,
+	0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
+	0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0xb9, 0x02, 0x0a, 0x22, 0x4c, 0x69, 0x67, 0x68, 0x74,
+	0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63,
+	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x61, 0x70, 0x65, 0x6c, 0x6c, 0x61, 0x12, 0x58, 0x0a,
+	0x0f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c,
+	0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72,
+	0x43, 0x61, 0x70, 0x65, 0x6c, 0x6c, 0x61, 0x52, 0x0e, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x4b, 0x0a, 0x0e, 0x73, 0x79, 0x6e, 0x63, 0x5f,
+	0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72,
+	0x65, 0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65,
+	0x67, 0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
+	0x65, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5,
+	0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79,
+	0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d,
+	0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53,
+	0x6c, 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c,
+	0x6f, 0x74, 0x22, 0xb5, 0x02, 0x0a, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65,
+	0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x44, 0x65, 0x6e, 0x65, 0x62, 0x12, 0x56, 0x0a, 0x0f, 0x61, 0x74, 0x74, 0x65, 0x73,
+	0x74, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
+	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c,
+	0x69, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x65, 0x6e, 0x65, 0x62, 0x52,
+	0x0e, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12,
+	0x4b, 0x0a, 0x0e, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
+	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
+	0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73,
+	0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e,
+	0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61,
+	0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73,
+	0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d,
+	0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67,
+	0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x42, 0x99, 0x01, 0x0a, 0x19, 0x6f,
+	0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
+	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x10, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43,
+	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x38, 0x67, 0x69,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74,
+	0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02,
+	0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -1693,7 +1800,7 @@ func file_proto_prysm_v1alpha1_light_client_proto_rawDescGZIP() []byte {
 	return file_proto_prysm_v1alpha1_light_client_proto_rawDescData
 }
 
-var file_proto_prysm_v1alpha1_light_client_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
+var file_proto_prysm_v1alpha1_light_client_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
 var file_proto_prysm_v1alpha1_light_client_proto_goTypes = []interface{}{
 	(*LightClientHeaderAltair)(nil),            // 0: ethereum.eth.v1alpha1.LightClientHeaderAltair
 	(*LightClientHeaderCapella)(nil),           // 1: ethereum.eth.v1alpha1.LightClientHeaderCapella
@@ -1709,65 +1816,69 @@ var file_proto_prysm_v1alpha1_light_client_proto_goTypes = []interface{}{
 	(*LightClientFinalityUpdateAltair)(nil),    // 11: ethereum.eth.v1alpha1.LightClientFinalityUpdateAltair
 	(*LightClientFinalityUpdateCapella)(nil),   // 12: ethereum.eth.v1alpha1.LightClientFinalityUpdateCapella
 	(*LightClientFinalityUpdateDeneb)(nil),     // 13: ethereum.eth.v1alpha1.LightClientFinalityUpdateDeneb
-	(*LightClientOptimisticUpdateAltair)(nil),  // 14: ethereum.eth.v1alpha1.LightClientOptimisticUpdateAltair
-	(*LightClientOptimisticUpdateCapella)(nil), // 15: ethereum.eth.v1alpha1.LightClientOptimisticUpdateCapella
-	(*LightClientOptimisticUpdateDeneb)(nil),   // 16: ethereum.eth.v1alpha1.LightClientOptimisticUpdateDeneb
-	(*BeaconBlockHeader)(nil),                  // 17: ethereum.eth.v1alpha1.BeaconBlockHeader
-	(*v1.ExecutionPayloadHeaderCapella)(nil),   // 18: ethereum.engine.v1.ExecutionPayloadHeaderCapella
-	(*v1.ExecutionPayloadHeaderDeneb)(nil),     // 19: ethereum.engine.v1.ExecutionPayloadHeaderDeneb
-	(*SyncCommittee)(nil),                      // 20: ethereum.eth.v1alpha1.SyncCommittee
-	(*SyncAggregate)(nil),                      // 21: ethereum.eth.v1alpha1.SyncAggregate
+	(*LightClientFinalityUpdateElectra)(nil),   // 14: ethereum.eth.v1alpha1.LightClientFinalityUpdateElectra
+	(*LightClientOptimisticUpdateAltair)(nil),  // 15: ethereum.eth.v1alpha1.LightClientOptimisticUpdateAltair
+	(*LightClientOptimisticUpdateCapella)(nil), // 16: ethereum.eth.v1alpha1.LightClientOptimisticUpdateCapella
+	(*LightClientOptimisticUpdateDeneb)(nil),   // 17: ethereum.eth.v1alpha1.LightClientOptimisticUpdateDeneb
+	(*BeaconBlockHeader)(nil),                  // 18: ethereum.eth.v1alpha1.BeaconBlockHeader
+	(*v1.ExecutionPayloadHeaderCapella)(nil),   // 19: ethereum.engine.v1.ExecutionPayloadHeaderCapella
+	(*v1.ExecutionPayloadHeaderDeneb)(nil),     // 20: ethereum.engine.v1.ExecutionPayloadHeaderDeneb
+	(*SyncCommittee)(nil),                      // 21: ethereum.eth.v1alpha1.SyncCommittee
+	(*SyncAggregate)(nil),                      // 22: ethereum.eth.v1alpha1.SyncAggregate
 }
 var file_proto_prysm_v1alpha1_light_client_proto_depIdxs = []int32{
-	17, // 0: ethereum.eth.v1alpha1.LightClientHeaderAltair.beacon:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	17, // 1: ethereum.eth.v1alpha1.LightClientHeaderCapella.beacon:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	18, // 2: ethereum.eth.v1alpha1.LightClientHeaderCapella.execution:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderCapella
-	17, // 3: ethereum.eth.v1alpha1.LightClientHeaderDeneb.beacon:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	19, // 4: ethereum.eth.v1alpha1.LightClientHeaderDeneb.execution:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
+	18, // 0: ethereum.eth.v1alpha1.LightClientHeaderAltair.beacon:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	18, // 1: ethereum.eth.v1alpha1.LightClientHeaderCapella.beacon:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	19, // 2: ethereum.eth.v1alpha1.LightClientHeaderCapella.execution:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderCapella
+	18, // 3: ethereum.eth.v1alpha1.LightClientHeaderDeneb.beacon:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	20, // 4: ethereum.eth.v1alpha1.LightClientHeaderDeneb.execution:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
 	0,  // 5: ethereum.eth.v1alpha1.LightClientBootstrapAltair.header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderAltair
-	20, // 6: ethereum.eth.v1alpha1.LightClientBootstrapAltair.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 6: ethereum.eth.v1alpha1.LightClientBootstrapAltair.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	1,  // 7: ethereum.eth.v1alpha1.LightClientBootstrapCapella.header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderCapella
-	20, // 8: ethereum.eth.v1alpha1.LightClientBootstrapCapella.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 8: ethereum.eth.v1alpha1.LightClientBootstrapCapella.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	2,  // 9: ethereum.eth.v1alpha1.LightClientBootstrapDeneb.header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	20, // 10: ethereum.eth.v1alpha1.LightClientBootstrapDeneb.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 10: ethereum.eth.v1alpha1.LightClientBootstrapDeneb.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	2,  // 11: ethereum.eth.v1alpha1.LightClientBootstrapElectra.header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	20, // 12: ethereum.eth.v1alpha1.LightClientBootstrapElectra.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 12: ethereum.eth.v1alpha1.LightClientBootstrapElectra.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	0,  // 13: ethereum.eth.v1alpha1.LightClientUpdateAltair.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderAltair
-	20, // 14: ethereum.eth.v1alpha1.LightClientUpdateAltair.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 14: ethereum.eth.v1alpha1.LightClientUpdateAltair.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	0,  // 15: ethereum.eth.v1alpha1.LightClientUpdateAltair.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderAltair
-	21, // 16: ethereum.eth.v1alpha1.LightClientUpdateAltair.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	22, // 16: ethereum.eth.v1alpha1.LightClientUpdateAltair.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
 	1,  // 17: ethereum.eth.v1alpha1.LightClientUpdateCapella.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderCapella
-	20, // 18: ethereum.eth.v1alpha1.LightClientUpdateCapella.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 18: ethereum.eth.v1alpha1.LightClientUpdateCapella.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	1,  // 19: ethereum.eth.v1alpha1.LightClientUpdateCapella.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderCapella
-	21, // 20: ethereum.eth.v1alpha1.LightClientUpdateCapella.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	22, // 20: ethereum.eth.v1alpha1.LightClientUpdateCapella.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
 	2,  // 21: ethereum.eth.v1alpha1.LightClientUpdateDeneb.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	20, // 22: ethereum.eth.v1alpha1.LightClientUpdateDeneb.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 22: ethereum.eth.v1alpha1.LightClientUpdateDeneb.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	2,  // 23: ethereum.eth.v1alpha1.LightClientUpdateDeneb.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	21, // 24: ethereum.eth.v1alpha1.LightClientUpdateDeneb.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	22, // 24: ethereum.eth.v1alpha1.LightClientUpdateDeneb.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
 	2,  // 25: ethereum.eth.v1alpha1.LightClientUpdateElectra.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	20, // 26: ethereum.eth.v1alpha1.LightClientUpdateElectra.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	21, // 26: ethereum.eth.v1alpha1.LightClientUpdateElectra.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
 	2,  // 27: ethereum.eth.v1alpha1.LightClientUpdateElectra.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	21, // 28: ethereum.eth.v1alpha1.LightClientUpdateElectra.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	22, // 28: ethereum.eth.v1alpha1.LightClientUpdateElectra.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
 	0,  // 29: ethereum.eth.v1alpha1.LightClientFinalityUpdateAltair.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderAltair
 	0,  // 30: ethereum.eth.v1alpha1.LightClientFinalityUpdateAltair.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderAltair
-	21, // 31: ethereum.eth.v1alpha1.LightClientFinalityUpdateAltair.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	22, // 31: ethereum.eth.v1alpha1.LightClientFinalityUpdateAltair.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
 	1,  // 32: ethereum.eth.v1alpha1.LightClientFinalityUpdateCapella.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderCapella
 	1,  // 33: ethereum.eth.v1alpha1.LightClientFinalityUpdateCapella.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderCapella
-	21, // 34: ethereum.eth.v1alpha1.LightClientFinalityUpdateCapella.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	22, // 34: ethereum.eth.v1alpha1.LightClientFinalityUpdateCapella.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
 	2,  // 35: ethereum.eth.v1alpha1.LightClientFinalityUpdateDeneb.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
 	2,  // 36: ethereum.eth.v1alpha1.LightClientFinalityUpdateDeneb.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	21, // 37: ethereum.eth.v1alpha1.LightClientFinalityUpdateDeneb.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
-	0,  // 38: ethereum.eth.v1alpha1.LightClientOptimisticUpdateAltair.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderAltair
-	21, // 39: ethereum.eth.v1alpha1.LightClientOptimisticUpdateAltair.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
-	1,  // 40: ethereum.eth.v1alpha1.LightClientOptimisticUpdateCapella.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderCapella
-	21, // 41: ethereum.eth.v1alpha1.LightClientOptimisticUpdateCapella.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
-	2,  // 42: ethereum.eth.v1alpha1.LightClientOptimisticUpdateDeneb.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
-	21, // 43: ethereum.eth.v1alpha1.LightClientOptimisticUpdateDeneb.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
-	44, // [44:44] is the sub-list for method output_type
-	44, // [44:44] is the sub-list for method input_type
-	44, // [44:44] is the sub-list for extension type_name
-	44, // [44:44] is the sub-list for extension extendee
-	0,  // [0:44] is the sub-list for field type_name
+	22, // 37: ethereum.eth.v1alpha1.LightClientFinalityUpdateDeneb.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	2,  // 38: ethereum.eth.v1alpha1.LightClientFinalityUpdateElectra.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
+	2,  // 39: ethereum.eth.v1alpha1.LightClientFinalityUpdateElectra.finalized_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
+	22, // 40: ethereum.eth.v1alpha1.LightClientFinalityUpdateElectra.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	0,  // 41: ethereum.eth.v1alpha1.LightClientOptimisticUpdateAltair.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderAltair
+	22, // 42: ethereum.eth.v1alpha1.LightClientOptimisticUpdateAltair.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	1,  // 43: ethereum.eth.v1alpha1.LightClientOptimisticUpdateCapella.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderCapella
+	22, // 44: ethereum.eth.v1alpha1.LightClientOptimisticUpdateCapella.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	2,  // 45: ethereum.eth.v1alpha1.LightClientOptimisticUpdateDeneb.attested_header:type_name -> ethereum.eth.v1alpha1.LightClientHeaderDeneb
+	22, // 46: ethereum.eth.v1alpha1.LightClientOptimisticUpdateDeneb.sync_aggregate:type_name -> ethereum.eth.v1alpha1.SyncAggregate
+	47, // [47:47] is the sub-list for method output_type
+	47, // [47:47] is the sub-list for method input_type
+	47, // [47:47] is the sub-list for extension type_name
+	47, // [47:47] is the sub-list for extension extendee
+	0,  // [0:47] is the sub-list for field type_name
 }
 
 func init() { file_proto_prysm_v1alpha1_light_client_proto_init() }
@@ -1947,7 +2058,7 @@ func file_proto_prysm_v1alpha1_light_client_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_light_client_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*LightClientOptimisticUpdateAltair); i {
+			switch v := v.(*LightClientFinalityUpdateElectra); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1959,7 +2070,7 @@ func file_proto_prysm_v1alpha1_light_client_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_light_client_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*LightClientOptimisticUpdateCapella); i {
+			switch v := v.(*LightClientOptimisticUpdateAltair); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1971,6 +2082,18 @@ func file_proto_prysm_v1alpha1_light_client_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_light_client_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*LightClientOptimisticUpdateCapella); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_light_client_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LightClientOptimisticUpdateDeneb); i {
 			case 0:
 				return &v.state
@@ -1989,7 +2112,7 @@ func file_proto_prysm_v1alpha1_light_client_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_prysm_v1alpha1_light_client_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   17,
+			NumMessages:   18,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/prysm/v1alpha1/light_client.proto

@@ -102,7 +102,7 @@ message LightClientUpdateElectra {
   SyncCommittee next_sync_committee = 2;
   repeated bytes next_sync_committee_branch = 3 [(ethereum.eth.ext.ssz_size) = "6,32"];
   LightClientHeaderDeneb finalized_header = 4;
-  repeated bytes finality_branch = 5 [(ethereum.eth.ext.ssz_size) = "6,32"];
+  repeated bytes finality_branch = 5 [(ethereum.eth.ext.ssz_size) = "7,32"];
   SyncAggregate sync_aggregate = 6;
   uint64 signature_slot = 7 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
 }
@@ -131,6 +131,14 @@ message LightClientFinalityUpdateDeneb {
   uint64 signature_slot = 5 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
 }
 
+message LightClientFinalityUpdateElectra {
+  LightClientHeaderDeneb attested_header = 1;
+  LightClientHeaderDeneb finalized_header = 2;
+  repeated bytes finality_branch = 3 [(ethereum.eth.ext.ssz_max) = "7,32"];
+  SyncAggregate sync_aggregate = 4;
+  uint64 signature_slot = 5 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
+}
+
 message LightClientOptimisticUpdateAltair {
   LightClientHeaderAltair attested_header = 1;
   SyncAggregate sync_aggregate = 2;

proto/prysm/v1alpha1/non-core.ssz.go

@@ -1,5 +1,5 @@
 // Code generated by fastssz. DO NOT EDIT.
-// Hash: bfd7d6b556134c3bd236b880245717aa01ae79573b33f2746a08c165ba5dcedb
+// Hash: c9ac7a1f653faa9b9d8f1ffba7c326db17da4f0005bf98299770bc52c93c7e11
 package eth
 
 import (
@@ -551,6 +551,106 @@ func (m *MetaDataV1) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	return
 }
 
+// MarshalSSZ ssz marshals the MetaDataV2 object
+func (m *MetaDataV2) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(m)
+}
+
+// MarshalSSZTo ssz marshals the MetaDataV2 object to a target array
+func (m *MetaDataV2) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+
+	// Field (0) 'SeqNumber'
+	dst = ssz.MarshalUint64(dst, m.SeqNumber)
+
+	// Field (1) 'Attnets'
+	if size := len(m.Attnets); size != 8 {
+		err = ssz.ErrBytesLengthFn("--.Attnets", size, 8)
+		return
+	}
+	dst = append(dst, m.Attnets...)
+
+	// Field (2) 'Syncnets'
+	if size := len(m.Syncnets); size != 1 {
+		err = ssz.ErrBytesLengthFn("--.Syncnets", size, 1)
+		return
+	}
+	dst = append(dst, m.Syncnets...)
+
+	// Field (3) 'CustodySubnetCount'
+	dst = ssz.MarshalUint64(dst, m.CustodySubnetCount)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the MetaDataV2 object
+func (m *MetaDataV2) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size != 25 {
+		return ssz.ErrSize
+	}
+
+	// Field (0) 'SeqNumber'
+	m.SeqNumber = ssz.UnmarshallUint64(buf[0:8])
+
+	// Field (1) 'Attnets'
+	if cap(m.Attnets) == 0 {
+		m.Attnets = make([]byte, 0, len(buf[8:16]))
+	}
+	m.Attnets = append(m.Attnets, buf[8:16]...)
+
+	// Field (2) 'Syncnets'
+	if cap(m.Syncnets) == 0 {
+		m.Syncnets = make([]byte, 0, len(buf[16:17]))
+	}
+	m.Syncnets = append(m.Syncnets, buf[16:17]...)
+
+	// Field (3) 'CustodySubnetCount'
+	m.CustodySubnetCount = ssz.UnmarshallUint64(buf[17:25])
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the MetaDataV2 object
+func (m *MetaDataV2) SizeSSZ() (size int) {
+	size = 25
+	return
+}
+
+// HashTreeRoot ssz hashes the MetaDataV2 object
+func (m *MetaDataV2) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(m)
+}
+
+// HashTreeRootWith ssz hashes the MetaDataV2 object with a hasher
+func (m *MetaDataV2) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'SeqNumber'
+	hh.PutUint64(m.SeqNumber)
+
+	// Field (1) 'Attnets'
+	if size := len(m.Attnets); size != 8 {
+		err = ssz.ErrBytesLengthFn("--.Attnets", size, 8)
+		return
+	}
+	hh.PutBytes(m.Attnets)
+
+	// Field (2) 'Syncnets'
+	if size := len(m.Syncnets); size != 1 {
+		err = ssz.ErrBytesLengthFn("--.Syncnets", size, 1)
+		return
+	}
+	hh.PutBytes(m.Syncnets)
+
+	// Field (3) 'CustodySubnetCount'
+	hh.PutUint64(m.CustodySubnetCount)
+
+	hh.Merkleize(indx)
+	return
+}
+
 // MarshalSSZ ssz marshals the BlobSidecarsByRangeRequest object
 func (b *BlobSidecarsByRangeRequest) MarshalSSZ() ([]byte, error) {
 	return ssz.MarshalSSZ(b)
@@ -611,6 +711,124 @@ func (b *BlobSidecarsByRangeRequest) HashTreeRootWith(hh *ssz.Hasher) (err error
 	return
 }
 
+// MarshalSSZ ssz marshals the DataColumnSidecarsByRangeRequest object
+func (d *DataColumnSidecarsByRangeRequest) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(d)
+}
+
+// MarshalSSZTo ssz marshals the DataColumnSidecarsByRangeRequest object to a target array
+func (d *DataColumnSidecarsByRangeRequest) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(20)
+
+	// Field (0) 'StartSlot'
+	dst = ssz.MarshalUint64(dst, uint64(d.StartSlot))
+
+	// Field (1) 'Count'
+	dst = ssz.MarshalUint64(dst, d.Count)
+
+	// Offset (2) 'Columns'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(d.Columns) * 8
+
+	// Field (2) 'Columns'
+	if size := len(d.Columns); size > 128 {
+		err = ssz.ErrListTooBigFn("--.Columns", size, 128)
+		return
+	}
+	for ii := 0; ii < len(d.Columns); ii++ {
+		dst = ssz.MarshalUint64(dst, d.Columns[ii])
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the DataColumnSidecarsByRangeRequest object
+func (d *DataColumnSidecarsByRangeRequest) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 20 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o2 uint64
+
+	// Field (0) 'StartSlot'
+	d.StartSlot = github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+
+	// Field (1) 'Count'
+	d.Count = ssz.UnmarshallUint64(buf[8:16])
+
+	// Offset (2) 'Columns'
+	if o2 = ssz.ReadOffset(buf[16:20]); o2 > size {
+		return ssz.ErrOffset
+	}
+
+	if o2 != 20 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (2) 'Columns'
+	{
+		buf = tail[o2:]
+		num, err := ssz.DivideInt2(len(buf), 8, 128)
+		if err != nil {
+			return err
+		}
+		d.Columns = ssz.ExtendUint64(d.Columns, num)
+		for ii := 0; ii < num; ii++ {
+			d.Columns[ii] = ssz.UnmarshallUint64(buf[ii*8 : (ii+1)*8])
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the DataColumnSidecarsByRangeRequest object
+func (d *DataColumnSidecarsByRangeRequest) SizeSSZ() (size int) {
+	size = 20
+
+	// Field (2) 'Columns'
+	size += len(d.Columns) * 8
+
+	return
+}
+
+// HashTreeRoot ssz hashes the DataColumnSidecarsByRangeRequest object
+func (d *DataColumnSidecarsByRangeRequest) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(d)
+}
+
+// HashTreeRootWith ssz hashes the DataColumnSidecarsByRangeRequest object with a hasher
+func (d *DataColumnSidecarsByRangeRequest) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'StartSlot'
+	hh.PutUint64(uint64(d.StartSlot))
+
+	// Field (1) 'Count'
+	hh.PutUint64(d.Count)
+
+	// Field (2) 'Columns'
+	{
+		if size := len(d.Columns); size > 128 {
+			err = ssz.ErrListTooBigFn("--.Columns", size, 128)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range d.Columns {
+			hh.AppendUint64(i)
+		}
+		hh.FillUpTo32()
+
+		numItems := uint64(len(d.Columns))
+		hh.MerkleizeWithMixin(subIndx, numItems, ssz.CalculateLimit(128, numItems, 8))
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
 // MarshalSSZ ssz marshals the DepositSnapshot object
 func (d *DepositSnapshot) MarshalSSZ() ([]byte, error) {
 	return ssz.MarshalSSZ(d)