implement eip-7928 as a gloas fork without eip-7732

* adding in check for post fulu support

* gaz

* fixing unit tests and typo

* gaz

* manu feedback

* addressing manu's suggestion

* fixing tests

beacon-chain/core/gloas/BUILD.bazel

@@ -0,0 +1,19 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["upgrade.go"],
+    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/gloas",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//config/params:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)

beacon-chain/core/gloas/upgrade.go

@@ -0,0 +1,189 @@
+package gloas
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/pkg/errors"
+)
+
+// UpgradeToGloas updates inputs a generic state to return the version Gloas state.
+// This implements the upgrade_to_eip7928 function from the specification.
+func UpgradeToGloas(ctx context.Context, beaconState state.BeaconState) (state.BeaconState, error) {
+	epoch := time.CurrentEpoch(beaconState)
+
+	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSyncCommittee, err := beaconState.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	inactivityScores, err := beaconState.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := payloadHeader.TransactionsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wdRoot, err := payloadHeader.WithdrawalsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wi, err := beaconState.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	vi, err := beaconState.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	summaries, err := beaconState.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	excessBlobGas, err := payloadHeader.ExcessBlobGas()
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payloadHeader.BlobGasUsed()
+	if err != nil {
+		return nil, err
+	}
+	depositRequestsStartIndex, err := beaconState.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, err
+	}
+	depositBalanceToConsume, err := beaconState.DepositBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	exitBalanceToConsume, err := beaconState.ExitBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	earliestExitEpoch, err := beaconState.EarliestExitEpoch()
+	if err != nil {
+		return nil, err
+	}
+	consolidationBalanceToConsume, err := beaconState.ConsolidationBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	earliestConsolidationEpoch, err := beaconState.EarliestConsolidationEpoch()
+	if err != nil {
+		return nil, err
+	}
+	pendingDeposits, err := beaconState.PendingDeposits()
+	if err != nil {
+		return nil, err
+	}
+	pendingPartialWithdrawals, err := beaconState.PendingPartialWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+	pendingConsolidations, err := beaconState.PendingConsolidations()
+	if err != nil {
+		return nil, err
+	}
+	proposerLookahead, err := helpers.InitializeProposerLookahead(ctx, beaconState, slots.ToEpoch(beaconState.Slot()))
+	if err != nil {
+		return nil, err
+	}
+
+	// Create the new Gloas execution payload header with block_access_list_root
+	// as specified in the EIP7928 upgrade function
+	latestExecutionPayloadHeader := &enginev1.ExecutionPayloadHeaderGloas{
+		ParentHash:          payloadHeader.ParentHash(),
+		FeeRecipient:        payloadHeader.FeeRecipient(),
+		StateRoot:           payloadHeader.StateRoot(),
+		ReceiptsRoot:        payloadHeader.ReceiptsRoot(),
+		LogsBloom:           payloadHeader.LogsBloom(),
+		PrevRandao:          payloadHeader.PrevRandao(),
+		BlockNumber:         payloadHeader.BlockNumber(),
+		GasLimit:            payloadHeader.GasLimit(),
+		GasUsed:             payloadHeader.GasUsed(),
+		Timestamp:           payloadHeader.Timestamp(),
+		ExtraData:           payloadHeader.ExtraData(),
+		BaseFeePerGas:       payloadHeader.BaseFeePerGas(),
+		BlockHash:           payloadHeader.BlockHash(),
+		TransactionsRoot:    txRoot,
+		WithdrawalsRoot:     wdRoot,
+		BlobGasUsed:         blobGasUsed,
+		ExcessBlobGas:       excessBlobGas,
+		BlockAccessListRoot: make([]byte, 32), // New in EIP7928 - empty Root()
+	}
+
+	s := &ethpb.BeaconStateGloas{
+		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
+		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
+		Slot:                  beaconState.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: beaconState.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().GloasForkVersion, // Modified in EIP7928
+			Epoch:           epoch,
+		},
+		LatestBlockHeader:             beaconState.LatestBlockHeader(),
+		BlockRoots:                    beaconState.BlockRoots(),
+		StateRoots:                    beaconState.StateRoots(),
+		HistoricalRoots:               beaconState.HistoricalRoots(),
+		Eth1Data:                      beaconState.Eth1Data(),
+		Eth1DataVotes:                 beaconState.Eth1DataVotes(),
+		Eth1DepositIndex:              beaconState.Eth1DepositIndex(),
+		Validators:                    beaconState.Validators(),
+		Balances:                      beaconState.Balances(),
+		RandaoMixes:                   beaconState.RandaoMixes(),
+		Slashings:                     beaconState.Slashings(),
+		PreviousEpochParticipation:    prevEpochParticipation,
+		CurrentEpochParticipation:     currentEpochParticipation,
+		JustificationBits:             beaconState.JustificationBits(),
+		PreviousJustifiedCheckpoint:   beaconState.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:    beaconState.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:           beaconState.FinalizedCheckpoint(),
+		InactivityScores:              inactivityScores,
+		CurrentSyncCommittee:          currentSyncCommittee,
+		NextSyncCommittee:             nextSyncCommittee,
+		LatestExecutionPayloadHeader:  latestExecutionPayloadHeader,
+		NextWithdrawalIndex:           wi,
+		NextWithdrawalValidatorIndex:  vi,
+		HistoricalSummaries:           summaries,
+		DepositRequestsStartIndex:     depositRequestsStartIndex,
+		DepositBalanceToConsume:       depositBalanceToConsume,
+		ExitBalanceToConsume:          exitBalanceToConsume,
+		EarliestExitEpoch:             earliestExitEpoch,
+		ConsolidationBalanceToConsume: consolidationBalanceToConsume,
+		EarliestConsolidationEpoch:    earliestConsolidationEpoch,
+		PendingDeposits:               pendingDeposits,
+		PendingPartialWithdrawals:     pendingPartialWithdrawals,
+		PendingConsolidations:         pendingConsolidations,
+		ProposerLookahead:             proposerLookahead,
+	}
+
+	post, err := state_native.InitializeFromProtoUnsafeGloas(s)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize post gloas beaconState")
+	}
+
+	return post, nil
+}

beacon-chain/core/time/slot_epoch.go

@@ -108,6 +108,12 @@ func CanUpgradeToFulu(slot primitives.Slot) bool {
 	return epochStart && fuluEpoch
 }
 
+func CanUpgradeToGloas(slot primitives.Slot) bool {
+	epochStart := slots.IsEpochStart(slot)
+	gloasEpoch := slots.ToEpoch(slot) == params.BeaconConfig().GloasForkEpoch
+	return epochStart && gloasEpoch
+}
+
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //

beacon-chain/core/transition/BUILD.bazel

@@ -24,6 +24,7 @@ go_library(
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/execution:go_default_library",
         "//beacon-chain/core/fulu:go_default_library",
+        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",

beacon-chain/core/transition/transition.go

@@ -17,6 +17,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epoch/precompute"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/fulu"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
@@ -389,6 +390,15 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
+	if time.CanUpgradeToGloas(slot) {
+		state, err = gloas.UpgradeToGloas(ctx, state)
+		if err != nil {
+			tracing.AnnotateError(span, err)
+			return nil, err
+		}
+		upgraded = true
+	}
+
 	if upgraded {
 		log.WithField("version", version.String(state.Version())).Info("Upgraded state to")
 	}

beacon-chain/execution/engine_client.go

@@ -57,6 +57,11 @@ var (
 		GetPayloadMethodV5,
 		GetBlobsV2,
 	}
+
+	gloasEngineEndpoints = []string{
+		NewPayloadMethodV5,
+		GetPayloadMethodV6,
+	}
 )
 
 const (
@@ -67,6 +72,8 @@ const (
 	NewPayloadMethodV3 = "engine_newPayloadV3"
 	// NewPayloadMethodV4 is the engine_newPayloadVX method added at Electra.
 	NewPayloadMethodV4 = "engine_newPayloadV4"
+	// NewPayloadMethodV5 is the engine_newPayloadVX method added at Gloas.
+	NewPayloadMethodV5 = "engine_newPayloadV5"
 	// ForkchoiceUpdatedMethod v1 request string for JSON-RPC.
 	ForkchoiceUpdatedMethod = "engine_forkchoiceUpdatedV1"
 	// ForkchoiceUpdatedMethodV2 v2 request string for JSON-RPC.
@@ -83,6 +90,8 @@ const (
 	GetPayloadMethodV4 = "engine_getPayloadV4"
 	// GetPayloadMethodV5 is the get payload method added for fulu
 	GetPayloadMethodV5 = "engine_getPayloadV5"
+	// GetPayloadMethodV6 is the get payload method added for gloas
+	GetPayloadMethodV6 = "engine_getPayloadV6"
 	// BlockByHashMethod request string for JSON-RPC.
 	BlockByHashMethod = "eth_getBlockByHash"
 	// BlockByNumberMethod request string for JSON-RPC.
@@ -181,6 +190,18 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 				return nil, handleRPCError(err)
 			}
 		}
+	case *pb.ExecutionPayloadGloas:
+		if executionRequests == nil {
+			return nil, errors.New("execution requests are required for gloas execution payload")
+		}
+		flattenedRequests, err := pb.EncodeExecutionRequests(executionRequests)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to encode execution requests")
+		}
+		err = s.rpcClient.CallContext(ctx, result, NewPayloadMethodV5, payloadPb, versionedHashes, parentBlockRoot, flattenedRequests)
+		if err != nil {
+			return nil, handleRPCError(err)
+		}
 	default:
 		return nil, errors.New("unknown execution data type")
 	}
@@ -273,6 +294,9 @@ func (s *Service) ForkchoiceUpdated(
 
 func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
 	epoch := slots.ToEpoch(slot)
+	if epoch >= params.BeaconConfig().GloasForkEpoch {
+		return GetPayloadMethodV6, &pb.ExecutionBundleGloas{}
+	}
 	if epoch >= params.BeaconConfig().FuluForkEpoch {
 		return GetPayloadMethodV5, &pb.ExecutionBundleFulu{}
 	}
@@ -325,6 +349,10 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 		supportedEngineEndpoints = append(supportedEngineEndpoints, fuluEngineEndpoints...)
 	}
 
+	if params.GloasEnabled() {
+		supportedEngineEndpoints = append(supportedEngineEndpoints, gloasEngineEndpoints...)
+	}
+
 	elSupportedEndpointsSlice := make([]string, len(supportedEngineEndpoints))
 	if err := s.rpcClient.CallContext(ctx, &elSupportedEndpointsSlice, ExchangeCapabilities, supportedEngineEndpoints); err != nil {
 		return nil, handleRPCError(err)

beacon-chain/p2p/gossip_topic_mappings.go

@@ -32,6 +32,9 @@ var gossipTopicMappings = map[string]func() proto.Message{
 func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 	switch topic {
 	case BlockSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().GloasForkEpoch {
+			return &ethpb.SignedBeaconBlockGloas{}
+		}
 		if epoch >= params.BeaconConfig().FuluForkEpoch {
 			return &ethpb.SignedBeaconBlockFulu{}
 		}
@@ -144,4 +147,7 @@ func init() {
 
 	// Specially handle Fulu objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockFulu{})] = BlockSubnetTopicFormat
+
+	// Specially handle Gloas objects.
+	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockGloas{})] = BlockSubnetTopicFormat
 }

beacon-chain/p2p/types/object_mapping.go

@@ -85,6 +85,11 @@ func InitializeDataMaps() {
 				&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
 			)
 		},
+		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (interfaces.ReadOnlySignedBeaconBlock, error) {
+			return blocks.NewSignedBeaconBlock(
+				&ethpb.SignedBeaconBlockGloas{Block: &ethpb.BeaconBlockGloas{Body: &ethpb.BeaconBlockBodyGloas{ExecutionPayload: &enginev1.ExecutionPayloadGloas{}}}},
+			)
+		},
 	}
 
 	// Reset our metadata map.
@@ -110,6 +115,9 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (metadata.Metadata, error) {
 			return wrapper.WrappedMetadataV2(&ethpb.MetaDataV2{}), nil
 		},
+		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV2(&ethpb.MetaDataV2{}), nil
+		},
 	}
 
 	// Reset our attestation map.
@@ -135,6 +143,9 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.Att, error) {
 			return &ethpb.SingleAttestation{}, nil
 		},
+		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.SingleAttestation{}, nil
+		},
 	}
 
 	// Reset our aggregate attestation map.
@@ -160,6 +171,9 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
 			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
 		},
+		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
+		},
 	}
 
 	// Reset our aggregate attestation map.
@@ -185,6 +199,9 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.AttSlashing, error) {
 			return &ethpb.AttesterSlashingElectra{}, nil
 		},
+		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashingElectra{}, nil
+		},
 	}
 
 	// Reset our light client optimistic update map.
@@ -204,6 +221,12 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
 			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
 		},
+		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
+		},
 	}
 
 	// Reset our light client finality update map.
@@ -223,5 +246,11 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
 			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
 		},
+		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
+		},
 	}
 }

beacon-chain/rpc/endpoints.go

@@ -1230,6 +1230,7 @@ func (s *Service) prysmBeaconEndpoints(
 			methods: []string{http.MethodGet},
 		},
 		{
+			// Warning: no longer supported post Fulu fork
 			template: "/prysm/v1/beacon/blobs",
 			name:     namespace + ".PublishBlobs",
 			middleware: []middleware.Middleware{

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

@@ -186,6 +186,7 @@ func (s *Server) GetChainHead(w http.ResponseWriter, r *http.Request) {
 	httputil.WriteJson(w, response)
 }
 
+// Warning: no longer supported post Fulu blobs
 func (s *Server) PublishBlobs(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.PublishBlobs")
 	defer span.End()
@@ -215,6 +216,15 @@ func (s *Server) PublishBlobs(w http.ResponseWriter, r *http.Request) {
 			httputil.HandleError(w, "Could not decode blob sidecar: "+err.Error(), http.StatusBadRequest)
 			return
 		}
+		scEpoch := slots.ToEpoch(sc.SignedBlockHeader.Header.Slot)
+		if scEpoch < params.BeaconConfig().DenebForkEpoch {
+			httputil.HandleError(w, "Blob sidecars not supported for pre deneb", http.StatusBadRequest)
+			return
+		}
+		if scEpoch > params.BeaconConfig().FuluForkEpoch {
+			httputil.HandleError(w, "Blob sidecars not supported for post fulu blobs", http.StatusBadRequest)
+			return
+		}
 
 		readOnlySc, err := blocks.NewROBlobWithRoot(sc, bytesutil.ToBytes32(root))
 		if err != nil {

beacon-chain/rpc/prysm/beacon/handlers_test.go

@@ -1017,6 +1017,11 @@ func TestPublishBlobs_BadBlockRoot(t *testing.T) {
 }
 
 func TestPublishBlobs(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 0 // Set Deneb fork to epoch 0 so slot 0 is valid
+	params.OverrideBeaconConfig(cfg)
+
 	server := &Server{
 		BlobReceiver: &chainMock.ChainService{},
 		Broadcaster:  &mockp2p.MockBroadcaster{},
@@ -1032,3 +1037,94 @@ func TestPublishBlobs(t *testing.T) {
 	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 1)
 	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), true)
 }
+
+func TestPublishBlobs_PreDeneb(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 10 // Set Deneb fork to epoch 10, so slot 0 is pre-Deneb
+	params.OverrideBeaconConfig(cfg)
+
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequest)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Blob sidecars not supported for pre deneb", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_PostFulu(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 0
+	cfg.FuluForkEpoch = 0 // Set Fulu fork to epoch 0
+	params.OverrideBeaconConfig(cfg)
+
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	// Create a custom request with a slot in epoch 1 (which is > FuluForkEpoch of 0)
+	postFuluRequest := fmt.Sprintf(`{
+		"block_root" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"blob_sidecars" : {
+		   "sidecars" : [
+			  {
+				 "blob" : "%s",
+				 "index" : "0",
+				 "kzg_commitment" : "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+				 "kzg_commitment_inclusion_proof" : [
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000",
+					"0x0000000000000000000000000000000000000000000000000000000000000000"
+				 ],
+				 "kzg_proof" : "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+				 "signed_block_header" : {
+					"message" : {
+					   "body_root" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+					   "parent_root" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+					   "proposer_index" : "0",
+					   "slot" : "33",
+					   "state_root" : "0x0000000000000000000000000000000000000000000000000000000000000000"
+					},
+					"signature" : "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+				 }
+			  }
+		   ]
+		}
+	 }`, rpctesting.Blob)
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(postFuluRequest)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Blob sidecars not supported for post fulu blobs", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}

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

@@ -57,6 +57,12 @@ func (vs *Server) constructGenericBeaconBlock(
 			return nil, fmt.Errorf("expected *BlobsBundleV2, got %T", blobsBundler)
 		}
 		return vs.constructFuluBlock(blockProto, isBlinded, bidStr, bundle), nil
+	case version.Gloas:
+		bundle, ok := blobsBundler.(*enginev1.BlobsBundleV2)
+		if blobsBundler != nil && !ok {
+			return nil, fmt.Errorf("expected *BlobsBundleV2, got %T", blobsBundler)
+		}
+		return vs.constructGloasBlock(blockProto, isBlinded, bidStr, bundle), nil
 	default:
 		return nil, fmt.Errorf("unknown block version: %d", sBlk.Version())
 	}
@@ -120,3 +126,12 @@ func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, p
 	}
 	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Fulu{Fulu: fuluContents}, IsBlinded: false, PayloadValue: payloadValue}
 }
+
+func (vs *Server) constructGloasBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundleV2) *ethpb.GenericBeaconBlock {
+	gloasContents := &ethpb.BeaconBlockContentsGloas{Block: blockProto.(*ethpb.BeaconBlockGloas)}
+	if bundle != nil {
+		gloasContents.KzgProofs = bundle.Proofs
+		gloasContents.Blobs = bundle.Blobs
+	}
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Gloas{Gloas: gloasContents}, IsBlinded: false, PayloadValue: payloadValue}
+}

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

@@ -300,7 +300,7 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 		return nil, status.Errorf(codes.Internal, "Could not hash tree root: %v", err)
 	}
 
