Grpc stateless gloas

api/server/structs/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "conversions_blob.go",
         "conversions_block.go",
         "conversions_block_execution.go",
+        "conversions_block_gloas.go",
         "conversions_gloas.go",
         "conversions_lightclient.go",
         "conversions_state.go",

api/server/structs/block.go

@@ -614,3 +614,17 @@ type SignedExecutionPayloadEnvelopeContents struct {
 	KzgProofs                      []string                        `json:"kzg_proofs"`
 	Blobs                          []string                        `json:"blobs"`
 }
+
+// BlindedExecutionPayloadEnvelope replaces the full payload with payload_root so its HTR matches the full envelope.
+type BlindedExecutionPayloadEnvelope struct {
+	PayloadRoot           string             `json:"payload_root"`
+	ExecutionRequests     *ExecutionRequests `json:"execution_requests"`
+	BuilderIndex          string             `json:"builder_index"`
+	BeaconBlockRoot       string             `json:"beacon_block_root"`
+	ParentBeaconBlockRoot string             `json:"parent_beacon_block_root"`
+}
+
+type SignedBlindedExecutionPayloadEnvelope struct {
+	Message   *BlindedExecutionPayloadEnvelope `json:"message"`
+	Signature string                           `json:"signature"`
+}

api/server/structs/conversions_block.go

@@ -3342,168 +3342,3 @@ func (p *PayloadAttestationMessage) ToConsensus() (*eth.PayloadAttestationMessag
 		Signature:      sig,
 	}, nil
 }
