changelog

* update diff

* deps

* changelog

* remove `SetNextSyncCommitteeBranchElectra`

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,12 +19,13 @@ 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
-- Added validator index label to `validator_statuses` metric
+- 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.
 
 ### Changed
 
@@ -52,10 +53,13 @@ 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)
+- 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)
 
 ### Deprecated
 
@@ -84,6 +88,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - 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)
 
 
 ### Security

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/events/events.go

@@ -451,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))
@@ -483,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))

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) {

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.

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
+}

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",

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/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;

validator/client/aggregate.go

@@ -88,6 +88,7 @@ func (v *validator) SubmitAggregateAndProof(ctx context.Context, slot primitives
 		PublicKey:      pubKey[:],
 		SlotSignature:  slotSig,
 	}
+	// TODO: look at renaming SubmitAggregateSelectionProof functions as they are GET beacon API
 	var agg ethpb.AggregateAttAndProof
 	if postElectra {
 		res, err := v.validatorClient.SubmitAggregateSelectionProofElectra(ctx, aggSelectionRequest, duty.ValidatorIndex, uint64(len(duty.Committee)))

validator/client/beacon-api/BUILD.bazel

@@ -129,6 +129,7 @@ go_test(
         "//network/httputil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//time/slots:go_default_library",

validator/client/beacon-api/beacon_api_validator_client.go

@@ -155,7 +155,12 @@ func (c *beaconApiValidatorClient) ProposeAttestation(ctx context.Context, in *e
 }
 
 func (c *beaconApiValidatorClient) ProposeAttestationElectra(ctx context.Context, in *ethpb.AttestationElectra) (*ethpb.AttestResponse, error) {
-	return nil, errors.New("ProposeAttestationElectra is not implemented")
+	ctx, span := trace.StartSpan(ctx, "beacon-api.ProposeAttestationElectra")
+	defer span.End()
+
+	return wrapInMetrics[*ethpb.AttestResponse]("ProposeAttestationElectra", func() (*ethpb.AttestResponse, error) {
+		return c.proposeAttestationElectra(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) ProposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
@@ -190,7 +195,12 @@ func (c *beaconApiValidatorClient) SubmitAggregateSelectionProof(ctx context.Con
 }
 
 func (c *beaconApiValidatorClient) SubmitAggregateSelectionProofElectra(ctx context.Context, in *ethpb.AggregateSelectionRequest, index primitives.ValidatorIndex, committeeLength uint64) (*ethpb.AggregateSelectionElectraResponse, error) {
-	return nil, errors.New("SubmitAggregateSelectionProofElectra is not implemented")
+	ctx, span := trace.StartSpan(ctx, "beacon-api.SubmitAggregateSelectionProofElectra")
+	defer span.End()
+
+	return wrapInMetrics[*ethpb.AggregateSelectionElectraResponse]("SubmitAggregateSelectionProofElectra", func() (*ethpb.AggregateSelectionElectraResponse, error) {
+		return c.submitAggregateSelectionProofElectra(ctx, in, index, committeeLength)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProof(ctx context.Context, in *ethpb.SignedAggregateSubmitRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
@@ -203,7 +213,12 @@ func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProof(ctx conte
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProofElectra(ctx context.Context, in *ethpb.SignedAggregateSubmitElectraRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
-	return nil, errors.New("SubmitSignedAggregateSelectionProofElectra is not implemented")
+	ctx, span := trace.StartSpan(ctx, "beacon-api.SubmitSignedAggregateSelectionProofElectra")
+	defer span.End()
+
+	return wrapInMetrics[*ethpb.SignedAggregateSubmitResponse]("SubmitSignedAggregateSelectionProofElectra", func() (*ethpb.SignedAggregateSubmitResponse, error) {
+		return c.submitSignedAggregateSelectionProofElectra(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedContributionAndProof(ctx context.Context, in *ethpb.SignedContributionAndProof) (*empty.Empty, error) {

validator/client/beacon-api/beacon_block_json_helpers.go

@@ -51,6 +51,14 @@ func jsonifyAttestations(attestations []*ethpb.Attestation) []*structs.Attestati
 	return jsonAttestations
 }
 
+func jsonifyAttestationsElectra(attestations []*ethpb.AttestationElectra) []*structs.AttestationElectra {
+	jsonAttestations := make([]*structs.AttestationElectra, len(attestations))
+	for index, attestation := range attestations {
+		jsonAttestations[index] = jsonifyAttestationElectra(attestation)
+	}
+	return jsonAttestations
+}
+
 func jsonifyAttesterSlashings(attesterSlashings []*ethpb.AttesterSlashing) []*structs.AttesterSlashing {
 	jsonAttesterSlashings := make([]*structs.AttesterSlashing, len(attesterSlashings))
 	for index, attesterSlashing := range attesterSlashings {
@@ -164,6 +172,15 @@ func jsonifyAttestation(attestation *ethpb.Attestation) *structs.Attestation {
 	}
 }
 
+func jsonifyAttestationElectra(attestation *ethpb.AttestationElectra) *structs.AttestationElectra {
+	return &structs.AttestationElectra{
+		AggregationBits: hexutil.Encode(attestation.AggregationBits),
+		Data:            jsonifyAttestationData(attestation.Data),
+		Signature:       hexutil.Encode(attestation.Signature),
+		CommitteeBits:   hexutil.Encode(attestation.CommitteeBits),
+	}
+}
+
 func jsonifySignedAggregateAndProof(signedAggregateAndProof *ethpb.SignedAggregateAttestationAndProof) *structs.SignedAggregateAttestationAndProof {
 	return &structs.SignedAggregateAttestationAndProof{
 		Message: &structs.AggregateAttestationAndProof{
@@ -175,6 +192,17 @@ func jsonifySignedAggregateAndProof(signedAggregateAndProof *ethpb.SignedAggrega
 	}
 }
 
+func jsonifySignedAggregateAndProofElectra(signedAggregateAndProof *ethpb.SignedAggregateAttestationAndProofElectra) *structs.SignedAggregateAttestationAndProofElectra {
+	return &structs.SignedAggregateAttestationAndProofElectra{
+		Message: &structs.AggregateAttestationAndProofElectra{
+			AggregatorIndex: uint64ToString(signedAggregateAndProof.Message.AggregatorIndex),
+			Aggregate:       jsonifyAttestationElectra(signedAggregateAndProof.Message.Aggregate),
+			SelectionProof:  hexutil.Encode(signedAggregateAndProof.Message.SelectionProof),
+		},
+		Signature: hexutil.Encode(signedAggregateAndProof.Signature),
+	}
+}
+
 func jsonifyWithdrawals(withdrawals []*enginev1.Withdrawal) []*structs.Withdrawal {
 	jsonWithdrawals := make([]*structs.Withdrawal, len(withdrawals))
 	for index, withdrawal := range withdrawals {

validator/client/beacon-api/beacon_block_proto_helpers.go

@@ -197,6 +197,39 @@ func convertAttestationToProto(jsonAttestation *structs.Attestation) (*ethpb.Att
 	}, nil
 }
 
+func convertAttestationElectraToProto(jsonAttestation *structs.AttestationElectra) (*ethpb.AttestationElectra, error) {
+	if jsonAttestation == nil {
+		return nil, errors.New("json attestation is nil")
+	}
+
+	aggregationBits, err := hexutil.Decode(jsonAttestation.AggregationBits)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to decode aggregation bits `%s`", jsonAttestation.AggregationBits)
+	}
+
+	attestationData, err := convertAttestationDataToProto(jsonAttestation.Data)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get attestation data")
+	}
+
+	signature, err := hexutil.Decode(jsonAttestation.Signature)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to decode attestation signature `%s`", jsonAttestation.Signature)
+	}
+
+	committeeBits, err := hexutil.Decode(jsonAttestation.CommitteeBits)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to decode committee bits `%s`", jsonAttestation.CommitteeBits)
+	}
+
+	return &ethpb.AttestationElectra{
+		AggregationBits: aggregationBits,
+		Data:            attestationData,
+		Signature:       signature,
+		CommitteeBits:   committeeBits,
+	}, nil
+}
+
 func convertAttestationsToProto(jsonAttestations []*structs.Attestation) ([]*ethpb.Attestation, error) {
 	var attestations []*ethpb.Attestation
 	for index, jsonAttestation := range jsonAttestations {

validator/client/beacon-api/propose_attestation.go

@@ -4,25 +4,73 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"net/http"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
 func (c *beaconApiValidatorClient) proposeAttestation(ctx context.Context, attestation *ethpb.Attestation) (*ethpb.AttestResponse, error) {
-	if err := checkNilAttestation(attestation); err != nil {
+	if err := validateNilAttestation(attestation); err != nil {
 		return nil, err
 	}
-
 	marshalledAttestation, err := json.Marshal(jsonifyAttestations([]*ethpb.Attestation{attestation}))
 	if err != nil {
 		return nil, err
 	}
 
+	headers := map[string]string{"Eth-Consensus-Version": version.String(attestation.Version())}
+	err = c.jsonRestHandler.Post(
+		ctx,
+		"/eth/v2/beacon/pool/attestations",
+		headers,
+		bytes.NewBuffer(marshalledAttestation),
+		nil,
+	)
+	errJson := &httputil.DefaultJsonError{}
+	if err != nil {
+		// TODO: remove this when v2 becomes default
+		if !errors.As(err, &errJson) {
+			return nil, err
+		}
+		if errJson.Code != http.StatusNotFound {
+			return nil, errJson
+		}
+		log.Debug("Endpoint /eth/v2/beacon/pool/attestations is not supported, falling back to older endpoints for submit attestation.")
+		if err = c.jsonRestHandler.Post(
+			ctx,
+			"/eth/v1/beacon/pool/attestations",
+			nil,
+			bytes.NewBuffer(marshalledAttestation),
+			nil,
+		); err != nil {
+			return nil, err
+		}
+	}
+
+	attestationDataRoot, err := attestation.Data.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to compute attestation data root")
+	}
+
+	return &ethpb.AttestResponse{AttestationDataRoot: attestationDataRoot[:]}, nil
+}
+
+func (c *beaconApiValidatorClient) proposeAttestationElectra(ctx context.Context, attestation *ethpb.AttestationElectra) (*ethpb.AttestResponse, error) {
+	if err := validateNilAttestation(attestation); err != nil {
+		return nil, err
+	}
+	marshalledAttestation, err := json.Marshal(jsonifyAttestationsElectra([]*ethpb.AttestationElectra{attestation}))
+	if err != nil {
+		return nil, err
+	}
+	headers := map[string]string{"Eth-Consensus-Version": version.String(attestation.Version())}
 	if err = c.jsonRestHandler.Post(
 		ctx,
-		"/eth/v1/beacon/pool/attestations",
-		nil,
+		"/eth/v2/beacon/pool/attestations",
+		headers,
 		bytes.NewBuffer(marshalledAttestation),
 		nil,
 	); err != nil {
@@ -37,27 +85,27 @@ func (c *beaconApiValidatorClient) proposeAttestation(ctx context.Context, attes
 	return &ethpb.AttestResponse{AttestationDataRoot: attestationDataRoot[:]}, nil
 }
 
-// checkNilAttestation returns error if attestation or any field of attestation is nil.
-func checkNilAttestation(attestation *ethpb.Attestation) error {
-	if attestation == nil {
-		return errors.New("attestation is nil")
+func validateNilAttestation(attestation ethpb.Att) error {
+	if attestation == nil || attestation.IsNil() {
+		return errors.New("attestation can't be nil")
 	}
-
-	if attestation.Data == nil {
-		return errors.New("attestation data is nil")
+	if attestation.GetData().Source == nil {
+		return errors.New("attestation's source can't be nil")
 	}
-
-	if attestation.Data.Source == nil || attestation.Data.Target == nil {
-		return errors.New("source/target in attestation data is nil")
+	if attestation.GetData().Target == nil {
+		return errors.New("attestation's target can't be nil")
 	}
-
-	if len(attestation.AggregationBits) == 0 {
-		return errors.New("attestation aggregation bits is empty")
+	v := attestation.Version()
+	if len(attestation.GetAggregationBits()) == 0 {
+		return errors.New("attestation's bitfield can't be nil")
 	}
-
-	if len(attestation.Signature) == 0 {
-		return errors.New("attestation signature is empty")
+	if len(attestation.GetSignature()) == 0 {
+		return errors.New("attestation signature can't be nil")
+	}
+	if v >= version.Electra {
+		if len(attestation.CommitteeBitsVal().BitIndices()) == 0 {
+			return errors.New("attestation committee bits can't be nil")
+		}
 	}
-
 	return nil
 }

validator/client/beacon-api/propose_attestation_test.go

@@ -5,9 +5,12 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"net/http"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/beacon-api/mock"
@@ -48,7 +51,7 @@ func TestProposeAttestation(t *testing.T) {
 		},
 		{
 			name:                 "nil attestation",
-			expectedErrorMessage: "attestation is nil",
+			expectedErrorMessage: "attestation can't be nil",
 		},
 		{
 			name: "nil attestation data",
@@ -56,7 +59,7 @@ func TestProposeAttestation(t *testing.T) {
 				AggregationBits: testhelpers.FillByteSlice(4, 74),
 				Signature:       testhelpers.FillByteSlice(96, 82),
 			},
-			expectedErrorMessage: "attestation data is nil",
+			expectedErrorMessage: "attestation can't be nil",
 		},
 		{
 			name: "nil source checkpoint",
@@ -67,7 +70,7 @@ func TestProposeAttestation(t *testing.T) {
 				},
 				Signature: testhelpers.FillByteSlice(96, 82),
 			},
-			expectedErrorMessage: "source/target in attestation data is nil",
+			expectedErrorMessage: "attestation's source can't be nil",
 		},
 		{
 			name: "nil target checkpoint",
@@ -78,7 +81,7 @@ func TestProposeAttestation(t *testing.T) {
 				},
 				Signature: testhelpers.FillByteSlice(96, 82),
 			},
-			expectedErrorMessage: "source/target in attestation data is nil",
+			expectedErrorMessage: "attestation's target can't be nil",
 		},
 		{
 			name: "nil aggregation bits",
@@ -89,7 +92,7 @@ func TestProposeAttestation(t *testing.T) {
 				},
 				Signature: testhelpers.FillByteSlice(96, 82),
 			},
-			expectedErrorMessage: "attestation aggregation bits is empty",
+			expectedErrorMessage: "attestation's bitfield can't be nil",
 		},
 		{
 			name: "nil signature",
@@ -100,7 +103,7 @@ func TestProposeAttestation(t *testing.T) {
 					Target: &ethpb.Checkpoint{},
 				},
 			},
-			expectedErrorMessage: "attestation signature is empty",
+			expectedErrorMessage: "attestation signature can't be nil",
 		},
 		{
 			name:                 "bad request",
@@ -117,7 +120,7 @@ func TestProposeAttestation(t *testing.T) {
 			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			var marshalledAttestations []byte
-			if checkNilAttestation(test.attestation) == nil {
+			if validateNilAttestation(test.attestation) == nil {
 				b, err := json.Marshal(jsonifyAttestations([]*ethpb.Attestation{test.attestation}))
 				require.NoError(t, err)
 				marshalledAttestations = b
@@ -125,10 +128,11 @@ func TestProposeAttestation(t *testing.T) {
 
 			ctx := context.Background()
 
+			headers := map[string]string{"Eth-Consensus-Version": version.String(test.attestation.Version())}
 			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
-				"/eth/v1/beacon/pool/attestations",
-				nil,
+				"/eth/v2/beacon/pool/attestations",
+				headers,
 				bytes.NewBuffer(marshalledAttestations),
 				nil,
 			).Return(
@@ -153,3 +157,235 @@ func TestProposeAttestation(t *testing.T) {
 		})
 	}
 }
+
+func TestProposeAttestationFallBack(t *testing.T) {
+	attestation := &ethpb.Attestation{
+		AggregationBits: testhelpers.FillByteSlice(4, 74),
+		Data: &ethpb.AttestationData{
+			Slot:            75,
+			CommitteeIndex:  76,
+			BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
+			Source: &ethpb.Checkpoint{
+				Epoch: 78,
+				Root:  testhelpers.FillByteSlice(32, 79),
+			},
+			Target: &ethpb.Checkpoint{
+				Epoch: 80,
+				Root:  testhelpers.FillByteSlice(32, 81),
+			},
+		},
+		Signature: testhelpers.FillByteSlice(96, 82),
+	}
+
+	ctrl := gomock.NewController(t)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+	var marshalledAttestations []byte
+	if validateNilAttestation(attestation) == nil {
+		b, err := json.Marshal(jsonifyAttestations([]*ethpb.Attestation{attestation}))
+		require.NoError(t, err)
+		marshalledAttestations = b
+	}
+
+	ctx := context.Background()
+	headers := map[string]string{"Eth-Consensus-Version": version.String(attestation.Version())}
+	jsonRestHandler.EXPECT().Post(
+		gomock.Any(),
+		"/eth/v2/beacon/pool/attestations",
+		headers,
+		bytes.NewBuffer(marshalledAttestations),
+		nil,
+	).Return(
+		&httputil.DefaultJsonError{
+			Code: http.StatusNotFound,
+		},
+	).Times(1)
+
+	jsonRestHandler.EXPECT().Post(
+		gomock.Any(),
+		"/eth/v1/beacon/pool/attestations",
+		nil,
+		bytes.NewBuffer(marshalledAttestations),
+		nil,
+	).Return(
+		nil,
+	).Times(1)
+
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	proposeResponse, err := validatorClient.proposeAttestation(ctx, attestation)
+
+	require.NoError(t, err)
+	require.NotNil(t, proposeResponse)
+
+	expectedAttestationDataRoot, err := attestation.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	// Make sure that the attestation data root is set
+	assert.DeepEqual(t, expectedAttestationDataRoot[:], proposeResponse.AttestationDataRoot)
+}
+
+func TestProposeAttestationElectra(t *testing.T) {
+	attestation := &ethpb.AttestationElectra{
+		AggregationBits: testhelpers.FillByteSlice(4, 74),
+		Data: &ethpb.AttestationData{
+			Slot:            75,
+			CommitteeIndex:  76,
+			BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
+			Source: &ethpb.Checkpoint{
+				Epoch: 78,
+				Root:  testhelpers.FillByteSlice(32, 79),
+			},
+			Target: &ethpb.Checkpoint{
+				Epoch: 80,
+				Root:  testhelpers.FillByteSlice(32, 81),
+			},
+		},
+		Signature:     testhelpers.FillByteSlice(96, 82),
+		CommitteeBits: testhelpers.FillByteSlice(8, 83),
+	}
+
+	tests := []struct {
+		name                 string
+		attestation          *ethpb.AttestationElectra
+		expectedErrorMessage string
+		endpointError        error
+		endpointCall         int
+	}{
+		{
+			name:         "valid",
+			attestation:  attestation,
+			endpointCall: 1,
+		},
+		{
+			name:                 "nil attestation",
+			expectedErrorMessage: "attestation can't be nil",
+		},
+		{
+			name: "nil attestation data",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Signature:       testhelpers.FillByteSlice(96, 82),
+				CommitteeBits:   testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation can't be nil",
+		},
+		{
+			name: "nil source checkpoint",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Target: &ethpb.Checkpoint{},
+				},
+				Signature:     testhelpers.FillByteSlice(96, 82),
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation's source can't be nil",
+		},
+		{
+			name: "nil target checkpoint",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Source: &ethpb.Checkpoint{},
+				},
+				Signature:     testhelpers.FillByteSlice(96, 82),
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation's target can't be nil",
+		},
+		{
+			name: "nil aggregation bits",
+			attestation: &ethpb.AttestationElectra{
+				Data: &ethpb.AttestationData{
+					Source: &ethpb.Checkpoint{},
+					Target: &ethpb.Checkpoint{},
+				},
+				Signature:     testhelpers.FillByteSlice(96, 82),
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation's bitfield can't be nil",
+		},
+		{
+			name: "nil signature",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Source: &ethpb.Checkpoint{},
+					Target: &ethpb.Checkpoint{},
+				},
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			expectedErrorMessage: "attestation signature can't be nil",
+		},
+		{
+			name: "nil committee bits",
+			attestation: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Slot:            75,
+					CommitteeIndex:  76,
+					BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
+					Source: &ethpb.Checkpoint{
+						Epoch: 78,
+						Root:  testhelpers.FillByteSlice(32, 79),
+					},
+					Target: &ethpb.Checkpoint{
+						Epoch: 80,
+						Root:  testhelpers.FillByteSlice(32, 81),
+					},
+				},
+				Signature: testhelpers.FillByteSlice(96, 82),
+			},
+			expectedErrorMessage: "attestation committee bits can't be nil",
+		},
+		{
+			name:                 "bad request",
+			attestation:          attestation,
+			expectedErrorMessage: "bad request",
+			endpointError:        errors.New("bad request"),
+			endpointCall:         1,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			var marshalledAttestations []byte
+			if validateNilAttestation(test.attestation) == nil {
+				b, err := json.Marshal(jsonifyAttestationsElectra([]*ethpb.AttestationElectra{test.attestation}))
+				require.NoError(t, err)
+				marshalledAttestations = b
+			}
+
+			ctx := context.Background()
+			headers := map[string]string{"Eth-Consensus-Version": version.String(test.attestation.Version())}
+			jsonRestHandler.EXPECT().Post(
+				gomock.Any(),
+				"/eth/v2/beacon/pool/attestations",
+				headers,
+				bytes.NewBuffer(marshalledAttestations),
+				nil,
+			).Return(
+				test.endpointError,
+			).Times(test.endpointCall)
+
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			proposeResponse, err := validatorClient.proposeAttestationElectra(ctx, test.attestation)
+			if test.expectedErrorMessage != "" {
+				require.ErrorContains(t, test.expectedErrorMessage, err)
+				return
+			}
+
+			require.NoError(t, err)
+			require.NotNil(t, proposeResponse)
+
+			expectedAttestationDataRoot, err := attestation.Data.HashTreeRoot()
+			require.NoError(t, err)
+
+			// Make sure that the attestation data root is set
+			assert.DeepEqual(t, expectedAttestationDataRoot[:], proposeResponse.AttestationDataRoot)
+		})
+	}
+}

validator/client/beacon-api/submit_aggregate_selection_proof.go

@@ -3,6 +3,7 @@ package beacon_api
 import (
 	"context"
 	"encoding/json"
+	"net/http"
 	"net/url"
 	"strconv"
 
@@ -11,6 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
@@ -20,6 +22,71 @@ func (c *beaconApiValidatorClient) submitAggregateSelectionProof(
 	index primitives.ValidatorIndex,
 	committeeLength uint64,
 ) (*ethpb.AggregateSelectionResponse, error) {
+	attestationDataRoot, err := c.getAttestationDataRootFromRequest(ctx, in, committeeLength)
+	if err != nil {
+		return nil, err
+	}
+
+	aggregateAttestationResponse, err := c.aggregateAttestation(ctx, in.Slot, attestationDataRoot, in.CommitteeIndex)
+	if err != nil {
+		return nil, err
+	}
+
+	var attData *structs.Attestation
+	if err := json.Unmarshal(aggregateAttestationResponse.Data, &attData); err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal aggregate attestation data")
+	}
+
+	aggregatedAttestation, err := convertAttestationToProto(attData)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to convert aggregate attestation json to proto")
+	}
+
+	return &ethpb.AggregateSelectionResponse{
+		AggregateAndProof: &ethpb.AggregateAttestationAndProof{
+			AggregatorIndex: index,
+			Aggregate:       aggregatedAttestation,
+			SelectionProof:  in.SlotSignature,
+		},
+	}, nil
+}
+
+func (c *beaconApiValidatorClient) submitAggregateSelectionProofElectra(
+	ctx context.Context,
+	in *ethpb.AggregateSelectionRequest,
+	index primitives.ValidatorIndex,
+	committeeLength uint64,
+) (*ethpb.AggregateSelectionElectraResponse, error) {
+	attestationDataRoot, err := c.getAttestationDataRootFromRequest(ctx, in, committeeLength)
+	if err != nil {
+		return nil, err
+	}
+
+	aggregateAttestationResponse, err := c.aggregateAttestationElectra(ctx, in.Slot, attestationDataRoot, in.CommitteeIndex)
+	if err != nil {
+		return nil, err
+	}
+
+	var attData *structs.AttestationElectra
+	if err := json.Unmarshal(aggregateAttestationResponse.Data, &attData); err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal aggregate attestation electra data")
+	}
+
+	aggregatedAttestation, err := convertAttestationElectraToProto(attData)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to convert aggregate attestation json to proto")
+	}
+
+	return &ethpb.AggregateSelectionElectraResponse{
+		AggregateAndProof: &ethpb.AggregateAttestationAndProofElectra{
+			AggregatorIndex: index,
+			Aggregate:       aggregatedAttestation,
+			SelectionProof:  in.SlotSignature,
+		},
+	}, nil
+}
+
+func (c *beaconApiValidatorClient) getAttestationDataRootFromRequest(ctx context.Context, in *ethpb.AggregateSelectionRequest, committeeLength uint64) ([]byte, error) {
 	isOptimistic, err := c.isOptimistic(ctx)
 	if err != nil {
 		return nil, err
@@ -47,40 +114,56 @@ func (c *beaconApiValidatorClient) submitAggregateSelectionProof(
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to calculate attestation data root")
 	}
-
-	aggregateAttestationResponse, err := c.aggregateAttestation(ctx, in.Slot, attestationDataRoot[:])
-	if err != nil {
-		return nil, err
-	}
-
-	var attData *structs.Attestation
-	if err := json.Unmarshal(aggregateAttestationResponse.Data, &attData); err != nil {
-		return nil, errors.Wrap(err, "failed to unmarshal aggregate attestation data")
-	}
-
-	aggregatedAttestation, err := convertAttestationToProto(attData)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to convert aggregate attestation json to proto")
-	}
-
-	return &ethpb.AggregateSelectionResponse{
-		AggregateAndProof: &ethpb.AggregateAttestationAndProof{
-			AggregatorIndex: index,
-			Aggregate:       aggregatedAttestation,
-			SelectionProof:  in.SlotSignature,
-		},
-	}, nil
+	return attestationDataRoot[:], nil
 }
 
 func (c *beaconApiValidatorClient) aggregateAttestation(
 	ctx context.Context,
 	slot primitives.Slot,
 	attestationDataRoot []byte,
+	committeeIndex primitives.CommitteeIndex,
 ) (*structs.AggregateAttestationResponse, error) {
 	params := url.Values{}
 	params.Add("slot", strconv.FormatUint(uint64(slot), 10))
 	params.Add("attestation_data_root", hexutil.Encode(attestationDataRoot))
-	endpoint := buildURL("/eth/v1/validator/aggregate_attestation", params)
+	params.Add("committee_index", strconv.FormatUint(uint64(committeeIndex), 10))
+	endpoint := buildURL("/eth/v2/validator/aggregate_attestation", params)
+
+	var aggregateAttestationResponse structs.AggregateAttestationResponse
+	err := c.jsonRestHandler.Get(ctx, endpoint, &aggregateAttestationResponse)
+	errJson := &httputil.DefaultJsonError{}
+	if err != nil {
+		// TODO: remove this when v2 becomes default
+		if !errors.As(err, &errJson) {
+			return nil, err
+		}
+		if errJson.Code != http.StatusNotFound {
+			return nil, errJson
+		}
+		log.Debug("Endpoint /eth/v2/validator/aggregate_attestation is not supported, falling back to older endpoints for get aggregated attestation.")
+		params = url.Values{}
+		params.Add("slot", strconv.FormatUint(uint64(slot), 10))
+		params.Add("attestation_data_root", hexutil.Encode(attestationDataRoot))
+		oldEndpoint := buildURL("/eth/v1/validator/aggregate_attestation", params)
+		if err = c.jsonRestHandler.Get(ctx, oldEndpoint, &aggregateAttestationResponse); err != nil {
+			return nil, err
+		}
+	}
+
+	return &aggregateAttestationResponse, nil
+}
+
+func (c *beaconApiValidatorClient) aggregateAttestationElectra(
+	ctx context.Context,
+	slot primitives.Slot,
+	attestationDataRoot []byte,
+	committeeIndex primitives.CommitteeIndex,
+) (*structs.AggregateAttestationResponse, error) {
+	params := url.Values{}
+	params.Add("slot", strconv.FormatUint(uint64(slot), 10))
+	params.Add("attestation_data_root", hexutil.Encode(attestationDataRoot))
+	params.Add("committee_index", strconv.FormatUint(uint64(committeeIndex), 10))
+	endpoint := buildURL("/eth/v2/validator/aggregate_attestation", params)
 
 	var aggregateAttestationResponse structs.AggregateAttestationResponse
 	if err := c.jsonRestHandler.Get(ctx, endpoint, &aggregateAttestationResponse); err != nil {

validator/client/beacon-api/submit_aggregate_selection_proof_test.go

@@ -5,11 +5,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net/http"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -23,7 +25,7 @@ func TestSubmitAggregateSelectionProof(t *testing.T) {
 		pubkeyStr                    = "0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13"
 		syncingEndpoint              = "/eth/v1/node/syncing"
 		attestationDataEndpoint      = "/eth/v1/validator/attestation_data"
-		aggregateAttestationEndpoint = "/eth/v1/validator/aggregate_attestation"
+		aggregateAttestationEndpoint = "/eth/v2/validator/aggregate_attestation"
 		validatorIndex               = primitives.ValidatorIndex(55293)
 		slotSignature                = "0x8776a37d6802c4797d113169c5fcfda50e68a32058eb6356a6f00d06d7da64c841a00c7c38b9b94a204751eca53707bd03523ce4797827d9bacff116a6e776a20bbccff4b683bf5201b610797ed0502557a58a65c8395f8a1649b976c3112d15"
 		slot                         = primitives.Slot(123)
@@ -131,7 +133,7 @@ func TestSubmitAggregateSelectionProof(t *testing.T) {
 			// Call attestation data to get attestation data root to query aggregate attestation.
 			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
-				fmt.Sprintf("%s?attestation_data_root=%s&slot=%d", aggregateAttestationEndpoint, hexutil.Encode(attestationDataRootBytes[:]), slot),
+				fmt.Sprintf("%s?attestation_data_root=%s&committee_index=%d&slot=%d", aggregateAttestationEndpoint, hexutil.Encode(attestationDataRootBytes[:]), committeeIndex, slot),
 				&structs.AggregateAttestationResponse{},
 			).SetArg(
 				2,
@@ -185,3 +187,295 @@ func TestSubmitAggregateSelectionProof(t *testing.T) {
 		})
 	}
 }
+
+func TestSubmitAggregateSelectionProofFallBack(t *testing.T) {
+	const (
+		pubkeyStr                      = "0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13"
+		syncingEndpoint                = "/eth/v1/node/syncing"
+		attestationDataEndpoint        = "/eth/v1/validator/attestation_data"
+		aggregateAttestationEndpoint   = "/eth/v1/validator/aggregate_attestation"
+		aggregateAttestationV2Endpoint = "/eth/v2/validator/aggregate_attestation"
+		validatorIndex                 = primitives.ValidatorIndex(55293)
+		slotSignature                  = "0x8776a37d6802c4797d113169c5fcfda50e68a32058eb6356a6f00d06d7da64c841a00c7c38b9b94a204751eca53707bd03523ce4797827d9bacff116a6e776a20bbccff4b683bf5201b610797ed0502557a58a65c8395f8a1649b976c3112d15"
+		slot                           = primitives.Slot(123)
+		committeeIndex                 = primitives.CommitteeIndex(1)
+		committeesAtSlot               = uint64(1)
+	)
+
+	attestationDataResponse := generateValidAttestation(uint64(slot), uint64(committeeIndex))
+	attestationDataProto, err := attestationDataResponse.Data.ToConsensus()
+	require.NoError(t, err)
+	attestationDataRootBytes, err := attestationDataProto.HashTreeRoot()
+	require.NoError(t, err)
+
+	aggregateAttestation := &ethpb.Attestation{
+		AggregationBits: testhelpers.FillByteSlice(4, 74),
+		Data:            attestationDataProto,
+		Signature:       testhelpers.FillByteSlice(96, 82),
+	}
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	ctx := context.Background()
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+	// Call node syncing endpoint to check if head is optimistic.
+	jsonRestHandler.EXPECT().Get(
+		gomock.Any(),
+		syncingEndpoint,
+		&structs.SyncStatusResponse{},
+	).SetArg(
+		2,
+		structs.SyncStatusResponse{
+			Data: &structs.SyncStatusResponseData{
+				IsOptimistic: false,
+			},
+		},
+	).Return(
+		nil,
+	).Times(1)
+
+	// Call attestation data to get attestation data root to query aggregate attestation.
+	jsonRestHandler.EXPECT().Get(
+		gomock.Any(),
+		fmt.Sprintf("%s?committee_index=%d&slot=%d", attestationDataEndpoint, committeeIndex, slot),
+		&structs.GetAttestationDataResponse{},
+	).SetArg(
+		2,
+		attestationDataResponse,
+	).Return(
+		nil,
+	).Times(1)
+
+	attestationJSON, err := json.Marshal(jsonifyAttestation(aggregateAttestation))
+	require.NoError(t, err)
+
+	// Call attestation data to get attestation data root to query aggregate attestation.
+	jsonRestHandler.EXPECT().Get(
+		gomock.Any(),
+		fmt.Sprintf("%s?attestation_data_root=%s&committee_index=%d&slot=%d", aggregateAttestationV2Endpoint, hexutil.Encode(attestationDataRootBytes[:]), committeeIndex, slot),
+		&structs.AggregateAttestationResponse{},
+	).Return(
+		&httputil.DefaultJsonError{
+			Code: http.StatusNotFound,
+		},
+	).Times(1)
+
+	// Call attestation data to get attestation data root to query aggregate attestation.
+	jsonRestHandler.EXPECT().Get(
+		gomock.Any(),
+		fmt.Sprintf("%s?attestation_data_root=%s&slot=%d", aggregateAttestationEndpoint, hexutil.Encode(attestationDataRootBytes[:]), slot),
+		&structs.AggregateAttestationResponse{},
+	).SetArg(
+		2,
+		structs.AggregateAttestationResponse{
+			Data: attestationJSON,
+		},
+	).Return(
+		nil,
+	).Times(1)
+
+	pubkey, err := hexutil.Decode(pubkeyStr)
+	require.NoError(t, err)
+
+	slotSignatureBytes, err := hexutil.Decode(slotSignature)
+	require.NoError(t, err)
+
+	expectedResponse := &ethpb.AggregateSelectionResponse{
+		AggregateAndProof: &ethpb.AggregateAttestationAndProof{
+			AggregatorIndex: primitives.ValidatorIndex(55293),
+			Aggregate:       aggregateAttestation,
+			SelectionProof:  slotSignatureBytes,
+		},
+	}
+
+	validatorClient := &beaconApiValidatorClient{
+		jsonRestHandler: jsonRestHandler,
+		stateValidatorsProvider: beaconApiStateValidatorsProvider{
+			jsonRestHandler: jsonRestHandler,
+		},
+		dutiesProvider: beaconApiDutiesProvider{
+			jsonRestHandler: jsonRestHandler,
+		},
+	}
+
+	actualResponse, err := validatorClient.submitAggregateSelectionProof(ctx, &ethpb.AggregateSelectionRequest{
+		Slot:           slot,
+		CommitteeIndex: committeeIndex,
+		PublicKey:      pubkey,
+		SlotSignature:  slotSignatureBytes,
+	}, validatorIndex, committeesAtSlot)
+
+	require.NoError(t, err)
+	assert.DeepEqual(t, expectedResponse, actualResponse)
+
+}
+
+func TestSubmitAggregateSelectionProofElectra(t *testing.T) {
+	const (
+		pubkeyStr                    = "0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13"
+		syncingEndpoint              = "/eth/v1/node/syncing"
+		attestationDataEndpoint      = "/eth/v1/validator/attestation_data"
+		aggregateAttestationEndpoint = "/eth/v2/validator/aggregate_attestation"
+		validatorIndex               = primitives.ValidatorIndex(55293)
+		slotSignature                = "0x8776a37d6802c4797d113169c5fcfda50e68a32058eb6356a6f00d06d7da64c841a00c7c38b9b94a204751eca53707bd03523ce4797827d9bacff116a6e776a20bbccff4b683bf5201b610797ed0502557a58a65c8395f8a1649b976c3112d15"
+		slot                         = primitives.Slot(123)
+		committeeIndex               = primitives.CommitteeIndex(1)
+		committeesAtSlot             = uint64(1)
+	)
+
+	attestationDataResponse := generateValidAttestation(uint64(slot), uint64(committeeIndex))
+	attestationDataProto, err := attestationDataResponse.Data.ToConsensus()
+	require.NoError(t, err)
+	attestationDataRootBytes, err := attestationDataProto.HashTreeRoot()
+	require.NoError(t, err)
+
+	aggregateAttestation := &ethpb.AttestationElectra{
+		AggregationBits: testhelpers.FillByteSlice(4, 74),
+		Data:            attestationDataProto,
+		Signature:       testhelpers.FillByteSlice(96, 82),
+		CommitteeBits:   testhelpers.FillByteSlice(8, 83),
+	}
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	tests := []struct {
+		name                       string
+		isOptimistic               bool
+		syncingErr                 error
+		attestationDataErr         error
+		aggregateAttestationErr    error
+		attestationDataCalled      int
+		aggregateAttestationCalled int
+		expectedErrorMsg           string
+		committeesAtSlot           uint64
+	}{
+		{
+			name:                       "success",
+			attestationDataCalled:      1,
+			aggregateAttestationCalled: 1,
+		},
+		{
+			name:             "head is optimistic",
+			isOptimistic:     true,
+			expectedErrorMsg: "the node is currently optimistic and cannot serve validators",
+		},
+		{
+			name:             "syncing error",
+			syncingErr:       errors.New("bad request"),
+			expectedErrorMsg: "failed to get syncing status",
+		},
+		{
+			name:                  "attestation data error",
+			attestationDataCalled: 1,
+			attestationDataErr:    errors.New("bad request"),
+			expectedErrorMsg:      fmt.Sprintf("failed to get attestation data for slot=%d and committee_index=%d", slot, committeeIndex),
+		},
+		{
+			name:                       "aggregate attestation error",
+			attestationDataCalled:      1,
+			aggregateAttestationCalled: 1,
+			aggregateAttestationErr:    errors.New("bad request"),
+			expectedErrorMsg:           "bad request",
+		},
+		{
+			name:             "validator is not an aggregator",
+			committeesAtSlot: 64,
+			expectedErrorMsg: "validator is not an aggregator",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ctx := context.Background()
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			// Call node syncing endpoint to check if head is optimistic.
+			jsonRestHandler.EXPECT().Get(
+				gomock.Any(),
+				syncingEndpoint,
+				&structs.SyncStatusResponse{},
+			).SetArg(
+				2,
+				structs.SyncStatusResponse{
+					Data: &structs.SyncStatusResponseData{
+						IsOptimistic: test.isOptimistic,
+					},
+				},
+			).Return(
+				test.syncingErr,
+			).Times(1)
+
+			// Call attestation data to get attestation data root to query aggregate attestation.
+			jsonRestHandler.EXPECT().Get(
+				gomock.Any(),
+				fmt.Sprintf("%s?committee_index=%d&slot=%d", attestationDataEndpoint, committeeIndex, slot),
+				&structs.GetAttestationDataResponse{},
+			).SetArg(
+				2,
+				attestationDataResponse,
+			).Return(
+				test.attestationDataErr,
+			).Times(test.attestationDataCalled)
+
+			attestationJSON, err := json.Marshal(jsonifyAttestationElectra(aggregateAttestation))
+			require.NoError(t, err)
+
+			// Call attestation data to get attestation data root to query aggregate attestation.
+			jsonRestHandler.EXPECT().Get(
+				gomock.Any(),
+				fmt.Sprintf("%s?attestation_data_root=%s&committee_index=%d&slot=%d", aggregateAttestationEndpoint, hexutil.Encode(attestationDataRootBytes[:]), committeeIndex, slot),
+				&structs.AggregateAttestationResponse{},
+			).SetArg(
+				2,
+				structs.AggregateAttestationResponse{
+					Data: attestationJSON,
+				},
+			).Return(
+				test.aggregateAttestationErr,
+			).Times(test.aggregateAttestationCalled)
+
+			pubkey, err := hexutil.Decode(pubkeyStr)
+			require.NoError(t, err)
+
+			slotSignatureBytes, err := hexutil.Decode(slotSignature)
+			require.NoError(t, err)
+
+			expectedResponse := &ethpb.AggregateSelectionElectraResponse{
+				AggregateAndProof: &ethpb.AggregateAttestationAndProofElectra{
+					AggregatorIndex: primitives.ValidatorIndex(55293),
+					Aggregate:       aggregateAttestation,
+					SelectionProof:  slotSignatureBytes,
+				},
+			}
+
+			validatorClient := &beaconApiValidatorClient{
+				jsonRestHandler: jsonRestHandler,
+				stateValidatorsProvider: beaconApiStateValidatorsProvider{
+					jsonRestHandler: jsonRestHandler,
+				},
+				dutiesProvider: beaconApiDutiesProvider{
+					jsonRestHandler: jsonRestHandler,
+				},
+			}
+
+			committees := committeesAtSlot
+			if test.committeesAtSlot != 0 {
+				committees = test.committeesAtSlot
+			}
+			actualResponse, err := validatorClient.submitAggregateSelectionProofElectra(ctx, &ethpb.AggregateSelectionRequest{
+				Slot:           slot,
+				CommitteeIndex: committeeIndex,
+				PublicKey:      pubkey,
+				SlotSignature:  slotSignatureBytes,
+			}, validatorIndex, committees)
+			if test.expectedErrorMsg == "" {
+				require.NoError(t, err)
+				assert.DeepEqual(t, expectedResponse, actualResponse)
+			} else {
+				require.ErrorContains(t, test.expectedErrorMsg, err)
+			}
+		})
+	}
+}

validator/client/beacon-api/submit_signed_aggregate_proof.go

@@ -4,10 +4,13 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"net/http"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
 func (c *beaconApiValidatorClient) submitSignedAggregateSelectionProof(ctx context.Context, in *ethpb.SignedAggregateSubmitRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
@@ -15,8 +18,44 @@ func (c *beaconApiValidatorClient) submitSignedAggregateSelectionProof(ctx conte
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to marshal SignedAggregateAttestationAndProof")
 	}
+	headers := map[string]string{"Eth-Consensus-Version": version.String(in.SignedAggregateAndProof.Version())}
+	err = c.jsonRestHandler.Post(ctx, "/eth/v2/validator/aggregate_and_proofs", headers, bytes.NewBuffer(body), nil)
+	errJson := &httputil.DefaultJsonError{}
+	if err != nil {
+		// TODO: remove this when v2 becomes default
+		if !errors.As(err, &errJson) {
+			return nil, err
+		}
+		if errJson.Code != http.StatusNotFound {
+			return nil, errJson
+		}
+		log.Debug("Endpoint /eth/v2/validator/aggregate_and_proofs is not supported, falling back to older endpoints for publish aggregate and proofs.")
+		if err = c.jsonRestHandler.Post(
+			ctx,
+			"/eth/v1/validator/aggregate_and_proofs",
+			nil,
+			bytes.NewBuffer(body),
+			nil,
+		); err != nil {
+			return nil, err
+		}
+	}
 
-	if err = c.jsonRestHandler.Post(ctx, "/eth/v1/validator/aggregate_and_proofs", nil, bytes.NewBuffer(body), nil); err != nil {
+	attestationDataRoot, err := in.SignedAggregateAndProof.Message.Aggregate.Data.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to compute attestation data root")
+	}
+
+	return &ethpb.SignedAggregateSubmitResponse{AttestationDataRoot: attestationDataRoot[:]}, nil
+}
+
+func (c *beaconApiValidatorClient) submitSignedAggregateSelectionProofElectra(ctx context.Context, in *ethpb.SignedAggregateSubmitElectraRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
+	body, err := json.Marshal([]*structs.SignedAggregateAttestationAndProofElectra{jsonifySignedAggregateAndProofElectra(in.SignedAggregateAndProof)})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshal SignedAggregateAttestationAndProofElectra")
+	}
+	headers := map[string]string{"Eth-Consensus-Version": version.String(in.SignedAggregateAndProof.Version())}
+	if err = c.jsonRestHandler.Post(ctx, "/eth/v2/validator/aggregate_and_proofs", headers, bytes.NewBuffer(body), nil); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/submit_signed_aggregate_proof_test.go

@@ -4,11 +4,14 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"net/http"
 	"testing"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/beacon-api/mock"
@@ -25,12 +28,12 @@ func TestSubmitSignedAggregateSelectionProof_Valid(t *testing.T) {
 	require.NoError(t, err)
 
 	ctx := context.Background()
-
+	headers := map[string]string{"Eth-Consensus-Version": version.String(signedAggregateAndProof.Message.Version())}
 	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
-		"/eth/v1/validator/aggregate_and_proofs",
-		nil,
+		"/eth/v2/validator/aggregate_and_proofs",
+		headers,
 		bytes.NewBuffer(marshalledSignedAggregateSignedAndProof),
 		nil,
 	).Return(
@@ -57,11 +60,12 @@ func TestSubmitSignedAggregateSelectionProof_BadRequest(t *testing.T) {
 	require.NoError(t, err)
 
 	ctx := context.Background()
+	headers := map[string]string{"Eth-Consensus-Version": version.String(signedAggregateAndProof.Message.Version())}
 	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
-		"/eth/v1/validator/aggregate_and_proofs",
-		nil,
+		"/eth/v2/validator/aggregate_and_proofs",
+		headers,
 		bytes.NewBuffer(marshalledSignedAggregateSignedAndProof),
 		nil,
 	).Return(
@@ -75,6 +79,110 @@ func TestSubmitSignedAggregateSelectionProof_BadRequest(t *testing.T) {
 	assert.ErrorContains(t, "bad request", err)
 }
 
+func TestSubmitSignedAggregateSelectionProof_Fallback(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	signedAggregateAndProof := generateSignedAggregateAndProofJson()
+	marshalledSignedAggregateSignedAndProof, err := json.Marshal([]*structs.SignedAggregateAttestationAndProof{jsonifySignedAggregateAndProof(signedAggregateAndProof)})
+	require.NoError(t, err)
+
+	ctx := context.Background()
+
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	headers := map[string]string{"Eth-Consensus-Version": version.String(signedAggregateAndProof.Message.Version())}
+	jsonRestHandler.EXPECT().Post(
+		gomock.Any(),
+		"/eth/v2/validator/aggregate_and_proofs",
+		headers,
+		bytes.NewBuffer(marshalledSignedAggregateSignedAndProof),
+		nil,
+	).Return(
+		&httputil.DefaultJsonError{
+			Code: http.StatusNotFound,
+		},
+	).Times(1)
+	jsonRestHandler.EXPECT().Post(
+		gomock.Any(),
+		"/eth/v1/validator/aggregate_and_proofs",
+		nil,
+		bytes.NewBuffer(marshalledSignedAggregateSignedAndProof),
+		nil,
+	).Return(
+		nil,
+	).Times(1)
+
+	attestationDataRoot, err := signedAggregateAndProof.Message.Aggregate.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	resp, err := validatorClient.submitSignedAggregateSelectionProof(ctx, &ethpb.SignedAggregateSubmitRequest{
+		SignedAggregateAndProof: signedAggregateAndProof,
+	})
+	require.NoError(t, err)
+	assert.DeepEqual(t, attestationDataRoot[:], resp.AttestationDataRoot)
+}
+
+func TestSubmitSignedAggregateSelectionProofElectra_Valid(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	signedAggregateAndProofElectra := generateSignedAggregateAndProofElectraJson()
+	marshalledSignedAggregateSignedAndProofElectra, err := json.Marshal([]*structs.SignedAggregateAttestationAndProofElectra{jsonifySignedAggregateAndProofElectra(signedAggregateAndProofElectra)})
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	headers := map[string]string{"Eth-Consensus-Version": version.String(signedAggregateAndProofElectra.Message.Version())}
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
+		gomock.Any(),
+		"/eth/v2/validator/aggregate_and_proofs",
+		headers,
+		bytes.NewBuffer(marshalledSignedAggregateSignedAndProofElectra),
+		nil,
+	).Return(
+		nil,
+	).Times(1)
+
+	attestationDataRoot, err := signedAggregateAndProofElectra.Message.Aggregate.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	resp, err := validatorClient.submitSignedAggregateSelectionProofElectra(ctx, &ethpb.SignedAggregateSubmitElectraRequest{
+		SignedAggregateAndProof: signedAggregateAndProofElectra,
+	})
+	require.NoError(t, err)
+	assert.DeepEqual(t, attestationDataRoot[:], resp.AttestationDataRoot)
+}
+
+func TestSubmitSignedAggregateSelectionProofElectra_BadRequest(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	signedAggregateAndProofElectra := generateSignedAggregateAndProofElectraJson()
+	marshalledSignedAggregateSignedAndProofElectra, err := json.Marshal([]*structs.SignedAggregateAttestationAndProofElectra{jsonifySignedAggregateAndProofElectra(signedAggregateAndProofElectra)})
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	headers := map[string]string{"Eth-Consensus-Version": version.String(signedAggregateAndProofElectra.Message.Version())}
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
+		gomock.Any(),
+		"/eth/v2/validator/aggregate_and_proofs",
+		headers,
+		bytes.NewBuffer(marshalledSignedAggregateSignedAndProofElectra),
+		nil,
+	).Return(
+		errors.New("bad request"),
+	).Times(1)
+
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	_, err = validatorClient.submitSignedAggregateSelectionProofElectra(ctx, &ethpb.SignedAggregateSubmitElectraRequest{
+		SignedAggregateAndProof: signedAggregateAndProofElectra,
+	})
+	assert.ErrorContains(t, "bad request", err)
+}
+
 func generateSignedAggregateAndProofJson() *ethpb.SignedAggregateAttestationAndProof {
 	return &ethpb.SignedAggregateAttestationAndProof{
 		Message: &ethpb.AggregateAttestationAndProof{
@@ -101,3 +209,31 @@ func generateSignedAggregateAndProofJson() *ethpb.SignedAggregateAttestationAndP
 		Signature: testhelpers.FillByteSlice(96, 82),
 	}
 }
+
+func generateSignedAggregateAndProofElectraJson() *ethpb.SignedAggregateAttestationAndProofElectra {
+	return &ethpb.SignedAggregateAttestationAndProofElectra{
+		Message: &ethpb.AggregateAttestationAndProofElectra{
+			AggregatorIndex: 72,
+			Aggregate: &ethpb.AttestationElectra{
+				AggregationBits: testhelpers.FillByteSlice(4, 74),
+				Data: &ethpb.AttestationData{
+					Slot:            75,
+					CommitteeIndex:  76,
+					BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
+					Source: &ethpb.Checkpoint{
+						Epoch: 78,
+						Root:  testhelpers.FillByteSlice(32, 79),
+					},
+					Target: &ethpb.Checkpoint{
+						Epoch: 80,
+						Root:  testhelpers.FillByteSlice(32, 81),
+					},
+				},
+				Signature:     testhelpers.FillByteSlice(96, 82),
+				CommitteeBits: testhelpers.FillByteSlice(8, 83),
+			},
+			SelectionProof: testhelpers.FillByteSlice(96, 84),
+		},
+		Signature: testhelpers.FillByteSlice(96, 85),
+	}
+}