-	// For post-Fulu blinded blocks, submit to relay and return early
+	// For post-Fulu blinded blocks (including Gloas), submit to relay and return early
 	if block.IsBlinded() && slots.ToEpoch(block.Block().Slot()) >= params.BeaconConfig().FuluForkEpoch {
 		err := vs.BlockBuilder.SubmitBlindedBlockPostFulu(ctx, block)
 		if err != nil {
@@ -365,7 +365,7 @@ func (vs *Server) broadcastAndReceiveSidecars(
 }
 
 // handleBlindedBlock processes blinded beacon blocks (pre-Fulu only).
-// Post-Fulu blinded blocks are handled directly in ProposeBeaconBlock.
+// Post-Fulu blinded blocks (including Gloas) are handled directly in ProposeBeaconBlock.
 func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.SignedBeaconBlock) (interfaces.SignedBeaconBlock, []*ethpb.BlobSidecar, error) {
 	if block.Version() < version.Bellatrix {
 		return nil, nil, errors.New("pre-Bellatrix blinded block")
@@ -632,6 +632,9 @@ func blobsAndProofs(req *ethpb.GenericSignedBeaconBlock) ([][]byte, [][]byte, er
 	case req.GetFulu() != nil:
 		dbBlockContents := req.GetFulu()
 		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
+	case req.GetGloas() != nil:
+		dbBlockContents := req.GetGloas()
+		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
 	default:
 		return nil, nil, errors.Errorf("unknown request type provided: %T", req)
 	}

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

@@ -473,6 +473,11 @@ func isVersionCompatible(bidVersion, headBlockVersion int) bool {
 		return true
 	}
 
+	// Allow Electra bids for Gloas blocks - they have compatible payload formats
+	if bidVersion == version.Electra && headBlockVersion == version.Gloas {
+		return true
+	}
+
 	// For all other cases, require exact version match
 	return false
 }

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

@@ -16,6 +16,11 @@ func getEmptyBlock(slot primitives.Slot) (interfaces.SignedBeaconBlock, error) {
 	var err error
 	epoch := slots.ToEpoch(slot)
 	switch {
+	case epoch >= params.BeaconConfig().GloasForkEpoch:
+		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: &ethpb.BeaconBlockGloas{Body: &ethpb.BeaconBlockBodyGloas{}}})
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
+		}
 	case epoch >= params.BeaconConfig().FuluForkEpoch:
 		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
 		if err != nil {

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

@@ -136,7 +136,7 @@ func (vs *Server) getLocalPayloadFromEngine(
 	}
 	var attr payloadattribute.Attributer
 	switch st.Version() {
-	case version.Deneb, version.Electra, version.Fulu:
+	case version.Deneb, version.Electra, version.Fulu, version.Gloas:
 		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			return nil, err

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

@@ -52,6 +52,7 @@ type BeaconState struct {
 	latestExecutionPayloadHeader        *enginev1.ExecutionPayloadHeader
 	latestExecutionPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella
 	latestExecutionPayloadHeaderDeneb   *enginev1.ExecutionPayloadHeaderDeneb
+	latestExecutionPayloadHeaderGloas   *enginev1.ExecutionPayloadHeaderGloas
 
 	// Capella fields
 	nextWithdrawalIndex          uint64

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

@@ -17,6 +17,10 @@ func (b *BeaconState) LatestExecutionPayloadHeader() (interfaces.ExecutionData,
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
+	if b.version >= version.Gloas {
+		return blocks.WrappedExecutionPayloadHeaderGloas(b.latestExecutionPayloadHeaderGloas.Copy())
+	}
+
 	if b.version >= version.Deneb {
 		return blocks.WrappedExecutionPayloadHeaderDeneb(b.latestExecutionPayloadHeaderDeneb.Copy())
 	}

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

@@ -55,6 +55,17 @@ func (b *BeaconState) SetLatestExecutionPayloadHeader(val interfaces.ExecutionDa
 		b.latestExecutionPayloadHeaderDeneb = latest
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderDeneb)
 		return nil
+	case *enginev1.ExecutionPayloadGloas:
+		if !(b.version >= version.Gloas) {
+			return fmt.Errorf("wrong state version (%s) for gloas execution payload", version.String(b.version))
+		}
+		latest, err := consensusblocks.PayloadToHeaderGloas(val)
+		if err != nil {
+			return errors.Wrap(err, "could not convert payload to header")
+		}
+		b.latestExecutionPayloadHeaderGloas = latest
+		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderGloas)
+		return nil
 	case *enginev1.ExecutionPayloadHeader:
 		if b.version != version.Bellatrix {
 			return fmt.Errorf("wrong state version (%s) for bellatrix execution payload header", version.String(b.version))
@@ -76,6 +87,13 @@ func (b *BeaconState) SetLatestExecutionPayloadHeader(val interfaces.ExecutionDa
 		b.latestExecutionPayloadHeaderDeneb = header
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderDeneb)
 		return nil
+	case *enginev1.ExecutionPayloadHeaderGloas:
+		if !(b.version >= version.Gloas) {
+			return fmt.Errorf("wrong state version (%s) for gloas execution payload header", version.String(b.version))
+		}
+		b.latestExecutionPayloadHeaderGloas = header
+		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderGloas)
+		return nil
 	default:
 		return errors.New("value must be an execution payload header")
 	}

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

@@ -112,6 +112,24 @@ var (
 		electraFields,
 		types.ProposerLookahead,
 	)
+
+	gloasFields = append(
+		altairFields,
+		types.LatestExecutionPayloadHeaderGloas,
+		types.NextWithdrawalIndex,
+		types.NextWithdrawalValidatorIndex,
+		types.HistoricalSummaries,
+		types.DepositRequestsStartIndex,
+		types.DepositBalanceToConsume,
+		types.ExitBalanceToConsume,
+		types.EarliestExitEpoch,
+		types.ConsolidationBalanceToConsume,
+		types.EarliestConsolidationEpoch,
+		types.PendingDeposits,
+		types.PendingPartialWithdrawals,
+		types.PendingConsolidations,
+		types.ProposerLookahead,
+	)
 )
 
 const (
@@ -122,6 +140,7 @@ const (
 	denebSharedFieldRefCount     = 7
 	electraSharedFieldRefCount   = 10
 	fuluSharedFieldRefCount      = 11
+	gloasSharedFieldRefCount     = 11
 )
 
 // InitializeFromProtoPhase0 the beacon state from a protobuf representation.
@@ -159,6 +178,11 @@ func InitializeFromProtoFulu(st *ethpb.BeaconStateFulu) (state.BeaconState, erro
 	return InitializeFromProtoUnsafeFulu(proto.Clone(st).(*ethpb.BeaconStateFulu))
 }
 
+// InitializeFromProtoGloas the beacon state from a protobuf representation.
+func InitializeFromProtoGloas(st *ethpb.BeaconStateGloas) (state.BeaconState, error) {
+	return InitializeFromProtoUnsafeGloas(proto.Clone(st).(*ethpb.BeaconStateGloas))
+}
+
 // InitializeFromProtoUnsafePhase0 directly uses the beacon state protobuf fields
 // and sets them as fields of the BeaconState type.
 func InitializeFromProtoUnsafePhase0(st *ethpb.BeaconState) (state.BeaconState, error) {
@@ -731,6 +755,105 @@ func InitializeFromProtoUnsafeFulu(st *ethpb.BeaconStateFulu) (state.BeaconState
 	return b, nil
 }
 
+// InitializeFromProtoUnsafeGloas directly uses the beacon state protobuf fields
+// and sets them as fields of the BeaconState type.
+func InitializeFromProtoUnsafeGloas(st *ethpb.BeaconStateGloas) (state.BeaconState, error) {
+	if st == nil {
+		return nil, errors.New("received nil state")
+	}
+
+	hRoots := customtypes.HistoricalRoots(make([][32]byte, len(st.HistoricalRoots)))
+	for i, r := range st.HistoricalRoots {
+		hRoots[i] = bytesutil.ToBytes32(r)
+	}
+
+	proposerLookahead := make([]primitives.ValidatorIndex, len(st.ProposerLookahead))
+	for i, v := range st.ProposerLookahead {
+		proposerLookahead[i] = primitives.ValidatorIndex(v)
+	}
+	fieldCount := params.BeaconConfig().BeaconStateFuluFieldCount
+	b := &BeaconState{
+		version:                           version.Gloas,
+		genesisTime:                       st.GenesisTime,
+		genesisValidatorsRoot:             bytesutil.ToBytes32(st.GenesisValidatorsRoot),
+		slot:                              st.Slot,
+		fork:                              st.Fork,
+		latestBlockHeader:                 st.LatestBlockHeader,
+		historicalRoots:                   hRoots,
+		eth1Data:                          st.Eth1Data,
+		eth1DataVotes:                     st.Eth1DataVotes,
+		eth1DepositIndex:                  st.Eth1DepositIndex,
+		slashings:                         st.Slashings,
+		previousEpochParticipation:        st.PreviousEpochParticipation,
+		currentEpochParticipation:         st.CurrentEpochParticipation,
+		justificationBits:                 st.JustificationBits,
+		previousJustifiedCheckpoint:       st.PreviousJustifiedCheckpoint,
+		currentJustifiedCheckpoint:        st.CurrentJustifiedCheckpoint,
+		finalizedCheckpoint:               st.FinalizedCheckpoint,
+		currentSyncCommittee:              st.CurrentSyncCommittee,
+		nextSyncCommittee:                 st.NextSyncCommittee,
+		latestExecutionPayloadHeaderGloas: st.LatestExecutionPayloadHeader,
+		nextWithdrawalIndex:               st.NextWithdrawalIndex,
+		nextWithdrawalValidatorIndex:      st.NextWithdrawalValidatorIndex,
+		historicalSummaries:               st.HistoricalSummaries,
+		depositRequestsStartIndex:         st.DepositRequestsStartIndex,
+		depositBalanceToConsume:           st.DepositBalanceToConsume,
+		exitBalanceToConsume:              st.ExitBalanceToConsume,
+		earliestExitEpoch:                 st.EarliestExitEpoch,
+		consolidationBalanceToConsume:     st.ConsolidationBalanceToConsume,
+		earliestConsolidationEpoch:        st.EarliestConsolidationEpoch,
+		pendingDeposits:                   st.PendingDeposits,
+		pendingPartialWithdrawals:         st.PendingPartialWithdrawals,
+		pendingConsolidations:             st.PendingConsolidations,
+		proposerLookahead:                 proposerLookahead,
+
+		id: types.Enumerator.Inc(),
+
+		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
+		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
+		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
+		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
+		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
+	}
+
+	b.blockRootsMultiValue = NewMultiValueBlockRoots(st.BlockRoots)
+	b.stateRootsMultiValue = NewMultiValueStateRoots(st.StateRoots)
+	b.randaoMixesMultiValue = NewMultiValueRandaoMixes(st.RandaoMixes)
+	b.balancesMultiValue = NewMultiValueBalances(st.Balances)
+	b.validatorsMultiValue = NewMultiValueValidators(st.Validators)
+	b.inactivityScoresMultiValue = NewMultiValueInactivityScores(st.InactivityScores)
+	b.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, gloasSharedFieldRefCount)
+
+	for _, f := range gloasFields {
+		b.dirtyFields[f] = true
+		b.rebuildTrie[f] = true
+		b.dirtyIndices[f] = []uint64{}
+		trie, err := fieldtrie.NewFieldTrie(f, types.BasicArray, nil, 0)
+		if err != nil {
+			return nil, err
+		}
+		b.stateFieldLeaves[f] = trie
+	}
+
+	// Initialize field reference tracking for shared data.
+	b.sharedFieldReferences[types.HistoricalRoots] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.Eth1DataVotes] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.Slashings] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PreviousEpochParticipationBits] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.CurrentEpochParticipationBits] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.LatestExecutionPayloadHeaderGloas] = stateutil.NewRef(1) // New in Gloas.
+	b.sharedFieldReferences[types.HistoricalSummaries] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PendingDeposits] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PendingPartialWithdrawals] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.PendingConsolidations] = stateutil.NewRef(1)
+	b.sharedFieldReferences[types.ProposerLookahead] = stateutil.NewRef(1)
+
+	state.Count.Inc()
+	// Finalizer runs when dst is being destroyed in garbage collection.
+	runtime.SetFinalizer(b, finalizerCleanup)
+	return b, nil
+}
+
 // Copy returns a deep copy of the beacon state.
 func (b *BeaconState) Copy() state.BeaconState {
 	b.lock.RLock()
@@ -752,6 +875,8 @@ func (b *BeaconState) Copy() state.BeaconState {
 		fieldCount = params.BeaconConfig().BeaconStateElectraFieldCount
 	case version.Fulu:
 		fieldCount = params.BeaconConfig().BeaconStateFuluFieldCount
+	case version.Gloas:
+		fieldCount = params.BeaconConfig().BeaconStateFuluFieldCount
 	}
 
 	dst := &BeaconState{
@@ -806,6 +931,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 		latestExecutionPayloadHeader:        b.latestExecutionPayloadHeader.Copy(),
 		latestExecutionPayloadHeaderCapella: b.latestExecutionPayloadHeaderCapella.Copy(),
 		latestExecutionPayloadHeaderDeneb:   b.latestExecutionPayloadHeaderDeneb.Copy(),
+		latestExecutionPayloadHeaderGloas:   b.latestExecutionPayloadHeaderGloas.Copy(),
 
 		id: types.Enumerator.Inc(),
 
@@ -842,6 +968,8 @@ func (b *BeaconState) Copy() state.BeaconState {
 		dst.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, electraSharedFieldRefCount)
 	case version.Fulu:
 		dst.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, fuluSharedFieldRefCount)
+	case version.Gloas:
+		dst.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, gloasSharedFieldRefCount)
 	}
 
 	for field, ref := range b.sharedFieldReferences {
@@ -937,6 +1065,8 @@ func (b *BeaconState) initializeMerkleLayers(ctx context.Context) error {
 		b.dirtyFields = make(map[types.FieldIndex]bool, params.BeaconConfig().BeaconStateElectraFieldCount)
 	case version.Fulu:
 		b.dirtyFields = make(map[types.FieldIndex]bool, params.BeaconConfig().BeaconStateFuluFieldCount)
+	case version.Gloas:
+		b.dirtyFields = make(map[types.FieldIndex]bool, params.BeaconConfig().BeaconStateFuluFieldCount)
 	default:
 		return fmt.Errorf("unknown state version (%s) when computing dirty fields in merklization", version.String(b.version))
 	}
@@ -1149,6 +1279,8 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		return b.latestExecutionPayloadHeaderCapella.HashTreeRoot()
 	case types.LatestExecutionPayloadHeaderDeneb:
 		return b.latestExecutionPayloadHeaderDeneb.HashTreeRoot()
+	case types.LatestExecutionPayloadHeaderGloas:
+		return b.latestExecutionPayloadHeaderGloas.HashTreeRoot()
 	case types.NextWithdrawalIndex:
 		return ssz.Uint64Root(b.nextWithdrawalIndex), nil
 	case types.NextWithdrawalValidatorIndex:

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

@@ -88,6 +88,8 @@ func (f FieldIndex) String() string {
 		return "latestExecutionPayloadHeaderCapella"
 	case LatestExecutionPayloadHeaderDeneb:
 		return "latestExecutionPayloadHeaderDeneb"
+	case LatestExecutionPayloadHeaderGloas:
+		return "latestExecutionPayloadHeaderGloas"
 	case NextWithdrawalIndex:
 		return "nextWithdrawalIndex"
 	case NextWithdrawalValidatorIndex:
@@ -171,7 +173,7 @@ func (f FieldIndex) RealPosition() int {
 		return 22
 	case NextSyncCommittee:
 		return 23
-	case LatestExecutionPayloadHeader, LatestExecutionPayloadHeaderCapella, LatestExecutionPayloadHeaderDeneb:
+	case LatestExecutionPayloadHeader, LatestExecutionPayloadHeaderCapella, LatestExecutionPayloadHeaderDeneb, LatestExecutionPayloadHeaderGloas:
 		return 24
 	case NextWithdrawalIndex:
 		return 25
@@ -251,6 +253,7 @@ const (
 	LatestExecutionPayloadHeader
 	LatestExecutionPayloadHeaderCapella
 	LatestExecutionPayloadHeaderDeneb
+	LatestExecutionPayloadHeaderGloas
 	NextWithdrawalIndex
 	NextWithdrawalValidatorIndex
 	HistoricalSummaries

changelog/james-prysm_deprecate-publish-blos.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Deprecated and added error to /prysm/v1/beacon/blobs endpoint for post Fulu fork.

changelog/james-prysm_post-block-ssz.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Switching default of validator client rest call for submit block from JSON to SSZ. Fallback json will be attempted.

changelog/kasey_unwedge-ethspecify.md

@@ -0,0 +1,2 @@
+### Ignored
+- Unwedge ethspecify.

config/params/config.go

@@ -180,6 +180,8 @@ type BeaconChainConfig struct {
 	ElectraForkEpoch     primitives.Epoch `yaml:"ELECTRA_FORK_EPOCH" spec:"true"`     // ElectraForkEpoch is used to represent the assigned fork epoch for electra.
 	FuluForkVersion      []byte           `yaml:"FULU_FORK_VERSION" spec:"true"`      // FuluForkVersion is used to represent the fork version for fulu.
 	FuluForkEpoch        primitives.Epoch `yaml:"FULU_FORK_EPOCH" spec:"true"`        // FuluForkEpoch is used to represent the assigned fork epoch for fulu.
+	GloasForkVersion     []byte           `yaml:"GLOAS_FORK_VERSION" spec:"true"`     // GloasForkVersion is used to represent the fork version for gloas.
+	GloasForkEpoch       primitives.Epoch `yaml:"GLOAS_FORK_EPOCH" spec:"true"`       // GloasForkEpoch is used to represent the assigned fork epoch for gloas.
 
 	ForkVersionSchedule map[[fieldparams.VersionLength]byte]primitives.Epoch // Schedule of fork epochs by version.
 	ForkVersionNames    map[[fieldparams.VersionLength]byte]string           // Human-readable names of fork versions.
@@ -601,6 +603,7 @@ func initForkSchedule(b *BeaconChainConfig) *NetworkSchedule {
 		{Epoch: b.DenebForkEpoch, isFork: true, ForkVersion: to4(b.DenebForkVersion), MaxBlobsPerBlock: uint64(b.DeprecatedMaxBlobsPerBlock), VersionEnum: version.Deneb},
 		{Epoch: b.ElectraForkEpoch, isFork: true, ForkVersion: to4(b.ElectraForkVersion), MaxBlobsPerBlock: uint64(b.DeprecatedMaxBlobsPerBlockElectra), VersionEnum: version.Electra},
 		{Epoch: b.FuluForkEpoch, isFork: true, ForkVersion: to4(b.FuluForkVersion), VersionEnum: version.Fulu},
+		{Epoch: b.GloasForkEpoch, isFork: true, ForkVersion: to4(b.GloasForkVersion), VersionEnum: version.Gloas},
 	})
 }
 
@@ -625,6 +628,7 @@ func configForkSchedule(b *BeaconChainConfig) map[[fieldparams.VersionLength]byt
 	fvs[bytesutil.ToBytes4(b.DenebForkVersion)] = b.DenebForkEpoch
 	fvs[bytesutil.ToBytes4(b.ElectraForkVersion)] = b.ElectraForkEpoch
 	fvs[bytesutil.ToBytes4(b.FuluForkVersion)] = b.FuluForkEpoch
+	fvs[bytesutil.ToBytes4(b.GloasForkVersion)] = b.GloasForkEpoch
 	return fvs
 }
 
@@ -648,6 +652,7 @@ func ConfigForkVersions(b *BeaconChainConfig) map[[fieldparams.VersionLength]byt
 		bytesutil.ToBytes4(b.DenebForkVersion):     version.Deneb,
 		bytesutil.ToBytes4(b.ElectraForkVersion):   version.Electra,
 		bytesutil.ToBytes4(b.FuluForkVersion):      version.Fulu,
+		bytesutil.ToBytes4(b.GloasForkVersion):     version.Gloas,
 	}
 }
 
@@ -766,6 +771,12 @@ func FuluEnabled() bool {
 	return BeaconConfig().FuluForkEpoch < math.MaxUint64
 }
 
+// GloasEnabled centralizes the check to determine if code paths that are specific to Gloas should be allowed to execute.
+// This will make it easier to find call sites that do this kind of check and remove them post-gloas.
+func GloasEnabled() bool {
+	return BeaconConfig().GloasForkEpoch < math.MaxUint64
+}
+
 // WithinDAPeriod checks if the block epoch is within the data availability retention period.
 func WithinDAPeriod(block, current primitives.Epoch) bool {
 	if block >= BeaconConfig().FuluForkEpoch {

config/params/mainnet_config.go

@@ -31,6 +31,8 @@ const (
 	mainnetElectraForkEpoch = 364032 // May 7, 2025, 10:05:11 UTC
 	// Fulu Fork Epoch for mainnet config
 	mainnetFuluForkEpoch = math.MaxUint64 // Far future / to be defined
+	// Gloas Fork Epoch for mainnet config
+	mainnetGloasForkEpoch = math.MaxUint64 // Far future / to be defined
 )
 
 var mainnetNetworkConfig = &NetworkConfig{
@@ -221,6 +223,8 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	ElectraForkEpoch:     mainnetElectraForkEpoch,
 	FuluForkVersion:      []byte{6, 0, 0, 0},
 	FuluForkEpoch:        mainnetFuluForkEpoch,
+	GloasForkVersion:     []byte{7, 0, 0, 0},
+	GloasForkEpoch:       mainnetGloasForkEpoch,
 
 	// New values introduced in Altair hard fork 1.
 	// Participation flag indices.
@@ -362,6 +366,7 @@ func FillTestVersions(c *BeaconChainConfig, b byte) {
 	c.DenebForkVersion = make([]byte, fieldparams.VersionLength)
 	c.ElectraForkVersion = make([]byte, fieldparams.VersionLength)
 	c.FuluForkVersion = make([]byte, fieldparams.VersionLength)
+	c.GloasForkVersion = make([]byte, fieldparams.VersionLength)
 
 	c.GenesisForkVersion[fieldparams.VersionLength-1] = b
 	c.AltairForkVersion[fieldparams.VersionLength-1] = b
@@ -370,6 +375,7 @@ func FillTestVersions(c *BeaconChainConfig, b byte) {
 	c.DenebForkVersion[fieldparams.VersionLength-1] = b
 	c.ElectraForkVersion[fieldparams.VersionLength-1] = b
 	c.FuluForkVersion[fieldparams.VersionLength-1] = b
+	c.GloasForkVersion[fieldparams.VersionLength-1] = b
 
 	c.GenesisForkVersion[0] = 0
 	c.AltairForkVersion[0] = 1
@@ -378,4 +384,5 @@ func FillTestVersions(c *BeaconChainConfig, b byte) {
 	c.DenebForkVersion[0] = 4
 	c.ElectraForkVersion[0] = 5
 	c.FuluForkVersion[0] = 6
+	c.GloasForkVersion[0] = 7
 }

config/params/minimal_config.go

@@ -97,6 +97,8 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.ElectraForkEpoch = math.MaxUint64
 	minimalConfig.FuluForkVersion = []byte{6, 0, 0, 1}
 	minimalConfig.FuluForkEpoch = math.MaxUint64
+	minimalConfig.GloasForkVersion = []byte{7, 0, 0, 1}
+	minimalConfig.GloasForkEpoch = math.MaxUint64
 
 	minimalConfig.SyncCommitteeSize = 32
 	minimalConfig.InactivityScoreBias = 4

config/params/testnet_e2e_config.go

@@ -9,6 +9,7 @@ const (
 	DenebE2EForkEpoch     = 12
 	ElectraE2EForkEpoch   = 14
 	FuluE2EForkEpoch      = math.MaxUint64
+	GloasE2EForkEpoch     = math.MaxUint64
 )
 
 // E2ETestConfig retrieves the configurations made specifically for E2E testing.
@@ -46,6 +47,7 @@ func E2ETestConfig() *BeaconChainConfig {
 	e2eConfig.DenebForkEpoch = DenebE2EForkEpoch
 	e2eConfig.ElectraForkEpoch = ElectraE2EForkEpoch
 	e2eConfig.FuluForkEpoch = FuluE2EForkEpoch
+	e2eConfig.GloasForkEpoch = GloasE2EForkEpoch
 
 	// Terminal Total Difficulty.
 	e2eConfig.TerminalTotalDifficulty = "480"
@@ -59,6 +61,7 @@ func E2ETestConfig() *BeaconChainConfig {
 	e2eConfig.DenebForkVersion = []byte{4, 0, 0, 253}
 	e2eConfig.ElectraForkVersion = []byte{5, 0, 0, 253}
 	e2eConfig.FuluForkVersion = []byte{6, 0, 0, 253}
+	e2eConfig.GloasForkVersion = []byte{7, 0, 0, 253}
 
 	e2eConfig.BlobSchedule = []BlobScheduleEntry{
 		{Epoch: 12, MaxBlobsPerBlock: 6},
@@ -97,6 +100,7 @@ func E2EMainnetTestConfig() *BeaconChainConfig {
 	e2eConfig.DenebForkEpoch = DenebE2EForkEpoch
 	e2eConfig.ElectraForkEpoch = ElectraE2EForkEpoch
 	e2eConfig.FuluForkEpoch = FuluE2EForkEpoch
+	e2eConfig.GloasForkEpoch = GloasE2EForkEpoch
 
 	// Terminal Total Difficulty.
 	e2eConfig.TerminalTotalDifficulty = "480"
@@ -110,6 +114,7 @@ func E2EMainnetTestConfig() *BeaconChainConfig {
 	e2eConfig.DenebForkVersion = []byte{4, 0, 0, 254}
 	e2eConfig.ElectraForkVersion = []byte{5, 0, 0, 254}
 	e2eConfig.FuluForkVersion = []byte{6, 0, 0, 254}
+	e2eConfig.GloasForkVersion = []byte{7, 0, 0, 254}
 
 	// Deneb changes.
 	e2eConfig.MinPerEpochChurnLimit = 2

config/params/testnet_holesky_config.go

@@ -43,6 +43,8 @@ func HoleskyConfig() *BeaconChainConfig {
 	cfg.ElectraForkVersion = []byte{0x06, 0x1, 0x70, 0x0}
 	cfg.FuluForkEpoch = math.MaxUint64
 	cfg.FuluForkVersion = []byte{0x07, 0x1, 0x70, 0x0} // TODO: Define holesky fork version for fulu. This is a placeholder value.
+	cfg.GloasForkEpoch = math.MaxUint64
+	cfg.GloasForkVersion = []byte{0x08, 0x1, 0x70, 0x0} // TODO: Define holesky fork version for gloas. This is a placeholder value.
 	cfg.TerminalTotalDifficulty = "0"
 	cfg.DepositContractAddress = "0x4242424242424242424242424242424242424242"
 	cfg.EjectionBalance = 28000000000

config/params/testnet_hoodi_config.go

@@ -51,6 +51,8 @@ func HoodiConfig() *BeaconChainConfig {
 	cfg.ElectraForkVersion = []byte{0x60, 0x00, 0x09, 0x10}
 	cfg.FuluForkEpoch = math.MaxUint64
 	cfg.FuluForkVersion = []byte{0x70, 0x00, 0x09, 0x10}
+	cfg.GloasForkEpoch = math.MaxUint64
+	cfg.GloasForkVersion = []byte{0x80, 0x00, 0x09, 0x10}
 	cfg.TerminalTotalDifficulty = "0"
 	cfg.DepositContractAddress = "0x00000000219ab540356cBB839Cbe05303d7705Fa"
 	cfg.BlobSchedule = []BlobScheduleEntry{}

config/params/testnet_sepolia_config.go

@@ -48,6 +48,8 @@ func SepoliaConfig() *BeaconChainConfig {
 	cfg.ElectraForkVersion = []byte{0x90, 0x00, 0x00, 0x74}
 	cfg.FuluForkEpoch = math.MaxUint64
 	cfg.FuluForkVersion = []byte{0x90, 0x00, 0x00, 0x75} // TODO: Define sepolia fork version for fulu. This is a placeholder value.
+	cfg.GloasForkEpoch = math.MaxUint64
+	cfg.GloasForkVersion = []byte{0x90, 0x00, 0x00, 0x76} // TODO: Define sepolia fork version for gloas. This is a placeholder value.
 	cfg.TerminalTotalDifficulty = "17000000000000000"
 	cfg.DepositContractAddress = "0x7f02C3E3c98b133055B8B348B2Ac625669Ed295D"
 	cfg.DefaultBuilderGasLimit = uint64(60000000)

consensus-types/blocks/execution.go

@@ -37,6 +37,10 @@ func NewWrappedExecutionData(v proto.Message) (interfaces.ExecutionData, error)
 		return WrappedExecutionPayloadDeneb(pbStruct)
 	case *enginev1.ExecutionPayloadDenebWithValueAndBlobsBundle:
 		return WrappedExecutionPayloadDeneb(pbStruct.Payload)
+	case *enginev1.ExecutionPayloadGloas:
+		return WrappedExecutionPayloadGloas(pbStruct)
+	case *enginev1.ExecutionPayloadHeaderGloas:
+		return WrappedExecutionPayloadHeaderGloas(pbStruct)
 	case *enginev1.ExecutionBundleElectra:
 		// note: no payload changes in electra so using deneb
 		return WrappedExecutionPayloadDeneb(pbStruct.Payload)
@@ -786,6 +790,59 @@ func PayloadToHeaderDeneb(payload interfaces.ExecutionData) (*enginev1.Execution
 	}, nil
 }
 
+// PayloadToHeaderGloas converts `payload` into execution payload header format.
+func PayloadToHeaderGloas(payload interfaces.ExecutionData) (*enginev1.ExecutionPayloadHeaderGloas, error) {
+	txs, err := payload.Transactions()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := ssz.TransactionsRoot(txs)
+	if err != nil {
+		return nil, err
+	}
+	withdrawals, err := payload.Withdrawals()
+	if err != nil {
+		return nil, err
+	}
+	withdrawalsRoot, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payload.BlobGasUsed()
+	if err != nil {
+		return nil, err
+	}
+	excessBlobGas, err := payload.ExcessBlobGas()
+	if err != nil {
+		return nil, err
+	}
+
+	// For Gloas, we need to compute the BlockAccessListRoot
+	// This will need to be implemented once we have access to the BlockAccessList field
+	var blockAccessListRoot [32]byte
+
+	return &enginev1.ExecutionPayloadHeaderGloas{
+		ParentHash:          bytesutil.SafeCopyBytes(payload.ParentHash()),
+		FeeRecipient:        bytesutil.SafeCopyBytes(payload.FeeRecipient()),
+		StateRoot:           bytesutil.SafeCopyBytes(payload.StateRoot()),
+		ReceiptsRoot:        bytesutil.SafeCopyBytes(payload.ReceiptsRoot()),
+		LogsBloom:           bytesutil.SafeCopyBytes(payload.LogsBloom()),
+		PrevRandao:          bytesutil.SafeCopyBytes(payload.PrevRandao()),
+		BlockNumber:         payload.BlockNumber(),
+		GasLimit:            payload.GasLimit(),
+		GasUsed:             payload.GasUsed(),
+		Timestamp:           payload.Timestamp(),
+		ExtraData:           bytesutil.SafeCopyBytes(payload.ExtraData()),
+		BaseFeePerGas:       bytesutil.SafeCopyBytes(payload.BaseFeePerGas()),
+		BlockHash:           bytesutil.SafeCopyBytes(payload.BlockHash()),
+		TransactionsRoot:    txRoot[:],
+		WithdrawalsRoot:     withdrawalsRoot[:],
+		BlobGasUsed:         blobGasUsed,
+		ExcessBlobGas:       excessBlobGas,
+		BlockAccessListRoot: blockAccessListRoot[:],
+	}, nil
+}
+
 var (
 	PayloadToHeaderElectra = PayloadToHeaderDeneb
 	PayloadToHeaderFulu    = PayloadToHeaderDeneb
@@ -1164,3 +1221,317 @@ func (e executionPayloadDeneb) ExcessBlobGas() (uint64, error) {
 func (e executionPayloadDeneb) IsBlinded() bool {
 	return false
 }
+
+// executionPayloadGloas is a convenience wrapper around a beacon block body's execution payload data structure
+// This wrapper allows us to conform to a common interface so that beacon
+// blocks for future forks can also be applied across Prysm without issues.
+type executionPayloadGloas struct {
+	p *enginev1.ExecutionPayloadGloas
+}
+
+var _ interfaces.ExecutionData = &executionPayloadGloas{}
+
+// WrappedExecutionPayloadGloas is a constructor which wraps a protobuf execution payload into an interface.
+func WrappedExecutionPayloadGloas(p *enginev1.ExecutionPayloadGloas) (interfaces.ExecutionData, error) {
+	w := executionPayloadGloas{p: p}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// IsNil checks if the underlying data is nil.
+func (e executionPayloadGloas) IsNil() bool {
+	return e.p == nil
+}
+
+// MarshalSSZ --
+func (e executionPayloadGloas) MarshalSSZ() ([]byte, error) {
+	return e.p.MarshalSSZ()
+}
+
+// MarshalSSZTo --
+func (e executionPayloadGloas) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return e.p.MarshalSSZTo(dst)
+}
+
+// SizeSSZ --
+func (e executionPayloadGloas) SizeSSZ() int {
+	return e.p.SizeSSZ()
+}
+
+// UnmarshalSSZ --
+func (e executionPayloadGloas) UnmarshalSSZ(buf []byte) error {
+	return e.p.UnmarshalSSZ(buf)
+}
+
+// HashTreeRoot --
+func (e executionPayloadGloas) HashTreeRoot() ([32]byte, error) {
+	return e.p.HashTreeRoot()
+}
+
+// HashTreeRootWith --
+func (e executionPayloadGloas) HashTreeRootWith(hh *fastssz.Hasher) error {
+	return e.p.HashTreeRootWith(hh)
+}
+
+// Proto --
+func (e executionPayloadGloas) Proto() proto.Message {
+	return e.p
+}
+
+// ParentHash --
+func (e executionPayloadGloas) ParentHash() []byte {
+	return e.p.ParentHash
+}
+
+// FeeRecipient --
+func (e executionPayloadGloas) FeeRecipient() []byte {
+	return e.p.FeeRecipient
+}
+
+// StateRoot --
+func (e executionPayloadGloas) StateRoot() []byte {
+	return e.p.StateRoot
+}
+
+// ReceiptsRoot --
+func (e executionPayloadGloas) ReceiptsRoot() []byte {
+	return e.p.ReceiptsRoot
+}
+
+// LogsBloom --
+func (e executionPayloadGloas) LogsBloom() []byte {
+	return e.p.LogsBloom
+}
+
+// PrevRandao --
+func (e executionPayloadGloas) PrevRandao() []byte {
+	return e.p.PrevRandao
+}
+
+// BlockNumber --
+func (e executionPayloadGloas) BlockNumber() uint64 {
+	return e.p.BlockNumber
+}
+
+// GasLimit --
+func (e executionPayloadGloas) GasLimit() uint64 {
+	return e.p.GasLimit
+}
+
+// GasUsed --
+func (e executionPayloadGloas) GasUsed() uint64 {
+	return e.p.GasUsed
+}
+
+// Timestamp --
+func (e executionPayloadGloas) Timestamp() uint64 {
+	return e.p.Timestamp
+}
+
+// ExtraData --
+func (e executionPayloadGloas) ExtraData() []byte {
+	return e.p.ExtraData
+}
+
+// BaseFeePerGas --
+func (e executionPayloadGloas) BaseFeePerGas() []byte {
+	return e.p.BaseFeePerGas
+}
+
+// BlockHash --
+func (e executionPayloadGloas) BlockHash() []byte {
+	return e.p.BlockHash
+}
+
+// Transactions --
+func (e executionPayloadGloas) Transactions() ([][]byte, error) {
+	return e.p.Transactions, nil
+}
+
+// TransactionsRoot --
+func (e executionPayloadGloas) TransactionsRoot() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// Withdrawals --
+func (e executionPayloadGloas) Withdrawals() ([]*enginev1.Withdrawal, error) {
+	return e.p.Withdrawals, nil
+}
+
+// WithdrawalsRoot --
+func (e executionPayloadGloas) WithdrawalsRoot() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+func (e executionPayloadGloas) BlobGasUsed() (uint64, error) {
+	return e.p.BlobGasUsed, nil
+}
+
+func (e executionPayloadGloas) ExcessBlobGas() (uint64, error) {
+	return e.p.ExcessBlobGas, nil
+}
+
+// IsBlinded returns true if the underlying data is blinded.
+func (e executionPayloadGloas) IsBlinded() bool {
+	return false
+}
+
+// executionPayloadHeaderGloas is a convenience wrapper around a blinded beacon block body's execution header data structure.
+// This wrapper allows us to conform to a common interface so that beacon
+// blocks for future forks can also be applied across Prysm without issues.
+type executionPayloadHeaderGloas struct {
+	p *enginev1.ExecutionPayloadHeaderGloas
+}
+
+var _ interfaces.ExecutionData = &executionPayloadHeaderGloas{}
+
+// WrappedExecutionPayloadHeaderGloas is a constructor which wraps a protobuf execution header into an interface.
+func WrappedExecutionPayloadHeaderGloas(p *enginev1.ExecutionPayloadHeaderGloas) (interfaces.ExecutionData, error) {
+	w := executionPayloadHeaderGloas{p: p}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// IsNil checks if the underlying data is nil.
+func (e executionPayloadHeaderGloas) IsNil() bool {
+	return e.p == nil
+}
+
+// MarshalSSZ --
+func (e executionPayloadHeaderGloas) MarshalSSZ() ([]byte, error) {
+	return e.p.MarshalSSZ()
+}
+
+// MarshalSSZTo --
+func (e executionPayloadHeaderGloas) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return e.p.MarshalSSZTo(dst)
+}
+
+// SizeSSZ --
+func (e executionPayloadHeaderGloas) SizeSSZ() int {
+	return e.p.SizeSSZ()
+}
+
+// UnmarshalSSZ --
+func (e executionPayloadHeaderGloas) UnmarshalSSZ(buf []byte) error {
+	return e.p.UnmarshalSSZ(buf)
+}
+
+// HashTreeRoot --
+func (e executionPayloadHeaderGloas) HashTreeRoot() ([32]byte, error) {
+	return e.p.HashTreeRoot()
+}
+
+// HashTreeRootWith --
+func (e executionPayloadHeaderGloas) HashTreeRootWith(hh *fastssz.Hasher) error {
+	return e.p.HashTreeRootWith(hh)
+}
+
+// Proto --
+func (e executionPayloadHeaderGloas) Proto() proto.Message {
+	return e.p
+}
+
+// ParentHash --
+func (e executionPayloadHeaderGloas) ParentHash() []byte {
+	return e.p.ParentHash
+}
+
+// FeeRecipient --
+func (e executionPayloadHeaderGloas) FeeRecipient() []byte {
+	return e.p.FeeRecipient
+}
+
+// StateRoot --
+func (e executionPayloadHeaderGloas) StateRoot() []byte {
+	return e.p.StateRoot
+}
+
+// ReceiptsRoot --
+func (e executionPayloadHeaderGloas) ReceiptsRoot() []byte {
+	return e.p.ReceiptsRoot
+}
+
+// LogsBloom --
+func (e executionPayloadHeaderGloas) LogsBloom() []byte {
+	return e.p.LogsBloom
+}
+
+// PrevRandao --
+func (e executionPayloadHeaderGloas) PrevRandao() []byte {
+	return e.p.PrevRandao
+}
+
+// BlockNumber --
+func (e executionPayloadHeaderGloas) BlockNumber() uint64 {
+	return e.p.BlockNumber
+}
+
+// GasLimit --
+func (e executionPayloadHeaderGloas) GasLimit() uint64 {
+	return e.p.GasLimit
+}
+
+// GasUsed --
+func (e executionPayloadHeaderGloas) GasUsed() uint64 {
+	return e.p.GasUsed
+}
+
+// Timestamp --
+func (e executionPayloadHeaderGloas) Timestamp() uint64 {
+	return e.p.Timestamp
+}
+
+// ExtraData --
+func (e executionPayloadHeaderGloas) ExtraData() []byte {
+	return e.p.ExtraData
+}
+
+// BaseFeePerGas --
+func (e executionPayloadHeaderGloas) BaseFeePerGas() []byte {
+	return e.p.BaseFeePerGas
+}
+
+// BlockHash --
+func (e executionPayloadHeaderGloas) BlockHash() []byte {
+	return e.p.BlockHash
+}
+
+// Transactions --
+func (executionPayloadHeaderGloas) Transactions() ([][]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// TransactionsRoot --
+func (e executionPayloadHeaderGloas) TransactionsRoot() ([]byte, error) {
+	return e.p.TransactionsRoot, nil
+}
+
+// Withdrawals --
+func (e executionPayloadHeaderGloas) Withdrawals() ([]*enginev1.Withdrawal, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// WithdrawalsRoot --
+func (e executionPayloadHeaderGloas) WithdrawalsRoot() ([]byte, error) {
+	return e.p.WithdrawalsRoot, nil
+}
+
+// BlobGasUsed --
+func (e executionPayloadHeaderGloas) BlobGasUsed() (uint64, error) {
+	return e.p.BlobGasUsed, nil
+}
+
+// ExcessBlobGas --
+func (e executionPayloadHeaderGloas) ExcessBlobGas() (uint64, error) {
+	return e.p.ExcessBlobGas, nil
+}
+
+// IsBlinded returns true if the underlying data is blinded.
+func (e executionPayloadHeaderGloas) IsBlinded() bool {
+	return true
+}

consensus-types/blocks/factory.go

@@ -82,6 +82,10 @@ func NewSignedBeaconBlock(i interface{}) (interfaces.SignedBeaconBlock, error) {
 		return initBlindedSignedBlockFromProtoFulu(b)
 	case *eth.GenericSignedBeaconBlock_BlindedFulu:
 		return initBlindedSignedBlockFromProtoFulu(b.BlindedFulu)
+	case *eth.GenericSignedBeaconBlock_Gloas:
+		return initSignedBlockFromProtoGloas(b.Gloas.Block)
+	case *eth.SignedBeaconBlockGloas:
+		return initSignedBlockFromProtoGloas(b)
 	default:
 		return nil, errors.Wrapf(ErrUnsupportedSignedBeaconBlock, "unable to create block from type %T", i)
 	}
@@ -138,6 +142,10 @@ func NewBeaconBlock(i interface{}) (interfaces.ReadOnlyBeaconBlock, error) {
 		return initBlindedBlockFromProtoFulu(b)
 	case *eth.GenericBeaconBlock_BlindedFulu:
 		return initBlindedBlockFromProtoFulu(b.BlindedFulu)
+	case *eth.GenericBeaconBlock_Gloas:
+		return initBlockFromProtoGloas(b.Gloas.Block)
+	case *eth.BeaconBlockGloas:
+		return initBlockFromProtoGloas(b)
 	default:
 		return nil, errors.Wrapf(errUnsupportedBeaconBlock, "unable to create block from type %T", i)
 	}
@@ -260,6 +268,19 @@ func BuildSignedBeaconBlock(blk interfaces.ReadOnlyBeaconBlock, signature []byte
 			return nil, errIncorrectBlockVersion
 		}
 		return NewSignedBeaconBlock(&eth.SignedBeaconBlockFulu{Block: pb, Signature: signature})
+	case version.Gloas:
+		if blk.IsBlinded() {
+			pb, ok := pb.(*eth.BlindedBeaconBlockFulu)
+			if !ok {
+				return nil, errIncorrectBlockVersion
+			}
+			return NewSignedBeaconBlock(&eth.SignedBlindedBeaconBlockFulu{Message: pb, Signature: signature})
+		}
+		pb, ok := pb.(*eth.BeaconBlockGloas)
+		if !ok {
+			return nil, errIncorrectBlockVersion
+		}
+		return NewSignedBeaconBlock(&eth.SignedBeaconBlockGloas{Block: pb, Signature: signature})
 	default:
 		return nil, errUnsupportedBeaconBlock
 	}
@@ -273,6 +294,8 @@ func getWrappedPayload(payload interface{}) (wrappedPayload interfaces.Execution
 		wrappedPayload, wrapErr = WrappedExecutionPayloadCapella(p)
 	case *enginev1.ExecutionPayloadDeneb:
 		wrappedPayload, wrapErr = WrappedExecutionPayloadDeneb(p)
+	case *enginev1.ExecutionPayloadGloas:
+		wrappedPayload, wrapErr = WrappedExecutionPayloadGloas(p)
 	default:
 		wrappedPayload, wrapErr = nil, fmt.Errorf("%T is not a type of execution payload", p)
 	}
@@ -629,6 +652,89 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 			},
 			Signature: sig[:],
 		}
+	case version.Gloas:
+		p, ok := payload.(*enginev1.ExecutionPayloadGloas)
+		if !ok {
+			return nil, fmt.Errorf("payload has wrong type (expected %T, got %T)", &enginev1.ExecutionPayloadGloas{}, payload)
+		}
+		blsToExecutionChanges, err := b.Body().BLSToExecutionChanges()
+		if err != nil {
+			return nil, err
+		}
+		commitments, err := b.Body().BlobKzgCommitments()
+		if err != nil {
+			return nil, err
+		}
+		var atts []*eth.AttestationElectra
+		if b.Body().Attestations() != nil {
+			atts = make([]*eth.AttestationElectra, len(b.Body().Attestations()))
+			for i, att := range b.Body().Attestations() {
+				a, ok := att.(*eth.AttestationElectra)
+				if !ok {
+					return nil, fmt.Errorf("attestation has wrong type (expected %T, got %T)", &eth.AttestationElectra{}, att)
+				}
+				atts[i] = a
+			}
+		}
+		var attSlashings []*eth.AttesterSlashingElectra
+		if b.Body().AttesterSlashings() != nil {
+			attSlashings = make([]*eth.AttesterSlashingElectra, len(b.Body().AttesterSlashings()))
+			for i, slashing := range b.Body().AttesterSlashings() {
+				s, ok := slashing.(*eth.AttesterSlashingElectra)
+				if !ok {
+					return nil, fmt.Errorf("attester slashing has wrong type (expected %T, got %T)", &eth.AttesterSlashingElectra{}, slashing)
+				}
+				attSlashings[i] = s
+			}
+		}
+
+		er, err := b.Body().ExecutionRequests()
+		if err != nil {
+			return nil, err
+		}
+
+		fullBlock = &eth.SignedBeaconBlockFulu{
+			Block: &eth.BeaconBlockElectra{
+				Slot:          b.Slot(),
+				ProposerIndex: b.ProposerIndex(),
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				Body: &eth.BeaconBlockBodyElectra{
+					RandaoReveal:      randaoReveal[:],
+					Eth1Data:          b.Body().Eth1Data(),
+					Graffiti:          graffiti[:],
+					ProposerSlashings: b.Body().ProposerSlashings(),
+					AttesterSlashings: attSlashings,
+					Attestations:      atts,
+					Deposits:          b.Body().Deposits(),
+					VoluntaryExits:    b.Body().VoluntaryExits(),
+					SyncAggregate:     syncAgg,
+					ExecutionPayload: &enginev1.ExecutionPayloadDeneb{
+						ParentHash:    p.ParentHash,
+						FeeRecipient:  p.FeeRecipient,
+						StateRoot:     p.StateRoot,
+						ReceiptsRoot:  p.ReceiptsRoot,
+						LogsBloom:     p.LogsBloom,
+						PrevRandao:    p.PrevRandao,
+						BlockNumber:   p.BlockNumber,
+						GasLimit:      p.GasLimit,
+						GasUsed:       p.GasUsed,
+						Timestamp:     p.Timestamp,
+						ExtraData:     p.ExtraData,
+						BaseFeePerGas: p.BaseFeePerGas,
+						BlockHash:     p.BlockHash,
+						Transactions:  p.Transactions,
+						Withdrawals:   p.Withdrawals,
+						BlobGasUsed:   p.BlobGasUsed,
+						ExcessBlobGas: p.ExcessBlobGas,
+					},
+					BlsToExecutionChanges: blsToExecutionChanges,
+					BlobKzgCommitments:    commitments,
+					ExecutionRequests:     er,
+				},
+			},
+			Signature: sig[:],
+		}
 	default:
 		return nil, errors.New("Block not of known type")
 	}

consensus-types/blocks/getters.go

@@ -80,6 +80,8 @@ func (b *SignedBeaconBlock) Copy() (interfaces.SignedBeaconBlock, error) {
 			return initBlindedSignedBlockFromProtoFulu(pb.(*eth.SignedBlindedBeaconBlockFulu).Copy())
 		}
 		return initSignedBlockFromProtoFulu(pb.(*eth.SignedBeaconBlockFulu).Copy())
+	case version.Gloas:
+		return initSignedBlockFromProtoGloas(pb.(*eth.SignedBeaconBlockGloas).Copy())
 	default:
 		return nil, errIncorrectBlockVersion
 	}
@@ -157,6 +159,14 @@ func (b *SignedBeaconBlock) PbGenericBlock() (*eth.GenericSignedBeaconBlock, err
 		return &eth.GenericSignedBeaconBlock{
 			Block: &eth.GenericSignedBeaconBlock_Fulu{Fulu: bc},
 		}, nil
+	case version.Gloas:
+		bc, ok := pb.(*eth.SignedBeaconBlockContentsGloas)
+		if !ok {
+			return nil, fmt.Errorf("PbGenericBlock() only supports block content type but got %T", pb)
+		}
+		return &eth.GenericSignedBeaconBlock{
+			Block: &eth.GenericSignedBeaconBlock_Gloas{Gloas: bc},
+		}, nil
 	default:
 		return nil, errIncorrectBlockVersion
 	}
@@ -336,6 +346,57 @@ func (b *SignedBeaconBlock) ToBlinded() (interfaces.ReadOnlySignedBeaconBlock, e
 				},
 				Signature: b.signature[:],
 			})
+	case *enginev1.ExecutionPayloadGloas:
+		header, err := PayloadToHeaderGloas(payload)
+		if err != nil {
+			return nil, errors.Wrap(err, "payload to header gloas")
+		}
+		// Convert ExecutionPayloadHeaderGloas to ExecutionPayloadHeaderDeneb for compatibility
+		// TODO: Create proper Gloas blinded block types
+		denebHeader := &enginev1.ExecutionPayloadHeaderDeneb{
+			ParentHash:       header.ParentHash,
+			FeeRecipient:     header.FeeRecipient,
+			StateRoot:        header.StateRoot,
+			ReceiptsRoot:     header.ReceiptsRoot,
+			LogsBloom:        header.LogsBloom,
+			PrevRandao:       header.PrevRandao,
+			BlockNumber:      header.BlockNumber,
+			GasLimit:         header.GasLimit,
+			GasUsed:          header.GasUsed,
+			Timestamp:        header.Timestamp,
+			ExtraData:        header.ExtraData,
+			BaseFeePerGas:    header.BaseFeePerGas,
+			BlockHash:        header.BlockHash,
+			TransactionsRoot: header.TransactionsRoot,
+			WithdrawalsRoot:  header.WithdrawalsRoot,
+			BlobGasUsed:      header.BlobGasUsed,
+			ExcessBlobGas:    header.ExcessBlobGas,
+		}
+		return initBlindedSignedBlockFromProtoFulu(
+			&eth.SignedBlindedBeaconBlockFulu{
+				Message: &eth.BlindedBeaconBlockFulu{
+					Slot:          b.block.slot,
+					ProposerIndex: b.block.proposerIndex,
+					ParentRoot:    b.block.parentRoot[:],
+					StateRoot:     b.block.stateRoot[:],
+					Body: &eth.BlindedBeaconBlockBodyElectra{
+						RandaoReveal:           b.block.body.randaoReveal[:],
+						Eth1Data:               b.block.body.eth1Data,
+						Graffiti:               b.block.body.graffiti[:],
+						ProposerSlashings:      b.block.body.proposerSlashings,
+						AttesterSlashings:      b.block.body.attesterSlashingsElectra,
+						Attestations:           b.block.body.attestationsElectra,
+						Deposits:               b.block.body.deposits,
+						VoluntaryExits:         b.block.body.voluntaryExits,
+						SyncAggregate:          b.block.body.syncAggregate,
+						ExecutionPayloadHeader: denebHeader,
+						BlsToExecutionChanges:  b.block.body.blsToExecutionChanges,
+						BlobKzgCommitments:     b.block.body.blobKzgCommitments,
+						ExecutionRequests:      b.block.body.executionRequests,
+					},
+				},
+				Signature: b.signature[:],
+			})
 	default:
 		return nil, fmt.Errorf("%T is not an execution payload header", p)
 	}
@@ -437,6 +498,11 @@ func (b *SignedBeaconBlock) MarshalSSZ() ([]byte, error) {
 			return pb.(*eth.SignedBlindedBeaconBlockFulu).MarshalSSZ()
 		}
 		return pb.(*eth.SignedBeaconBlockFulu).MarshalSSZ()
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.SignedBlindedBeaconBlockFulu).MarshalSSZ()
+		}
+		return pb.(*eth.SignedBeaconBlockGloas).MarshalSSZ()
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -479,6 +545,11 @@ func (b *SignedBeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) {
 			return pb.(*eth.SignedBlindedBeaconBlockFulu).MarshalSSZTo(dst)
 		}
 		return pb.(*eth.SignedBeaconBlockFulu).MarshalSSZTo(dst)
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.SignedBlindedBeaconBlockFulu).MarshalSSZTo(dst)
+		}
+		return pb.(*eth.SignedBeaconBlockGloas).MarshalSSZTo(dst)
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -526,6 +597,11 @@ func (b *SignedBeaconBlock) SizeSSZ() int {
 			return pb.(*eth.SignedBlindedBeaconBlockFulu).SizeSSZ()
 		}
 		return pb.(*eth.SignedBeaconBlockFulu).SizeSSZ()
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.SignedBlindedBeaconBlockFulu).SizeSSZ()
+		}
+		return pb.(*eth.SignedBeaconBlockGloas).SizeSSZ()
 	default:
 		panic(incorrectBlockVersion)
 	}
@@ -666,6 +742,28 @@ func (b *SignedBeaconBlock) UnmarshalSSZ(buf []byte) error {
 				return err
 			}
 		}
+	case version.Gloas:
+		if b.IsBlinded() {
+			pb := &eth.SignedBlindedBeaconBlockFulu{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initBlindedSignedBlockFromProtoFulu(pb)
+			if err != nil {
+				return err
+			}
+		} else {
+			pb := &eth.SignedBeaconBlockGloas{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initSignedBlockFromProtoGloas(pb)
+			if err != nil {
+				return err
+			}
+		}
 	default:
 		return errIncorrectBlockVersion
 	}
@@ -749,6 +847,11 @@ func (b *BeaconBlock) HashTreeRoot() ([field_params.RootLength]byte, error) {
 			return pb.(*eth.BlindedBeaconBlockFulu).HashTreeRoot()
 		}
 		return pb.(*eth.BeaconBlockElectra).HashTreeRoot()
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockFulu).HashTreeRoot()
+		}
+		return pb.(*eth.BeaconBlockGloas).HashTreeRoot()
 	default:
 		return [field_params.RootLength]byte{}, errIncorrectBlockVersion
 	}