-
-// ExecutionPayloadEnvelopeFromConsensus converts a proto envelope to the API struct.
-func ExecutionPayloadEnvelopeFromConsensus(e *eth.ExecutionPayloadEnvelope) (*ExecutionPayloadEnvelope, error) {
-	payload, err := ExecutionPayloadGloasFromConsensus(e.Payload)
-	if err != nil {
-		return nil, err
-	}
-	var requests *ExecutionRequests
-	if e.ExecutionRequests != nil {
-		requests = ExecutionRequestsFromConsensus(e.ExecutionRequests)
-	}
-	return &ExecutionPayloadEnvelope{
-		Payload:               payload,
-		ExecutionRequests:     requests,
-		BuilderIndex:          fmt.Sprintf("%d", e.BuilderIndex),
-		BeaconBlockRoot:       hexutil.Encode(e.BeaconBlockRoot),
-		ParentBeaconBlockRoot: hexutil.Encode(e.ParentBeaconBlockRoot),
-	}, nil
-}
-
-// SignedExecutionPayloadEnvelopeFromConsensus converts a signed proto envelope to the API struct.
-func SignedExecutionPayloadEnvelopeFromConsensus(e *eth.SignedExecutionPayloadEnvelope) (*SignedExecutionPayloadEnvelope, error) {
-	envelope, err := ExecutionPayloadEnvelopeFromConsensus(e.Message)
-	if err != nil {
-		return nil, err
-	}
-	return &SignedExecutionPayloadEnvelope{
-		Message:   envelope,
-		Signature: hexutil.Encode(e.Signature),
-	}, nil
-}
-
-// BlockContentsGloasFromConsensus converts a proto Gloas block, envelope, and
-// blob data to the API struct.
-func BlockContentsGloasFromConsensus(block *eth.BeaconBlockGloas, envelope *eth.ExecutionPayloadEnvelope, kzgProofs [][]byte, blobs [][]byte) (*BlockContentsGloas, error) {
-	b, err := BeaconBlockGloasFromConsensus(block)
-	if err != nil {
-		return nil, err
-	}
-	env, err := ExecutionPayloadEnvelopeFromConsensus(envelope)
-	if err != nil {
-		return nil, err
-	}
-	encodedProofs := make([]string, len(kzgProofs))
-	for i, p := range kzgProofs {
-		encodedProofs[i] = hexutil.Encode(p)
-	}
-	encodedBlobs := make([]string, len(blobs))
-	for i, b := range blobs {
-		encodedBlobs[i] = hexutil.Encode(b)
-	}
-	return &BlockContentsGloas{
-		Block:                    b,
-		ExecutionPayloadEnvelope: env,
-		KzgProofs:                encodedProofs,
-		Blobs:                    encodedBlobs,
-	}, nil
-}
-
-// ToConsensus converts the API struct to a proto ExecutionPayloadEnvelope.
-func (e *ExecutionPayloadEnvelope) ToConsensus() (*eth.ExecutionPayloadEnvelope, error) {
-	if e == nil {
-		return nil, server.NewDecodeError(errNilValue, "ExecutionPayloadEnvelope")
-	}
-	payload, err := e.Payload.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Payload")
-	}
-	var requests *enginev1.ExecutionRequests
-	if e.ExecutionRequests != nil {
-		requests, err = e.ExecutionRequests.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, "ExecutionRequests")
-		}
-	}
-	builderIndex, err := strconv.ParseUint(e.BuilderIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BuilderIndex")
-	}
-	beaconBlockRoot, err := bytesutil.DecodeHexWithLength(e.BeaconBlockRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BeaconBlockRoot")
-	}
-	parentBeaconBlockRoot, err := bytesutil.DecodeHexWithLength(e.ParentBeaconBlockRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentBeaconBlockRoot")
-	}
-	return &eth.ExecutionPayloadEnvelope{
-		Payload:               payload,
-		ExecutionRequests:     requests,
-		BuilderIndex:          primitives.BuilderIndex(builderIndex),
-		BeaconBlockRoot:       beaconBlockRoot,
-		ParentBeaconBlockRoot: parentBeaconBlockRoot,
-	}, nil
-}
-
-// ToConsensus converts the API struct to a proto SignedExecutionPayloadEnvelope.
-func (e *SignedExecutionPayloadEnvelope) ToConsensus() (*eth.SignedExecutionPayloadEnvelope, error) {
-	if e == nil {
-		return nil, server.NewDecodeError(errNilValue, "SignedExecutionPayloadEnvelope")
-	}
-	msg, err := e.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Message")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(e.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	return &eth.SignedExecutionPayloadEnvelope{
-		Message:   msg,
-		Signature: sig,
-	}, nil
-}
-
-// SignedExecutionPayloadEnvelopeContentsFromConsensus builds the API struct
-// used for stateless envelope publishing from native components.
-func SignedExecutionPayloadEnvelopeContentsFromConsensus(signed *eth.SignedExecutionPayloadEnvelope, kzgProofs [][]byte, blobs [][]byte) (*SignedExecutionPayloadEnvelopeContents, error) {
-	signedJSON, err := SignedExecutionPayloadEnvelopeFromConsensus(signed)
-	if err != nil {
-		return nil, err
-	}
-	encodedProofs := make([]string, len(kzgProofs))
-	for i, p := range kzgProofs {
-		encodedProofs[i] = hexutil.Encode(p)
-	}
-	encodedBlobs := make([]string, len(blobs))
-	for i, b := range blobs {
-		encodedBlobs[i] = hexutil.Encode(b)
-	}
-	return &SignedExecutionPayloadEnvelopeContents{
-		SignedExecutionPayloadEnvelope: signedJSON,
-		KzgProofs:                      encodedProofs,
-		Blobs:                          encodedBlobs,
-	}, nil
-}
-
-// ToConsensus decodes the API struct into the signed envelope plus raw blob and
-// KZG proof bytes used by the stateless publish path.
-func (c *SignedExecutionPayloadEnvelopeContents) ToConsensus() (*eth.SignedExecutionPayloadEnvelope, [][]byte, [][]byte, error) {
-	if c == nil {
-		return nil, nil, nil, server.NewDecodeError(errNilValue, "SignedExecutionPayloadEnvelopeContents")
-	}
-	signed, err := c.SignedExecutionPayloadEnvelope.ToConsensus()
-	if err != nil {
-		return nil, nil, nil, server.NewDecodeError(err, "SignedExecutionPayloadEnvelope")
-	}
-	proofs := make([][]byte, len(c.KzgProofs))
-	for i, p := range c.KzgProofs {
-		proof, err := bytesutil.DecodeHexWithLength(p, 48)
-		if err != nil {
-			return nil, nil, nil, server.NewDecodeError(err, fmt.Sprintf("KzgProofs[%d]", i))
-		}
-		proofs[i] = proof
-	}
-	blobs := make([][]byte, len(c.Blobs))
-	for i, b := range c.Blobs {
-		blob, err := bytesutil.DecodeHexWithLength(b, fieldparams.BlobSize)
-		if err != nil {
-			return nil, nil, nil, server.NewDecodeError(err, fmt.Sprintf("Blobs[%d]", i))
-		}
-		blobs[i] = blob
-	}
-	return signed, proofs, blobs, nil
-}