Add getHeader SSZ support

.golangci.yml

@@ -30,6 +30,7 @@ linters:
     - goconst
     - gosec
     - ireturn
+    - maintidx
     - noctx
     - tagliatelle
     - perfsprint

server/accept.go

@@ -0,0 +1,40 @@
+package server
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// AcceptEntry represents a parsed Accept header entry with q-weight.
+type AcceptEntry struct {
+	MediaType string
+	QValue    float64
+}
+
+// ParseAcceptHeader parses and sorts the Accept header by q-values.
+func ParseAcceptHeader(header string) []AcceptEntry {
+	rawAcceptValues := strings.Split(header, ",")
+	entries := make([]AcceptEntry, 0, len(rawAcceptValues))
+
+	for _, part := range rawAcceptValues {
+		mediaQ := strings.Split(strings.TrimSpace(part), ";")
+		mediaType := mediaQ[0]
+		qValue := 1.0 // Default q-value if not specified
+
+		if len(mediaQ) > 1 && strings.HasPrefix(mediaQ[1], "q=") {
+			if q, err := strconv.ParseFloat(strings.TrimPrefix(mediaQ[1], "q="), 64); err == nil {
+				qValue = q
+			}
+		}
+
+		entries = append(entries, AcceptEntry{MediaType: mediaType, QValue: qValue})
+	}
+
+	// Sort by q-value (highest first)
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].QValue > entries[j].QValue
+	})
+
+	return entries
+}

server/get_header.go

@@ -2,12 +2,19 @@ package server
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"sync"
 	"time"
 
+	builderApiBellatrix "github.com/attestantio/go-builder-client/api/bellatrix"
+	builderApiCapella "github.com/attestantio/go-builder-client/api/capella"
+	builderApiDeneb "github.com/attestantio/go-builder-client/api/deneb"
+	builderApiElectra "github.com/attestantio/go-builder-client/api/electra"
 	builderSpec "github.com/attestantio/go-builder-client/spec"
+	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/flashbots/mev-boost/config"
 	"github.com/flashbots/mev-boost/server/types"
@@ -16,7 +23,7 @@ import (
 )
 
 // getHeader requests a bid from each relay and returns the most profitable one