@@ -790,6 +893,11 @@ func (b *BeaconBlock) HashTreeRootWith(h *ssz.Hasher) error {
 			return pb.(*eth.BlindedBeaconBlockFulu).HashTreeRootWith(h)
 		}
 		return pb.(*eth.BeaconBlockElectra).HashTreeRootWith(h)
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockFulu).HashTreeRootWith(h)
+		}
+		return pb.(*eth.BeaconBlockGloas).HashTreeRootWith(h)
 	default:
 		return errIncorrectBlockVersion
 	}
@@ -832,6 +940,11 @@ func (b *BeaconBlock) MarshalSSZ() ([]byte, error) {
 			return pb.(*eth.BlindedBeaconBlockFulu).MarshalSSZ()
 		}
 		return pb.(*eth.BeaconBlockElectra).MarshalSSZ()
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockFulu).MarshalSSZ()
+		}
+		return pb.(*eth.BeaconBlockGloas).MarshalSSZ()
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -874,6 +987,11 @@ func (b *BeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) {
 			return pb.(*eth.BlindedBeaconBlockFulu).MarshalSSZTo(dst)
 		}
 		return pb.(*eth.BeaconBlockElectra).MarshalSSZTo(dst)
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockFulu).MarshalSSZTo(dst)
+		}
+		return pb.(*eth.BeaconBlockGloas).MarshalSSZTo(dst)
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -921,6 +1039,11 @@ func (b *BeaconBlock) SizeSSZ() int {
 			return pb.(*eth.BlindedBeaconBlockFulu).SizeSSZ()
 		}
 		return pb.(*eth.BeaconBlockElectra).SizeSSZ()
+	case version.Gloas:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockFulu).SizeSSZ()
+		}
+		return pb.(*eth.BeaconBlockGloas).SizeSSZ()
 	default:
 		panic(incorrectBodyVersion)
 	}
@@ -1061,6 +1184,28 @@ func (b *BeaconBlock) UnmarshalSSZ(buf []byte) error {
 				return err
 			}
 		}
+	case version.Gloas:
+		if b.IsBlinded() {
+			pb := &eth.BlindedBeaconBlockFulu{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initBlindedBlockFromProtoFulu(pb)
+			if err != nil {
+				return err
+			}
+		} else {
+			pb := &eth.BeaconBlockGloas{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initBlockFromProtoGloas(pb)
+			if err != nil {
+				return err
+			}
+		}
 	default:
 		return errIncorrectBlockVersion
 	}
@@ -1104,6 +1249,8 @@ func (b *BeaconBlock) AsSignRequestObject() (validatorpb.SignRequestObject, erro
 			return &validatorpb.SignRequest_BlindedBlockFulu{BlindedBlockFulu: pb.(*eth.BlindedBeaconBlockFulu)}, nil
 		}
 		return &validatorpb.SignRequest_BlockFulu{BlockFulu: pb.(*eth.BeaconBlockElectra)}, nil
+	case version.Gloas:
+		return &validatorpb.SignRequest_BlockGloas{BlockGloas: pb.(*eth.BeaconBlockGloas)}, nil
 	default:
 		return nil, errIncorrectBlockVersion
 	}

consensus-types/blocks/proofs.go

@@ -44,6 +44,8 @@ func ComputeBlockBodyFieldRoots(ctx context.Context, blockBody *BeaconBlockBody)
 		fieldRoots = make([][]byte, 13)
 	case version.Fulu:
 		fieldRoots = make([][]byte, 13)
+	case version.Gloas:
+		fieldRoots = make([][]byte, 13)
 	default:
 		return nil, fmt.Errorf("unknown block body version %s", version.String(blockBody.version))
 	}

consensus-types/blocks/proto.go

@@ -185,6 +185,33 @@ func (b *SignedBeaconBlock) Proto() (proto.Message, error) { // nolint:gocognit
 			Block:     block,
 			Signature: b.signature[:],
 		}, nil
+	case version.Gloas:
+		if b.IsBlinded() {
+			var block *eth.BlindedBeaconBlockFulu
+			if blockMessage != nil {
+				var ok bool
+				block, ok = blockMessage.(*eth.BlindedBeaconBlockFulu)
+				if !ok {
+					return nil, errIncorrectBlockVersion
+				}
+			}
+			return &eth.SignedBlindedBeaconBlockFulu{
+				Message:   block,
+				Signature: b.signature[:],
+			}, nil
+		}
+		var block *eth.BeaconBlockGloas
+		if blockMessage != nil {
+			var ok bool
+			block, ok = blockMessage.(*eth.BeaconBlockGloas)
+			if !ok {
+				return nil, errIncorrectBlockVersion
+			}
+		}
+		return &eth.SignedBeaconBlockGloas{
+			Block:     block,
+			Signature: b.signature[:],
+		}, nil
 	default:
 		return nil, errors.New("unsupported signed beacon block version")
 	}
@@ -399,6 +426,39 @@ func (b *BeaconBlock) Proto() (proto.Message, error) { // nolint:gocognit
 			StateRoot:     b.stateRoot[:],
 			Body:          body,
 		}, nil
+	case version.Gloas:
+		if b.IsBlinded() {
+			var body *eth.BlindedBeaconBlockBodyElectra
+			if bodyMessage != nil {
+				var ok bool
+				body, ok = bodyMessage.(*eth.BlindedBeaconBlockBodyElectra)
+				if !ok {
+					return nil, errIncorrectBodyVersion
+				}
+			}
+			return &eth.BlindedBeaconBlockFulu{
+				Slot:          b.slot,
+				ProposerIndex: b.proposerIndex,
+				ParentRoot:    b.parentRoot[:],
+				StateRoot:     b.stateRoot[:],
+				Body:          body,
+			}, nil
+		}
+		var body *eth.BeaconBlockBodyGloas
+		if bodyMessage != nil {
+			var ok bool
+			body, ok = bodyMessage.(*eth.BeaconBlockBodyGloas)
+			if !ok {
+				return nil, errIncorrectBodyVersion
+			}
+		}
+		return &eth.BeaconBlockGloas{
+			Slot:          b.slot,
+			ProposerIndex: b.proposerIndex,
+			ParentRoot:    b.parentRoot[:],
+			StateRoot:     b.stateRoot[:],
+			Body:          body,
+		}, nil
 	default:
 		return nil, fmt.Errorf("unsupported beacon block version: %s", version.String(b.version))
 	}
@@ -668,6 +728,78 @@ func (b *BeaconBlockBody) Proto() (proto.Message, error) {
 			BlobKzgCommitments:    b.blobKzgCommitments,
 			ExecutionRequests:     b.executionRequests,
 		}, nil
+	case version.Gloas:
+		if b.IsBlinded() {
+			var ph *enginev1.ExecutionPayloadHeaderGloas
+			var ok bool
+			if b.executionPayloadHeader != nil {
+				ph, ok = b.executionPayloadHeader.Proto().(*enginev1.ExecutionPayloadHeaderGloas)
+				if !ok {
+					return nil, errPayloadHeaderWrongType
+				}
+			}
+			// Use Electra body for now until Gloas-specific blinded body is created
+			denebHeader := &enginev1.ExecutionPayloadHeaderDeneb{}
+			if ph != nil {
+				denebHeader = &enginev1.ExecutionPayloadHeaderDeneb{
+					ParentHash:       ph.ParentHash,
+					FeeRecipient:     ph.FeeRecipient,
+					StateRoot:        ph.StateRoot,
+					ReceiptsRoot:     ph.ReceiptsRoot,
+					LogsBloom:        ph.LogsBloom,
+					PrevRandao:       ph.PrevRandao,
+					BlockNumber:      ph.BlockNumber,
+					GasLimit:         ph.GasLimit,
+					GasUsed:          ph.GasUsed,
+					Timestamp:        ph.Timestamp,
+					ExtraData:        ph.ExtraData,
+					BaseFeePerGas:    ph.BaseFeePerGas,
+					BlockHash:        ph.BlockHash,
+					TransactionsRoot: ph.TransactionsRoot,
+					WithdrawalsRoot:  ph.WithdrawalsRoot,
+					BlobGasUsed:      ph.BlobGasUsed,
+					ExcessBlobGas:    ph.ExcessBlobGas,
+				}
+			}
+			return &eth.BlindedBeaconBlockBodyElectra{
+				RandaoReveal:           b.randaoReveal[:],
+				Eth1Data:               b.eth1Data,
+				Graffiti:               b.graffiti[:],
+				ProposerSlashings:      b.proposerSlashings,
+				AttesterSlashings:      b.attesterSlashingsElectra,
+				Attestations:           b.attestationsElectra,
+				Deposits:               b.deposits,
+				VoluntaryExits:         b.voluntaryExits,
+				SyncAggregate:          b.syncAggregate,
+				ExecutionPayloadHeader: denebHeader,
+				BlsToExecutionChanges:  b.blsToExecutionChanges,
+				BlobKzgCommitments:     b.blobKzgCommitments,
+				ExecutionRequests:      b.executionRequests,
+			}, nil
+		}
+		var p *enginev1.ExecutionPayloadGloas
+		var ok bool
+		if b.executionPayload != nil {
+			p, ok = b.executionPayload.Proto().(*enginev1.ExecutionPayloadGloas)
+			if !ok {
+				return nil, errPayloadWrongType
+			}
+		}
+		return &eth.BeaconBlockBodyGloas{
+			RandaoReveal:          b.randaoReveal[:],
+			Eth1Data:              b.eth1Data,
+			Graffiti:              b.graffiti[:],
+			ProposerSlashings:     b.proposerSlashings,
+			AttesterSlashings:     b.attesterSlashingsElectra,
+			Attestations:          b.attestationsElectra,
+			Deposits:              b.deposits,
+			VoluntaryExits:        b.voluntaryExits,
+			SyncAggregate:         b.syncAggregate,
+			ExecutionPayload:      p,
+			BlsToExecutionChanges: b.blsToExecutionChanges,
+			BlobKzgCommitments:    b.blobKzgCommitments,
+			ExecutionRequests:     b.executionRequests,
+		}, nil
 	default:
 		return nil, errors.New("unsupported beacon block body version")
 	}
@@ -1412,6 +1544,43 @@ func initBlindedBlockFromProtoFulu(pb *eth.BlindedBeaconBlockFulu) (*BeaconBlock
 	return b, nil
 }
 
