fix gloas proposal endpoint support

beacon-chain/rpc/endpoints.go

@@ -426,7 +426,7 @@ func (s *Service) validatorEndpoints(
 			template: "/eth/v1/validator/execution_payload_envelope/{slot}",
 			name:     namespace + ".ExecutionPayloadEnvelope",
 			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.ExecutionPayloadEnvelope,
 			methods: []string{http.MethodGet},
@@ -935,7 +935,7 @@ func (s *Service) beaconEndpoints(
 			template: "/eth/v1/beacon/execution_payload_envelope",
 			name:     namespace + ".PublishExecutionPayloadEnvelope",
 			middleware: []middleware.Middleware{
-				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
+				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 			},
 			handler: server.PublishExecutionPayloadEnvelope,

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

@@ -26,6 +26,7 @@ go_library(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
+        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -111,6 +112,7 @@ go_test(
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//beacon-chain/state/stategen/mock:go_default_library",
         "//beacon-chain/sync/initial-sync/testing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

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

@@ -38,6 +38,7 @@ import (
 
 const (
 	broadcastValidationQueryParam               = "broadcast_validation"
+	broadcastValidationGossip                   = "gossip"
 	broadcastValidationConsensus                = "consensus"
 	broadcastValidationConsensusAndEquivocation = "consensus_and_equivocation"
 )

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

@@ -1,6 +1,7 @@
 package beacon
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"io"
@@ -9,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/shared"
@@ -104,27 +106,51 @@ func (s *Server) PublishExecutionPayloadEnvelope(w http.ResponseWriter, r *http.
 		return
 	}
 
-	// Contents wraps the signed envelope alongside blobs/kzg_proofs; the
-	// wrapper key distinguishes it from a bare envelope body.
-	var probe map[string]json.RawMessage
-	if err := json.Unmarshal(body, &probe); err != nil {
-		httputil.HandleError(w, "could not decode request body: "+err.Error(), http.StatusBadRequest)
-		return
-	}
-	if _, isContents := probe["signed_execution_payload_envelope"]; isContents {
-		s.publishExecutionPayloadEnvelopeContents(ctx, w, body)
-		return
-	}
+	var consensus *eth.SignedExecutionPayloadEnvelope
+	if httputil.IsRequestSsz(r) {
+		// Dispatch by SSZ lead offset: 12 = Contents, 100 = bare envelope.
+		contentsLeadOffset := []byte{12, 0, 0, 0}
+		if bytes.HasPrefix(body, contentsLeadOffset) {
+			contents := &eth.SignedExecutionPayloadEnvelopeContents{}
+			if err := contents.UnmarshalSSZ(body); err != nil {
+				httputil.HandleError(w, "could not decode SSZ envelope contents: "+err.Error(), http.StatusBadRequest)
+				return
+			}
+			s.publishExecutionPayloadEnvelopeContentsSSZ(ctx, w, r, contents)
+			return
+		}
+		consensus = &eth.SignedExecutionPayloadEnvelope{}
+		if err := consensus.UnmarshalSSZ(body); err != nil {
+			httputil.HandleError(w, "could not decode SSZ envelope: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+	} else {
+		// Contents wraps the signed envelope alongside blobs/kzg_proofs; the
+		// wrapper key distinguishes it from a bare envelope body.
+		var probe map[string]json.RawMessage
+		if err := json.Unmarshal(body, &probe); err != nil {
+			httputil.HandleError(w, "could not decode request body: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		if _, isContents := probe["signed_execution_payload_envelope"]; isContents {
+			s.publishExecutionPayloadEnvelopeContents(ctx, w, r, body)
+			return
+		}
 
-	var jsonEnvelope structs.SignedExecutionPayloadEnvelope
-	if err := json.Unmarshal(body, &jsonEnvelope); err != nil {
-		httputil.HandleError(w, "could not decode request body: "+err.Error(), http.StatusBadRequest)
-		return
+		var jsonEnvelope structs.SignedExecutionPayloadEnvelope
+		if err := json.Unmarshal(body, &jsonEnvelope); err != nil {
+			httputil.HandleError(w, "could not decode request body: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		consensus, err = jsonEnvelope.ToConsensus()
+		if err != nil {
+			httputil.HandleError(w, "invalid signed execution payload envelope: "+err.Error(), http.StatusBadRequest)
+			return
+		}
 	}
 
-	consensus, err := jsonEnvelope.ToConsensus()
-	if err != nil {
-		httputil.HandleError(w, "invalid signed execution payload envelope: "+err.Error(), http.StatusBadRequest)
+	if err := s.validateEnvelopeBroadcast(ctx, r, consensus); err != nil {
+		httputil.HandleError(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 
@@ -145,10 +171,8 @@ func (s *Server) PublishExecutionPayloadEnvelope(w http.ResponseWriter, r *http.
 	w.WriteHeader(http.StatusOK)
 }
 
-// publishExecutionPayloadEnvelopeContents handles the stateless variant:
-// verifies caller-supplied blobs/proofs, broadcasts derived sidecars, then
-// delegates the envelope to the bare publish path.
-func (s *Server) publishExecutionPayloadEnvelopeContents(ctx context.Context, w http.ResponseWriter, body []byte) {
+// publishExecutionPayloadEnvelopeContents handles the JSON stateless variant.
+func (s *Server) publishExecutionPayloadEnvelopeContents(ctx context.Context, w http.ResponseWriter, r *http.Request, body []byte) {
 	var contents structs.SignedExecutionPayloadEnvelopeContents
 	if err := json.Unmarshal(body, &contents); err != nil {
 		httputil.HandleError(w, "could not decode envelope contents: "+err.Error(), http.StatusBadRequest)
@@ -159,6 +183,25 @@ func (s *Server) publishExecutionPayloadEnvelopeContents(ctx context.Context, w
 		httputil.HandleError(w, "invalid signed execution payload envelope contents: "+err.Error(), http.StatusBadRequest)
 		return
 	}
+	s.processEnvelopeContents(ctx, w, r, signed, kzgProofs, blobs)
+}
+
+// publishExecutionPayloadEnvelopeContentsSSZ handles the SSZ stateless variant.
+func (s *Server) publishExecutionPayloadEnvelopeContentsSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, contents *eth.SignedExecutionPayloadEnvelopeContents) {
+	if contents == nil || contents.SignedExecutionPayloadEnvelope == nil {
+		httputil.HandleError(w, "nil signed execution payload envelope contents", http.StatusBadRequest)
+		return
+	}
+	s.processEnvelopeContents(ctx, w, r, contents.SignedExecutionPayloadEnvelope, contents.KzgProofs, contents.Blobs)
+}
+
+// processEnvelopeContents verifies caller-supplied blobs/proofs, broadcasts
+// derived sidecars, then delegates the envelope to the bare publish path.
+func (s *Server) processEnvelopeContents(ctx context.Context, w http.ResponseWriter, r *http.Request, signed *eth.SignedExecutionPayloadEnvelope, kzgProofs, blobs [][]byte) {
+	if err := s.validateEnvelopeBroadcast(ctx, r, signed); err != nil {
+		httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
 
 	if len(blobs) > 0 {
 		blockRoot := bytesutil.ToBytes32(signed.Message.BeaconBlockRoot)
@@ -207,6 +250,50 @@ func (s *Server) publishExecutionPayloadEnvelopeContents(ctx context.Context, w
 	w.WriteHeader(http.StatusOK)
 }
 
+// validateEnvelopeBroadcast applies broadcast_validation semantics to an
+// envelope publish before it is broadcast to gossip. Spec: beacon-APIs #580.
+//   - gossip (default): no extra checks.
+//   - consensus: run full envelope consensus checks (signature + payload
+//     consistency against the pre-state at envelope.beacon_block_root).
+//   - consensus_and_equivocation: consensus + reject if a different beacon
+//     block at the envelope's slot has already been received.
+func (s *Server) validateEnvelopeBroadcast(ctx context.Context, r *http.Request, signed *eth.SignedExecutionPayloadEnvelope) error {
+	level := r.URL.Query().Get(broadcastValidationQueryParam)
+	switch level {
+	case "", broadcastValidationGossip:
+		return nil
+	case broadcastValidationConsensus, broadcastValidationConsensusAndEquivocation:
+	default:
+		return errors.Errorf("invalid %s value: %q", broadcastValidationQueryParam, level)
+	}
+
+	envSlot := primitives.Slot(signed.Message.Payload.SlotNumber)
+	envRoot := bytesutil.ToBytes32(signed.Message.BeaconBlockRoot)
+
+	if level == broadcastValidationConsensusAndEquivocation {
+		if s.ForkchoiceFetcher.HighestReceivedBlockSlot() == envSlot &&
+			s.ForkchoiceFetcher.HighestReceivedBlockRoot() != envRoot {
+			return errors.Wrapf(errEquivocatedBlock, "another block for slot %d already exists in fork choice", envSlot)
+		}
+	}
+
+	st, err := s.StateGenService.StateByRoot(ctx, envRoot)
+	if err != nil {
+		return errors.Wrap(err, "could not get state for envelope beacon block root")
+	}
+	if st == nil || st.IsNil() {
+		return errors.Errorf("could not get state for envelope beacon block root %#x", envRoot)
+	}
+	roSigned, err := consensusblocks.WrappedROSignedExecutionPayloadEnvelope(signed)
+	if err != nil {
+		return errors.Wrap(err, "could not wrap signed envelope")
+	}
+	if err := gloas.VerifyExecutionPayloadEnvelope(ctx, st, roSigned); err != nil {
+		return errors.Wrap(err, "consensus validation failed")
+	}
+	return nil
+}
+
 // verifyCellProofs batch-verifies cell proofs against commitments derived
 // from the supplied blobs. Does not tie data to a specific block — that needs
 // the block's BlobKzgCommitments which a stateless receiver may not have.