-func (m *BoostService) getHeader(log *logrus.Entry, ua UserAgent, slot phase0.Slot, pubkey, parentHashHex string) (bidResp, error) {
+func (m *BoostService) getHeader(log *logrus.Entry, slot phase0.Slot, pubkey, parentHashHex string, header http.Header) (bidResp, error) {
 	// Ensure arguments are valid
 	if len(pubkey) != 98 {
 		return bidResp{}, errInvalidPubkey
@@ -44,11 +51,9 @@ func (m *BoostService) getHeader(log *logrus.Entry, ua UserAgent, slot phase0.Sl
 		"msIntoSlot":  msIntoSlot,
 	}).Infof("getHeader request start - %d milliseconds into slot %d", msIntoSlot, slot)
 
-	// Add request headers
-	headers := map[string]string{
-		HeaderKeySlotUID:      slotUID.String(),
-		HeaderStartTimeUnixMS: fmt.Sprintf("%d", time.Now().UTC().UnixMilli()),
-	}
+	// Get the optional version, used with SSZ decoding
+	ethConsensusVersion := header.Get("Eth-Consensus-Version")
+	log = log.WithField("ethConsensusVersion", ethConsensusVersion)
 
 	var (
 		mu sync.Mutex
@@ -71,18 +76,60 @@ func (m *BoostService) getHeader(log *logrus.Entry, ua UserAgent, slot phase0.Sl
 			url := relay.GetURI(fmt.Sprintf("/eth/v1/builder/header/%d/%s/%s", slot, parentHashHex, pubkey))
 			log := log.WithField("url", url)
 
-			// Send the get bid request to the relay
-			bid := new(builderSpec.VersionedSignedBuilderBid)
-			code, err := SendHTTPRequest(context.Background(), m.httpClientGetHeader, http.MethodGet, url, ua, headers, nil, bid)
+			// Make a new request
+			req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, url, nil)
 			if err != nil {
-				log.WithError(err).Warn("error making request to relay")
+				log.WithError(err).Warn("error creating new request")
 				return
 			}
-			if code == http.StatusNoContent {
+
+			// Add headers from the request to this request.
+			// This includes Accept and Eth-Consensus-Version, if provided.
+			for key, values := range header {
+				req.Header[key] = values
+			}
+
+			// Send the request
+			log.Debug("requesting header")
+			resp, err := m.httpClientGetHeader.Do(req)
+			if err != nil {
+				log.WithError(err).Warn("error calling getHeader on relay")
+				return
+			}
+			defer resp.Body.Close()
+
+			// Check if no header is available
+			if resp.StatusCode == http.StatusNoContent {
 				log.Debug("no-content response")
 				return
 			}
 
+			// Check that the response was successful
+			if resp.StatusCode != http.StatusOK {
+				err = fmt.Errorf("%w: %d", errHTTPErrorResponse, resp.StatusCode)
+				log.WithError(err).Warn("error status code")
+				return
+			}
+
+			// Get the resp body content
+			respBytes, err := io.ReadAll(resp.Body)
+			if err != nil {
+				log.WithError(err).Warn("error reading response body")
+				return
+			}
+
+			// Get the response's content type
+			respContentType := resp.Header.Get("Content-Type")
+			log = log.WithField("respContentType", respContentType)
+
+			// Decode bid
+			bid := new(builderSpec.VersionedSignedBuilderBid)
+			err = decodeBid(respBytes, respContentType, ethConsensusVersion, bid)
+			if err != nil {
+				log.WithError(err).Warn("error decoding bid")
+				return
+			}
+
 			// Skip if bid is empty
 			if bid.IsEmpty() {
 				return
@@ -189,3 +236,39 @@ func (m *BoostService) getHeader(log *logrus.Entry, ua UserAgent, slot phase0.Sl
 	result.relays = relays[BlockHashHex(result.bidInfo.blockHash.String())]
 	return result, nil
 }
+
+// decodeBid decodes a bid by SSZ or JSON, depending on the provided respContentType
+func decodeBid(respBytes []byte, respContentType, ethConsensusVersion string, bid *builderSpec.VersionedSignedBuilderBid) error {
+	switch respContentType {
+	case MediaTypeOctetStream:
+		if ethConsensusVersion != "" {
+			// Do SSZ decoding
+			switch ethConsensusVersion {
+			case "bellatrix":
+				bid.Version = spec.DataVersionBellatrix
+				bid.Bellatrix = new(builderApiBellatrix.SignedBuilderBid)
+				return bid.Bellatrix.UnmarshalSSZ(respBytes)
+			case "capella":
+				bid.Version = spec.DataVersionCapella
+				bid.Capella = new(builderApiCapella.SignedBuilderBid)
+				return bid.Capella.UnmarshalSSZ(respBytes)
+			case "deneb":
+				bid.Version = spec.DataVersionDeneb
+				bid.Deneb = new(builderApiDeneb.SignedBuilderBid)
+				return bid.Deneb.UnmarshalSSZ(respBytes)
+			case "electra":
+				bid.Version = spec.DataVersionElectra
+				bid.Electra = new(builderApiElectra.SignedBuilderBid)
+				return bid.Electra.UnmarshalSSZ(respBytes)
+			default:
+				return errInvalidForkVersion
+			}
+		} else {
+			return types.ErrMissingEthConsensusVersion
+		}
+	case MediaTypeJSON:
+		// Do JSON decoding
+		return json.Unmarshal(respBytes, bid)
+	}
+	return types.ErrInvalidContentType
+}

server/media_types.go

@@ -0,0 +1,6 @@
+package server
+
+const (
+	MediaTypeJSON        = "application/json"
+	MediaTypeOctetStream = "application/octet-stream"
+)

server/mock/mock_relay.go

@@ -202,6 +202,7 @@ func (m *Relay) MakeGetHeaderResponse(value uint64, blockHash, parentHash, publi
 				ParentHash:      HexToHash(parentHash),
 				WithdrawalsRoot: phase0.Root{},
 				BaseFeePerGas:   uint256.NewInt(0),
+				ExtraData:       make([]byte, 0),
 			},
 			BlobKZGCommitments: make([]deneb.KZGCommitment, 0),
 			Value:              uint256.NewInt(value),
@@ -259,15 +260,11 @@ func (m *Relay) handleGetHeader(w http.ResponseWriter, req *http.Request) {
 		m.handlerOverrideGetHeader(w, req)
 		return
 	}
-	m.defaultHandleGetHeader(w)
+	m.defaultHandleGetHeader(w, req)
 }
 
 // defaultHandleGetHeader returns the default handler for handleGetHeader
-func (m *Relay) defaultHandleGetHeader(w http.ResponseWriter) {
-	// By default, everything will be ok.
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-
+func (m *Relay) defaultHandleGetHeader(w http.ResponseWriter, req *http.Request) {
 	// Build the default response.
 	response := m.MakeGetHeaderResponse(
 		12345,
@@ -280,9 +277,26 @@ func (m *Relay) defaultHandleGetHeader(w http.ResponseWriter) {
 		response = m.GetHeaderResponse
 	}
 
-	if err := json.NewEncoder(w).Encode(response); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
+	if req.Header.Get("Accept") == "application/octet-stream" {
+		w.Header().Set("Content-Type", "application/octet-stream")
+		w.WriteHeader(http.StatusOK)
+		sszData, err := response.Deneb.MarshalSSZ()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		_, err = w.Write(sszData)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		if err := json.NewEncoder(w).Encode(response); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
 	}
 }
 

server/service.go

@@ -21,6 +21,7 @@ import (
 	eth2ApiV1Capella "github.com/attestantio/go-eth2-client/api/v1/capella"
 	eth2ApiV1Deneb "github.com/attestantio/go-eth2-client/api/v1/deneb"
 	eth2ApiV1Electra "github.com/attestantio/go-eth2-client/api/v1/electra"
+	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/flashbots/go-boost-utils/ssz"
 	"github.com/flashbots/go-utils/httplogger"
@@ -299,29 +300,37 @@ func (m *BoostService) handleGetHeader(w http.ResponseWriter, req *http.Request)
 		ua            = UserAgent(req.Header.Get("User-Agent"))
 	)
 
+	// Parse the slot
 	slotValue, err := strconv.ParseUint(vars["slot"], 10, 64)
 	if err != nil {
 		m.respondError(w, http.StatusBadRequest, errInvalidSlot.Error())
 		return
 	}
 	slot := phase0.Slot(slotValue)
 
+	// Add relevant fields to the logger
 	log := m.log.WithFields(logrus.Fields{
 		"method":     "getHeader",
 		"slot":       slot,
 		"parentHash": parentHashHex,
 		"pubkey":     pubkey,
 		"ua":         ua,
 	})
-	log.Debug("getHeader")
+	log.Debug("handling request")
+
+	// Additional header fields
+	header := req.Header
+	header.Set("User-Agent", wrapUserAgent(ua))
+	header.Set(HeaderStartTimeUnixMS, fmt.Sprintf("%d", time.Now().UTC().UnixMilli()))
 
 	// Query the relays for the header
-	result, err := m.getHeader(log, ua, slot, pubkey, parentHashHex)
+	result, err := m.getHeader(log, slot, pubkey, parentHashHex, header)
 	if err != nil {
 		m.respondError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
+	// Bail if none of the relays returned a bid
 	if result.response.IsEmpty() {
 		log.Info("no bid received")
 		w.WriteHeader(http.StatusNoContent)
@@ -333,6 +342,10 @@ func (m *BoostService) handleGetHeader(w http.ResponseWriter, req *http.Request)
 	m.bids[bidKey(slot, result.bidInfo.blockHash)] = result
 	m.bidsLock.Unlock()
 
+	// How should we respond to the client
+	clientAccepts := ParseAcceptHeader(req.Header.Get("Accept"))
+	log.Debug("clientAccepts", clientAccepts)
+
 	// Log result
 	valueEth := weiBigIntToEthBigFloat(result.bidInfo.value.ToBig())
 	log.WithFields(logrus.Fields{
@@ -343,8 +356,65 @@ func (m *BoostService) handleGetHeader(w http.ResponseWriter, req *http.Request)
 		"relays":      strings.Join(types.RelayEntriesToStrings(result.relays), ", "),
 	}).Info("best bid")
 
-	// Return the bid
-	m.respondOK(w, &result.response)
+	// A function which responds in the JSON encoding
+	respondJSON := func() {
+		w.Header().Set("Content-Type", MediaTypeJSON)
+		w.WriteHeader(http.StatusOK)
+
+		// Serialize and write the data
+		if err := json.NewEncoder(w).Encode(&result.response); err != nil {
+			m.log.WithField("response", result.response).WithError(err).Error("could not write OK response")
+			http.Error(w, "", http.StatusInternalServerError)
+		}
+	}
+
+	// A function which responds in the SSZ encoding
+	respondSSZ := func() {
+		w.Header().Set("Content-Type", MediaTypeOctetStream)
+		w.WriteHeader(http.StatusOK)
+
+		// Serialize the response
+		var sszData []byte
+		switch result.response.Version {
+		case spec.DataVersionBellatrix:
+			sszData, err = result.response.Bellatrix.MarshalSSZ()
+		case spec.DataVersionCapella:
+			sszData, err = result.response.Capella.MarshalSSZ()
+		case spec.DataVersionDeneb:
+			sszData, err = result.response.Deneb.MarshalSSZ()
+		case spec.DataVersionElectra:
+			sszData, err = result.response.Electra.MarshalSSZ()
+		case spec.DataVersionUnknown, spec.DataVersionPhase0, spec.DataVersionAltair:
+			err = errInvalidForkVersion
+		}
+		if err != nil {
+			m.log.WithError(err).Error("error serializing response as SSZ")
+			http.Error(w, "failed to serialize response", http.StatusInternalServerError)
+			return
+		}
+
+		// Write SSZ data
+		if _, err := w.Write(sszData); err != nil {
+			m.log.WithError(err).Error("error writing SSZ response")
+			http.Error(w, "failed to write response", http.StatusInternalServerError)
+		}
+	}
+
+	// Return the bid. We iterate over the client's acceptable
+	// media types in order of highest to lowest quality.
+	for _, accept := range clientAccepts {
+		switch accept.MediaType {
+		case MediaTypeJSON:
+			respondJSON()
+			return
+		case MediaTypeOctetStream:
+			respondSSZ()
+			return
+		}
+	}
+
+	// If the accept value is unknown, respond with JSON
+	respondJSON()
 }
 
 // respondPayload responds to the proposer with the payload