+func initSignedBlockFromProtoGloas(pb *eth.SignedBeaconBlockGloas) (*SignedBeaconBlock, error) {
+	if pb == nil {
+		return nil, errNilBlock
+	}
+
+	block, err := initBlockFromProtoGloas(pb.Block)
+	if err != nil {
+		return nil, err
+	}
+	b := &SignedBeaconBlock{
+		version:   version.Gloas,
+		block:     block,
+		signature: bytesutil.ToBytes96(pb.Signature),
+	}
+	return b, nil
+}
+
+func initBlockFromProtoGloas(pb *eth.BeaconBlockGloas) (*BeaconBlock, error) {
+	if pb == nil {
+		return nil, errNilBlock
+	}
+
+	body, err := initBlockBodyFromProtoGloas(pb.Body)
+	if err != nil {
+		return nil, err
+	}
+	b := &BeaconBlock{
+		version:       version.Gloas,
+		slot:          pb.Slot,
+		proposerIndex: pb.ProposerIndex,
+		parentRoot:    bytesutil.ToBytes32(pb.ParentRoot),
+		stateRoot:     bytesutil.ToBytes32(pb.StateRoot),
+		body:          body,
+	}
+	return b, nil
+}
+
 func initBlockBodyFromProtoFulu(pb *eth.BeaconBlockBodyElectra) (*BeaconBlockBody, error) {
 	if pb == nil {
 		return nil, errNilBlockBody
@@ -1477,3 +1646,36 @@ func initBlindedBlockBodyFromProtoFulu(pb *eth.BlindedBeaconBlockBodyElectra) (*
 	}
 	return b, nil
 }
+
+func initBlockBodyFromProtoGloas(pb *eth.BeaconBlockBodyGloas) (*BeaconBlockBody, error) {
+	if pb == nil {
+		return nil, errNilBlockBody
+	}
+
+	p, err := WrappedExecutionPayloadGloas(pb.ExecutionPayload)
+	// We allow the payload to be nil
+	if err != nil && !errors.Is(err, consensus_types.ErrNilObjectWrapped) {
+		return nil, err
+	}
+	er := pb.ExecutionRequests
+	if er == nil {
+		er = &enginev1.ExecutionRequests{}
+	}
+	b := &BeaconBlockBody{
+		version:                  version.Gloas,
+		randaoReveal:             bytesutil.ToBytes96(pb.RandaoReveal),
+		eth1Data:                 pb.Eth1Data,
+		graffiti:                 bytesutil.ToBytes32(pb.Graffiti),
+		proposerSlashings:        pb.ProposerSlashings,
+		attesterSlashingsElectra: pb.AttesterSlashings,
+		attestationsElectra:      pb.Attestations,
+		deposits:                 pb.Deposits,
+		voluntaryExits:           pb.VoluntaryExits,
+		syncAggregate:            pb.SyncAggregate,
+		executionPayload:         p,
+		blsToExecutionChanges:    pb.BlsToExecutionChanges,
+		blobKzgCommitments:       pb.BlobKzgCommitments,
+		executionRequests:        er,
+	}
+	return b, nil
+}

consensus-types/blocks/testing/factory.go

@@ -36,6 +36,9 @@ func NewSignedBeaconBlockFromGeneric(gb *eth.GenericSignedBeaconBlock) (interfac
 	case *eth.GenericSignedBeaconBlock_Fulu:
 		return blocks.NewSignedBeaconBlock(bb.Fulu.Block)
 		// Generic Signed Beacon Block Deneb can't be used here as it is not a block, but block content with blobs
+	case *eth.GenericSignedBeaconBlock_Gloas:
+		return blocks.NewSignedBeaconBlock(bb.Gloas.Block)
+		// Generic Signed Beacon Block Gloas can't be used here as it is not a block, but block content with blobs
 	default:
 		return nil, errors.Wrapf(blocks.ErrUnsupportedSignedBeaconBlock, "unable to create block from type %T", gb)
 	}

proto/engine/v1/BUILD.bazel

@@ -43,6 +43,8 @@ ssz_gen_marshal(
         "ExecutionPayloadDeneb",
         "ExecutionPayloadDenebAndBlobsBundle",
         "ExecutionPayloadDenebAndBlobsBundleV2",
+        "ExecutionPayloadGloas",
+        "ExecutionPayloadHeaderGloas",
         "BlindedBlobsBundle",
         "BlobsBundle",
         "BlobsBundleV2",
@@ -116,6 +118,7 @@ ssz_proto_files(
         "electra.proto",
         "execution_engine.proto",
         "fulu.proto",
+        "gloas.proto",
     ],
     config = select({
         "//conditions:default": "mainnet",

proto/engine/v1/engine.ssz.go

@@ -1791,6 +1791,864 @@ func (e *ExecutionPayloadDeneb) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	return
 }
 
+// MarshalSSZ ssz marshals the ExecutionPayloadGloas object
+func (e *ExecutionPayloadGloas) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(e)
+}
+
+// MarshalSSZTo ssz marshals the ExecutionPayloadGloas object to a target array
+func (e *ExecutionPayloadGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(532)
+
+	// Field (0) 'ParentHash'
+	if size := len(e.ParentHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ParentHash", size, 32)
+		return
+	}
+	dst = append(dst, e.ParentHash...)
+
+	// Field (1) 'FeeRecipient'
+	if size := len(e.FeeRecipient); size != 20 {
+		err = ssz.ErrBytesLengthFn("--.FeeRecipient", size, 20)
+		return
+	}
+	dst = append(dst, e.FeeRecipient...)
+
+	// Field (2) 'StateRoot'
+	if size := len(e.StateRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.StateRoot", size, 32)
+		return
+	}
+	dst = append(dst, e.StateRoot...)
+
+	// Field (3) 'ReceiptsRoot'
+	if size := len(e.ReceiptsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ReceiptsRoot", size, 32)
+		return
+	}
+	dst = append(dst, e.ReceiptsRoot...)
+
+	// Field (4) 'LogsBloom'
+	if size := len(e.LogsBloom); size != 256 {
+		err = ssz.ErrBytesLengthFn("--.LogsBloom", size, 256)
+		return
+	}
+	dst = append(dst, e.LogsBloom...)
+
+	// Field (5) 'PrevRandao'
+	if size := len(e.PrevRandao); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.PrevRandao", size, 32)
+		return
+	}
+	dst = append(dst, e.PrevRandao...)
+
+	// Field (6) 'BlockNumber'
+	dst = ssz.MarshalUint64(dst, e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	dst = ssz.MarshalUint64(dst, e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	dst = ssz.MarshalUint64(dst, e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	dst = ssz.MarshalUint64(dst, e.Timestamp)
+
+	// Offset (10) 'ExtraData'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.ExtraData)
+
+	// Field (11) 'BaseFeePerGas'
+	if size := len(e.BaseFeePerGas); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BaseFeePerGas", size, 32)
+		return
+	}
+	dst = append(dst, e.BaseFeePerGas...)
+
+	// Field (12) 'BlockHash'
+	if size := len(e.BlockHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockHash", size, 32)
+		return
+	}
+	dst = append(dst, e.BlockHash...)
+
+	// Offset (13) 'Transactions'
+	dst = ssz.WriteOffset(dst, offset)
+	for ii := 0; ii < len(e.Transactions); ii++ {
+		offset += 4
+		offset += len(e.Transactions[ii])
+	}
+
+	// Offset (14) 'Withdrawals'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.Withdrawals) * 44
+
+	// Field (15) 'BlobGasUsed'
+	dst = ssz.MarshalUint64(dst, e.BlobGasUsed)
+
+	// Field (16) 'ExcessBlobGas'
+	dst = ssz.MarshalUint64(dst, e.ExcessBlobGas)
+
+	// Offset (17) 'BlockAccessList'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.BlockAccessList)
+
+	// Field (10) 'ExtraData'
+	if size := len(e.ExtraData); size > 32 {
+		err = ssz.ErrBytesLengthFn("--.ExtraData", size, 32)
+		return
+	}
+	dst = append(dst, e.ExtraData...)
+
+	// Field (13) 'Transactions'
+	if size := len(e.Transactions); size > 1048576 {
+		err = ssz.ErrListTooBigFn("--.Transactions", size, 1048576)
+		return
+	}
+	{
+		offset = 4 * len(e.Transactions)
+		for ii := 0; ii < len(e.Transactions); ii++ {
+			dst = ssz.WriteOffset(dst, offset)
+			offset += len(e.Transactions[ii])
+		}
+	}
+	for ii := 0; ii < len(e.Transactions); ii++ {
+		if size := len(e.Transactions[ii]); size > 1073741824 {
+			err = ssz.ErrBytesLengthFn("--.Transactions[ii]", size, 1073741824)
+			return
+		}
+		dst = append(dst, e.Transactions[ii]...)
+	}
+
+	// Field (14) 'Withdrawals'
+	if size := len(e.Withdrawals); size > 16 {
+		err = ssz.ErrListTooBigFn("--.Withdrawals", size, 16)
+		return
+	}
+	for ii := 0; ii < len(e.Withdrawals); ii++ {
+		if dst, err = e.Withdrawals[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (17) 'BlockAccessList'
+	if size := len(e.BlockAccessList); size > 1073741824 {
+		err = ssz.ErrBytesLengthFn("--.BlockAccessList", size, 1073741824)
+		return
+	}
+	dst = append(dst, e.BlockAccessList...)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the ExecutionPayloadGloas object
+func (e *ExecutionPayloadGloas) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 532 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o10, o13, o14, o17 uint64
+
+	// Field (0) 'ParentHash'
+	if cap(e.ParentHash) == 0 {
+		e.ParentHash = make([]byte, 0, len(buf[0:32]))
+	}
+	e.ParentHash = append(e.ParentHash, buf[0:32]...)
+
+	// Field (1) 'FeeRecipient'
+	if cap(e.FeeRecipient) == 0 {
+		e.FeeRecipient = make([]byte, 0, len(buf[32:52]))
+	}
+	e.FeeRecipient = append(e.FeeRecipient, buf[32:52]...)
+
+	// Field (2) 'StateRoot'
+	if cap(e.StateRoot) == 0 {
+		e.StateRoot = make([]byte, 0, len(buf[52:84]))
+	}
+	e.StateRoot = append(e.StateRoot, buf[52:84]...)
+
+	// Field (3) 'ReceiptsRoot'
+	if cap(e.ReceiptsRoot) == 0 {
+		e.ReceiptsRoot = make([]byte, 0, len(buf[84:116]))
+	}
+	e.ReceiptsRoot = append(e.ReceiptsRoot, buf[84:116]...)
+
+	// Field (4) 'LogsBloom'
+	if cap(e.LogsBloom) == 0 {
+		e.LogsBloom = make([]byte, 0, len(buf[116:372]))
+	}
+	e.LogsBloom = append(e.LogsBloom, buf[116:372]...)
+
+	// Field (5) 'PrevRandao'
+	if cap(e.PrevRandao) == 0 {
+		e.PrevRandao = make([]byte, 0, len(buf[372:404]))
+	}
+	e.PrevRandao = append(e.PrevRandao, buf[372:404]...)
+
+	// Field (6) 'BlockNumber'
+	e.BlockNumber = ssz.UnmarshallUint64(buf[404:412])
+
+	// Field (7) 'GasLimit'
+	e.GasLimit = ssz.UnmarshallUint64(buf[412:420])
+
+	// Field (8) 'GasUsed'
+	e.GasUsed = ssz.UnmarshallUint64(buf[420:428])
+
+	// Field (9) 'Timestamp'
+	e.Timestamp = ssz.UnmarshallUint64(buf[428:436])
+
+	// Offset (10) 'ExtraData'
+	if o10 = ssz.ReadOffset(buf[436:440]); o10 > size {
+		return ssz.ErrOffset
+	}
+
+	if o10 != 532 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	if cap(e.BaseFeePerGas) == 0 {
+		e.BaseFeePerGas = make([]byte, 0, len(buf[440:472]))
+	}
+	e.BaseFeePerGas = append(e.BaseFeePerGas, buf[440:472]...)
+
+	// Field (12) 'BlockHash'
+	if cap(e.BlockHash) == 0 {
+		e.BlockHash = make([]byte, 0, len(buf[472:504]))
+	}
+	e.BlockHash = append(e.BlockHash, buf[472:504]...)
+
+	// Offset (13) 'Transactions'
+	if o13 = ssz.ReadOffset(buf[504:508]); o13 > size || o10 > o13 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (14) 'Withdrawals'
+	if o14 = ssz.ReadOffset(buf[508:512]); o14 > size || o13 > o14 {
+		return ssz.ErrOffset
+	}
+
+	// Field (15) 'BlobGasUsed'
+	e.BlobGasUsed = ssz.UnmarshallUint64(buf[512:520])
+
+	// Field (16) 'ExcessBlobGas'
+	e.ExcessBlobGas = ssz.UnmarshallUint64(buf[520:528])
+
+	// Offset (17) 'BlockAccessList'
+	if o17 = ssz.ReadOffset(buf[528:532]); o17 > size || o14 > o17 {
+		return ssz.ErrOffset
+	}
+
+	// Field (10) 'ExtraData'
+	{
+		buf = tail[o10:o13]
+		if len(buf) > 32 {
+			return ssz.ErrBytesLength
+		}
+		if cap(e.ExtraData) == 0 {
+			e.ExtraData = make([]byte, 0, len(buf))
+		}
+		e.ExtraData = append(e.ExtraData, buf...)
+	}
+
+	// Field (13) 'Transactions'
+	{
+		buf = tail[o13:o14]
+		num, err := ssz.DecodeDynamicLength(buf, 1048576)
+		if err != nil {
+			return err
+		}
+		e.Transactions = make([][]byte, num)
+		err = ssz.UnmarshalDynamic(buf, num, func(indx int, buf []byte) (err error) {
+			if len(buf) > 1073741824 {
+				return ssz.ErrBytesLength
+			}
+			if cap(e.Transactions[indx]) == 0 {
+				e.Transactions[indx] = make([]byte, 0, len(buf))
+			}
+			e.Transactions[indx] = append(e.Transactions[indx], buf...)
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	// Field (14) 'Withdrawals'
+	{
+		buf = tail[o14:o17]
+		num, err := ssz.DivideInt2(len(buf), 44, 16)
+		if err != nil {
+			return err
+		}
+		e.Withdrawals = make([]*Withdrawal, num)
+		for ii := 0; ii < num; ii++ {
+			if e.Withdrawals[ii] == nil {
+				e.Withdrawals[ii] = new(Withdrawal)
+			}
+			if err = e.Withdrawals[ii].UnmarshalSSZ(buf[ii*44 : (ii+1)*44]); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Field (17) 'BlockAccessList'
+	{
+		buf = tail[o17:]
+		if len(buf) > 1073741824 {
+			return ssz.ErrBytesLength
+		}
+		if cap(e.BlockAccessList) == 0 {
+			e.BlockAccessList = make([]byte, 0, len(buf))
+		}
+		e.BlockAccessList = append(e.BlockAccessList, buf...)
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the ExecutionPayloadGloas object
+func (e *ExecutionPayloadGloas) SizeSSZ() (size int) {
+	size = 532
+
+	// Field (10) 'ExtraData'
+	size += len(e.ExtraData)
+
+	// Field (13) 'Transactions'
+	for ii := 0; ii < len(e.Transactions); ii++ {
+		size += 4
+		size += len(e.Transactions[ii])
+	}
+
+	// Field (14) 'Withdrawals'
+	size += len(e.Withdrawals) * 44
+
+	// Field (17) 'BlockAccessList'
+	size += len(e.BlockAccessList)
+
+	return
+}
+
+// HashTreeRoot ssz hashes the ExecutionPayloadGloas object
+func (e *ExecutionPayloadGloas) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(e)
+}
+
+// HashTreeRootWith ssz hashes the ExecutionPayloadGloas object with a hasher
+func (e *ExecutionPayloadGloas) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'ParentHash'
+	if size := len(e.ParentHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ParentHash", size, 32)
+		return
+	}
+	hh.PutBytes(e.ParentHash)
+
+	// Field (1) 'FeeRecipient'
+	if size := len(e.FeeRecipient); size != 20 {
+		err = ssz.ErrBytesLengthFn("--.FeeRecipient", size, 20)
+		return
+	}
+	hh.PutBytes(e.FeeRecipient)
+
+	// Field (2) 'StateRoot'
+	if size := len(e.StateRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.StateRoot", size, 32)
+		return
+	}
+	hh.PutBytes(e.StateRoot)
+
+	// Field (3) 'ReceiptsRoot'
+	if size := len(e.ReceiptsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ReceiptsRoot", size, 32)
+		return
+	}
+	hh.PutBytes(e.ReceiptsRoot)
+
+	// Field (4) 'LogsBloom'
+	if size := len(e.LogsBloom); size != 256 {
+		err = ssz.ErrBytesLengthFn("--.LogsBloom", size, 256)
+		return
+	}
+	hh.PutBytes(e.LogsBloom)
+
+	// Field (5) 'PrevRandao'
+	if size := len(e.PrevRandao); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.PrevRandao", size, 32)
+		return
+	}
+	hh.PutBytes(e.PrevRandao)
+
+	// Field (6) 'BlockNumber'
+	hh.PutUint64(e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	hh.PutUint64(e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	hh.PutUint64(e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	hh.PutUint64(e.Timestamp)
+
+	// Field (10) 'ExtraData'
+	{
+		elemIndx := hh.Index()
+		byteLen := uint64(len(e.ExtraData))
+		if byteLen > 32 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		hh.PutBytes(e.ExtraData)
+		hh.MerkleizeWithMixin(elemIndx, byteLen, (32+31)/32)
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	if size := len(e.BaseFeePerGas); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BaseFeePerGas", size, 32)
+		return
+	}
+	hh.PutBytes(e.BaseFeePerGas)
+
+	// Field (12) 'BlockHash'
+	if size := len(e.BlockHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockHash", size, 32)
+		return
+	}
+	hh.PutBytes(e.BlockHash)
+
+	// Field (13) 'Transactions'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(e.Transactions))
+		if num > 1048576 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range e.Transactions {
+			{
+				elemIndx := hh.Index()
+				byteLen := uint64(len(elem))
+				if byteLen > 1073741824 {
+					err = ssz.ErrIncorrectListSize
+					return
+				}
+				hh.AppendBytes32(elem)
+				hh.MerkleizeWithMixin(elemIndx, byteLen, (1073741824+31)/32)
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 1048576)
+	}
+
+	// Field (14) 'Withdrawals'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(e.Withdrawals))
+		if num > 16 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range e.Withdrawals {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 16)
+	}
+
+	// Field (15) 'BlobGasUsed'
+	hh.PutUint64(e.BlobGasUsed)
+
+	// Field (16) 'ExcessBlobGas'
+	hh.PutUint64(e.ExcessBlobGas)
+
+	// Field (17) 'BlockAccessList'
+	{
+		elemIndx := hh.Index()
+		byteLen := uint64(len(e.BlockAccessList))
+		if byteLen > 1073741824 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		hh.PutBytes(e.BlockAccessList)
+		hh.MerkleizeWithMixin(elemIndx, byteLen, (1073741824+31)/32)
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
+// MarshalSSZ ssz marshals the ExecutionPayloadHeaderGloas object
+func (e *ExecutionPayloadHeaderGloas) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(e)
+}
+
+// MarshalSSZTo ssz marshals the ExecutionPayloadHeaderGloas object to a target array
+func (e *ExecutionPayloadHeaderGloas) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(616)
+
+	// Field (0) 'ParentHash'
+	if size := len(e.ParentHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ParentHash", size, 32)
+		return
+	}
+	dst = append(dst, e.ParentHash...)
+
+	// Field (1) 'FeeRecipient'
+	if size := len(e.FeeRecipient); size != 20 {
+		err = ssz.ErrBytesLengthFn("--.FeeRecipient", size, 20)
+		return
+	}
+	dst = append(dst, e.FeeRecipient...)
+
+	// Field (2) 'StateRoot'
+	if size := len(e.StateRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.StateRoot", size, 32)
+		return
+	}
+	dst = append(dst, e.StateRoot...)
+
+	// Field (3) 'ReceiptsRoot'
+	if size := len(e.ReceiptsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ReceiptsRoot", size, 32)
+		return
+	}
+	dst = append(dst, e.ReceiptsRoot...)
+
+	// Field (4) 'LogsBloom'
+	if size := len(e.LogsBloom); size != 256 {
+		err = ssz.ErrBytesLengthFn("--.LogsBloom", size, 256)
+		return
+	}
+	dst = append(dst, e.LogsBloom...)
+
+	// Field (5) 'PrevRandao'
+	if size := len(e.PrevRandao); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.PrevRandao", size, 32)
+		return
+	}
+	dst = append(dst, e.PrevRandao...)
+
+	// Field (6) 'BlockNumber'
+	dst = ssz.MarshalUint64(dst, e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	dst = ssz.MarshalUint64(dst, e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	dst = ssz.MarshalUint64(dst, e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	dst = ssz.MarshalUint64(dst, e.Timestamp)
+
+	// Offset (10) 'ExtraData'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.ExtraData)
+
+	// Field (11) 'BaseFeePerGas'
+	if size := len(e.BaseFeePerGas); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BaseFeePerGas", size, 32)
+		return
+	}
+	dst = append(dst, e.BaseFeePerGas...)
+
+	// Field (12) 'BlockHash'
+	if size := len(e.BlockHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockHash", size, 32)
+		return
+	}
+	dst = append(dst, e.BlockHash...)
+
+	// Field (13) 'TransactionsRoot'
+	if size := len(e.TransactionsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.TransactionsRoot", size, 32)
+		return
+	}
+	dst = append(dst, e.TransactionsRoot...)
+
+	// Field (14) 'WithdrawalsRoot'
+	if size := len(e.WithdrawalsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.WithdrawalsRoot", size, 32)
+		return
+	}
+	dst = append(dst, e.WithdrawalsRoot...)
+
+	// Field (15) 'BlobGasUsed'
+	dst = ssz.MarshalUint64(dst, e.BlobGasUsed)
+
+	// Field (16) 'ExcessBlobGas'
+	dst = ssz.MarshalUint64(dst, e.ExcessBlobGas)
+
+	// Field (17) 'BlockAccessListRoot'
+	if size := len(e.BlockAccessListRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockAccessListRoot", size, 32)
+		return
+	}
+	dst = append(dst, e.BlockAccessListRoot...)
+
+	// Field (10) 'ExtraData'
+	if size := len(e.ExtraData); size > 32 {
+		err = ssz.ErrBytesLengthFn("--.ExtraData", size, 32)
+		return
+	}
+	dst = append(dst, e.ExtraData...)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the ExecutionPayloadHeaderGloas object
+func (e *ExecutionPayloadHeaderGloas) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 616 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o10 uint64
+
+	// Field (0) 'ParentHash'
+	if cap(e.ParentHash) == 0 {
+		e.ParentHash = make([]byte, 0, len(buf[0:32]))
+	}
+	e.ParentHash = append(e.ParentHash, buf[0:32]...)
+
+	// Field (1) 'FeeRecipient'
+	if cap(e.FeeRecipient) == 0 {
+		e.FeeRecipient = make([]byte, 0, len(buf[32:52]))
+	}
+	e.FeeRecipient = append(e.FeeRecipient, buf[32:52]...)
+
+	// Field (2) 'StateRoot'
+	if cap(e.StateRoot) == 0 {
+		e.StateRoot = make([]byte, 0, len(buf[52:84]))
+	}
+	e.StateRoot = append(e.StateRoot, buf[52:84]...)
+
+	// Field (3) 'ReceiptsRoot'
+	if cap(e.ReceiptsRoot) == 0 {
+		e.ReceiptsRoot = make([]byte, 0, len(buf[84:116]))
+	}
+	e.ReceiptsRoot = append(e.ReceiptsRoot, buf[84:116]...)
+
+	// Field (4) 'LogsBloom'
+	if cap(e.LogsBloom) == 0 {
+		e.LogsBloom = make([]byte, 0, len(buf[116:372]))
+	}
+	e.LogsBloom = append(e.LogsBloom, buf[116:372]...)
+
+	// Field (5) 'PrevRandao'
+	if cap(e.PrevRandao) == 0 {
+		e.PrevRandao = make([]byte, 0, len(buf[372:404]))
+	}
+	e.PrevRandao = append(e.PrevRandao, buf[372:404]...)
+
+	// Field (6) 'BlockNumber'
+	e.BlockNumber = ssz.UnmarshallUint64(buf[404:412])
+
+	// Field (7) 'GasLimit'
+	e.GasLimit = ssz.UnmarshallUint64(buf[412:420])
+
+	// Field (8) 'GasUsed'
+	e.GasUsed = ssz.UnmarshallUint64(buf[420:428])
+
+	// Field (9) 'Timestamp'
+	e.Timestamp = ssz.UnmarshallUint64(buf[428:436])
+
+	// Offset (10) 'ExtraData'
+	if o10 = ssz.ReadOffset(buf[436:440]); o10 > size {
+		return ssz.ErrOffset
+	}
+
+	if o10 != 616 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	if cap(e.BaseFeePerGas) == 0 {
+		e.BaseFeePerGas = make([]byte, 0, len(buf[440:472]))
+	}
+	e.BaseFeePerGas = append(e.BaseFeePerGas, buf[440:472]...)
+
+	// Field (12) 'BlockHash'
+	if cap(e.BlockHash) == 0 {
+		e.BlockHash = make([]byte, 0, len(buf[472:504]))
+	}
+	e.BlockHash = append(e.BlockHash, buf[472:504]...)
+
+	// Field (13) 'TransactionsRoot'
+	if cap(e.TransactionsRoot) == 0 {
+		e.TransactionsRoot = make([]byte, 0, len(buf[504:536]))
+	}
+	e.TransactionsRoot = append(e.TransactionsRoot, buf[504:536]...)
+
+	// Field (14) 'WithdrawalsRoot'
+	if cap(e.WithdrawalsRoot) == 0 {
+		e.WithdrawalsRoot = make([]byte, 0, len(buf[536:568]))
+	}
+	e.WithdrawalsRoot = append(e.WithdrawalsRoot, buf[536:568]...)
+
+	// Field (15) 'BlobGasUsed'
+	e.BlobGasUsed = ssz.UnmarshallUint64(buf[568:576])
+
+	// Field (16) 'ExcessBlobGas'
+	e.ExcessBlobGas = ssz.UnmarshallUint64(buf[576:584])
+
+	// Field (17) 'BlockAccessListRoot'
+	if cap(e.BlockAccessListRoot) == 0 {
+		e.BlockAccessListRoot = make([]byte, 0, len(buf[584:616]))
+	}
+	e.BlockAccessListRoot = append(e.BlockAccessListRoot, buf[584:616]...)
+
+	// Field (10) 'ExtraData'
+	{
+		buf = tail[o10:]
+		if len(buf) > 32 {
+			return ssz.ErrBytesLength
+		}
+		if cap(e.ExtraData) == 0 {
+			e.ExtraData = make([]byte, 0, len(buf))
+		}
+		e.ExtraData = append(e.ExtraData, buf...)
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the ExecutionPayloadHeaderGloas object
+func (e *ExecutionPayloadHeaderGloas) SizeSSZ() (size int) {
+	size = 616
+
+	// Field (10) 'ExtraData'
+	size += len(e.ExtraData)
+
+	return
+}
+
+// HashTreeRoot ssz hashes the ExecutionPayloadHeaderGloas object
+func (e *ExecutionPayloadHeaderGloas) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(e)
+}
+
+// HashTreeRootWith ssz hashes the ExecutionPayloadHeaderGloas object with a hasher
+func (e *ExecutionPayloadHeaderGloas) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'ParentHash'
+	if size := len(e.ParentHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ParentHash", size, 32)
+		return
+	}
+	hh.PutBytes(e.ParentHash)
+
+	// Field (1) 'FeeRecipient'
+	if size := len(e.FeeRecipient); size != 20 {
+		err = ssz.ErrBytesLengthFn("--.FeeRecipient", size, 20)
+		return
+	}
+	hh.PutBytes(e.FeeRecipient)
+
+	// Field (2) 'StateRoot'
+	if size := len(e.StateRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.StateRoot", size, 32)
+		return
+	}
+	hh.PutBytes(e.StateRoot)
+
+	// Field (3) 'ReceiptsRoot'
+	if size := len(e.ReceiptsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.ReceiptsRoot", size, 32)
+		return
+	}
+	hh.PutBytes(e.ReceiptsRoot)
+
+	// Field (4) 'LogsBloom'
+	if size := len(e.LogsBloom); size != 256 {
+		err = ssz.ErrBytesLengthFn("--.LogsBloom", size, 256)
+		return
+	}
+	hh.PutBytes(e.LogsBloom)
+
+	// Field (5) 'PrevRandao'
+	if size := len(e.PrevRandao); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.PrevRandao", size, 32)
+		return
+	}
+	hh.PutBytes(e.PrevRandao)
+
+	// Field (6) 'BlockNumber'
+	hh.PutUint64(e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	hh.PutUint64(e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	hh.PutUint64(e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	hh.PutUint64(e.Timestamp)
+
+	// Field (10) 'ExtraData'
+	{
+		elemIndx := hh.Index()
+		byteLen := uint64(len(e.ExtraData))
+		if byteLen > 32 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		hh.PutBytes(e.ExtraData)
+		hh.MerkleizeWithMixin(elemIndx, byteLen, (32+31)/32)
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	if size := len(e.BaseFeePerGas); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BaseFeePerGas", size, 32)
+		return
+	}
+	hh.PutBytes(e.BaseFeePerGas)
+
+	// Field (12) 'BlockHash'
+	if size := len(e.BlockHash); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockHash", size, 32)
+		return
+	}
+	hh.PutBytes(e.BlockHash)
+
+	// Field (13) 'TransactionsRoot'
+	if size := len(e.TransactionsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.TransactionsRoot", size, 32)
+		return
+	}
+	hh.PutBytes(e.TransactionsRoot)
+
+	// Field (14) 'WithdrawalsRoot'
+	if size := len(e.WithdrawalsRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.WithdrawalsRoot", size, 32)
+		return
+	}
+	hh.PutBytes(e.WithdrawalsRoot)
+
+	// Field (15) 'BlobGasUsed'
+	hh.PutUint64(e.BlobGasUsed)
+
+	// Field (16) 'ExcessBlobGas'
+	hh.PutUint64(e.ExcessBlobGas)
+
+	// Field (17) 'BlockAccessListRoot'
+	if size := len(e.BlockAccessListRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockAccessListRoot", size, 32)
+		return
+	}
+	hh.PutBytes(e.BlockAccessListRoot)
+
+	hh.Merkleize(indx)
+	return
+}
+
 // MarshalSSZ ssz marshals the ExecutionPayloadDenebAndBlobsBundle object
 func (e *ExecutionPayloadDenebAndBlobsBundle) MarshalSSZ() ([]byte, error) {
 	return ssz.MarshalSSZ(e)

proto/engine/v1/execution_engine.go

@@ -1,6 +1,8 @@
 package enginev1
 
-import "github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+import (
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+)
 
 type copier[T any] interface {
 	Copy() T
@@ -214,3 +216,57 @@ func (payload *ExecutionPayloadHeader) Copy() *ExecutionPayloadHeader {
 		TransactionsRoot: bytesutil.SafeCopyBytes(payload.TransactionsRoot),
 	}
 }
+
+// Copy -- Gloas
+func (payload *ExecutionPayloadGloas) Copy() *ExecutionPayloadGloas {
+	if payload == nil {
+		return nil
+	}
+	return &ExecutionPayloadGloas{
+		ParentHash:      bytesutil.SafeCopyBytes(payload.ParentHash),
+		FeeRecipient:    bytesutil.SafeCopyBytes(payload.FeeRecipient),
+		StateRoot:       bytesutil.SafeCopyBytes(payload.StateRoot),
+		ReceiptsRoot:    bytesutil.SafeCopyBytes(payload.ReceiptsRoot),
+		LogsBloom:       bytesutil.SafeCopyBytes(payload.LogsBloom),
+		PrevRandao:      bytesutil.SafeCopyBytes(payload.PrevRandao),
+		BlockNumber:     payload.BlockNumber,
+		GasLimit:        payload.GasLimit,
+		GasUsed:         payload.GasUsed,
+		Timestamp:       payload.Timestamp,
+		ExtraData:       bytesutil.SafeCopyBytes(payload.ExtraData),
+		BaseFeePerGas:   bytesutil.SafeCopyBytes(payload.BaseFeePerGas),
+		BlockHash:       bytesutil.SafeCopyBytes(payload.BlockHash),
+		Transactions:    bytesutil.SafeCopy2dBytes(payload.Transactions),
+		Withdrawals:     copySlice(payload.Withdrawals),
+		BlobGasUsed:     payload.BlobGasUsed,
+		ExcessBlobGas:   payload.ExcessBlobGas,
+		BlockAccessList: bytesutil.SafeCopyBytes(payload.BlockAccessList),
+	}
+}
+
+// Copy -- Gloas
+func (payload *ExecutionPayloadHeaderGloas) Copy() *ExecutionPayloadHeaderGloas {
+	if payload == nil {
+		return nil
+	}
+	return &ExecutionPayloadHeaderGloas{
+		ParentHash:          bytesutil.SafeCopyBytes(payload.ParentHash),
+		FeeRecipient:        bytesutil.SafeCopyBytes(payload.FeeRecipient),
+		StateRoot:           bytesutil.SafeCopyBytes(payload.StateRoot),
+		ReceiptsRoot:        bytesutil.SafeCopyBytes(payload.ReceiptsRoot),
+		LogsBloom:           bytesutil.SafeCopyBytes(payload.LogsBloom),
+		PrevRandao:          bytesutil.SafeCopyBytes(payload.PrevRandao),
+		BlockNumber:         payload.BlockNumber,
+		GasLimit:            payload.GasLimit,
+		GasUsed:             payload.GasUsed,
+		Timestamp:           payload.Timestamp,
+		ExtraData:           bytesutil.SafeCopyBytes(payload.ExtraData),
+		BaseFeePerGas:       bytesutil.SafeCopyBytes(payload.BaseFeePerGas),
+		BlockHash:           bytesutil.SafeCopyBytes(payload.BlockHash),
+		TransactionsRoot:    bytesutil.SafeCopyBytes(payload.TransactionsRoot),
+		WithdrawalsRoot:     bytesutil.SafeCopyBytes(payload.WithdrawalsRoot),
+		BlobGasUsed:         payload.BlobGasUsed,
+		ExcessBlobGas:       payload.ExcessBlobGas,
+		BlockAccessListRoot: bytesutil.SafeCopyBytes(payload.BlockAccessListRoot),
+	}
+}

proto/engine/v1/execution_engine.proto

@@ -92,6 +92,53 @@ message ExecutionPayloadDeneb {
   uint64 excess_blob_gas = 17;
 }
 
+message ExecutionPayloadGloas {
+  bytes parent_hash = 1 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes fee_recipient = 2 [ (ethereum.eth.ext.ssz_size) = "20" ];
+  bytes state_root = 3 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes receipts_root = 4 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes logs_bloom = 5 [ (ethereum.eth.ext.ssz_size) = "logs_bloom.size" ];
+  bytes prev_randao = 6 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  uint64 block_number = 7;
+  uint64 gas_limit = 8;
+  uint64 gas_used = 9;
+  uint64 timestamp = 10;
+  bytes extra_data = 11 [ (ethereum.eth.ext.ssz_max) = "extra_data.size" ];
+  bytes base_fee_per_gas = 12 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes block_hash = 13 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  repeated bytes transactions = 14 [
+    (ethereum.eth.ext.ssz_size) = "?,?",
+    (ethereum.eth.ext.ssz_max) = "1048576,1073741824"
+  ];
+  // MAX_WITHDRAWALS_PER_PAYLOAD
+  repeated Withdrawal withdrawals = 15
+  [ (ethereum.eth.ext.ssz_max) = "withdrawal.size" ];
+  uint64 blob_gas_used = 16;
+  uint64 excess_blob_gas = 17;
+  bytes block_access_list = 18 [ (ethereum.eth.ext.ssz_max) = "1073741824" ];
+}
+
+message ExecutionPayloadHeaderGloas {
+  bytes parent_hash = 1 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes fee_recipient = 2 [ (ethereum.eth.ext.ssz_size) = "20" ];
+  bytes state_root = 3 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes receipts_root = 4 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes logs_bloom = 5 [ (ethereum.eth.ext.ssz_size) = "logs_bloom.size" ];
+  bytes prev_randao = 6 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  uint64 block_number = 7;
+  uint64 gas_limit = 8;
+  uint64 gas_used = 9;
+  uint64 timestamp = 10;
+  bytes extra_data = 11 [ (ethereum.eth.ext.ssz_max) = "extra_data.size" ];
+  bytes base_fee_per_gas = 12 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes block_hash = 13 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes transactions_root = 14 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  bytes withdrawals_root = 15 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  uint64 blob_gas_used = 16;
+  uint64 excess_blob_gas = 17;
+  bytes block_access_list_root = 18 [ (ethereum.eth.ext.ssz_size) = "32" ];
+}
+
 message ExecutionPayloadCapellaWithValue {
   ExecutionPayloadCapella payload = 1;
   bytes value = 2;

proto/engine/v1/gloas.pb.go

@@ -0,0 +1,208 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.33.0
+// 	protoc        v3.21.7
+// source: proto/engine/v1/gloas.proto
+
+package enginev1
+
+import (
+	reflect "reflect"
+	sync "sync"
+
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type ExecutionBundleGloas struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Payload               *ExecutionPayloadGloas `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
+	Value                 []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	BlobsBundle           *BlobsBundleV2         `protobuf:"bytes,3,opt,name=blobs_bundle,json=blobsBundle,proto3" json:"blobs_bundle,omitempty"`
+	ShouldOverrideBuilder bool                   `protobuf:"varint,4,opt,name=should_override_builder,json=shouldOverrideBuilder,proto3" json:"should_override_builder,omitempty"`
+	ExecutionRequests     [][]byte               `protobuf:"bytes,5,rep,name=execution_requests,json=executionRequests,proto3" json:"execution_requests,omitempty"`
+}
+
+func (x *ExecutionBundleGloas) Reset() {
+	*x = ExecutionBundleGloas{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_engine_v1_gloas_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExecutionBundleGloas) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExecutionBundleGloas) ProtoMessage() {}
+
+func (x *ExecutionBundleGloas) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_engine_v1_gloas_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExecutionBundleGloas.ProtoReflect.Descriptor instead.
+func (*ExecutionBundleGloas) Descriptor() ([]byte, []int) {
+	return file_proto_engine_v1_gloas_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ExecutionBundleGloas) GetPayload() *ExecutionPayloadGloas {
+	if x != nil {
+		return x.Payload
+	}
+	return nil
+}
+
+func (x *ExecutionBundleGloas) GetValue() []byte {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *ExecutionBundleGloas) GetBlobsBundle() *BlobsBundleV2 {
+	if x != nil {
+		return x.BlobsBundle
+	}
+	return nil
+}
+
+func (x *ExecutionBundleGloas) GetShouldOverrideBuilder() bool {
+	if x != nil {
+		return x.ShouldOverrideBuilder
+	}
+	return false
+}
+
+func (x *ExecutionBundleGloas) GetExecutionRequests() [][]byte {
+	if x != nil {
+		return x.ExecutionRequests
+	}
+	return nil
+}
+
+var File_proto_engine_v1_gloas_proto protoreflect.FileDescriptor
+
+var file_proto_engine_v1_gloas_proto_rawDesc = []byte{
+	0x0a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76,
+	0x31, 0x2f, 0x67, 0x6c, 0x6f, 0x61, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x65,
+	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76,
+	0x31, 0x1a, 0x26, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f,
+	0x76, 0x31, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x67,
+	0x69, 0x6e, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x9e, 0x02, 0x0a, 0x14, 0x45, 0x78,
+	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x47, 0x6c, 0x6f,
+	0x61, 0x73, 0x12, 0x43, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
+	0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x47, 0x6c, 0x6f, 0x61, 0x73, 0x52, 0x07,
+	0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x44, 0x0a,
+	0x0c, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x5f, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
+	0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75,
+	0x6e, 0x64, 0x6c, 0x65, 0x56, 0x32, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75, 0x6e,
+	0x64, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x5f, 0x6f, 0x76,
+	0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65, 0x72,
+	0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x12, 0x2d, 0x0a, 0x12, 0x65,
+	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x42, 0x8c, 0x01, 0x0a, 0x16, 0x6f,
+	0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69,
+	0x6e, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x47, 0x6c, 0x6f, 0x61, 0x73, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
+	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
+	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67,
+	0x69, 0x6e, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x76, 0x31, 0xaa,
+	0x02, 0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x6e, 0x67, 0x69, 0x6e,
+	0x65, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x12, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c,
+	0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5c, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
+}
+
+var (
+	file_proto_engine_v1_gloas_proto_rawDescOnce sync.Once
+	file_proto_engine_v1_gloas_proto_rawDescData = file_proto_engine_v1_gloas_proto_rawDesc
+)
+
+func file_proto_engine_v1_gloas_proto_rawDescGZIP() []byte {
+	file_proto_engine_v1_gloas_proto_rawDescOnce.Do(func() {
+		file_proto_engine_v1_gloas_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_engine_v1_gloas_proto_rawDescData)
+	})
+	return file_proto_engine_v1_gloas_proto_rawDescData
+}
+
+var file_proto_engine_v1_gloas_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_proto_engine_v1_gloas_proto_goTypes = []interface{}{
+	(*ExecutionBundleGloas)(nil),  // 0: ethereum.engine.v1.ExecutionBundleGloas
+	(*ExecutionPayloadGloas)(nil), // 1: ethereum.engine.v1.ExecutionPayloadGloas
+	(*BlobsBundleV2)(nil),         // 2: ethereum.engine.v1.BlobsBundleV2
+}
+var file_proto_engine_v1_gloas_proto_depIdxs = []int32{
+	1, // 0: ethereum.engine.v1.ExecutionBundleGloas.payload:type_name -> ethereum.engine.v1.ExecutionPayloadGloas
+	2, // 1: ethereum.engine.v1.ExecutionBundleGloas.blobs_bundle:type_name -> ethereum.engine.v1.BlobsBundleV2
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	2, // [2:2] is the sub-list for extension extendee
+	0, // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_proto_engine_v1_gloas_proto_init() }
+func file_proto_engine_v1_gloas_proto_init() {
+	if File_proto_engine_v1_gloas_proto != nil {
+		return
+	}
+	file_proto_engine_v1_execution_engine_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_proto_engine_v1_gloas_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExecutionBundleGloas); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_proto_engine_v1_gloas_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_proto_engine_v1_gloas_proto_goTypes,
+		DependencyIndexes: file_proto_engine_v1_gloas_proto_depIdxs,
+		MessageInfos:      file_proto_engine_v1_gloas_proto_msgTypes,
+	}.Build()
+	File_proto_engine_v1_gloas_proto = out.File
+	file_proto_engine_v1_gloas_proto_rawDesc = nil
+	file_proto_engine_v1_gloas_proto_goTypes = nil
+	file_proto_engine_v1_gloas_proto_depIdxs = nil
+}

proto/engine/v1/gloas.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package ethereum.engine.v1;
+
+import "proto/engine/v1/execution_engine.proto";
+
+option csharp_namespace = "Ethereum.Engine.V1";
+option go_package = "github.com/prysmaticlabs/prysm/v5/proto/engine/v1;enginev1";
+option java_multiple_files = true;
+option java_outer_classname = "GloasProto";
+option java_package = "org.ethereum.engine.v1";
+option php_namespace = "Ethereum\\Engine\\v1";
+
+message ExecutionBundleGloas {
+  ExecutionPayloadGloas payload = 1;
+  bytes value = 2;
+  BlobsBundleV2 blobs_bundle = 3;
+  bool should_override_builder = 4;
+  repeated bytes execution_requests = 5;
+}

proto/prysm/v1alpha1/BUILD.bazel

@@ -194,6 +194,15 @@ ssz_fulu_objs = [
     "SignedBlindedBeaconBlockFulu",
 ]
 
+ssz_gloas_objs = [
+    "BeaconBlockBodyGloas",
+    "BeaconBlockContentsGloas",
+    "BeaconBlockGloas",
+    "BeaconStateGloas",
+    "SignedBeaconBlockContentsGloas",
+    "SignedBeaconBlockGloas",
+]
+
 ssz_gen_marshal(
     name = "ssz_generated_phase0",
     out = "phase0.ssz.go",
@@ -284,6 +293,19 @@ ssz_gen_marshal(
     objs = ssz_fulu_objs,
 )
 
+ssz_gen_marshal(
+    name = "ssz_generated_gloas",
+    out = "gloas.ssz.go",
+    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs + ssz_capella_objs + ssz_deneb_objs + ssz_electra_objs + ssz_fulu_objs,
+    go_proto = ":go_proto",
+    includes = [
+        "//consensus-types/primitives:go_default_library",
+        "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
+    ],
+    objs = ssz_gloas_objs,
+)
+
 ssz_gen_marshal(
     name = "ssz_generated_non_core",
     out = "non-core.ssz.go",
@@ -352,6 +374,7 @@ go_library(
         ":ssz_generated_deneb",  # keep
         ":ssz_generated_electra",  # keep
         ":ssz_generated_fulu",  # keep
+        ":ssz_generated_gloas",  # keep
         ":ssz_generated_non_core",  # keep
         ":ssz_generated_phase0",  # keep
     ],

proto/prysm/v1alpha1/beacon_block.go

@@ -695,3 +695,54 @@ func (sigBlock *SignedBeaconBlockFulu) Copy() *SignedBeaconBlockFulu {
 		Signature: bytesutil.SafeCopyBytes(sigBlock.Signature),
 	}
 }
+
+// ----------------------------------------------------------------------------
+// Gloas
+// ----------------------------------------------------------------------------
+
+// Copy --
+func (sigBlock *SignedBeaconBlockGloas) Copy() *SignedBeaconBlockGloas {
+	if sigBlock == nil {
+		return nil
+	}
+	return &SignedBeaconBlockGloas{
+		Block:     sigBlock.Block.Copy(),
+		Signature: bytesutil.SafeCopyBytes(sigBlock.Signature),
+	}
+}
+
+// Copy --
+func (block *BeaconBlockGloas) Copy() *BeaconBlockGloas {
+	if block == nil {
+		return nil
+	}
+	return &BeaconBlockGloas{
+		Slot:          block.Slot,
+		ProposerIndex: block.ProposerIndex,
+		ParentRoot:    bytesutil.SafeCopyBytes(block.ParentRoot),
+		StateRoot:     bytesutil.SafeCopyBytes(block.StateRoot),
+		Body:          block.Body.Copy(),
+	}
+}
+
+// Copy --
+func (body *BeaconBlockBodyGloas) Copy() *BeaconBlockBodyGloas {
+	if body == nil {
+		return nil
+	}
+	return &BeaconBlockBodyGloas{
+		RandaoReveal:          bytesutil.SafeCopyBytes(body.RandaoReveal),
+		Eth1Data:              body.Eth1Data.Copy(),
+		Graffiti:              bytesutil.SafeCopyBytes(body.Graffiti),
+		ProposerSlashings:     CopySlice(body.ProposerSlashings),
+		AttesterSlashings:     CopySlice(body.AttesterSlashings),
+		Attestations:          CopySlice(body.Attestations),
+		Deposits:              CopySlice(body.Deposits),
+		VoluntaryExits:        CopySlice(body.VoluntaryExits),
+		SyncAggregate:         body.SyncAggregate.Copy(),
+		ExecutionPayload:      body.ExecutionPayload.Copy(),
+		BlsToExecutionChanges: CopySlice(body.BlsToExecutionChanges),
+		BlobKzgCommitments:    CopyBlobKZGs(body.BlobKzgCommitments),
+		ExecutionRequests:     CopyExecutionRequests(body.ExecutionRequests),
+	}
+}

proto/prysm/v1alpha1/beacon_block.proto

@@ -71,6 +71,8 @@ message GenericSignedBeaconBlock {
 
     // Representing a signed, post-Fulu fork blinded beacon block.
     SignedBlindedBeaconBlockFulu blinded_fulu = 12;
+    // Representing a signed, post-Gloas fork beacon block content.
+    SignedBeaconBlockContentsGloas gloas = 13;
   }
   bool is_blinded = 100;
   reserved 101; // Deprecated fields
@@ -115,6 +117,8 @@ message GenericBeaconBlock {
 
     // Representing a post-Fulu fork blinded beacon block.
     BlindedBeaconBlockFulu blinded_fulu = 12;
+    // Representing a post-Gloas fork beacon block content.
+    BeaconBlockContentsGloas gloas = 13;
   }
   bool is_blinded = 100;
   string payload_value = 101;
@@ -1245,3 +1249,95 @@ message BlindedBeaconBlockFulu {
   // The blinded beacon block body.
   BlindedBeaconBlockBodyElectra body = 5;
 }
+
+// Gloas structures
+message BeaconBlockBodyGloas {
+  // The validators RANDAO reveal 96 byte value.
+  bytes randao_reveal = 1 [ (ethereum.eth.ext.ssz_size) = "96" ];
+  // A reference to the Ethereum 1.x chain.
+  Eth1Data eth1_data = 2;
+  // 32 byte field of arbitrary data. This field may contain any data and
+  // is not used for anything other than a fun message.
+  bytes graffiti = 3 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  // Block operations
+  // Refer to spec constants at
+  // https://github.com/ethereum/consensus-specs/blob/master/specs/core/0_beacon-chain.md#max-operations-per-block
+  // At most MAX_PROPOSER_SLASHINGS.
+  repeated ProposerSlashing proposer_slashings = 4
+      [ (ethereum.eth.ext.ssz_max) = "16" ];
+  // At most MAX_ATTESTER_SLASHINGS_ELECTRA.
+  repeated AttesterSlashingElectra attester_slashings = 5
+      [ (ethereum.eth.ext.ssz_max) = "1" ];
+  // At most MAX_ATTESTATIONS_ELECTRA.
+  repeated AttestationElectra attestations = 6
+      [ (ethereum.eth.ext.ssz_max) = "8" ];
+  // At most MAX_DEPOSITS.
+  repeated Deposit deposits = 7 [ (ethereum.eth.ext.ssz_max) = "16" ];
+  // At most MAX_VOLUNTARY_EXITS.
+  repeated SignedVoluntaryExit voluntary_exits = 8
+      [ (ethereum.eth.ext.ssz_max) = "16" ];
+  // Sync aggregate object for the beacon chain to track sync committee votes.
+  SyncAggregate sync_aggregate = 9;
+  // Execution payload from the execution chain. New in Gloas network
+  // upgrade.
+  ethereum.engine.v1.ExecutionPayloadGloas execution_payload = 10;
+  // At most MAX_BLS_TO_EXECUTION_CHANGES. New in Capella network upgrade.
+  repeated SignedBLSToExecutionChange bls_to_execution_changes = 11
+      [ (ethereum.eth.ext.ssz_max) = "16" ];
+  // Blob KZG commitments.
+  repeated bytes blob_kzg_commitments = 12 [
+    (ethereum.eth.ext.ssz_size) = "?,48",
+    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
+  ];
+
+  ethereum.engine.v1.ExecutionRequests execution_requests = 13;
+}
+
+message BeaconBlockGloas {
+  // Beacon chain slot that this block represents.
+  uint64 slot = 1 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"
+  ];
+  // Validator index of the validator that proposed the block header.
+  uint64 proposer_index = 2 [ (ethereum.eth.ext.cast_type) =
+                                  "github.com/OffchainLabs/prysm/v6/"
+                                  "consensus-types/primitives.ValidatorIndex" ];
+  // 32 byte root of the parent block.
+  bytes parent_root = 3 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  // 32 byte root of the resulting state after processing this block.
+  bytes state_root = 4 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  // The beacon block body.
+  BeaconBlockBodyGloas body = 5;
+}
+
+message SignedBeaconBlockGloas {
+  // The unsigned beacon block itself.
+  BeaconBlockGloas block = 1;
+  // 96 byte BLS signature from the validator that produced this block.
+  bytes signature = 2 [ (ethereum.eth.ext.ssz_size) = "96" ];
+}
+
+message SignedBeaconBlockContentsGloas {
+  SignedBeaconBlockGloas block = 1;
+  repeated bytes kzg_proofs = 2 [
+    (ethereum.eth.ext.ssz_size) = "?,48",
+    (ethereum.eth.ext.ssz_max) = "max_cell_proofs_length.size"
+  ];
+  repeated bytes blobs = 3 [
+    (ethereum.eth.ext.ssz_size) = "?,blob.size",
+    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
+  ];
+}
+
+message BeaconBlockContentsGloas {
+  BeaconBlockGloas block = 1;
+  repeated bytes kzg_proofs = 2 [
+    (ethereum.eth.ext.ssz_size) = "?,48",
+    (ethereum.eth.ext.ssz_max) = "max_cell_proofs_length.size"
+  ];
+  repeated bytes blobs = 3 [
+    (ethereum.eth.ext.ssz_size) = "?,blob.size",
+    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
+  ];
+}

proto/prysm/v1alpha1/beacon_state.pb.go

@@ -2630,6 +2630,349 @@ func (x *BeaconStateFulu) GetProposerLookahead() []uint64 {
 	return nil
 }
 
+type BeaconStateGloas struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	GenesisTime                   uint64                                                                     `protobuf:"varint,1001,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`
+	GenesisValidatorsRoot         []byte                                                                     `protobuf:"bytes,1002,opt,name=genesis_validators_root,json=genesisValidatorsRoot,proto3" json:"genesis_validators_root,omitempty" ssz-size:"32"`
+	Slot                          github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot           `protobuf:"varint,1003,opt,name=slot,proto3" json:"slot,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"`
+	Fork                          *Fork                                                                      `protobuf:"bytes,1004,opt,name=fork,proto3" json:"fork,omitempty"`
+	LatestBlockHeader             *BeaconBlockHeader                                                         `protobuf:"bytes,2001,opt,name=latest_block_header,json=latestBlockHeader,proto3" json:"latest_block_header,omitempty"`
+	BlockRoots                    [][]byte                                                                   `protobuf:"bytes,2002,rep,name=block_roots,json=blockRoots,proto3" json:"block_roots,omitempty" ssz-size:"8192,32"`
+	StateRoots                    [][]byte                                                                   `protobuf:"bytes,2003,rep,name=state_roots,json=stateRoots,proto3" json:"state_roots,omitempty" ssz-size:"8192,32"`
+	HistoricalRoots               [][]byte                                                                   `protobuf:"bytes,2004,rep,name=historical_roots,json=historicalRoots,proto3" json:"historical_roots,omitempty" ssz-max:"16777216" ssz-size:"?,32"`
+	Eth1Data                      *Eth1Data                                                                  `protobuf:"bytes,3001,opt,name=eth1_data,json=eth1Data,proto3" json:"eth1_data,omitempty"`
+	Eth1DataVotes                 []*Eth1Data                                                                `protobuf:"bytes,3002,rep,name=eth1_data_votes,json=eth1DataVotes,proto3" json:"eth1_data_votes,omitempty" ssz-max:"2048"`
+	Eth1DepositIndex              uint64                                                                     `protobuf:"varint,3003,opt,name=eth1_deposit_index,json=eth1DepositIndex,proto3" json:"eth1_deposit_index,omitempty"`
+	Validators                    []*Validator                                                               `protobuf:"bytes,4001,rep,name=validators,proto3" json:"validators,omitempty" ssz-max:"1099511627776"`
+	Balances                      []uint64                                                                   `protobuf:"varint,4002,rep,packed,name=balances,proto3" json:"balances,omitempty" ssz-max:"1099511627776"`
+	RandaoMixes                   [][]byte                                                                   `protobuf:"bytes,5001,rep,name=randao_mixes,json=randaoMixes,proto3" json:"randao_mixes,omitempty" ssz-size:"65536,32"`
+	Slashings                     []uint64                                                                   `protobuf:"varint,6001,rep,packed,name=slashings,proto3" json:"slashings,omitempty" ssz-size:"8192"`
+	PreviousEpochParticipation    []byte                                                                     `protobuf:"bytes,7001,opt,name=previous_epoch_participation,json=previousEpochParticipation,proto3" json:"previous_epoch_participation,omitempty" ssz-max:"1099511627776"`
+	CurrentEpochParticipation     []byte                                                                     `protobuf:"bytes,7002,opt,name=current_epoch_participation,json=currentEpochParticipation,proto3" json:"current_epoch_participation,omitempty" ssz-max:"1099511627776"`
+	JustificationBits             github_com_prysmaticlabs_go_bitfield.Bitvector4                            `protobuf:"bytes,8001,opt,name=justification_bits,json=justificationBits,proto3" json:"justification_bits,omitempty" cast-type:"github.com/prysmaticlabs/go-bitfield.Bitvector4" ssz-size:"1"`
+	PreviousJustifiedCheckpoint   *Checkpoint                                                                `protobuf:"bytes,8002,opt,name=previous_justified_checkpoint,json=previousJustifiedCheckpoint,proto3" json:"previous_justified_checkpoint,omitempty"`
+	CurrentJustifiedCheckpoint    *Checkpoint                                                                `protobuf:"bytes,8003,opt,name=current_justified_checkpoint,json=currentJustifiedCheckpoint,proto3" json:"current_justified_checkpoint,omitempty"`
+	FinalizedCheckpoint           *Checkpoint                                                                `protobuf:"bytes,8004,opt,name=finalized_checkpoint,json=finalizedCheckpoint,proto3" json:"finalized_checkpoint,omitempty"`
+	InactivityScores              []uint64                                                                   `protobuf:"varint,9001,rep,packed,name=inactivity_scores,json=inactivityScores,proto3" json:"inactivity_scores,omitempty" ssz-max:"1099511627776"`
+	CurrentSyncCommittee          *SyncCommittee                                                             `protobuf:"bytes,9002,opt,name=current_sync_committee,json=currentSyncCommittee,proto3" json:"current_sync_committee,omitempty"`
+	NextSyncCommittee             *SyncCommittee                                                             `protobuf:"bytes,9003,opt,name=next_sync_committee,json=nextSyncCommittee,proto3" json:"next_sync_committee,omitempty"`
+	LatestExecutionPayloadHeader  *v1.ExecutionPayloadHeaderGloas                                            `protobuf:"bytes,10001,opt,name=latest_execution_payload_header,json=latestExecutionPayloadHeader,proto3" json:"latest_execution_payload_header,omitempty"`
+	NextWithdrawalIndex           uint64                                                                     `protobuf:"varint,11001,opt,name=next_withdrawal_index,json=nextWithdrawalIndex,proto3" json:"next_withdrawal_index,omitempty"`
+	NextWithdrawalValidatorIndex  github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex `protobuf:"varint,11002,opt,name=next_withdrawal_validator_index,json=nextWithdrawalValidatorIndex,proto3" json:"next_withdrawal_validator_index,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.ValidatorIndex"`
+	HistoricalSummaries           []*HistoricalSummary                                                       `protobuf:"bytes,11003,rep,name=historical_summaries,json=historicalSummaries,proto3" json:"historical_summaries,omitempty" ssz-max:"16777216"`
+	DepositRequestsStartIndex     uint64                                                                     `protobuf:"varint,12001,opt,name=deposit_requests_start_index,json=depositRequestsStartIndex,proto3" json:"deposit_requests_start_index,omitempty"`
+	DepositBalanceToConsume       github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei           `protobuf:"varint,12002,opt,name=deposit_balance_to_consume,json=depositBalanceToConsume,proto3" json:"deposit_balance_to_consume,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Gwei"`
+	ExitBalanceToConsume          github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei           `protobuf:"varint,12003,opt,name=exit_balance_to_consume,json=exitBalanceToConsume,proto3" json:"exit_balance_to_consume,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Gwei"`
+	EarliestExitEpoch             github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch          `protobuf:"varint,12004,opt,name=earliest_exit_epoch,json=earliestExitEpoch,proto3" json:"earliest_exit_epoch,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Epoch"`
+	ConsolidationBalanceToConsume github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei           `protobuf:"varint,12005,opt,name=consolidation_balance_to_consume,json=consolidationBalanceToConsume,proto3" json:"consolidation_balance_to_consume,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Gwei"`
+	EarliestConsolidationEpoch    github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch          `protobuf:"varint,12006,opt,name=earliest_consolidation_epoch,json=earliestConsolidationEpoch,proto3" json:"earliest_consolidation_epoch,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Epoch"`
+	PendingDeposits               []*PendingDeposit                                                          `protobuf:"bytes,12007,rep,name=pending_deposits,json=pendingDeposits,proto3" json:"pending_deposits,omitempty" ssz-max:"134217728"`
+	PendingPartialWithdrawals     []*PendingPartialWithdrawal                                                `protobuf:"bytes,12008,rep,name=pending_partial_withdrawals,json=pendingPartialWithdrawals,proto3" json:"pending_partial_withdrawals,omitempty" ssz-max:"134217728"`
+	PendingConsolidations         []*PendingConsolidation                                                    `protobuf:"bytes,12009,rep,name=pending_consolidations,json=pendingConsolidations,proto3" json:"pending_consolidations,omitempty" ssz-max:"262144"`
+	ProposerLookahead             []uint64                                                                   `protobuf:"varint,13001,rep,packed,name=proposer_lookahead,json=proposerLookahead,proto3" json:"proposer_lookahead,omitempty" ssz-size:"64"`
+}
+
+func (x *BeaconStateGloas) Reset() {
+	*x = BeaconStateGloas{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_beacon_state_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *BeaconStateGloas) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BeaconStateGloas) ProtoMessage() {}
+
+func (x *BeaconStateGloas) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_beacon_state_proto_msgTypes[19]
+	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 BeaconStateGloas.ProtoReflect.Descriptor instead.
+func (*BeaconStateGloas) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_beacon_state_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *BeaconStateGloas) GetGenesisTime() uint64 {
+	if x != nil {
+		return x.GenesisTime
+	}
+	return 0
+}
+
+func (x *BeaconStateGloas) GetGenesisValidatorsRoot() []byte {
+	if x != nil {
+		return x.GenesisValidatorsRoot
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
+	if x != nil {
+		return x.Slot
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(0)
+}
+
+func (x *BeaconStateGloas) GetFork() *Fork {
+	if x != nil {
+		return x.Fork
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetLatestBlockHeader() *BeaconBlockHeader {
+	if x != nil {
+		return x.LatestBlockHeader
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetBlockRoots() [][]byte {
+	if x != nil {
+		return x.BlockRoots
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetStateRoots() [][]byte {
+	if x != nil {
+		return x.StateRoots
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetHistoricalRoots() [][]byte {
+	if x != nil {
+		return x.HistoricalRoots
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetEth1Data() *Eth1Data {
+	if x != nil {
+		return x.Eth1Data
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetEth1DataVotes() []*Eth1Data {
+	if x != nil {
+		return x.Eth1DataVotes
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetEth1DepositIndex() uint64 {
+	if x != nil {
+		return x.Eth1DepositIndex
+	}
+	return 0
+}
+
+func (x *BeaconStateGloas) GetValidators() []*Validator {
+	if x != nil {
+		return x.Validators
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetBalances() []uint64 {
+	if x != nil {
+		return x.Balances
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetRandaoMixes() [][]byte {
+	if x != nil {
+		return x.RandaoMixes
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetSlashings() []uint64 {
+	if x != nil {
+		return x.Slashings
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetPreviousEpochParticipation() []byte {
+	if x != nil {
+		return x.PreviousEpochParticipation
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetCurrentEpochParticipation() []byte {
+	if x != nil {
+		return x.CurrentEpochParticipation
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetJustificationBits() github_com_prysmaticlabs_go_bitfield.Bitvector4 {
+	if x != nil {
+		return x.JustificationBits
+	}
+	return github_com_prysmaticlabs_go_bitfield.Bitvector4(nil)
+}
+
+func (x *BeaconStateGloas) GetPreviousJustifiedCheckpoint() *Checkpoint {
+	if x != nil {
+		return x.PreviousJustifiedCheckpoint
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetCurrentJustifiedCheckpoint() *Checkpoint {
+	if x != nil {
+		return x.CurrentJustifiedCheckpoint
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetFinalizedCheckpoint() *Checkpoint {
+	if x != nil {
+		return x.FinalizedCheckpoint
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetInactivityScores() []uint64 {
+	if x != nil {
+		return x.InactivityScores
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetCurrentSyncCommittee() *SyncCommittee {
+	if x != nil {
+		return x.CurrentSyncCommittee
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetNextSyncCommittee() *SyncCommittee {
+	if x != nil {
+		return x.NextSyncCommittee
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetLatestExecutionPayloadHeader() *v1.ExecutionPayloadHeaderGloas {
+	if x != nil {
+		return x.LatestExecutionPayloadHeader
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetNextWithdrawalIndex() uint64 {
+	if x != nil {
+		return x.NextWithdrawalIndex
+	}
+	return 0
+}
+
+func (x *BeaconStateGloas) GetNextWithdrawalValidatorIndex() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex {
+	if x != nil {
+		return x.NextWithdrawalValidatorIndex
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(0)
+}
+
+func (x *BeaconStateGloas) GetHistoricalSummaries() []*HistoricalSummary {
+	if x != nil {
+		return x.HistoricalSummaries
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetDepositRequestsStartIndex() uint64 {
+	if x != nil {
+		return x.DepositRequestsStartIndex
+	}
+	return 0
+}
+
+func (x *BeaconStateGloas) GetDepositBalanceToConsume() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei {
+	if x != nil {
+		return x.DepositBalanceToConsume
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(0)
+}
+
+func (x *BeaconStateGloas) GetExitBalanceToConsume() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei {
+	if x != nil {
+		return x.ExitBalanceToConsume
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(0)
+}
+
+func (x *BeaconStateGloas) GetEarliestExitEpoch() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch {
+	if x != nil {
+		return x.EarliestExitEpoch
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(0)
+}
+
+func (x *BeaconStateGloas) GetConsolidationBalanceToConsume() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei {
+	if x != nil {
+		return x.ConsolidationBalanceToConsume
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(0)
+}
+
+func (x *BeaconStateGloas) GetEarliestConsolidationEpoch() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch {
+	if x != nil {
+		return x.EarliestConsolidationEpoch
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(0)
+}
+
+func (x *BeaconStateGloas) GetPendingDeposits() []*PendingDeposit {
+	if x != nil {
+		return x.PendingDeposits
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetPendingPartialWithdrawals() []*PendingPartialWithdrawal {
+	if x != nil {
+		return x.PendingPartialWithdrawals
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetPendingConsolidations() []*PendingConsolidation {
+	if x != nil {
+		return x.PendingConsolidations
+	}
+	return nil
+}
+
+func (x *BeaconStateGloas) GetProposerLookahead() []uint64 {
+	if x != nil {
+		return x.ProposerLookahead
+	}
+	return nil
+}
+
 var File_proto_prysm_v1alpha1_beacon_state_proto protoreflect.FileDescriptor
 
 var file_proto_prysm_v1alpha1_beacon_state_proto_rawDesc = []byte{
@@ -3779,17 +4122,224 @@ var file_proto_prysm_v1alpha1_beacon_state_proto_rawDesc = []byte{
 	0x12, 0x36, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x6c, 0x6f, 0x6f,
 	0x6b, 0x61, 0x68, 0x65, 0x61, 0x64, 0x18, 0xc9, 0x65, 0x20, 0x03, 0x28, 0x04, 0x42, 0x06, 0x8a,
 	0xb5, 0x18, 0x02, 0x36, 0x34, 0x52, 0x11, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x4c,
-	0x6f, 0x6f, 0x6b, 0x61, 0x68, 0x65, 0x61, 0x64, 0x42, 0x9a, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67,
+	0x6f, 0x6f, 0x6b, 0x61, 0x68, 0x65, 0x61, 0x64, 0x22, 0xe8, 0x19, 0x0a, 0x10, 0x42, 0x65, 0x61,
+	0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x47, 0x6c, 0x6f, 0x61, 0x73, 0x12, 0x22, 0x0a,
+	0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0xe9, 0x07,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x54, 0x69, 0x6d,
+	0x65, 0x12, 0x3f, 0x0a, 0x17, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0xea, 0x07, 0x20,
+	0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x15, 0x67, 0x65, 0x6e,
+	0x65, 0x73, 0x69, 0x73, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x6f,
+	0x6f, 0x74, 0x12, 0x59, 0x0a, 0x04, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0xeb, 0x07, 0x20, 0x01, 0x28,
+	0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
+	0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70,
+	0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x04, 0x73, 0x6c, 0x6f, 0x74, 0x12, 0x30, 0x0a,
+	0x04, 0x66, 0x6f, 0x72, 0x6b, 0x18, 0xec, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x65,
+	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x52, 0x04, 0x66, 0x6f, 0x72, 0x6b, 0x12,
+	0x59, 0x0a, 0x13, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
+	0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0xd1, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e,
+	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61,
+	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63,
+	0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x11, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x42,
+	0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x2d, 0x0a, 0x0b, 0x62, 0x6c,
+	0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x73, 0x18, 0xd2, 0x0f, 0x20, 0x03, 0x28, 0x0c,
+	0x42, 0x0b, 0x8a, 0xb5, 0x18, 0x07, 0x38, 0x31, 0x39, 0x32, 0x2c, 0x33, 0x32, 0x52, 0x0a, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x12, 0x2d, 0x0a, 0x0b, 0x73, 0x74, 0x61,
+	0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x73, 0x18, 0xd3, 0x0f, 0x20, 0x03, 0x28, 0x0c, 0x42,
+	0x0b, 0x8a, 0xb5, 0x18, 0x07, 0x38, 0x31, 0x39, 0x32, 0x2c, 0x33, 0x32, 0x52, 0x0a, 0x73, 0x74,
+	0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x10, 0x68, 0x69, 0x73, 0x74,
+	0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x73, 0x18, 0xd4, 0x0f, 0x20,
+	0x03, 0x28, 0x0c, 0x42, 0x14, 0x8a, 0xb5, 0x18, 0x04, 0x3f, 0x2c, 0x33, 0x32, 0x92, 0xb5, 0x18,
+	0x08, 0x31, 0x36, 0x37, 0x37, 0x37, 0x32, 0x31, 0x36, 0x52, 0x0f, 0x68, 0x69, 0x73, 0x74, 0x6f,
+	0x72, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x12, 0x3d, 0x0a, 0x09, 0x65, 0x74,
+	0x68, 0x31, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0xb9, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f,
 	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
-	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x10, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74,
-	0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x74, 0x68, 0x31, 0x44, 0x61, 0x74, 0x61, 0x52,
+	0x08, 0x65, 0x74, 0x68, 0x31, 0x44, 0x61, 0x74, 0x61, 0x12, 0x52, 0x0a, 0x0f, 0x65, 0x74, 0x68,
+	0x31, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x76, 0x6f, 0x74, 0x65, 0x73, 0x18, 0xba, 0x17, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
+	0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x74, 0x68, 0x31,
+	0x44, 0x61, 0x74, 0x61, 0x42, 0x08, 0x92, 0xb5, 0x18, 0x04, 0x32, 0x30, 0x34, 0x38, 0x52, 0x0d,
+	0x65, 0x74, 0x68, 0x31, 0x44, 0x61, 0x74, 0x61, 0x56, 0x6f, 0x74, 0x65, 0x73, 0x12, 0x2d, 0x0a,
+	0x12, 0x65, 0x74, 0x68, 0x31, 0x5f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x69, 0x6e,
+	0x64, 0x65, 0x78, 0x18, 0xbb, 0x17, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x65, 0x74, 0x68, 0x31,
+	0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x54, 0x0a, 0x0a,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0xa1, 0x1f, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x20, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68,
+	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x42, 0x11, 0x92, 0xb5, 0x18, 0x0d, 0x31, 0x30, 0x39, 0x39, 0x35, 0x31, 0x31,
+	0x36, 0x32, 0x37, 0x37, 0x37, 0x36, 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x73, 0x12, 0x2e, 0x0a, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0xa2,
+	0x1f, 0x20, 0x03, 0x28, 0x04, 0x42, 0x11, 0x92, 0xb5, 0x18, 0x0d, 0x31, 0x30, 0x39, 0x39, 0x35,
+	0x31, 0x31, 0x36, 0x32, 0x37, 0x37, 0x37, 0x36, 0x52, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63,
+	0x65, 0x73, 0x12, 0x30, 0x0a, 0x0c, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x5f, 0x6d, 0x69, 0x78,
+	0x65, 0x73, 0x18, 0x89, 0x27, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x0c, 0x8a, 0xb5, 0x18, 0x08, 0x36,
+	0x35, 0x35, 0x33, 0x36, 0x2c, 0x33, 0x32, 0x52, 0x0b, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x4d,
+	0x69, 0x78, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x09, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+	0x73, 0x18, 0xf1, 0x2e, 0x20, 0x03, 0x28, 0x04, 0x42, 0x08, 0x8a, 0xb5, 0x18, 0x04, 0x38, 0x31,
+	0x39, 0x32, 0x52, 0x09, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x54, 0x0a,
+	0x1c, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xd9, 0x36,
+	0x20, 0x01, 0x28, 0x0c, 0x42, 0x11, 0x92, 0xb5, 0x18, 0x0d, 0x31, 0x30, 0x39, 0x39, 0x35, 0x31,
+	0x31, 0x36, 0x32, 0x37, 0x37, 0x37, 0x36, 0x52, 0x1a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75,
+	0x73, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x12, 0x52, 0x0a, 0x1b, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65,
+	0x70, 0x6f, 0x63, 0x68, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0xda, 0x36, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x11, 0x92, 0xb5, 0x18, 0x0d, 0x31,
+	0x30, 0x39, 0x39, 0x35, 0x31, 0x31, 0x36, 0x32, 0x37, 0x37, 0x37, 0x36, 0x52, 0x19, 0x63, 0x75,
+	0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x68, 0x0a, 0x12, 0x6a, 0x75, 0x73, 0x74, 0x69,
+	0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x69, 0x74, 0x73, 0x18, 0xc1, 0x3e,
+	0x20, 0x01, 0x28, 0x0c, 0x42, 0x38, 0x82, 0xb5, 0x18, 0x2f, 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, 0x67, 0x6f, 0x2d, 0x62, 0x69, 0x74, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x42,
+	0x69, 0x74, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x34, 0x8a, 0xb5, 0x18, 0x01, 0x31, 0x52, 0x11,
+	0x6a, 0x75, 0x73, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x69, 0x74,
+	0x73, 0x12, 0x66, 0x0a, 0x1d, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x6a, 0x75,
+	0x73, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69,
+	0x6e, 0x74, 0x18, 0xc2, 0x3e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65,
+	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x1b, 0x70, 0x72,
+	0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x4a, 0x75, 0x73, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x43,
+	0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x64, 0x0a, 0x1c, 0x63, 0x75, 0x72,
+	0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x63,
+	0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0xc3, 0x3e, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
+	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f,
+	0x69, 0x6e, 0x74, 0x52, 0x1a, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4a, 0x75, 0x73, 0x74,
+	0x69, 0x66, 0x69, 0x65, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12,
+	0x55, 0x0a, 0x14, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x63, 0x68, 0x65,
+	0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0xc4, 0x3e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21,
+	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e,
+	0x74, 0x52, 0x13, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x43, 0x68, 0x65, 0x63,
+	0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x3f, 0x0a, 0x11, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69,
+	0x76, 0x69, 0x74, 0x79, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0xa9, 0x46, 0x20, 0x03,
+	0x28, 0x04, 0x42, 0x11, 0x92, 0xb5, 0x18, 0x0d, 0x31, 0x30, 0x39, 0x39, 0x35, 0x31, 0x31, 0x36,
+	0x32, 0x37, 0x37, 0x37, 0x36, 0x52, 0x10, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74,
+	0x79, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x5b, 0x0a, 0x16, 0x63, 0x75, 0x72, 0x72, 0x65,
+	0x6e, 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65,
+	0x65, 0x18, 0xaa, 0x46, 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, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x52, 0x14,
+	0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69,
+	0x74, 0x74, 0x65, 0x65, 0x12, 0x55, 0x0a, 0x13, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x79, 0x6e,
+	0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x18, 0xab, 0x46, 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, 0x43,
+	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x52, 0x11, 0x6e, 0x65, 0x78, 0x74, 0x53, 0x79,
+	0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x12, 0x77, 0x0a, 0x1f, 0x6c,
+	0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+	0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x91,
+	0x4e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
+	0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75,
+	0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65,
+	0x72, 0x47, 0x6c, 0x6f, 0x61, 0x73, 0x52, 0x1c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x45, 0x78,
+	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x48, 0x65,
+	0x61, 0x64, 0x65, 0x72, 0x12, 0x33, 0x0a, 0x15, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x77, 0x69, 0x74,
+	0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0xf9, 0x55,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x6e, 0x65, 0x78, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72,
+	0x61, 0x77, 0x61, 0x6c, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x96, 0x01, 0x0a, 0x1f, 0x6e, 0x65,
+	0x78, 0x74, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x5f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0xfa, 0x55,
+	0x20, 0x01, 0x28, 0x04, 0x42, 0x4e, 0x82, 0xb5, 0x18, 0x4a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62,
+	0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49,
+	0x6e, 0x64, 0x65, 0x78, 0x52, 0x1c, 0x6e, 0x65, 0x78, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72,
+	0x61, 0x77, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64,
+	0x65, 0x78, 0x12, 0x6a, 0x0a, 0x14, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c,
+	0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x73, 0x18, 0xfb, 0x55, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68,
+	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72,
+	0x69, 0x63, 0x61, 0x6c, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x0c, 0x92, 0xb5, 0x18,
+	0x08, 0x31, 0x36, 0x37, 0x37, 0x37, 0x32, 0x31, 0x36, 0x52, 0x13, 0x68, 0x69, 0x73, 0x74, 0x6f,
+	0x72, 0x69, 0x63, 0x61, 0x6c, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x73, 0x12, 0x40,
+	0x0a, 0x1c, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0xe1,
+	0x5d, 0x20, 0x01, 0x28, 0x04, 0x52, 0x19, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78,
+	0x12, 0x82, 0x01, 0x0a, 0x1a, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x62, 0x61, 0x6c,
+	0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x18,
+	0xe2, 0x5d, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68,
 	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c,
-	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 0x2f, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
-	0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
-	0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56, 0x31, 0x41, 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,
+	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x47, 0x77, 0x65, 0x69, 0x52, 0x17, 0x64, 0x65,
+	0x70, 0x6f, 0x73, 0x69, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x6f, 0x43, 0x6f,
+	0x6e, 0x73, 0x75, 0x6d, 0x65, 0x12, 0x7c, 0x0a, 0x17, 0x65, 0x78, 0x69, 0x74, 0x5f, 0x62, 0x61,
+	0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65,
+	0x18, 0xe3, 0x5d, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74,
+	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e,
+	0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x47, 0x77, 0x65, 0x69, 0x52, 0x14, 0x65,
+	0x78, 0x69, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x6f, 0x43, 0x6f, 0x6e, 0x73,
+	0x75, 0x6d, 0x65, 0x12, 0x76, 0x0a, 0x13, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x5f,
+	0x65, 0x78, 0x69, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0xe4, 0x5d, 0x20, 0x01, 0x28,
+	0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
+	0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70,
+	0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x11, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65,
+	0x73, 0x74, 0x45, 0x78, 0x69, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x8e, 0x01, 0x0a, 0x20,
+	0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x61,
+	0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65,
+	0x18, 0xe5, 0x5d, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74,
+	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e,
+	0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x47, 0x77, 0x65, 0x69, 0x52, 0x1d, 0x63,
+	0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x61, 0x6c, 0x61,
+	0x6e, 0x63, 0x65, 0x54, 0x6f, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x12, 0x88, 0x01, 0x0a,
+	0x1c, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0xe6, 0x5d,
+	0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62,
+	0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x1a, 0x65, 0x61, 0x72,
+	0x6c, 0x69, 0x65, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x60, 0x0a, 0x10, 0x70, 0x65, 0x6e, 0x64, 0x69,
+	0x6e, 0x67, 0x5f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73, 0x18, 0xe7, 0x5d, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
+	0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69,
+	0x6e, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x42, 0x0d, 0x92, 0xb5, 0x18, 0x09, 0x31,
+	0x33, 0x34, 0x32, 0x31, 0x37, 0x37, 0x32, 0x38, 0x52, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e,
+	0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x73, 0x12, 0x7f, 0x0a, 0x1b, 0x70, 0x65, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x77, 0x69, 0x74,
+	0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x18, 0xe8, 0x5d, 0x20, 0x03, 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, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50,
+	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c,
+	0x42, 0x0d, 0x92, 0xb5, 0x18, 0x09, 0x31, 0x33, 0x34, 0x32, 0x31, 0x37, 0x37, 0x32, 0x38, 0x52,
+	0x19, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x57,
+	0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x12, 0x6f, 0x0a, 0x16, 0x70, 0x65,
+	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x18, 0xe9, 0x5d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x65, 0x74,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
+	0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x73, 0x6f,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0a, 0x92, 0xb5, 0x18, 0x06, 0x32, 0x36,
+	0x32, 0x31, 0x34, 0x34, 0x52, 0x15, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e,
+	0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x36, 0x0a, 0x12, 0x70,
+	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x6c, 0x6f, 0x6f, 0x6b, 0x61, 0x68, 0x65, 0x61,
+	0x64, 0x18, 0xc9, 0x65, 0x20, 0x03, 0x28, 0x04, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x36, 0x34,
+	0x52, 0x11, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x4c, 0x6f, 0x6f, 0x6b, 0x61, 0x68,
+	0x65, 0x61, 0x64, 0x42, 0x9a, 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, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
+	0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70,
+	0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72,
+	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68,
+	0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e,
+	0x56, 0x31, 0x41, 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 (
@@ -3804,7 +4354,7 @@ func file_proto_prysm_v1alpha1_beacon_state_proto_rawDescGZIP() []byte {
 	return file_proto_prysm_v1alpha1_beacon_state_proto_rawDescData
 }
 
-var file_proto_prysm_v1alpha1_beacon_state_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
+var file_proto_prysm_v1alpha1_beacon_state_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
 var file_proto_prysm_v1alpha1_beacon_state_proto_goTypes = []interface{}{
 	(*BeaconState)(nil),                      // 0: ethereum.eth.v1alpha1.BeaconState
 	(*Fork)(nil),                             // 1: ethereum.eth.v1alpha1.Fork
@@ -3825,111 +4375,128 @@ var file_proto_prysm_v1alpha1_beacon_state_proto_goTypes = []interface{}{
 	(*BeaconStateDeneb)(nil),                 // 16: ethereum.eth.v1alpha1.BeaconStateDeneb
 	(*BeaconStateElectra)(nil),               // 17: ethereum.eth.v1alpha1.BeaconStateElectra
 	(*BeaconStateFulu)(nil),                  // 18: ethereum.eth.v1alpha1.BeaconStateFulu
-	(*BeaconBlockHeader)(nil),                // 19: ethereum.eth.v1alpha1.BeaconBlockHeader
-	(*Eth1Data)(nil),                         // 20: ethereum.eth.v1alpha1.Eth1Data
-	(*Validator)(nil),                        // 21: ethereum.eth.v1alpha1.Validator
-	(*Checkpoint)(nil),                       // 22: ethereum.eth.v1alpha1.Checkpoint
-	(*AttestationData)(nil),                  // 23: ethereum.eth.v1alpha1.AttestationData
-	(*v1.ExecutionPayloadHeader)(nil),        // 24: ethereum.engine.v1.ExecutionPayloadHeader
-	(*v1.ExecutionPayloadHeaderCapella)(nil), // 25: ethereum.engine.v1.ExecutionPayloadHeaderCapella
-	(*v1.ExecutionPayloadHeaderDeneb)(nil),   // 26: ethereum.engine.v1.ExecutionPayloadHeaderDeneb
-	(*PendingDeposit)(nil),                   // 27: ethereum.eth.v1alpha1.PendingDeposit
-	(*PendingPartialWithdrawal)(nil),         // 28: ethereum.eth.v1alpha1.PendingPartialWithdrawal
-	(*PendingConsolidation)(nil),             // 29: ethereum.eth.v1alpha1.PendingConsolidation
+	(*BeaconStateGloas)(nil),                 // 19: ethereum.eth.v1alpha1.BeaconStateGloas
+	(*BeaconBlockHeader)(nil),                // 20: ethereum.eth.v1alpha1.BeaconBlockHeader
+	(*Eth1Data)(nil),                         // 21: ethereum.eth.v1alpha1.Eth1Data
+	(*Validator)(nil),                        // 22: ethereum.eth.v1alpha1.Validator
+	(*Checkpoint)(nil),                       // 23: ethereum.eth.v1alpha1.Checkpoint
+	(*AttestationData)(nil),                  // 24: ethereum.eth.v1alpha1.AttestationData
+	(*v1.ExecutionPayloadHeader)(nil),        // 25: ethereum.engine.v1.ExecutionPayloadHeader
+	(*v1.ExecutionPayloadHeaderCapella)(nil), // 26: ethereum.engine.v1.ExecutionPayloadHeaderCapella
+	(*v1.ExecutionPayloadHeaderDeneb)(nil),   // 27: ethereum.engine.v1.ExecutionPayloadHeaderDeneb
+	(*PendingDeposit)(nil),                   // 28: ethereum.eth.v1alpha1.PendingDeposit
+	(*PendingPartialWithdrawal)(nil),         // 29: ethereum.eth.v1alpha1.PendingPartialWithdrawal
+	(*PendingConsolidation)(nil),             // 30: ethereum.eth.v1alpha1.PendingConsolidation
+	(*v1.ExecutionPayloadHeaderGloas)(nil),   // 31: ethereum.engine.v1.ExecutionPayloadHeaderGloas
 }
 var file_proto_prysm_v1alpha1_beacon_state_proto_depIdxs = []int32{
-	1,  // 0: ethereum.eth.v1alpha1.BeaconState.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	19, // 1: ethereum.eth.v1alpha1.BeaconState.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	20, // 2: ethereum.eth.v1alpha1.BeaconState.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	20, // 3: ethereum.eth.v1alpha1.BeaconState.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	21, // 4: ethereum.eth.v1alpha1.BeaconState.validators:type_name -> ethereum.eth.v1alpha1.Validator
-	2,  // 5: ethereum.eth.v1alpha1.BeaconState.previous_epoch_attestations:type_name -> ethereum.eth.v1alpha1.PendingAttestation
-	2,  // 6: ethereum.eth.v1alpha1.BeaconState.current_epoch_attestations:type_name -> ethereum.eth.v1alpha1.PendingAttestation
-	22, // 7: ethereum.eth.v1alpha1.BeaconState.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 8: ethereum.eth.v1alpha1.BeaconState.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 9: ethereum.eth.v1alpha1.BeaconState.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	23, // 10: ethereum.eth.v1alpha1.PendingAttestation.data:type_name -> ethereum.eth.v1alpha1.AttestationData
-	1,  // 11: ethereum.eth.v1alpha1.CheckPtInfo.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	1,  // 12: ethereum.eth.v1alpha1.BeaconStateAltair.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	19, // 13: ethereum.eth.v1alpha1.BeaconStateAltair.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	20, // 14: ethereum.eth.v1alpha1.BeaconStateAltair.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	20, // 15: ethereum.eth.v1alpha1.BeaconStateAltair.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	21, // 16: ethereum.eth.v1alpha1.BeaconStateAltair.validators:type_name -> ethereum.eth.v1alpha1.Validator
-	22, // 17: ethereum.eth.v1alpha1.BeaconStateAltair.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 18: ethereum.eth.v1alpha1.BeaconStateAltair.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 19: ethereum.eth.v1alpha1.BeaconStateAltair.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	11, // 20: ethereum.eth.v1alpha1.BeaconStateAltair.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	11, // 21: ethereum.eth.v1alpha1.BeaconStateAltair.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	1,  // 22: ethereum.eth.v1alpha1.BeaconStateBellatrix.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	19, // 23: ethereum.eth.v1alpha1.BeaconStateBellatrix.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	20, // 24: ethereum.eth.v1alpha1.BeaconStateBellatrix.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	20, // 25: ethereum.eth.v1alpha1.BeaconStateBellatrix.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	21, // 26: ethereum.eth.v1alpha1.BeaconStateBellatrix.validators:type_name -> ethereum.eth.v1alpha1.Validator
-	22, // 27: ethereum.eth.v1alpha1.BeaconStateBellatrix.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 28: ethereum.eth.v1alpha1.BeaconStateBellatrix.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 29: ethereum.eth.v1alpha1.BeaconStateBellatrix.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	11, // 30: ethereum.eth.v1alpha1.BeaconStateBellatrix.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	11, // 31: ethereum.eth.v1alpha1.BeaconStateBellatrix.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	24, // 32: ethereum.eth.v1alpha1.BeaconStateBellatrix.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeader
-	1,  // 33: ethereum.eth.v1alpha1.BeaconStateCapella.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	19, // 34: ethereum.eth.v1alpha1.BeaconStateCapella.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	20, // 35: ethereum.eth.v1alpha1.BeaconStateCapella.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	20, // 36: ethereum.eth.v1alpha1.BeaconStateCapella.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	21, // 37: ethereum.eth.v1alpha1.BeaconStateCapella.validators:type_name -> ethereum.eth.v1alpha1.Validator
-	22, // 38: ethereum.eth.v1alpha1.BeaconStateCapella.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 39: ethereum.eth.v1alpha1.BeaconStateCapella.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 40: ethereum.eth.v1alpha1.BeaconStateCapella.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	11, // 41: ethereum.eth.v1alpha1.BeaconStateCapella.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	11, // 42: ethereum.eth.v1alpha1.BeaconStateCapella.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	25, // 43: ethereum.eth.v1alpha1.BeaconStateCapella.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderCapella
-	15, // 44: ethereum.eth.v1alpha1.BeaconStateCapella.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
-	1,  // 45: ethereum.eth.v1alpha1.BeaconStateDeneb.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	19, // 46: ethereum.eth.v1alpha1.BeaconStateDeneb.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	20, // 47: ethereum.eth.v1alpha1.BeaconStateDeneb.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	20, // 48: ethereum.eth.v1alpha1.BeaconStateDeneb.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	21, // 49: ethereum.eth.v1alpha1.BeaconStateDeneb.validators:type_name -> ethereum.eth.v1alpha1.Validator
-	22, // 50: ethereum.eth.v1alpha1.BeaconStateDeneb.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 51: ethereum.eth.v1alpha1.BeaconStateDeneb.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 52: ethereum.eth.v1alpha1.BeaconStateDeneb.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	11, // 53: ethereum.eth.v1alpha1.BeaconStateDeneb.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	11, // 54: ethereum.eth.v1alpha1.BeaconStateDeneb.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	26, // 55: ethereum.eth.v1alpha1.BeaconStateDeneb.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
-	15, // 56: ethereum.eth.v1alpha1.BeaconStateDeneb.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
-	1,  // 57: ethereum.eth.v1alpha1.BeaconStateElectra.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	19, // 58: ethereum.eth.v1alpha1.BeaconStateElectra.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	20, // 59: ethereum.eth.v1alpha1.BeaconStateElectra.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	20, // 60: ethereum.eth.v1alpha1.BeaconStateElectra.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	21, // 61: ethereum.eth.v1alpha1.BeaconStateElectra.validators:type_name -> ethereum.eth.v1alpha1.Validator
-	22, // 62: ethereum.eth.v1alpha1.BeaconStateElectra.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 63: ethereum.eth.v1alpha1.BeaconStateElectra.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 64: ethereum.eth.v1alpha1.BeaconStateElectra.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	11, // 65: ethereum.eth.v1alpha1.BeaconStateElectra.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	11, // 66: ethereum.eth.v1alpha1.BeaconStateElectra.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	26, // 67: ethereum.eth.v1alpha1.BeaconStateElectra.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
-	15, // 68: ethereum.eth.v1alpha1.BeaconStateElectra.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
-	27, // 69: ethereum.eth.v1alpha1.BeaconStateElectra.pending_deposits:type_name -> ethereum.eth.v1alpha1.PendingDeposit
-	28, // 70: ethereum.eth.v1alpha1.BeaconStateElectra.pending_partial_withdrawals:type_name -> ethereum.eth.v1alpha1.PendingPartialWithdrawal
-	29, // 71: ethereum.eth.v1alpha1.BeaconStateElectra.pending_consolidations:type_name -> ethereum.eth.v1alpha1.PendingConsolidation
-	1,  // 72: ethereum.eth.v1alpha1.BeaconStateFulu.fork:type_name -> ethereum.eth.v1alpha1.Fork
-	19, // 73: ethereum.eth.v1alpha1.BeaconStateFulu.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
-	20, // 74: ethereum.eth.v1alpha1.BeaconStateFulu.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	20, // 75: ethereum.eth.v1alpha1.BeaconStateFulu.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
-	21, // 76: ethereum.eth.v1alpha1.BeaconStateFulu.validators:type_name -> ethereum.eth.v1alpha1.Validator
-	22, // 77: ethereum.eth.v1alpha1.BeaconStateFulu.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 78: ethereum.eth.v1alpha1.BeaconStateFulu.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	22, // 79: ethereum.eth.v1alpha1.BeaconStateFulu.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
-	11, // 80: ethereum.eth.v1alpha1.BeaconStateFulu.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	11, // 81: ethereum.eth.v1alpha1.BeaconStateFulu.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
-	26, // 82: ethereum.eth.v1alpha1.BeaconStateFulu.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
-	15, // 83: ethereum.eth.v1alpha1.BeaconStateFulu.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
-	27, // 84: ethereum.eth.v1alpha1.BeaconStateFulu.pending_deposits:type_name -> ethereum.eth.v1alpha1.PendingDeposit
-	28, // 85: ethereum.eth.v1alpha1.BeaconStateFulu.pending_partial_withdrawals:type_name -> ethereum.eth.v1alpha1.PendingPartialWithdrawal
-	29, // 86: ethereum.eth.v1alpha1.BeaconStateFulu.pending_consolidations:type_name -> ethereum.eth.v1alpha1.PendingConsolidation
-	87, // [87:87] is the sub-list for method output_type
-	87, // [87:87] is the sub-list for method input_type
-	87, // [87:87] is the sub-list for extension type_name
-	87, // [87:87] is the sub-list for extension extendee
-	0,  // [0:87] is the sub-list for field type_name
+	1,   // 0: ethereum.eth.v1alpha1.BeaconState.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 1: ethereum.eth.v1alpha1.BeaconState.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 2: ethereum.eth.v1alpha1.BeaconState.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 3: ethereum.eth.v1alpha1.BeaconState.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 4: ethereum.eth.v1alpha1.BeaconState.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	2,   // 5: ethereum.eth.v1alpha1.BeaconState.previous_epoch_attestations:type_name -> ethereum.eth.v1alpha1.PendingAttestation
+	2,   // 6: ethereum.eth.v1alpha1.BeaconState.current_epoch_attestations:type_name -> ethereum.eth.v1alpha1.PendingAttestation
+	23,  // 7: ethereum.eth.v1alpha1.BeaconState.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 8: ethereum.eth.v1alpha1.BeaconState.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 9: ethereum.eth.v1alpha1.BeaconState.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	24,  // 10: ethereum.eth.v1alpha1.PendingAttestation.data:type_name -> ethereum.eth.v1alpha1.AttestationData
+	1,   // 11: ethereum.eth.v1alpha1.CheckPtInfo.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	1,   // 12: ethereum.eth.v1alpha1.BeaconStateAltair.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 13: ethereum.eth.v1alpha1.BeaconStateAltair.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 14: ethereum.eth.v1alpha1.BeaconStateAltair.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 15: ethereum.eth.v1alpha1.BeaconStateAltair.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 16: ethereum.eth.v1alpha1.BeaconStateAltair.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	23,  // 17: ethereum.eth.v1alpha1.BeaconStateAltair.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 18: ethereum.eth.v1alpha1.BeaconStateAltair.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 19: ethereum.eth.v1alpha1.BeaconStateAltair.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	11,  // 20: ethereum.eth.v1alpha1.BeaconStateAltair.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	11,  // 21: ethereum.eth.v1alpha1.BeaconStateAltair.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	1,   // 22: ethereum.eth.v1alpha1.BeaconStateBellatrix.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 23: ethereum.eth.v1alpha1.BeaconStateBellatrix.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 24: ethereum.eth.v1alpha1.BeaconStateBellatrix.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 25: ethereum.eth.v1alpha1.BeaconStateBellatrix.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 26: ethereum.eth.v1alpha1.BeaconStateBellatrix.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	23,  // 27: ethereum.eth.v1alpha1.BeaconStateBellatrix.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 28: ethereum.eth.v1alpha1.BeaconStateBellatrix.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 29: ethereum.eth.v1alpha1.BeaconStateBellatrix.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	11,  // 30: ethereum.eth.v1alpha1.BeaconStateBellatrix.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	11,  // 31: ethereum.eth.v1alpha1.BeaconStateBellatrix.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	25,  // 32: ethereum.eth.v1alpha1.BeaconStateBellatrix.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeader
+	1,   // 33: ethereum.eth.v1alpha1.BeaconStateCapella.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 34: ethereum.eth.v1alpha1.BeaconStateCapella.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 35: ethereum.eth.v1alpha1.BeaconStateCapella.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 36: ethereum.eth.v1alpha1.BeaconStateCapella.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 37: ethereum.eth.v1alpha1.BeaconStateCapella.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	23,  // 38: ethereum.eth.v1alpha1.BeaconStateCapella.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 39: ethereum.eth.v1alpha1.BeaconStateCapella.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 40: ethereum.eth.v1alpha1.BeaconStateCapella.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	11,  // 41: ethereum.eth.v1alpha1.BeaconStateCapella.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	11,  // 42: ethereum.eth.v1alpha1.BeaconStateCapella.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	26,  // 43: ethereum.eth.v1alpha1.BeaconStateCapella.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderCapella
+	15,  // 44: ethereum.eth.v1alpha1.BeaconStateCapella.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
+	1,   // 45: ethereum.eth.v1alpha1.BeaconStateDeneb.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 46: ethereum.eth.v1alpha1.BeaconStateDeneb.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 47: ethereum.eth.v1alpha1.BeaconStateDeneb.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 48: ethereum.eth.v1alpha1.BeaconStateDeneb.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 49: ethereum.eth.v1alpha1.BeaconStateDeneb.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	23,  // 50: ethereum.eth.v1alpha1.BeaconStateDeneb.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 51: ethereum.eth.v1alpha1.BeaconStateDeneb.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 52: ethereum.eth.v1alpha1.BeaconStateDeneb.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	11,  // 53: ethereum.eth.v1alpha1.BeaconStateDeneb.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	11,  // 54: ethereum.eth.v1alpha1.BeaconStateDeneb.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	27,  // 55: ethereum.eth.v1alpha1.BeaconStateDeneb.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
+	15,  // 56: ethereum.eth.v1alpha1.BeaconStateDeneb.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
+	1,   // 57: ethereum.eth.v1alpha1.BeaconStateElectra.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 58: ethereum.eth.v1alpha1.BeaconStateElectra.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 59: ethereum.eth.v1alpha1.BeaconStateElectra.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 60: ethereum.eth.v1alpha1.BeaconStateElectra.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 61: ethereum.eth.v1alpha1.BeaconStateElectra.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	23,  // 62: ethereum.eth.v1alpha1.BeaconStateElectra.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 63: ethereum.eth.v1alpha1.BeaconStateElectra.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 64: ethereum.eth.v1alpha1.BeaconStateElectra.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	11,  // 65: ethereum.eth.v1alpha1.BeaconStateElectra.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	11,  // 66: ethereum.eth.v1alpha1.BeaconStateElectra.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	27,  // 67: ethereum.eth.v1alpha1.BeaconStateElectra.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
+	15,  // 68: ethereum.eth.v1alpha1.BeaconStateElectra.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
+	28,  // 69: ethereum.eth.v1alpha1.BeaconStateElectra.pending_deposits:type_name -> ethereum.eth.v1alpha1.PendingDeposit
+	29,  // 70: ethereum.eth.v1alpha1.BeaconStateElectra.pending_partial_withdrawals:type_name -> ethereum.eth.v1alpha1.PendingPartialWithdrawal
+	30,  // 71: ethereum.eth.v1alpha1.BeaconStateElectra.pending_consolidations:type_name -> ethereum.eth.v1alpha1.PendingConsolidation
+	1,   // 72: ethereum.eth.v1alpha1.BeaconStateFulu.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 73: ethereum.eth.v1alpha1.BeaconStateFulu.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 74: ethereum.eth.v1alpha1.BeaconStateFulu.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 75: ethereum.eth.v1alpha1.BeaconStateFulu.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 76: ethereum.eth.v1alpha1.BeaconStateFulu.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	23,  // 77: ethereum.eth.v1alpha1.BeaconStateFulu.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 78: ethereum.eth.v1alpha1.BeaconStateFulu.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 79: ethereum.eth.v1alpha1.BeaconStateFulu.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	11,  // 80: ethereum.eth.v1alpha1.BeaconStateFulu.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	11,  // 81: ethereum.eth.v1alpha1.BeaconStateFulu.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	27,  // 82: ethereum.eth.v1alpha1.BeaconStateFulu.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderDeneb
+	15,  // 83: ethereum.eth.v1alpha1.BeaconStateFulu.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
+	28,  // 84: ethereum.eth.v1alpha1.BeaconStateFulu.pending_deposits:type_name -> ethereum.eth.v1alpha1.PendingDeposit
+	29,  // 85: ethereum.eth.v1alpha1.BeaconStateFulu.pending_partial_withdrawals:type_name -> ethereum.eth.v1alpha1.PendingPartialWithdrawal
+	30,  // 86: ethereum.eth.v1alpha1.BeaconStateFulu.pending_consolidations:type_name -> ethereum.eth.v1alpha1.PendingConsolidation
+	1,   // 87: ethereum.eth.v1alpha1.BeaconStateGloas.fork:type_name -> ethereum.eth.v1alpha1.Fork
+	20,  // 88: ethereum.eth.v1alpha1.BeaconStateGloas.latest_block_header:type_name -> ethereum.eth.v1alpha1.BeaconBlockHeader
+	21,  // 89: ethereum.eth.v1alpha1.BeaconStateGloas.eth1_data:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	21,  // 90: ethereum.eth.v1alpha1.BeaconStateGloas.eth1_data_votes:type_name -> ethereum.eth.v1alpha1.Eth1Data
+	22,  // 91: ethereum.eth.v1alpha1.BeaconStateGloas.validators:type_name -> ethereum.eth.v1alpha1.Validator
+	23,  // 92: ethereum.eth.v1alpha1.BeaconStateGloas.previous_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 93: ethereum.eth.v1alpha1.BeaconStateGloas.current_justified_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	23,  // 94: ethereum.eth.v1alpha1.BeaconStateGloas.finalized_checkpoint:type_name -> ethereum.eth.v1alpha1.Checkpoint
+	11,  // 95: ethereum.eth.v1alpha1.BeaconStateGloas.current_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	11,  // 96: ethereum.eth.v1alpha1.BeaconStateGloas.next_sync_committee:type_name -> ethereum.eth.v1alpha1.SyncCommittee
+	31,  // 97: ethereum.eth.v1alpha1.BeaconStateGloas.latest_execution_payload_header:type_name -> ethereum.engine.v1.ExecutionPayloadHeaderGloas
+	15,  // 98: ethereum.eth.v1alpha1.BeaconStateGloas.historical_summaries:type_name -> ethereum.eth.v1alpha1.HistoricalSummary
+	28,  // 99: ethereum.eth.v1alpha1.BeaconStateGloas.pending_deposits:type_name -> ethereum.eth.v1alpha1.PendingDeposit
+	29,  // 100: ethereum.eth.v1alpha1.BeaconStateGloas.pending_partial_withdrawals:type_name -> ethereum.eth.v1alpha1.PendingPartialWithdrawal
+	30,  // 101: ethereum.eth.v1alpha1.BeaconStateGloas.pending_consolidations:type_name -> ethereum.eth.v1alpha1.PendingConsolidation
+	102, // [102:102] is the sub-list for method output_type
+	102, // [102:102] is the sub-list for method input_type
+	102, // [102:102] is the sub-list for extension type_name
+	102, // [102:102] is the sub-list for extension extendee
+	0,   // [0:102] is the sub-list for field type_name
 }
 
 func init() { file_proto_prysm_v1alpha1_beacon_state_proto_init() }
@@ -4170,6 +4737,18 @@ func file_proto_prysm_v1alpha1_beacon_state_proto_init() {
 				return nil
 			}
 		}
+		file_proto_prysm_v1alpha1_beacon_state_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*BeaconStateGloas); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -4177,7 +4756,7 @@ func file_proto_prysm_v1alpha1_beacon_state_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_prysm_v1alpha1_beacon_state_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   19,
+			NumMessages:   20,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/prysm/v1alpha1/beacon_state.proto

@@ -748,3 +748,119 @@ message BeaconStateFulu {
   repeated uint64 proposer_lookahead = 13001
       [ (ethereum.eth.ext.ssz_size) = "proposer_lookahead_size" ];
 }
+
+// ----------------------------------------------------------------------------
+// Gloas
+// ----------------------------------------------------------------------------
+
+message BeaconStateGloas {
+  // Versioning [1001-2000]
+  uint64 genesis_time = 1001;
+  bytes genesis_validators_root = 1002 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  uint64 slot = 1003 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"
+  ];
+  Fork fork = 1004;
+
+  // History [2001-3000]
+  BeaconBlockHeader latest_block_header = 2001;
+  repeated bytes block_roots = 2002
+      [ (ethereum.eth.ext.ssz_size) = "block_roots.size" ];
+  repeated bytes state_roots = 2003
+      [ (ethereum.eth.ext.ssz_size) = "state_roots.size" ];
+  repeated bytes historical_roots = 2004 [
+    (ethereum.eth.ext.ssz_size) = "?,32",
+    (ethereum.eth.ext.ssz_max) = "16777216"
+  ];
+
+  // Eth1 [3001-4000]
+  Eth1Data eth1_data = 3001;
+  repeated Eth1Data eth1_data_votes = 3002
+      [ (ethereum.eth.ext.ssz_max) = "eth1_data_votes.size" ];
+  uint64 eth1_deposit_index = 3003;
+
+  // Registry [4001-5000]
+  repeated Validator validators = 4001
+      [ (ethereum.eth.ext.ssz_max) = "1099511627776" ];
+  repeated uint64 balances = 4002
+      [ (ethereum.eth.ext.ssz_max) = "1099511627776" ];
+
+  // Randomness [5001-6000]
+  repeated bytes randao_mixes = 5001
+      [ (ethereum.eth.ext.ssz_size) = "randao_mixes.size" ];
+
+  // Slashings [6001-7000]
+  repeated uint64 slashings = 6001
+      [ (ethereum.eth.ext.ssz_size) = "slashings.size" ];
+
+  // Participation [7001-8000]
+  bytes previous_epoch_participation = 7001
+      [ (ethereum.eth.ext.ssz_max) = "1099511627776" ];
+  bytes current_epoch_participation = 7002
+      [ (ethereum.eth.ext.ssz_max) = "1099511627776" ];
+
+  // Finality [8001-9000]
+  // Spec type [4]Bitvector which means this would be a fixed size of 4 bits.
+  bytes justification_bits = 8001 [
+    (ethereum.eth.ext.ssz_size) = "1",
+    (ethereum.eth.ext.cast_type) =
+        "github.com/prysmaticlabs/go-bitfield.Bitvector4"
+  ];
+  Checkpoint previous_justified_checkpoint = 8002;
+  Checkpoint current_justified_checkpoint = 8003;
+  Checkpoint finalized_checkpoint = 8004;
+
+  // Fields introduced in Altair fork [9001-10000]
+  repeated uint64 inactivity_scores = 9001
+      [ (ethereum.eth.ext.ssz_max) = "1099511627776" ];
+  SyncCommittee current_sync_committee = 9002;
+  SyncCommittee next_sync_committee = 9003;
+
+  // Fields introduced in Bellatrix fork [10001-11000]
+  // [Modified in EIP7928] - Gloas uses ExecutionPayloadHeaderGloas
+  ethereum.engine.v1.ExecutionPayloadHeaderGloas
+      latest_execution_payload_header = 10001;
+
+  // Fields introduced in Capella fork [11001-12000]
+  uint64 next_withdrawal_index = 11001;
+  uint64 next_withdrawal_validator_index = 11002
+      [ (ethereum.eth.ext.cast_type) =
+            "github.com/OffchainLabs/prysm/v6/consensus-types/"
+            "primitives.ValidatorIndex" ];
+  repeated HistoricalSummary historical_summaries = 11003
+      [ (ethereum.eth.ext.ssz_max) = "16777216" ];
+
+  // Fields introduced in Electra fork [12001-13000]
+  uint64 deposit_requests_start_index = 12001;
+  uint64 deposit_balance_to_consume = 12002 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Gwei"
+  ];
+  uint64 exit_balance_to_consume = 12003 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Gwei"
+  ];
+  uint64 earliest_exit_epoch = 12004 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Epoch"
+  ];
+  uint64 consolidation_balance_to_consume = 12005 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Gwei"
+  ];
+  uint64 earliest_consolidation_epoch = 12006 [
+    (ethereum.eth.ext.cast_type) =
+        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Epoch"
+  ];
+  repeated PendingDeposit pending_deposits = 12007
+      [ (ethereum.eth.ext.ssz_max) = "pending_deposits_limit" ];
+  repeated PendingPartialWithdrawal pending_partial_withdrawals = 12008
+      [ (ethereum.eth.ext.ssz_max) = "pending_partial_withdrawals_limit" ];
+  repeated PendingConsolidation pending_consolidations = 12009
+      [ (ethereum.eth.ext.ssz_max) = "pending_consolidations_limit" ];
+
+  // Fields introduced in Fulu fork [13001-14000]
+  repeated uint64 proposer_lookahead = 13001
+      [ (ethereum.eth.ext.ssz_size) = "proposer_lookahead_size" ];
+}

proto/prysm/v1alpha1/validator-client/keymanager.pb.go

@@ -109,6 +109,7 @@ type SignRequest struct {
 	//	*SignRequest_AggregateAttestationAndProofElectra
 	//	*SignRequest_BlockFulu
 	//	*SignRequest_BlindedBlockFulu
+	//	*SignRequest_BlockGloas
 	Object      isSignRequest_Object                                             `protobuf_oneof:"object"`
 	SigningSlot github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot `protobuf:"varint,6,opt,name=signing_slot,json=signingSlot,proto3" json:"signing_slot,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"`
 }
@@ -327,6 +328,13 @@ func (x *SignRequest) GetBlindedBlockFulu() *v1alpha1.BlindedBeaconBlockFulu {
 	return nil
 }
 
+func (x *SignRequest) GetBlockGloas() *v1alpha1.BeaconBlockGloas {
+	if x, ok := x.GetObject().(*SignRequest_BlockGloas); ok {
+		return x.BlockGloas
+	}
+	return nil
+}
+
 func (x *SignRequest) GetSigningSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
 	if x != nil {
 		return x.SigningSlot
@@ -426,6 +434,10 @@ type SignRequest_BlindedBlockFulu struct {
 	BlindedBlockFulu *v1alpha1.BlindedBeaconBlockFulu `protobuf:"bytes,122,opt,name=blinded_block_fulu,json=blindedBlockFulu,proto3,oneof"`
 }
 
+type SignRequest_BlockGloas struct {
+	BlockGloas *v1alpha1.BeaconBlockGloas `protobuf:"bytes,123,opt,name=block_gloas,json=blockGloas,proto3,oneof"`
+}
+
 func (*SignRequest_Block) isSignRequest_Object() {}
 
 func (*SignRequest_AttestationData) isSignRequest_Object() {}
@@ -470,6 +482,8 @@ func (*SignRequest_BlockFulu) isSignRequest_Object() {}
 
 func (*SignRequest_BlindedBlockFulu) isSignRequest_Object() {}
 
+func (*SignRequest_BlockGloas) isSignRequest_Object() {}
+
 type SignResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -726,7 +740,7 @@ var file_proto_prysm_v1alpha1_validator_client_keymanager_proto_rawDesc = []byte
 	0x63, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
 	0x29, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61,
 	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69,
-	0x74, 0x74, 0x65, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe5, 0x11, 0x0a, 0x0b, 0x53,
+	0x74, 0x74, 0x65, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb1, 0x12, 0x0a, 0x0b, 0x53,
 	0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75,
 	0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09,
 	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x69, 0x67,
@@ -861,84 +875,89 @@ var file_proto_prysm_v1alpha1_validator_client_keymanager_proto_rawDesc = []byte
 	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64,
 	0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x75, 0x6c, 0x75, 0x48,
 	0x00, 0x52, 0x10, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x46,
-	0x75, 0x6c, 0x75, 0x12, 0x67, 0x0a, 0x0c, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x73,
-	0x6c, 0x6f, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61,
-	0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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,
-	0x0b, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x6c, 0x6f, 0x74, 0x42, 0x08, 0x0a, 0x06,
-	0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, 0x04, 0x08, 0x05,
-	0x10, 0x06, 0x22, 0xb7, 0x01, 0x0a, 0x0c, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
-	0x65, 0x12, 0x4b, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0e, 0x32, 0x33, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e,
-	0x76, 0x32, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e,
-	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3c,
-	0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e,
-	0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44,
-	0x45, 0x44, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x44, 0x45, 0x4e, 0x49, 0x45, 0x44, 0x10, 0x02,
-	0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x03, 0x22, 0xb3, 0x01, 0x0a,
-	0x15, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x50,
-	0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x65,
-	0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66,
-	0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x47, 0x0a, 0x07, 0x62,
-	0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x65,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
-	0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x75,
-	0x69, 0x6c, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x07, 0x62, 0x75, 0x69,
-	0x6c, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x08, 0x67, 0x72, 0x61, 0x66, 0x66, 0x69, 0x74, 0x69,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x67, 0x72, 0x61, 0x66, 0x66, 0x69,
-	0x74, 0x69, 0x88, 0x01, 0x01, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x67, 0x72, 0x61, 0x66, 0x66, 0x69,
-	0x74, 0x69, 0x22, 0xa5, 0x01, 0x0a, 0x0d, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x43, 0x6f,
-	0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x62,
-	0x0a, 0x09, 0x67, 0x61, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
-	0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70,
-	0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75,
-	0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
-	0x72, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x08, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d,
-	0x69, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x73, 0x18, 0x03, 0x20, 0x03,
-	0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x73, 0x22, 0xe7, 0x02, 0x0a, 0x17, 0x50,
-	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x50,
-	0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x74, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73,
-	0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x4b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32,
-	0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67,
-	0x73, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65,
-	0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x70, 0x72,
-	0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x5c, 0x0a, 0x0e,
-	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e,
-	0x74, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x4f, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x0d, 0x64, 0x65, 0x66,
-	0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a, 0x78, 0x0a, 0x13, 0x50, 0x72,
-	0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72,
-	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
-	0x6b, 0x65, 0x79, 0x12, 0x4b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x35, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73,
-	0x2e, 0x76, 0x32, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x3a, 0x02, 0x38, 0x01, 0x42, 0xcd, 0x01, 0x0a, 0x22, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e,
-	0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32, 0x42, 0x0f, 0x4b, 0x65, 0x79,
-	0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x52,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68,
-	0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36,
-	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61,
-	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2d,
-	0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
-	0x70, 0x62, 0xaa, 0x02, 0x1e, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x56, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73,
-	0x2e, 0x56, 0x32, 0xca, 0x02, 0x1e, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x56,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5c, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74,
-	0x73, 0x5c, 0x56, 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x75, 0x6c, 0x75, 0x12, 0x4a, 0x0a, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x67, 0x6c, 0x6f,
+	0x61, 0x73, 0x18, 0x7b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
+	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
+	0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x47, 0x6c, 0x6f, 0x61,
+	0x73, 0x48, 0x00, 0x52, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x47, 0x6c, 0x6f, 0x61, 0x73, 0x12,
+	0x67, 0x0a, 0x0c, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68, 0x75,
+	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61,
+	0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x0b, 0x73, 0x69, 0x67,
+	0x6e, 0x69, 0x6e, 0x67, 0x53, 0x6c, 0x6f, 0x74, 0x42, 0x08, 0x0a, 0x06, 0x6f, 0x62, 0x6a, 0x65,
+	0x63, 0x74, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x22, 0xb7,
+	0x01, 0x0a, 0x0c, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x4b, 0x0a,
+	0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x33, 0x2e,
+	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x53,
+	0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x74, 0x61, 0x74,
+	0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3c, 0x0a, 0x06, 0x53, 0x74,
+	0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10,
+	0x00, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x01,
+	0x12, 0x0a, 0x0a, 0x06, 0x44, 0x45, 0x4e, 0x49, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06,
+	0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x03, 0x22, 0xb3, 0x01, 0x0a, 0x15, 0x50, 0x72, 0x6f,
+	0x70, 0x6f, 0x73, 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f,
+	0x61, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69,
+	0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66, 0x65, 0x65, 0x52, 0x65,
+	0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x47, 0x0a, 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64,
+	0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
+	0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63,
+	0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65,
+	0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72,
+	0x12, 0x1f, 0x0a, 0x08, 0x67, 0x72, 0x61, 0x66, 0x66, 0x69, 0x74, 0x69, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x67, 0x72, 0x61, 0x66, 0x66, 0x69, 0x74, 0x69, 0x88, 0x01,
+	0x01, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x67, 0x72, 0x61, 0x66, 0x66, 0x69, 0x74, 0x69, 0x22, 0xa5,
+	0x01, 0x0a, 0x0d, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
+	0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x62, 0x0a, 0x09, 0x67, 0x61,
+	0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82,
+	0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66,
+	0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d,
+	0x2f, 0x76, 0x36, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x55, 0x69,
+	0x6e, 0x74, 0x36, 0x34, 0x52, 0x08, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x16,
+	0x0a, 0x06, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06,
+	0x72, 0x65, 0x6c, 0x61, 0x79, 0x73, 0x22, 0xe7, 0x02, 0x0a, 0x17, 0x50, 0x72, 0x6f, 0x70, 0x6f,
+	0x73, 0x65, 0x72, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x50, 0x61, 0x79, 0x6c, 0x6f,
+	0x61, 0x64, 0x12, 0x74, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x63,
+	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4b, 0x2e, 0x65, 0x74,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32, 0x2e, 0x50, 0x72, 0x6f,
+	0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x50, 0x61, 0x79,
+	0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x43, 0x6f, 0x6e,
+	0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+	0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x5c, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61,
+	0x75, 0x6c, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x35, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76,
+	0x32, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a, 0x78, 0x0a, 0x13, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+	0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x4b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35,
+	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32, 0x2e,
+	0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61,
+	0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x42, 0xcd, 0x01, 0x0a, 0x22, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x61, 0x63, 0x63, 0x6f,
+	0x75, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x32, 0x42, 0x0f, 0x4b, 0x65, 0x79, 0x6d, 0x61, 0x6e, 0x61,
+	0x67, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x52, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c,
+	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2d, 0x63, 0x6c, 0x69, 0x65,
+	0x6e, 0x74, 0x3b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x70, 0x62, 0xaa, 0x02,
+	0x1e, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x56, 0x32, 0xca,
+	0x02, 0x1e, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x5c, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5c, 0x56, 0x32,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -981,6 +1000,7 @@ var file_proto_prysm_v1alpha1_validator_client_keymanager_proto_goTypes = []inte
 	(*v1alpha1.BlindedBeaconBlockElectra)(nil),           // 22: ethereum.eth.v1alpha1.BlindedBeaconBlockElectra
 	(*v1alpha1.AggregateAttestationAndProofElectra)(nil), // 23: ethereum.eth.v1alpha1.AggregateAttestationAndProofElectra
 	(*v1alpha1.BlindedBeaconBlockFulu)(nil),              // 24: ethereum.eth.v1alpha1.BlindedBeaconBlockFulu
+	(*v1alpha1.BeaconBlockGloas)(nil),                    // 25: ethereum.eth.v1alpha1.BeaconBlockGloas
 }
 var file_proto_prysm_v1alpha1_validator_client_keymanager_proto_depIdxs = []int32{
 	7,  // 0: ethereum.validator.accounts.v2.SignRequest.block:type_name -> ethereum.eth.v1alpha1.BeaconBlock
@@ -1002,16 +1022,17 @@ var file_proto_prysm_v1alpha1_validator_client_keymanager_proto_depIdxs = []int3
 	23, // 16: ethereum.validator.accounts.v2.SignRequest.aggregate_attestation_and_proof_electra:type_name -> ethereum.eth.v1alpha1.AggregateAttestationAndProofElectra
 	21, // 17: ethereum.validator.accounts.v2.SignRequest.block_fulu:type_name -> ethereum.eth.v1alpha1.BeaconBlockElectra
 	24, // 18: ethereum.validator.accounts.v2.SignRequest.blinded_block_fulu:type_name -> ethereum.eth.v1alpha1.BlindedBeaconBlockFulu
-	0,  // 19: ethereum.validator.accounts.v2.SignResponse.status:type_name -> ethereum.validator.accounts.v2.SignResponse.Status
-	4,  // 20: ethereum.validator.accounts.v2.ProposerOptionPayload.builder:type_name -> ethereum.validator.accounts.v2.BuilderConfig
-	6,  // 21: ethereum.validator.accounts.v2.ProposerSettingsPayload.proposer_config:type_name -> ethereum.validator.accounts.v2.ProposerSettingsPayload.ProposerConfigEntry
-	3,  // 22: ethereum.validator.accounts.v2.ProposerSettingsPayload.default_config:type_name -> ethereum.validator.accounts.v2.ProposerOptionPayload
-	3,  // 23: ethereum.validator.accounts.v2.ProposerSettingsPayload.ProposerConfigEntry.value:type_name -> ethereum.validator.accounts.v2.ProposerOptionPayload
-	24, // [24:24] is the sub-list for method output_type
-	24, // [24:24] is the sub-list for method input_type
-	24, // [24:24] is the sub-list for extension type_name
-	24, // [24:24] is the sub-list for extension extendee
-	0,  // [0:24] is the sub-list for field type_name
+	25, // 19: ethereum.validator.accounts.v2.SignRequest.block_gloas:type_name -> ethereum.eth.v1alpha1.BeaconBlockGloas
+	0,  // 20: ethereum.validator.accounts.v2.SignResponse.status:type_name -> ethereum.validator.accounts.v2.SignResponse.Status
+	4,  // 21: ethereum.validator.accounts.v2.ProposerOptionPayload.builder:type_name -> ethereum.validator.accounts.v2.BuilderConfig
+	6,  // 22: ethereum.validator.accounts.v2.ProposerSettingsPayload.proposer_config:type_name -> ethereum.validator.accounts.v2.ProposerSettingsPayload.ProposerConfigEntry
+	3,  // 23: ethereum.validator.accounts.v2.ProposerSettingsPayload.default_config:type_name -> ethereum.validator.accounts.v2.ProposerOptionPayload
+	3,  // 24: ethereum.validator.accounts.v2.ProposerSettingsPayload.ProposerConfigEntry.value:type_name -> ethereum.validator.accounts.v2.ProposerOptionPayload
+	25, // [25:25] is the sub-list for method output_type
+	25, // [25:25] is the sub-list for method input_type
+	25, // [25:25] is the sub-list for extension type_name
+	25, // [25:25] is the sub-list for extension extendee
+	0,  // [0:25] is the sub-list for field type_name
 }
 
 func init() { file_proto_prysm_v1alpha1_validator_client_keymanager_proto_init() }
@@ -1104,6 +1125,7 @@ func file_proto_prysm_v1alpha1_validator_client_keymanager_proto_init() {
 		(*SignRequest_AggregateAttestationAndProofElectra)(nil),
 		(*SignRequest_BlockFulu)(nil),
 		(*SignRequest_BlindedBlockFulu)(nil),
+		(*SignRequest_BlockGloas)(nil),
 	}
 	file_proto_prysm_v1alpha1_validator_client_keymanager_proto_msgTypes[2].OneofWrappers = []interface{}{}
 	type x struct{}

proto/prysm/v1alpha1/validator-client/keymanager.proto

@@ -79,6 +79,8 @@ message SignRequest {
     // Fulu objects.
     ethereum.eth.v1alpha1.BeaconBlockElectra block_fulu = 121;
     ethereum.eth.v1alpha1.BlindedBeaconBlockFulu blinded_block_fulu = 122;
+
+    ethereum.eth.v1alpha1.BeaconBlockGloas block_gloas = 123;
   }
 
   reserved 4, 5; // Reserving old, deleted fields.

runtime/version/fork.go

@@ -14,6 +14,7 @@ const (
 	Deneb
 	Electra
 	Fulu
+	Gloas
 )
 
 var versionToString = map[int]string{
@@ -24,6 +25,7 @@ var versionToString = map[int]string{
 	Deneb:     "deneb",
 	Electra:   "electra",
 	Fulu:      "fulu",
+	Gloas:     "gloas",
 }
 
 // stringToVersion and allVersions are populated in init()

specrefs/functions.yml

@@ -3737,8 +3737,6 @@
   sources:
     - file: beacon-chain/core/validators/validator.go
       search: func InitiateValidatorExit(
-    - file: beacon-chain/core/validators/validator.go
-      search: if s.Version() < version.Electra {
   spec: |
     <spec fn="initiate_validator_exit" fork="phase0" hash="0483a058">
     def initiate_validator_exit(state: BeaconState, index: ValidatorIndex) -> None:

validator/client/beacon-api/BUILD.bazel

@@ -91,18 +91,6 @@ go_test(
         "index_test.go",
         "prepare_beacon_proposer_test.go",
         "propose_attestation_test.go",
-        "propose_beacon_block_altair_test.go",
-        "propose_beacon_block_bellatrix_test.go",
-        "propose_beacon_block_blinded_bellatrix_test.go",
-        "propose_beacon_block_blinded_capella_test.go",
-        "propose_beacon_block_blinded_deneb_test.go",
-        "propose_beacon_block_blinded_electra_test.go",
-        "propose_beacon_block_blinded_fulu_test.go",
-        "propose_beacon_block_capella_test.go",
-        "propose_beacon_block_deneb_test.go",
-        "propose_beacon_block_electra_test.go",
-        "propose_beacon_block_fulu_test.go",
-        "propose_beacon_block_phase0_test.go",
         "propose_beacon_block_test.go",
         "propose_exit_test.go",
         "prysm_beacon_chain_client_test.go",

validator/client/beacon-api/beacon_api_validator_client_test.go

@@ -1,14 +1,18 @@
 package beacon_api
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
+	"net/http"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
+	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/httputil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -136,15 +140,14 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockValid(t *testing.T) {
 	ctx := t.Context()
 
 	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	jsonRestHandler.EXPECT().PostSSZ(
 		gomock.Any(),
 		"/eth/v2/beacon/blocks",
-		map[string]string{"Eth-Consensus-Version": "phase0"},
 		gomock.Any(),
-		nil,
+		gomock.Any(),
 	).Return(
-		nil,
-	).Times(2)
+		nil, nil, nil,
+	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	expectedResp, expectedErr := validatorClient.proposeBeaconBlock(
@@ -153,34 +156,38 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockValid(t *testing.T) {
 			Block: generateSignedPhase0Block(),
 		},
 	)
-
-	resp, err := validatorClient.ProposeBeaconBlock(
-		ctx,
-		&ethpb.GenericSignedBeaconBlock{
-			Block: generateSignedPhase0Block(),
-		},
-	)
-
-	assert.DeepEqual(t, expectedErr, err)
-	assert.DeepEqual(t, expectedResp, resp)
+	require.NoError(t, expectedErr)
+	require.NotNil(t, expectedResp)
 }
 
-func TestBeaconApiValidatorClient_ProposeBeaconBlockError(t *testing.T) {
+func TestBeaconApiValidatorClient_ProposeBeaconBlockError_ThenPass(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
 	ctx := t.Context()
 
 	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().PostSSZ(
+		gomock.Any(),
+		"/eth/v2/beacon/blocks",
+		gomock.Any(),
+		gomock.Any(),
+	).Return(
+		nil, nil, &httputil.DefaultJsonError{
+			Code:    http.StatusNotAcceptable,
+			Message: "SSZ not supported",
+		},
+	).Times(1)
+
 	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v2/beacon/blocks",
-		map[string]string{"Eth-Consensus-Version": "phase0"},
 		gomock.Any(),
-		nil,
+		gomock.Any(),
+		gomock.Any(),
 	).Return(
-		errors.New("foo error"),
-	).Times(2)
+		nil,
+	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	expectedResp, expectedErr := validatorClient.proposeBeaconBlock(
@@ -189,16 +196,351 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockError(t *testing.T) {
 			Block: generateSignedPhase0Block(),
 		},
 	)
+	require.NoError(t, expectedErr)
+	require.NotNil(t, expectedResp)
+}
 
-	resp, err := validatorClient.ProposeBeaconBlock(
-		ctx,
-		&ethpb.GenericSignedBeaconBlock{
-			Block: generateSignedPhase0Block(),
+func TestBeaconApiValidatorClient_ProposeBeaconBlockAllTypes(t *testing.T) {
+	tests := []struct {
+		name          string
+		block         *ethpb.GenericSignedBeaconBlock
+		expectedPath  string
+		wantErr       bool
+		errorMessage string
+	}{
+		{
+			name: "Phase0 block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedPhase0Block(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
 		},
-	)
+		{
+			name: "Altair block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedAltairBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Bellatrix block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBellatrixBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Capella block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedCapellaBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Bellatrix block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedBellatrixBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Blinded Capella block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedCapellaBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Deneb block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedDenebBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Deneb block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedDenebBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Electra block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedElectraBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Electra block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedElectraBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Fulu block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedFuluBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Fulu block",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedFuluBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Unsupported block type",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: nil,
+			},
+			wantErr:      true,
+			errorMessage: "unsupported block type",
+		},
+	}
 
-	assert.ErrorContains(t, expectedErr.Error(), err)
-	assert.DeepEqual(t, expectedResp, resp)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			ctx := t.Context()
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			if !tt.wantErr {
+				jsonRestHandler.EXPECT().PostSSZ(
+					gomock.Any(),
+					tt.expectedPath,
+					gomock.Any(),
+					gomock.Any(),
+				).Return(nil, nil, nil).Times(1)
+			}
+
+			validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			resp, err := validatorClient.proposeBeaconBlock(ctx, tt.block)
+
+			if tt.wantErr {
+				require.ErrorContains(t, tt.errorMessage, err)
+				assert.Equal(t, (*ethpb.ProposeResponse)(nil), resp)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+			}
+		})
+	}
+}
+
+func TestBeaconApiValidatorClient_ProposeBeaconBlockHTTPErrors(t *testing.T) {
+	tests := []struct {
+		name         string
+		sszError     error
+		expectJSON   bool
+		errorMessage string
+	}{
+		{
+			name: "HTTP 202 Accepted - block broadcast but failed validation",
+			sszError: &httputil.DefaultJsonError{
+				Code:    http.StatusAccepted,
+				Message: "block broadcast but failed validation",
+			},
+			expectJSON:   false, // No fallback for non-406 errors
+			errorMessage: "failed to submit block ssz",
+		},
+		{
+			name: "Other HTTP error",
+			sszError: &httputil.DefaultJsonError{
+				Code:    http.StatusBadRequest,
+				Message: "bad request",
+			},
+			expectJSON:   false, // No fallback for non-406 errors
+			errorMessage: "failed to submit block ssz",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			ctx := t.Context()
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			jsonRestHandler.EXPECT().PostSSZ(
+				gomock.Any(),
+				"/eth/v2/beacon/blocks",
+				gomock.Any(),
+				gomock.Any(),
+			).Return(nil, nil, tt.sszError).Times(1)
+			
+			if tt.expectJSON {
+				// When SSZ fails, it falls back to JSON
+				jsonRestHandler.EXPECT().Post(
+					gomock.Any(),
+					"/eth/v2/beacon/blocks",
+					gomock.Any(),
+					gomock.Any(),
+					gomock.Any(),
+				).Return(tt.sszError).Times(1)
+			}
+
+			validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			_, err := validatorClient.proposeBeaconBlock(
+				ctx,
+				&ethpb.GenericSignedBeaconBlock{
+					Block: generateSignedPhase0Block(),
+				},
+			)
+			require.ErrorContains(t, tt.errorMessage, err)
+		})
+	}
+}
+
+func TestBeaconApiValidatorClient_ProposeBeaconBlockJSONFallback(t *testing.T) {
+	tests := []struct {
+		name         string
+		block        *ethpb.GenericSignedBeaconBlock
+		expectedPath string
+		jsonError    error
+		wantErr      bool
+	}{
+		{
+			name: "Phase0 block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedPhase0Block(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Altair block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedAltairBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Bellatrix block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBellatrixBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Capella block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedCapellaBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Bellatrix block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedBellatrixBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Blinded Capella block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedCapellaBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Deneb block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedDenebBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Deneb block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedDenebBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Electra block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedElectraBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Electra block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedElectraBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "Fulu block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedFuluBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+		},
+		{
+			name: "Blinded Fulu block JSON fallback success",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedBlindedFuluBlock(),
+			},
+			expectedPath: "/eth/v2/beacon/blinded_blocks",
+		},
+		{
+			name: "JSON fallback fails",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedPhase0Block(),
+			},
+			expectedPath: "/eth/v2/beacon/blocks",
+			jsonError:    errors.New("json post failed"),
+			wantErr:      true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			ctx := t.Context()
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			// SSZ call fails with 406 to trigger JSON fallback
+			jsonRestHandler.EXPECT().PostSSZ(
+				gomock.Any(),
+				tt.expectedPath,
+				gomock.Any(),
+				gomock.Any(),
+			).Return(nil, nil, &httputil.DefaultJsonError{
+				Code:    http.StatusNotAcceptable,
+				Message: "SSZ not supported",
+			}).Times(1)
+
+			// JSON fallback
+			jsonRestHandler.EXPECT().Post(
+				gomock.Any(),
+				tt.expectedPath,
+				gomock.Any(),
+				gomock.Any(),
+				gomock.Any(),
+			).Return(tt.jsonError).Times(1)
+
+			validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			resp, err := validatorClient.proposeBeaconBlock(ctx, tt.block)
+
+			if tt.wantErr {
+				assert.NotNil(t, err)
+				assert.Equal(t, (*ethpb.ProposeResponse)(nil), resp)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+			}
+		})
+	}
 }
 
 func TestBeaconApiValidatorClient_Host(t *testing.T) {
@@ -229,3 +571,88 @@ func TestBeaconApiValidatorClient_Host(t *testing.T) {
 	host = validatorClient.Host()
 	require.Equal(t, hosts[1], host)
 }
+
+// Helper functions for generating test blocks for newer consensus versions
+func generateSignedDenebBlock() *ethpb.GenericSignedBeaconBlock_Deneb {
+	var blockContents structs.SignedBeaconBlockContentsDeneb
+	if err := json.Unmarshal([]byte(rpctesting.DenebBlockContents), &blockContents); err != nil {
+		panic(err)
+	}
+	genericBlock, err := blockContents.ToGeneric()
+	if err != nil {
+		panic(err)
+	}
+	return &ethpb.GenericSignedBeaconBlock_Deneb{
+		Deneb: genericBlock.GetDeneb(),
+	}
+}
+
+func generateSignedBlindedDenebBlock() *ethpb.GenericSignedBeaconBlock_BlindedDeneb {
+	var blindedBlock structs.SignedBlindedBeaconBlockDeneb
+	if err := json.Unmarshal([]byte(rpctesting.BlindedDenebBlock), &blindedBlock); err != nil {
+		panic(err)
+	}
+	genericBlock, err := blindedBlock.ToGeneric()
+	if err != nil {
+		panic(err)
+	}
+	return &ethpb.GenericSignedBeaconBlock_BlindedDeneb{
+		BlindedDeneb: genericBlock.GetBlindedDeneb(),
+	}
+}
+
+func generateSignedElectraBlock() *ethpb.GenericSignedBeaconBlock_Electra {
+	var blockContents structs.SignedBeaconBlockContentsElectra
+	if err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blockContents); err != nil {
+		panic(err)
+	}
+	genericBlock, err := blockContents.ToGeneric()
+	if err != nil {
+		panic(err)
+	}
+	return &ethpb.GenericSignedBeaconBlock_Electra{
+		Electra: genericBlock.GetElectra(),
+	}
+}
+
+func generateSignedBlindedElectraBlock() *ethpb.GenericSignedBeaconBlock_BlindedElectra {
+	var blindedBlock structs.SignedBlindedBeaconBlockElectra
+	if err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blindedBlock); err != nil {
+		panic(err)
+	}
+	genericBlock, err := blindedBlock.ToGeneric()
+	if err != nil {
+		panic(err)
+	}
+	return &ethpb.GenericSignedBeaconBlock_BlindedElectra{
+		BlindedElectra: genericBlock.GetBlindedElectra(),
+	}
+}
+
+func generateSignedFuluBlock() *ethpb.GenericSignedBeaconBlock_Fulu {
+	var blockContents structs.SignedBeaconBlockContentsFulu
+	if err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blockContents); err != nil {
+		panic(err)
+	}
+	genericBlock, err := blockContents.ToGeneric()
+	if err != nil {
+		panic(err)
+	}
+	return &ethpb.GenericSignedBeaconBlock_Fulu{
+		Fulu: genericBlock.GetFulu(),
+	}
+}
+
+func generateSignedBlindedFuluBlock() *ethpb.GenericSignedBeaconBlock_BlindedFulu {
+	var blindedBlock structs.SignedBlindedBeaconBlockFulu
+	if err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blindedBlock); err != nil {
+		panic(err)
+	}
+	genericBlock, err := blindedBlock.ToGeneric()
+	if err != nil {
+		panic(err)
+	}
+	return &ethpb.GenericSignedBeaconBlock_BlindedFulu{
+		BlindedFulu: genericBlock.GetBlindedFulu(),
+	}
+}

validator/client/beacon-api/mock/json_rest_handler_mock.go

@@ -114,6 +114,22 @@ func (mr *MockJsonRestHandlerMockRecorder) Post(ctx, endpoint, headers, data, re
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockJsonRestHandler)(nil).Post), ctx, endpoint, headers, data, resp)
 }
 
+// Post mocks base method.
+func (m *MockJsonRestHandler) PostSSZ(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer) ([]byte, http.Header, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PostSSZ", ctx, endpoint, headers, data)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(http.Header)
+	ret2, _ := ret[2].(error)
+	return ret0,ret1,ret2
+}
+
+// Post indicates an expected call of Post.
+func (mr *MockJsonRestHandlerMockRecorder) PostSSZ(ctx, endpoint, headers, data any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSSZ", reflect.TypeOf((*MockJsonRestHandler)(nil).PostSSZ), ctx, endpoint, headers, data)
+}
+
 // SetHost mocks base method.
 func (m *MockJsonRestHandler) SetHost(host string) {
 	m.ctrl.T.Helper()

validator/client/beacon-api/propose_beacon_block.go

@@ -15,8 +15,10 @@ import (
 type blockProcessingResult struct {
 	consensusVersion string
 	beaconBlockRoot  [32]byte
-	marshalledJSON   []byte
+	marshalledSSZ    []byte
 	blinded          bool
+	// Function to marshal JSON on demand
+	marshalJSON func() ([]byte, error)
 }
 
 func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
@@ -62,17 +64,54 @@ func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *e
 	}
 
 	headers := map[string]string{"Eth-Consensus-Version": res.consensusVersion}
-	err = c.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(res.marshalledJSON), nil)
-	errJson := &httputil.DefaultJsonError{}
-	if err != nil {
-		if !errors.As(err, &errJson) {
-			return nil, err
+
+	// Try PostSSZ first with SSZ data
+	if res.marshalledSSZ != nil {
+		_, _, err = c.jsonRestHandler.PostSSZ(ctx, endpoint, headers, bytes.NewBuffer(res.marshalledSSZ))
+		if err != nil {
+			errJson := &httputil.DefaultJsonError{}
+			// If PostSSZ fails with 406 (Not Acceptable), fall back to JSON
+			if !errors.As(err, &errJson) {
+				return nil, err
+			}
+			if errJson.Code == http.StatusNotAcceptable && res.marshalJSON != nil {
+				log.WithError(err).Warn("Failed to submit block ssz, falling back to JSON")
+				jsonData, jsonErr := res.marshalJSON()
+				if jsonErr != nil {
+					return nil, errors.Wrap(jsonErr, "failed to marshal JSON")
+				}
+				// Reset headers for JSON
+				err = c.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
+				// If JSON also fails, return that error
+				if err != nil {
+					return nil, errors.Wrap(err, "failed to submit block via JSON fallback")
+				}
+			} else {
+				// For non-406 errors or when no JSON fallback is available, return the SSZ error
+				return nil, errors.Wrap(errJson, "failed to submit block ssz")
+			}
 		}
-		// Error 202 means that the block was successfully broadcast, but validation failed
-		if errJson.Code == http.StatusAccepted {
-			return nil, errors.New("block was successfully broadcast but failed validation")
+	} else if res.marshalJSON == nil {
+		return nil, errors.New("no marshalling functions available")
+	} else {
+		// No SSZ data available, marshal and use JSON
+		jsonData, jsonErr := res.marshalJSON()
+		if jsonErr != nil {
+			return nil, errors.Wrap(jsonErr, "failed to marshal JSON")
+		}
+		// Reset headers for JSON
+		err = c.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
+		errJson := &httputil.DefaultJsonError{}
+		if err != nil {
+			if !errors.As(err, &errJson) {
+				return nil, err
+			}
+			// Error 202 means that the block was successfully broadcast, but validation failed
+			if errJson.Code == http.StatusAccepted {
+				return nil, errors.New("block was successfully broadcast but failed validation")
+			}
+			return nil, errJson
 		}
-		return nil, errJson
 	}
 
 	return &ethpb.ProposeResponse{BlockRoot: res.beaconBlockRoot[:]}, nil
@@ -89,11 +128,19 @@ func handlePhase0Block(block *ethpb.GenericSignedBeaconBlock_Phase0) (*blockProc
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock := structs.SignedBeaconBlockPhase0FromConsensus(block.Phase0)
-	res.marshalledJSON, err = json.Marshal(signedBlock)
+	// Marshal SSZ
+	ssz, err := block.Phase0.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall phase0 beacon block to json")
+		return nil, errors.Wrap(err, "failed to serialize block for phase0 beacon block")
 	}
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock := structs.SignedBeaconBlockPhase0FromConsensus(block.Phase0)
+		return json.Marshal(signedBlock)
+	}
+
 	return &res, nil
 }
 
@@ -108,11 +155,19 @@ func handleAltairBlock(block *ethpb.GenericSignedBeaconBlock_Altair) (*blockProc
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock := structs.SignedBeaconBlockAltairFromConsensus(block.Altair)
-	res.marshalledJSON, err = json.Marshal(signedBlock)
+	// Marshal SSZ
+	ssz, err := block.Altair.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall altair beacon block to json")
+		return nil, errors.Wrap(err, "failed to serialize block for altair beacon block")
 	}
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock := structs.SignedBeaconBlockAltairFromConsensus(block.Altair)
+		return json.Marshal(signedBlock)
+	}
+
 	return &res, nil
 }
 
@@ -127,13 +182,20 @@ func handleBellatrixBlock(block *ethpb.GenericSignedBeaconBlock_Bellatrix) (*blo
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBeaconBlockBellatrixFromConsensus(block.Bellatrix)
+	// Marshal SSZ
+	ssz, err := block.Bellatrix.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall bellatrix beacon block")
+		return nil, errors.Wrap(err, "failed to serialize block for bellatrix beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall bellatrix beacon block to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBeaconBlockBellatrixFromConsensus(block.Bellatrix)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert bellatrix beacon block")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -150,13 +212,20 @@ func handleBlindedBellatrixBlock(block *ethpb.GenericSignedBeaconBlock_BlindedBe
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(block.BlindedBellatrix)
+	// Marshal SSZ
+	ssz, err := block.BlindedBellatrix.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall blinded bellatrix beacon block")
+		return nil, errors.Wrap(err, "failed to serialize block for bellatrix beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall blinded bellatrix beacon block to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(block.BlindedBellatrix)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert blinded bellatrix beacon block")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -173,13 +242,20 @@ func handleCapellaBlock(block *ethpb.GenericSignedBeaconBlock_Capella) (*blockPr
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBeaconBlockCapellaFromConsensus(block.Capella)
+	// Marshal SSZ
+	ssz, err := block.Capella.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall capella beacon block")
+		return nil, errors.Wrap(err, "failed to serialize capella beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall capella beacon block to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBeaconBlockCapellaFromConsensus(block.Capella)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert capella beacon block")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -196,13 +272,20 @@ func handleBlindedCapellaBlock(block *ethpb.GenericSignedBeaconBlock_BlindedCape
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(block.BlindedCapella)
+	// Marshal SSZ
+	ssz, err := block.BlindedCapella.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall blinded capella beacon block")
+		return nil, errors.Wrap(err, "failed to serialize blinded capella beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall blinded capella beacon block to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(block.BlindedCapella)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert blinded capella beacon block")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -219,13 +302,20 @@ func handleDenebBlockContents(block *ethpb.GenericSignedBeaconBlock_Deneb) (*blo
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBeaconBlockContentsDenebFromConsensus(block.Deneb)
+	// Marshal SSZ
+	ssz, err := block.Deneb.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall deneb beacon block contents")
+		return nil, errors.Wrap(err, "failed to serialize deneb beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall deneb beacon block contents to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBeaconBlockContentsDenebFromConsensus(block.Deneb)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert deneb beacon block contents")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -242,13 +332,20 @@ func handleBlindedDenebBlock(block *ethpb.GenericSignedBeaconBlock_BlindedDeneb)
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(block.BlindedDeneb)
+	// Marshal SSZ
+	ssz, err := block.BlindedDeneb.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall deneb blinded beacon block ")
+		return nil, errors.Wrap(err, "failed to serialize blinded deneb  beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall deneb blinded beacon block to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(block.BlindedDeneb)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert deneb blinded beacon block")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -265,13 +362,20 @@ func handleElectraBlockContents(block *ethpb.GenericSignedBeaconBlock_Electra) (
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
+	// Marshal SSZ
+	ssz, err := block.Electra.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall electra beacon block contents")
+		return nil, errors.Wrap(err, "failed to serialize electra beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall electra beacon block contents to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert electra beacon block contents")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -288,13 +392,20 @@ func handleBlindedElectraBlock(block *ethpb.GenericSignedBeaconBlock_BlindedElec
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBlindedBeaconBlockElectraFromConsensus(block.BlindedElectra)
+	// Marshal SSZ
+	ssz, err := block.BlindedElectra.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall electra blinded beacon block")
+		return nil, errors.Wrap(err, "failed to serialize blinded electra beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall electra blinded beacon block to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBlindedBeaconBlockElectraFromConsensus(block.BlindedElectra)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert electra blinded beacon block")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -311,13 +422,20 @@ func handleFuluBlockContents(block *ethpb.GenericSignedBeaconBlock_Fulu) (*block
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
+	// Marshal SSZ
+	ssz, err := block.Fulu.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall fulu beacon block contents")
+		return nil, errors.Wrap(err, "failed to serialize fulu beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall fulu beacon block contents to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert fulu beacon block contents")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil
@@ -334,13 +452,20 @@ func handleBlindedFuluBlock(block *ethpb.GenericSignedBeaconBlock_BlindedFulu) (
 	}
 	res.beaconBlockRoot = beaconBlockRoot
 
-	signedBlock, err := structs.SignedBlindedBeaconBlockFuluFromConsensus(block.BlindedFulu)
+	// Marshal SSZ
+	ssz, err := block.BlindedFulu.MarshalSSZ()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall fulu blinded beacon block")
+		return nil, errors.Wrap(err, "failed to serialize blinded fulu beacon block")
 	}
-	res.marshalledJSON, err = json.Marshal(signedBlock)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshall fulu blinded beacon block to json")
+	res.marshalledSSZ = ssz
+
+	// Set up JSON marshalling function for fallback
+	res.marshalJSON = func() ([]byte, error) {
+		signedBlock, err := structs.SignedBlindedBeaconBlockFuluFromConsensus(block.BlindedFulu)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert fulu blinded beacon block")
+		}
+		return json.Marshal(signedBlock)
 	}
 
 	return &res, nil

validator/client/beacon-api/propose_beacon_block_altair_test.go

@@ -1,63 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_Altair(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	altairBlock := generateSignedAltairBlock()
-
-	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
-	genericSignedBlock.Block = altairBlock
-
-	jsonAltairBlock := structs.SignedBeaconBlockAltairFromConsensus(altairBlock.Altair)
-
-	marshalledBlock, err := json.Marshal(jsonAltairBlock)
-	require.NoError(t, err)
-
-	ctx := t.Context()
-
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "altair"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blocks",
-		headers,
-		bytes.NewBuffer(marshalledBlock),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(ctx, genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := altairBlock.Altair.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}
-
-func generateSignedAltairBlock() *ethpb.GenericSignedBeaconBlock_Altair {
-	return &ethpb.GenericSignedBeaconBlock_Altair{
-		Altair: &ethpb.SignedBeaconBlockAltair{
-			Block:     testhelpers.GenerateProtoAltairBeaconBlock(),
-			Signature: testhelpers.FillByteSlice(96, 112),
-		},
-	}
-}

validator/client/beacon-api/propose_beacon_block_bellatrix_test.go

@@ -1,64 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_Bellatrix(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	bellatrixBlock := generateSignedBellatrixBlock()
-
-	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
-	genericSignedBlock.Block = bellatrixBlock
-
-	jsonBellatrixBlock, err := structs.SignedBeaconBlockBellatrixFromConsensus(bellatrixBlock.Bellatrix)
-	require.NoError(t, err)
-
-	marshalledBlock, err := json.Marshal(jsonBellatrixBlock)
-	require.NoError(t, err)
-
-	ctx := t.Context()
-
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "bellatrix"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blocks",
-		headers,
-		bytes.NewBuffer(marshalledBlock),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(ctx, genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := bellatrixBlock.Bellatrix.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}
-
-func generateSignedBellatrixBlock() *ethpb.GenericSignedBeaconBlock_Bellatrix {
-	return &ethpb.GenericSignedBeaconBlock_Bellatrix{
-		Bellatrix: &ethpb.SignedBeaconBlockBellatrix{
-			Block:     testhelpers.GenerateProtoBellatrixBeaconBlock(),
-			Signature: testhelpers.FillByteSlice(96, 127),
-		},
-	}
-}

validator/client/beacon-api/propose_beacon_block_blinded_bellatrix_test.go

@@ -1,291 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_BlindedBellatrix(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	blindedBellatrixBlock := generateSignedBlindedBellatrixBlock()
-
-	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
-	genericSignedBlock.Block = blindedBellatrixBlock
-
-	jsonBlindedBellatrixBlock, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(blindedBellatrixBlock.BlindedBellatrix)
-	require.NoError(t, err)
-
-	marshalledBlock, err := json.Marshal(jsonBlindedBellatrixBlock)
-	require.NoError(t, err)
-
-	ctx := t.Context()
-
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "bellatrix"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blinded_blocks",
-		headers,
-		bytes.NewBuffer(marshalledBlock),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(ctx, genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := blindedBellatrixBlock.BlindedBellatrix.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}
-
-func generateSignedBlindedBellatrixBlock() *ethpb.GenericSignedBeaconBlock_BlindedBellatrix {
-	return &ethpb.GenericSignedBeaconBlock_BlindedBellatrix{
-		BlindedBellatrix: &ethpb.SignedBlindedBeaconBlockBellatrix{
-			Block: &ethpb.BlindedBeaconBlockBellatrix{
-				Slot:          1,
-				ProposerIndex: 2,
-				ParentRoot:    testhelpers.FillByteSlice(32, 3),
-				StateRoot:     testhelpers.FillByteSlice(32, 4),
-				Body: &ethpb.BlindedBeaconBlockBodyBellatrix{
-					RandaoReveal: testhelpers.FillByteSlice(96, 5),
-					Eth1Data: &ethpb.Eth1Data{
-						DepositRoot:  testhelpers.FillByteSlice(32, 6),
-						DepositCount: 7,
-						BlockHash:    testhelpers.FillByteSlice(32, 8),
-					},
-					Graffiti: testhelpers.FillByteSlice(32, 9),
-					ProposerSlashings: []*ethpb.ProposerSlashing{
-						{
-							Header_1: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          10,
-									ProposerIndex: 11,
-									ParentRoot:    testhelpers.FillByteSlice(32, 12),
-									StateRoot:     testhelpers.FillByteSlice(32, 13),
-									BodyRoot:      testhelpers.FillByteSlice(32, 14),
-								},
-								Signature: testhelpers.FillByteSlice(96, 15),
-							},
-							Header_2: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          16,
-									ProposerIndex: 17,
-									ParentRoot:    testhelpers.FillByteSlice(32, 18),
-									StateRoot:     testhelpers.FillByteSlice(32, 19),
-									BodyRoot:      testhelpers.FillByteSlice(32, 20),
-								},
-								Signature: testhelpers.FillByteSlice(96, 21),
-							},
-						},
-						{
-							Header_1: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          22,
-									ProposerIndex: 23,
-									ParentRoot:    testhelpers.FillByteSlice(32, 24),
-									StateRoot:     testhelpers.FillByteSlice(32, 25),
-									BodyRoot:      testhelpers.FillByteSlice(32, 26),
-								},
-								Signature: testhelpers.FillByteSlice(96, 27),
-							},
-							Header_2: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          28,
-									ProposerIndex: 29,
-									ParentRoot:    testhelpers.FillByteSlice(32, 30),
-									StateRoot:     testhelpers.FillByteSlice(32, 31),
-									BodyRoot:      testhelpers.FillByteSlice(32, 32),
-								},
-								Signature: testhelpers.FillByteSlice(96, 33),
-							},
-						},
-					},
-					AttesterSlashings: []*ethpb.AttesterSlashing{
-						{
-							Attestation_1: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{34, 35},
-								Data: &ethpb.AttestationData{
-									Slot:            36,
-									CommitteeIndex:  37,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 39,
-										Root:  testhelpers.FillByteSlice(32, 40),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 41,
-										Root:  testhelpers.FillByteSlice(32, 42),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 43),
-							},
-							Attestation_2: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{44, 45},
-								Data: &ethpb.AttestationData{
-									Slot:            46,
-									CommitteeIndex:  47,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 49,
-										Root:  testhelpers.FillByteSlice(32, 50),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 51,
-										Root:  testhelpers.FillByteSlice(32, 52),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 53),
-							},
-						},
-						{
-							Attestation_1: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{54, 55},
-								Data: &ethpb.AttestationData{
-									Slot:            56,
-									CommitteeIndex:  57,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 59,
-										Root:  testhelpers.FillByteSlice(32, 60),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 61,
-										Root:  testhelpers.FillByteSlice(32, 62),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 63),
-							},
-							Attestation_2: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{64, 65},
-								Data: &ethpb.AttestationData{
-									Slot:            66,
-									CommitteeIndex:  67,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 69,
-										Root:  testhelpers.FillByteSlice(32, 70),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 71,
-										Root:  testhelpers.FillByteSlice(32, 72),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 73),
-							},
-						},
-					},
-					Attestations: []*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),
-						},
-						{
-							AggregationBits: testhelpers.FillByteSlice(4, 83),
-							Data: &ethpb.AttestationData{
-								Slot:            84,
-								CommitteeIndex:  85,
-								BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-								Source: &ethpb.Checkpoint{
-									Epoch: 87,
-									Root:  testhelpers.FillByteSlice(32, 88),
-								},
-								Target: &ethpb.Checkpoint{
-									Epoch: 89,
-									Root:  testhelpers.FillByteSlice(32, 90),
-								},
-							},
-							Signature: testhelpers.FillByteSlice(96, 91),
-						},
-					},
-					Deposits: []*ethpb.Deposit{
-						{
-							Proof: testhelpers.FillByteArraySlice(33, testhelpers.FillByteSlice(32, 92)),
-							Data: &ethpb.Deposit_Data{
-								PublicKey:             testhelpers.FillByteSlice(48, 94),
-								WithdrawalCredentials: testhelpers.FillByteSlice(32, 95),
-								Amount:                96,
-								Signature:             testhelpers.FillByteSlice(96, 97),
-							},
-						},
-						{
-							Proof: testhelpers.FillByteArraySlice(33, testhelpers.FillByteSlice(32, 98)),
-							Data: &ethpb.Deposit_Data{
-								PublicKey:             testhelpers.FillByteSlice(48, 100),
-								WithdrawalCredentials: testhelpers.FillByteSlice(32, 101),
-								Amount:                102,
-								Signature:             testhelpers.FillByteSlice(96, 103),
-							},
-						},
-					},
-					VoluntaryExits: []*ethpb.SignedVoluntaryExit{
-						{
-							Exit: &ethpb.VoluntaryExit{
-								Epoch:          104,
-								ValidatorIndex: 105,
-							},
-							Signature: testhelpers.FillByteSlice(96, 106),
-						},
-						{
-							Exit: &ethpb.VoluntaryExit{
-								Epoch:          107,
-								ValidatorIndex: 108,
-							},
-							Signature: testhelpers.FillByteSlice(96, 109),
-						},
-					},
-					SyncAggregate: &ethpb.SyncAggregate{
-						SyncCommitteeBits:      testhelpers.FillByteSlice(64, 110),
-						SyncCommitteeSignature: testhelpers.FillByteSlice(96, 111),
-					},
-					ExecutionPayloadHeader: &enginev1.ExecutionPayloadHeader{
-						ParentHash:       testhelpers.FillByteSlice(32, 112),
-						FeeRecipient:     testhelpers.FillByteSlice(20, 113),
-						StateRoot:        testhelpers.FillByteSlice(32, 114),
-						ReceiptsRoot:     testhelpers.FillByteSlice(32, 115),
-						LogsBloom:        testhelpers.FillByteSlice(256, 116),
-						PrevRandao:       testhelpers.FillByteSlice(32, 117),
-						BlockNumber:      118,
-						GasLimit:         119,
-						GasUsed:          120,
-						Timestamp:        121,
-						ExtraData:        testhelpers.FillByteSlice(32, 122),
-						BaseFeePerGas:    testhelpers.FillByteSlice(32, 123),
-						BlockHash:        testhelpers.FillByteSlice(32, 124),
-						TransactionsRoot: testhelpers.FillByteSlice(32, 125),
-					},
-				},
-			},
-			Signature: testhelpers.FillByteSlice(96, 126),
-		},
-	}
-}

validator/client/beacon-api/propose_beacon_block_blinded_capella_test.go

@@ -1,310 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_BlindedCapella(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	blindedCapellaBlock := generateSignedBlindedCapellaBlock()
-
-	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
-	genericSignedBlock.Block = blindedCapellaBlock
-
-	jsonBlindedCapellaBlock, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(blindedCapellaBlock.BlindedCapella)
-	require.NoError(t, err)
-
-	marshalledBlock, err := json.Marshal(jsonBlindedCapellaBlock)
-	require.NoError(t, err)
-
-	ctx := t.Context()
-
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "capella"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blinded_blocks",
-		headers,
-		bytes.NewBuffer(marshalledBlock),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(ctx, genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := blindedCapellaBlock.BlindedCapella.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}
-
-func generateSignedBlindedCapellaBlock() *ethpb.GenericSignedBeaconBlock_BlindedCapella {
-	return &ethpb.GenericSignedBeaconBlock_BlindedCapella{
-		BlindedCapella: &ethpb.SignedBlindedBeaconBlockCapella{
-			Block: &ethpb.BlindedBeaconBlockCapella{
-				Slot:          1,
-				ProposerIndex: 2,
-				ParentRoot:    testhelpers.FillByteSlice(32, 3),
-				StateRoot:     testhelpers.FillByteSlice(32, 4),
-				Body: &ethpb.BlindedBeaconBlockBodyCapella{
-					RandaoReveal: testhelpers.FillByteSlice(96, 5),
-					Eth1Data: &ethpb.Eth1Data{
-						DepositRoot:  testhelpers.FillByteSlice(32, 6),
-						DepositCount: 7,
-						BlockHash:    testhelpers.FillByteSlice(32, 8),
-					},
-					Graffiti: testhelpers.FillByteSlice(32, 9),
-					ProposerSlashings: []*ethpb.ProposerSlashing{
-						{
-							Header_1: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          10,
-									ProposerIndex: 11,
-									ParentRoot:    testhelpers.FillByteSlice(32, 12),
-									StateRoot:     testhelpers.FillByteSlice(32, 13),
-									BodyRoot:      testhelpers.FillByteSlice(32, 14),
-								},
-								Signature: testhelpers.FillByteSlice(96, 15),
-							},
-							Header_2: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          16,
-									ProposerIndex: 17,
-									ParentRoot:    testhelpers.FillByteSlice(32, 18),
-									StateRoot:     testhelpers.FillByteSlice(32, 19),
-									BodyRoot:      testhelpers.FillByteSlice(32, 20),
-								},
-								Signature: testhelpers.FillByteSlice(96, 21),
-							},
-						},
-						{
-							Header_1: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          22,
-									ProposerIndex: 23,
-									ParentRoot:    testhelpers.FillByteSlice(32, 24),
-									StateRoot:     testhelpers.FillByteSlice(32, 25),
-									BodyRoot:      testhelpers.FillByteSlice(32, 26),
-								},
-								Signature: testhelpers.FillByteSlice(96, 27),
-							},
-							Header_2: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									Slot:          28,
-									ProposerIndex: 29,
-									ParentRoot:    testhelpers.FillByteSlice(32, 30),
-									StateRoot:     testhelpers.FillByteSlice(32, 31),
-									BodyRoot:      testhelpers.FillByteSlice(32, 32),
-								},
-								Signature: testhelpers.FillByteSlice(96, 33),
-							},
-						},
-					},
-					AttesterSlashings: []*ethpb.AttesterSlashing{
-						{
-							Attestation_1: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{34, 35},
-								Data: &ethpb.AttestationData{
-									Slot:            36,
-									CommitteeIndex:  37,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 39,
-										Root:  testhelpers.FillByteSlice(32, 40),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 41,
-										Root:  testhelpers.FillByteSlice(32, 42),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 43),
-							},
-							Attestation_2: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{44, 45},
-								Data: &ethpb.AttestationData{
-									Slot:            46,
-									CommitteeIndex:  47,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 49,
-										Root:  testhelpers.FillByteSlice(32, 50),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 51,
-										Root:  testhelpers.FillByteSlice(32, 52),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 53),
-							},
-						},
-						{
-							Attestation_1: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{54, 55},
-								Data: &ethpb.AttestationData{
-									Slot:            56,
-									CommitteeIndex:  57,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 59,
-										Root:  testhelpers.FillByteSlice(32, 60),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 61,
-										Root:  testhelpers.FillByteSlice(32, 62),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 63),
-							},
-							Attestation_2: &ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{64, 65},
-								Data: &ethpb.AttestationData{
-									Slot:            66,
-									CommitteeIndex:  67,
-									BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-									Source: &ethpb.Checkpoint{
-										Epoch: 69,
-										Root:  testhelpers.FillByteSlice(32, 70),
-									},
-									Target: &ethpb.Checkpoint{
-										Epoch: 71,
-										Root:  testhelpers.FillByteSlice(32, 72),
-									},
-								},
-								Signature: testhelpers.FillByteSlice(96, 73),
-							},
-						},
-					},
-					Attestations: []*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),
-						},
-						{
-							AggregationBits: testhelpers.FillByteSlice(4, 83),
-							Data: &ethpb.AttestationData{
-								Slot:            84,
-								CommitteeIndex:  85,
-								BeaconBlockRoot: testhelpers.FillByteSlice(32, 38),
-								Source: &ethpb.Checkpoint{
-									Epoch: 87,
-									Root:  testhelpers.FillByteSlice(32, 88),
-								},
-								Target: &ethpb.Checkpoint{
-									Epoch: 89,
-									Root:  testhelpers.FillByteSlice(32, 90),
-								},
-							},
-							Signature: testhelpers.FillByteSlice(96, 91),
-						},
-					},
-					Deposits: []*ethpb.Deposit{
-						{
-							Proof: testhelpers.FillByteArraySlice(33, testhelpers.FillByteSlice(32, 92)),
-							Data: &ethpb.Deposit_Data{
-								PublicKey:             testhelpers.FillByteSlice(48, 94),
-								WithdrawalCredentials: testhelpers.FillByteSlice(32, 95),
-								Amount:                96,
-								Signature:             testhelpers.FillByteSlice(96, 97),
-							},
-						},
-						{
-							Proof: testhelpers.FillByteArraySlice(33, testhelpers.FillByteSlice(32, 98)),
-							Data: &ethpb.Deposit_Data{
-								PublicKey:             testhelpers.FillByteSlice(48, 100),
-								WithdrawalCredentials: testhelpers.FillByteSlice(32, 101),
-								Amount:                102,
-								Signature:             testhelpers.FillByteSlice(96, 103),
-							},
-						},
-					},
-					VoluntaryExits: []*ethpb.SignedVoluntaryExit{
-						{
-							Exit: &ethpb.VoluntaryExit{
-								Epoch:          104,
-								ValidatorIndex: 105,
-							},
-							Signature: testhelpers.FillByteSlice(96, 106),
-						},
-						{
-							Exit: &ethpb.VoluntaryExit{
-								Epoch:          107,
-								ValidatorIndex: 108,
-							},
-							Signature: testhelpers.FillByteSlice(96, 109),
-						},
-					},
-					SyncAggregate: &ethpb.SyncAggregate{
-						SyncCommitteeBits:      testhelpers.FillByteSlice(64, 110),
-						SyncCommitteeSignature: testhelpers.FillByteSlice(96, 111),
-					},
-					ExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderCapella{
-						ParentHash:       testhelpers.FillByteSlice(32, 112),
-						FeeRecipient:     testhelpers.FillByteSlice(20, 113),
-						StateRoot:        testhelpers.FillByteSlice(32, 114),
-						ReceiptsRoot:     testhelpers.FillByteSlice(32, 115),
-						LogsBloom:        testhelpers.FillByteSlice(256, 116),
-						PrevRandao:       testhelpers.FillByteSlice(32, 117),
-						BlockNumber:      118,
-						GasLimit:         119,
-						GasUsed:          120,
-						Timestamp:        121,
-						ExtraData:        testhelpers.FillByteSlice(32, 122),
-						BaseFeePerGas:    testhelpers.FillByteSlice(32, 123),
-						BlockHash:        testhelpers.FillByteSlice(32, 124),
-						TransactionsRoot: testhelpers.FillByteSlice(32, 125),
-						WithdrawalsRoot:  testhelpers.FillByteSlice(32, 126),
-					},
-					BlsToExecutionChanges: []*ethpb.SignedBLSToExecutionChange{
-						{
-							Message: &ethpb.BLSToExecutionChange{
-								ValidatorIndex:     127,
-								FromBlsPubkey:      testhelpers.FillByteSlice(48, 128),
-								ToExecutionAddress: testhelpers.FillByteSlice(20, 129),
-							},
-							Signature: testhelpers.FillByteSlice(96, 130),
-						},
-						{
-							Message: &ethpb.BLSToExecutionChange{
-								ValidatorIndex:     131,
-								FromBlsPubkey:      testhelpers.FillByteSlice(48, 132),
-								ToExecutionAddress: testhelpers.FillByteSlice(20, 133),
-							},
-							Signature: testhelpers.FillByteSlice(96, 134),
-						},
-					},
-				},
-			},
-			Signature: testhelpers.FillByteSlice(96, 135),
-		},
-	}
-}

validator/client/beacon-api/propose_beacon_block_blinded_deneb_test.go

@@ -1,49 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_BlindedDeneb(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	var block structs.SignedBlindedBeaconBlockDeneb
-	err := json.Unmarshal([]byte(rpctesting.BlindedDenebBlock), &block)
-	require.NoError(t, err)
-	genericSignedBlock, err := block.ToGeneric()
-	require.NoError(t, err)
-
-	denebBytes, err := json.Marshal(block)
-	require.NoError(t, err)
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "deneb"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blinded_blocks",
-		headers,
-		bytes.NewBuffer(denebBytes),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := genericSignedBlock.GetBlindedDeneb().HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}

validator/client/beacon-api/propose_beacon_block_blinded_electra_test.go

@@ -1,49 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_BlindedElectra(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	var block structs.SignedBlindedBeaconBlockElectra
-	err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &block)
-	require.NoError(t, err)
-	genericSignedBlock, err := block.ToGeneric()
-	require.NoError(t, err)
-
-	electraBytes, err := json.Marshal(block)
-	require.NoError(t, err)
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "electra"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blinded_blocks",
-		headers,
-		bytes.NewBuffer(electraBytes),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := genericSignedBlock.GetBlindedElectra().HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}

validator/client/beacon-api/propose_beacon_block_blinded_fulu_test.go

@@ -1,49 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_BlindedFulu(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	var block structs.SignedBlindedBeaconBlockFulu
-	err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &block)
-	require.NoError(t, err)
-	genericSignedBlock, err := block.ToGeneric()
-	require.NoError(t, err)
-
-	fuluBytes, err := json.Marshal(block)
-	require.NoError(t, err)
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "fulu"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blinded_blocks",
-		headers,
-		bytes.NewBuffer(fuluBytes),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := genericSignedBlock.GetBlindedFulu().HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}

validator/client/beacon-api/propose_beacon_block_capella_test.go

@@ -1,62 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_Capella(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	capellaBlock := generateSignedCapellaBlock()
-
-	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
-	genericSignedBlock.Block = capellaBlock
-
-	jsonCapellaBlock, err := structs.SignedBeaconBlockCapellaFromConsensus(capellaBlock.Capella)
-	require.NoError(t, err)
-
-	marshalledBlock, err := json.Marshal(jsonCapellaBlock)
-	require.NoError(t, err)
-
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "capella"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blocks",
-		headers,
-		bytes.NewBuffer(marshalledBlock),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := capellaBlock.Capella.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}
-
-func generateSignedCapellaBlock() *ethpb.GenericSignedBeaconBlock_Capella {
-	return &ethpb.GenericSignedBeaconBlock_Capella{
-		Capella: &ethpb.SignedBeaconBlockCapella{
-			Block:     testhelpers.GenerateProtoCapellaBeaconBlock(),
-			Signature: testhelpers.FillByteSlice(96, 127),
-		},
-	}
-}

validator/client/beacon-api/propose_beacon_block_deneb_test.go

@@ -1,49 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_Deneb(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	var blockContents structs.SignedBeaconBlockContentsDeneb
-	err := json.Unmarshal([]byte(rpctesting.DenebBlockContents), &blockContents)
-	require.NoError(t, err)
-	genericSignedBlock, err := blockContents.ToGeneric()
-	require.NoError(t, err)
-
-	denebBytes, err := json.Marshal(blockContents)
-	require.NoError(t, err)
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "deneb"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blocks",
-		headers,
-		bytes.NewBuffer(denebBytes),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := genericSignedBlock.GetDeneb().Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}

validator/client/beacon-api/propose_beacon_block_electra_test.go

@@ -1,49 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_Electra(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	var blockContents structs.SignedBeaconBlockContentsElectra
-	err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blockContents)
-	require.NoError(t, err)
-	genericSignedBlock, err := blockContents.ToGeneric()
-	require.NoError(t, err)
-
-	electraBytes, err := json.Marshal(blockContents)
-	require.NoError(t, err)
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "electra"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blocks",
-		headers,
-		bytes.NewBuffer(electraBytes),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := genericSignedBlock.GetElectra().Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}

validator/client/beacon-api/propose_beacon_block_fulu_test.go

@@ -1,49 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_Fulu(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	var blockContents structs.SignedBeaconBlockContentsFulu
-	err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blockContents)
-	require.NoError(t, err)
-	genericSignedBlock, err := blockContents.ToGeneric()
-	require.NoError(t, err)
-
-	fuluBytes, err := json.Marshal(blockContents)
-	require.NoError(t, err)
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "fulu"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blocks",
-		headers,
-		bytes.NewBuffer(fuluBytes),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := genericSignedBlock.GetFulu().Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}

validator/client/beacon-api/propose_beacon_block_phase0_test.go

@@ -1,63 +0,0 @@
-package beacon_api
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
-	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
-	"go.uber.org/mock/gomock"
-)
-
-func TestProposeBeaconBlock_Phase0(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-
-	phase0Block := generateSignedPhase0Block()
-
-	genericSignedBlock := &ethpb.GenericSignedBeaconBlock{}
-	genericSignedBlock.Block = phase0Block
-
-	jsonPhase0Block := structs.SignedBeaconBlockPhase0FromConsensus(phase0Block.Phase0)
-
-	marshalledBlock, err := json.Marshal(jsonPhase0Block)
-	require.NoError(t, err)
-
-	ctx := t.Context()
-
-	// Make sure that what we send in the POST body is the marshalled version of the protobuf block
-	headers := map[string]string{"Eth-Consensus-Version": "phase0"}
-	jsonRestHandler.EXPECT().Post(
-		gomock.Any(),
-		"/eth/v2/beacon/blocks",
-		headers,
-		bytes.NewBuffer(marshalledBlock),
-		nil,
-	)
-
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	proposeResponse, err := validatorClient.proposeBeaconBlock(ctx, genericSignedBlock)
-	assert.NoError(t, err)
-	require.NotNil(t, proposeResponse)
-
-	expectedBlockRoot, err := phase0Block.Phase0.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Make sure that the block root is set
-	assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
-}
-
-func generateSignedPhase0Block() *ethpb.GenericSignedBeaconBlock_Phase0 {
-	return &ethpb.GenericSignedBeaconBlock_Phase0{
-		Phase0: &ethpb.SignedBeaconBlock{
-			Block:     testhelpers.GenerateProtoPhase0BeaconBlock(),
-			Signature: testhelpers.FillByteSlice(96, 110),
-		},
-	}
-}

validator/client/beacon-api/propose_beacon_block_test.go

@@ -1,43 +1,42 @@
 package beacon_api
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
 	"net/http"
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/api/server/structs"
+	rpctesting "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared/testing"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
+	engine "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/mock"
+	testhelpers "github.com/OffchainLabs/prysm/v6/validator/client/beacon-api/test-helpers"
 	"go.uber.org/mock/gomock"
 )
 
-func TestProposeBeaconBlock_Error(t *testing.T) {
+func TestProposeBeaconBlock_SSZ_Error(t *testing.T) {
 	testSuites := []struct {
 		name                 string
 		returnedError        error
 		expectedErrorMessage string
 	}{
-		{
-			name:                 "error 202",
-			expectedErrorMessage: "block was successfully broadcast but failed validation",
-			returnedError: &httputil.DefaultJsonError{
-				Code:    http.StatusAccepted,
-				Message: "202 error",
-			},
-		},
 		{
 			name:                 "error 500",
-			expectedErrorMessage: "HTTP request unsuccessful (500: foo error)",
+			expectedErrorMessage: "failed to submit block ssz",
 			returnedError: &httputil.DefaultJsonError{
 				Code:    http.StatusInternalServerError,
-				Message: "foo error",
+				Message: "failed to submit block ssz",
 			},
 		},
 		{
 			name:                 "other error",
-			expectedErrorMessage: "foo error",
-			returnedError:        errors.New("foo error"),
+			expectedErrorMessage: "failed to submit block ssz",
+			returnedError:        errors.New("failed to submit block ssz"),
 		},
 	}
 
@@ -106,17 +105,21 @@ func TestProposeBeaconBlock_Error(t *testing.T) {
 				ctx := t.Context()
 				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
-				headers := map[string]string{"Eth-Consensus-Version": testCase.consensusVersion}
-				jsonRestHandler.EXPECT().Post(
+				// Expect PostSSZ to be called first with SSZ data
+				headers := map[string]string{
+					"Eth-Consensus-Version": testCase.consensusVersion,
+				}
+				jsonRestHandler.EXPECT().PostSSZ(
 					gomock.Any(),
 					testCase.endpoint,
 					headers,
 					gomock.Any(),
-					nil,
 				).Return(
-					testSuite.returnedError,
+					nil, nil, testSuite.returnedError,
 				).Times(1)
 
+				// No JSON fallback expected for non-406 errors
+
 				validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 				_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
 				assert.ErrorContains(t, testSuite.expectedErrorMessage, err)
@@ -130,3 +133,546 @@ func TestProposeBeaconBlock_UnsupportedBlockType(t *testing.T) {
 	_, err := validatorClient.proposeBeaconBlock(t.Context(), &ethpb.GenericSignedBeaconBlock{})
 	assert.ErrorContains(t, "unsupported block type", err)
 }
+
+func TestProposeBeaconBlock_SSZSuccess_NoFallback(t *testing.T) {
+	testCases := []struct {
+		name             string
+		consensusVersion string
+		endpoint         string
+		block            *ethpb.GenericSignedBeaconBlock
+	}{
+		{
+			name:             "phase0",
+			consensusVersion: "phase0",
+			endpoint:         "/eth/v2/beacon/blocks",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedPhase0Block(),
+			},
+		},
+		{
+			name:             "altair",
+			consensusVersion: "altair",
+			endpoint:         "/eth/v2/beacon/blocks",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedAltairBlock(),
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			ctx := t.Context()
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			// Expect PostSSZ to be called and succeed
+			headers := map[string]string{
+				"Eth-Consensus-Version": testCase.consensusVersion,
+			}
+			jsonRestHandler.EXPECT().PostSSZ(
+				gomock.Any(),
+				testCase.endpoint,
+				headers,
+				gomock.Any(),
+			).Return(
+				nil, nil, nil,
+			).Times(1)
+
+			// Post should NOT be called when PostSSZ succeeds
+			jsonRestHandler.EXPECT().Post(
+				gomock.Any(),
+				gomock.Any(),
+				gomock.Any(),
+				gomock.Any(),
+				gomock.Any(),
+			).Times(0)
+
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
+			assert.NoError(t, err)
+		})
+	}
+}
+
+func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
+	t.Run("deneb", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+		var blockContents structs.SignedBeaconBlockContentsDeneb
+		err := json.Unmarshal([]byte(rpctesting.DenebBlockContents), &blockContents)
+		require.NoError(t, err)
+		genericSignedBlock, err := blockContents.ToGeneric()
+		require.NoError(t, err)
+
+		denebBytes, err := genericSignedBlock.GetDeneb().MarshalSSZ()
+		require.NoError(t, err)
+
+		jsonRestHandler.EXPECT().PostSSZ(
+			gomock.Any(),
+			"/eth/v2/beacon/blocks",
+			gomock.Any(),
+			bytes.NewBuffer(denebBytes),
+		)
+
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
+		assert.NoError(t, err)
+		require.NotNil(t, proposeResponse)
+
+		expectedBlockRoot, err := genericSignedBlock.GetDeneb().Block.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
+	})
+
+	t.Run("blinded_deneb", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+		var blindedBlock structs.SignedBlindedBeaconBlockDeneb
+		err := json.Unmarshal([]byte(rpctesting.BlindedDenebBlock), &blindedBlock)
+		require.NoError(t, err)
+		genericSignedBlock, err := blindedBlock.ToGeneric()
+		require.NoError(t, err)
+
+		blindedDenebBytes, err := genericSignedBlock.GetBlindedDeneb().MarshalSSZ()
+		require.NoError(t, err)
+
+		jsonRestHandler.EXPECT().PostSSZ(
+			gomock.Any(),
+			"/eth/v2/beacon/blinded_blocks",
+			gomock.Any(),
+			bytes.NewBuffer(blindedDenebBytes),
+		)
+
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
+		assert.NoError(t, err)
+		require.NotNil(t, proposeResponse)
+
+		expectedBlockRoot, err := genericSignedBlock.GetBlindedDeneb().HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
+	})
+
+	t.Run("electra", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+		var blockContents structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blockContents)
+		require.NoError(t, err)
+		genericSignedBlock, err := blockContents.ToGeneric()
+		require.NoError(t, err)
+
+		electraBytes, err := genericSignedBlock.GetElectra().MarshalSSZ()
+		require.NoError(t, err)
+
+		jsonRestHandler.EXPECT().PostSSZ(
+			gomock.Any(),
+			"/eth/v2/beacon/blocks",
+			gomock.Any(),
+			bytes.NewBuffer(electraBytes),
+		)
+
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
+		assert.NoError(t, err)
+		require.NotNil(t, proposeResponse)
+
+		expectedBlockRoot, err := genericSignedBlock.GetElectra().Block.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
+	})
+
+	t.Run("blinded_electra", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+		var blindedBlock structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blindedBlock)
+		require.NoError(t, err)
+		genericSignedBlock, err := blindedBlock.ToGeneric()
+		require.NoError(t, err)
+
+		blindedElectraBytes, err := genericSignedBlock.GetBlindedElectra().MarshalSSZ()
+		require.NoError(t, err)
+
+		jsonRestHandler.EXPECT().PostSSZ(
+			gomock.Any(),
+			"/eth/v2/beacon/blinded_blocks",
+			gomock.Any(),
+			bytes.NewBuffer(blindedElectraBytes),
+		)
+
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
+		assert.NoError(t, err)
+		require.NotNil(t, proposeResponse)
+
+		expectedBlockRoot, err := genericSignedBlock.GetBlindedElectra().HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
+	})
+
+	t.Run("fulu", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+		var blockContents structs.SignedBeaconBlockContentsFulu
+		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blockContents)
+		require.NoError(t, err)
+		genericSignedBlock, err := blockContents.ToGeneric()
+		require.NoError(t, err)
+
+		fuluBytes, err := genericSignedBlock.GetFulu().MarshalSSZ()
+		require.NoError(t, err)
+
+		jsonRestHandler.EXPECT().PostSSZ(
+			gomock.Any(),
+			"/eth/v2/beacon/blocks",
+			gomock.Any(),
+			bytes.NewBuffer(fuluBytes),
+		)
+
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
+		assert.NoError(t, err)
+		require.NotNil(t, proposeResponse)
+
+		expectedBlockRoot, err := genericSignedBlock.GetFulu().Block.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
+	})
+
+	t.Run("blinded_fulu", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+		var blindedBlock structs.SignedBlindedBeaconBlockFulu
+		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blindedBlock)
+		require.NoError(t, err)
+		genericSignedBlock, err := blindedBlock.ToGeneric()
+		require.NoError(t, err)
+
+		blindedFuluBytes, err := genericSignedBlock.GetBlindedFulu().MarshalSSZ()
+		require.NoError(t, err)
+
+		jsonRestHandler.EXPECT().PostSSZ(
+			gomock.Any(),
+			"/eth/v2/beacon/blinded_blocks",
+			gomock.Any(),
+			bytes.NewBuffer(blindedFuluBytes),
+		)
+
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
+		assert.NoError(t, err)
+		require.NotNil(t, proposeResponse)
+
+		expectedBlockRoot, err := genericSignedBlock.GetBlindedFulu().HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedBlockRoot[:], proposeResponse.BlockRoot)
+	})
+}
+
+// Generator functions for test blocks
+func generateSignedPhase0Block() *ethpb.GenericSignedBeaconBlock_Phase0 {
+	return &ethpb.GenericSignedBeaconBlock_Phase0{
+		Phase0: &ethpb.SignedBeaconBlock{
+			Block:     testhelpers.GenerateProtoPhase0BeaconBlock(),
+			Signature: testhelpers.FillByteSlice(96, 110),
+		},
+	}
+}
+
+func generateSignedAltairBlock() *ethpb.GenericSignedBeaconBlock_Altair {
+	return &ethpb.GenericSignedBeaconBlock_Altair{
+		Altair: &ethpb.SignedBeaconBlockAltair{
+			Block:     testhelpers.GenerateProtoAltairBeaconBlock(),
+			Signature: testhelpers.FillByteSlice(96, 112),
+		},
+	}
+}
+
+func generateSignedBellatrixBlock() *ethpb.GenericSignedBeaconBlock_Bellatrix {
+	return &ethpb.GenericSignedBeaconBlock_Bellatrix{
+		Bellatrix: &ethpb.SignedBeaconBlockBellatrix{
+			Block:     testhelpers.GenerateProtoBellatrixBeaconBlock(),
+			Signature: testhelpers.FillByteSlice(96, 127),
+		},
+	}
+}
+
+func generateSignedBlindedBellatrixBlock() *ethpb.GenericSignedBeaconBlock_BlindedBellatrix {
+	return &ethpb.GenericSignedBeaconBlock_BlindedBellatrix{
+		BlindedBellatrix: &ethpb.SignedBlindedBeaconBlockBellatrix{
+			Block: &ethpb.BlindedBeaconBlockBellatrix{
+				Slot:          1,
+				ProposerIndex: 2,
+				ParentRoot:    testhelpers.FillByteSlice(32, 3),
+				StateRoot:     testhelpers.FillByteSlice(32, 4),
+				Body: &ethpb.BlindedBeaconBlockBodyBellatrix{
+					RandaoReveal: testhelpers.FillByteSlice(96, 5),
+					Eth1Data: &ethpb.Eth1Data{
+						DepositRoot:  testhelpers.FillByteSlice(32, 6),
+						DepositCount: 7,
+						BlockHash:    testhelpers.FillByteSlice(32, 8),
+					},
+					Graffiti: testhelpers.FillByteSlice(32, 9),
+					ProposerSlashings: []*ethpb.ProposerSlashing{
+						{
+							Header_1: &ethpb.SignedBeaconBlockHeader{
+								Header: &ethpb.BeaconBlockHeader{
+									Slot:          10,
+									ProposerIndex: 11,
+									ParentRoot:    testhelpers.FillByteSlice(32, 12),
+									StateRoot:     testhelpers.FillByteSlice(32, 13),
+									BodyRoot:      testhelpers.FillByteSlice(32, 14),
+								},
+								Signature: testhelpers.FillByteSlice(96, 15),
+							},
+							Header_2: &ethpb.SignedBeaconBlockHeader{
+								Header: &ethpb.BeaconBlockHeader{
+									Slot:          16,
+									ProposerIndex: 17,
+									ParentRoot:    testhelpers.FillByteSlice(32, 18),
+									StateRoot:     testhelpers.FillByteSlice(32, 19),
+									BodyRoot:      testhelpers.FillByteSlice(32, 20),
+								},
+								Signature: testhelpers.FillByteSlice(96, 21),
+							},
+						},
+					},
+					AttesterSlashings: []*ethpb.AttesterSlashing{},
+					Attestations:      []*ethpb.Attestation{},
+					Deposits:          []*ethpb.Deposit{},
+					VoluntaryExits:    []*ethpb.SignedVoluntaryExit{},
+					SyncAggregate: &ethpb.SyncAggregate{
+						SyncCommitteeBits:      testhelpers.FillByteSlice(64, 100),
+						SyncCommitteeSignature: testhelpers.FillByteSlice(96, 101),
+					},
+					ExecutionPayloadHeader: &engine.ExecutionPayloadHeader{
+						ParentHash:       testhelpers.FillByteSlice(32, 102),
+						FeeRecipient:     testhelpers.FillByteSlice(20, 103),
+						StateRoot:        testhelpers.FillByteSlice(32, 104),
+						ReceiptsRoot:     testhelpers.FillByteSlice(32, 105),
+						LogsBloom:        testhelpers.FillByteSlice(256, 106),
+						PrevRandao:       testhelpers.FillByteSlice(32, 107),
+						BlockNumber:      108,
+						GasLimit:         109,
+						GasUsed:          110,
+						Timestamp:        111,
+						ExtraData:        testhelpers.FillByteSlice(32, 112),
+						BaseFeePerGas:    testhelpers.FillByteSlice(32, 113),
+						BlockHash:        testhelpers.FillByteSlice(32, 114),
+						TransactionsRoot: testhelpers.FillByteSlice(32, 115),
+					},
+				},
+			},
+			Signature: testhelpers.FillByteSlice(96, 116),
+		},
+	}
+}
+
+func generateSignedCapellaBlock() *ethpb.GenericSignedBeaconBlock_Capella {
+	return &ethpb.GenericSignedBeaconBlock_Capella{
+		Capella: &ethpb.SignedBeaconBlockCapella{
+			Block:     testhelpers.GenerateProtoCapellaBeaconBlock(),
+			Signature: testhelpers.FillByteSlice(96, 127),
+		},
+	}
+}
+
+func generateSignedBlindedCapellaBlock() *ethpb.GenericSignedBeaconBlock_BlindedCapella {
+	return &ethpb.GenericSignedBeaconBlock_BlindedCapella{
+		BlindedCapella: &ethpb.SignedBlindedBeaconBlockCapella{
+			Block: &ethpb.BlindedBeaconBlockCapella{
+				Slot:          1,
+				ProposerIndex: 2,
+				ParentRoot:    testhelpers.FillByteSlice(32, 3),
+				StateRoot:     testhelpers.FillByteSlice(32, 4),
+				Body: &ethpb.BlindedBeaconBlockBodyCapella{
+					RandaoReveal: testhelpers.FillByteSlice(96, 5),
+					Eth1Data: &ethpb.Eth1Data{
+						DepositRoot:  testhelpers.FillByteSlice(32, 6),
+						DepositCount: 7,
+						BlockHash:    testhelpers.FillByteSlice(32, 8),
+					},
+					Graffiti: testhelpers.FillByteSlice(32, 9),
+					ProposerSlashings: []*ethpb.ProposerSlashing{
+						{
+							Header_1: &ethpb.SignedBeaconBlockHeader{
+								Header: &ethpb.BeaconBlockHeader{
+									Slot:          10,
+									ProposerIndex: 11,
+									ParentRoot:    testhelpers.FillByteSlice(32, 12),
+									StateRoot:     testhelpers.FillByteSlice(32, 13),
+									BodyRoot:      testhelpers.FillByteSlice(32, 14),
+								},
+								Signature: testhelpers.FillByteSlice(96, 15),
+							},
+							Header_2: &ethpb.SignedBeaconBlockHeader{
+								Header: &ethpb.BeaconBlockHeader{
+									Slot:          16,
+									ProposerIndex: 17,
+									ParentRoot:    testhelpers.FillByteSlice(32, 18),
+									StateRoot:     testhelpers.FillByteSlice(32, 19),
+									BodyRoot:      testhelpers.FillByteSlice(32, 20),
+								},
+								Signature: testhelpers.FillByteSlice(96, 21),
+							},
+						},
+					},
+					AttesterSlashings: []*ethpb.AttesterSlashing{},
+					Attestations:      []*ethpb.Attestation{},
+					Deposits:          []*ethpb.Deposit{},
+					VoluntaryExits:    []*ethpb.SignedVoluntaryExit{},
+					SyncAggregate: &ethpb.SyncAggregate{
+						SyncCommitteeBits:      testhelpers.FillByteSlice(64, 37),
+						SyncCommitteeSignature: testhelpers.FillByteSlice(96, 38),
+					},
+					ExecutionPayloadHeader: &engine.ExecutionPayloadHeaderCapella{
+						ParentHash:       testhelpers.FillByteSlice(32, 39),
+						FeeRecipient:     testhelpers.FillByteSlice(20, 40),
+						StateRoot:        testhelpers.FillByteSlice(32, 41),
+						ReceiptsRoot:     testhelpers.FillByteSlice(32, 42),
+						LogsBloom:        testhelpers.FillByteSlice(256, 43),
+						PrevRandao:       testhelpers.FillByteSlice(32, 44),
+						BlockNumber:      45,
+						GasLimit:         46,
+						GasUsed:          47,
+						Timestamp:        48,
+						ExtraData:        testhelpers.FillByteSlice(32, 49),
+						BaseFeePerGas:    testhelpers.FillByteSlice(32, 50),
+						BlockHash:        testhelpers.FillByteSlice(32, 51),
+						TransactionsRoot: testhelpers.FillByteSlice(32, 52),
+						WithdrawalsRoot:  testhelpers.FillByteSlice(32, 53),
+					},
+					BlsToExecutionChanges: []*ethpb.SignedBLSToExecutionChange{},
+				},
+			},
+			Signature: testhelpers.FillByteSlice(96, 54),
+		},
+	}
+}
+
+func TestProposeBeaconBlock_SSZFails_406_FallbackToJSON(t *testing.T) {
+	testCases := []struct {
+		name             string
+		consensusVersion string
+		endpoint         string
+		block            *ethpb.GenericSignedBeaconBlock
+	}{
+		{
+			name:             "phase0",
+			consensusVersion: "phase0",
+			endpoint:         "/eth/v2/beacon/blocks",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedPhase0Block(),
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			ctx := t.Context()
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			// Expect PostSSZ to be called first and fail
+			jsonRestHandler.EXPECT().PostSSZ(
+				gomock.Any(),
+				testCase.endpoint,
+				gomock.Any(),
+				gomock.Any(),
+			).Return(
+				nil, nil, &httputil.DefaultJsonError{
+					Code:    http.StatusNotAcceptable,
+					Message: "SSZ not supported",
+				},
+			).Times(1)
+
+			jsonRestHandler.EXPECT().Post(
+				gomock.Any(),
+				testCase.endpoint,
+				gomock.Any(),
+				gomock.Any(),
+				nil,
+			).Return(
+				nil,
+			).Times(1)
+
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
+			assert.NoError(t, err)
+		})
+	}
+}
+
+func TestProposeBeaconBlock_SSZFails_Non406_NoFallback(t *testing.T) {
+	testCases := []struct {
+		name             string
+		consensusVersion string
+		endpoint         string
+		block            *ethpb.GenericSignedBeaconBlock
+	}{
+		{
+			name:             "phase0",
+			consensusVersion: "phase0",
+			endpoint:         "/eth/v2/beacon/blocks",
+			block: &ethpb.GenericSignedBeaconBlock{
+				Block: generateSignedPhase0Block(),
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			ctx := t.Context()
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+
+			// Expect PostSSZ to be called first and fail with non-406 error
+			sszHeaders := map[string]string{
+				"Eth-Consensus-Version": testCase.consensusVersion,
+			}
+			jsonRestHandler.EXPECT().PostSSZ(
+				gomock.Any(),
+				testCase.endpoint,
+				sszHeaders,
+				gomock.Any(),
+			).Return(
+				nil, nil, &httputil.DefaultJsonError{
+					Code:    http.StatusInternalServerError,
+					Message: "Internal server error",
+				},
+			).Times(1)
+
+			// Post should NOT be called for non-406 errors
+			jsonRestHandler.EXPECT().Post(
+				gomock.Any(),
+				gomock.Any(),
+				gomock.Any(),
+				gomock.Any(),
+				gomock.Any(),
+			).Times(0)
+
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
+			require.ErrorContains(t, "Internal server error", err)
+		})
+	}
+}

validator/client/beacon-api/rest_handler_client.go

@@ -25,6 +25,7 @@ type RestHandler interface {
 	Get(ctx context.Context, endpoint string, resp interface{}) error
 	GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error)
 	Post(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer, resp interface{}) error
+	PostSSZ(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer) ([]byte, http.Header, error)
 	HttpClient() *http.Client
 	Host() string
 	SetHost(host string)
@@ -179,6 +180,75 @@ func (c *BeaconApiRestHandler) Post(
 	return decodeResp(httpResp, resp)
 }
 
+// PostSSZ sends a POST request and prefers an SSZ (application/octet-stream) response body.
+func (c *BeaconApiRestHandler) PostSSZ(
+	ctx context.Context,
+	apiEndpoint string,
+	headers map[string]string,
+	data *bytes.Buffer,
+) ([]byte, http.Header, error) {
+	if data == nil {
+		return nil, nil, errors.New("data is nil")
+	}
+	url := c.host + apiEndpoint
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, data)
+	if err != nil {
+		return nil, nil, errors.Wrapf(err, "failed to create request for endpoint %s", url)
+	}
+
+	// Accept header: prefer octet-stream (SSZ), fall back to JSON
+	primaryAcceptType := fmt.Sprintf("%s;q=%s", api.OctetStreamMediaType, "0.95")
+	secondaryAcceptType := fmt.Sprintf("%s;q=%s", api.JsonMediaType, "0.9")
+	acceptHeaderString := fmt.Sprintf("%s,%s", primaryAcceptType, secondaryAcceptType)
+	req.Header.Set("Accept", acceptHeaderString)
+
+	// User-supplied headers
+	for headerKey, headerValue := range headers {
+		req.Header.Set(headerKey, headerValue)
+	}
+
+	for _, o := range c.reqOverrides {
+		o(req)
+	}
+	req.Header.Set("Content-Type", api.OctetStreamMediaType)
+	req.Header.Set("User-Agent", version.BuildData())
+	httpResp, err := c.client.Do(req)
+	if err != nil {
+		return nil, nil, errors.Wrapf(err, "failed to perform request for endpoint %s", url)
+	}
+	defer func() {
+		if err := httpResp.Body.Close(); err != nil {
+			return
+		}
+	}()
+
+	accept := req.Header.Get("Accept")
+	contentType := httpResp.Header.Get("Content-Type")
+	body, err := io.ReadAll(httpResp.Body)
+	if err != nil {
+		return nil, nil, errors.Wrapf(err, "failed to read response body for %s", httpResp.Request.URL)
+	}
+
+	if !apiutil.PrimaryAcceptMatches(accept, contentType) {
+		log.WithFields(logrus.Fields{
+			"Accept":       accept,
+			"Content-Type": contentType,
+		}).Debug("Server responded with non primary accept type")
+	}
+
+	// non-2XX codes are a failure
+	if !strings.HasPrefix(httpResp.Status, "2") {
+		decoder := json.NewDecoder(bytes.NewBuffer(body))
+		errorJson := &httputil.DefaultJsonError{}
+		if err = decoder.Decode(errorJson); err != nil {
+			return nil, nil, errors.Wrapf(err, "failed to decode response body into error json for %s", httpResp.Request.URL)
+		}
+		return nil, nil, errorJson
+	}
+
+	return body, httpResp.Header, nil
+}
+
 func decodeResp(httpResp *http.Response, resp interface{}) error {
 	body, err := io.ReadAll(httpResp.Body)
 	if err != nil {