adding ssz response for get blobs beacon api endpoint

beacon-chain/rpc/apimiddleware/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
         "//beacon-chain/rpc/eth/helpers:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//network:go_default_library",
         "//proto/eth/v2:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",

beacon-chain/rpc/apimiddleware/custom_handlers.go

@@ -8,13 +8,13 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"regexp"
 	"strconv"
 	"strings"
 
 	"github.com/prysmaticlabs/prysm/v4/api/gateway/apimiddleware"
 	"github.com/prysmaticlabs/prysm/v4/api/grpc"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/events"
+	"github.com/prysmaticlabs/prysm/v4/network"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"github.com/r3labs/sse"
 )
@@ -26,9 +26,6 @@ const (
 	octetStreamMediaType = "application/octet-stream"
 )
 
-// match a number with optional decimals
-var priorityRegex = regexp.MustCompile(`q=(\d+(?:\.\d+)?)`)
-
 type sszConfig struct {
 	fileName     string
 	responseJson SszResponse
@@ -120,7 +117,7 @@ func handleGetSSZ(
 	req *http.Request,
 	config sszConfig,
 ) (handled bool) {
-	ssz, err := sszRequested(req)
+	ssz, err := network.SszRequested(req)
 	if err != nil {
 		apimiddleware.WriteError(w, apimiddleware.InternalServerError(err), nil)
 		return true
@@ -213,44 +210,6 @@ func handlePostSSZ(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.E
 	return true
 }
 
-func sszRequested(req *http.Request) (bool, error) {
-	accept := req.Header.Values("Accept")
-	if len(accept) == 0 {
-		return false, nil
-	}
-	types := strings.Split(accept[0], ",")
-	currentType, currentPriority := "", 0.0
-	for _, t := range types {
-		values := strings.Split(t, ";")
-		name := values[0]
-		if name != jsonMediaType && name != octetStreamMediaType {
-			continue
-		}
-		// no params specified
-		if len(values) == 1 {
-			priority := 1.0
-			if priority > currentPriority {
-				currentType, currentPriority = name, priority
-			}
-			continue
-		}
-		params := values[1]
-		match := priorityRegex.FindAllStringSubmatch(params, 1)
-		if len(match) != 1 {
-			continue
-		}
-		priority, err := strconv.ParseFloat(match[0][1], 32)
-		if err != nil {
-			return false, err
-		}
-		if priority > currentPriority {
-			currentType, currentPriority = name, priority
-		}
-	}
-
-	return currentType == octetStreamMediaType, nil
-}
-
 func sszPosted(req *http.Request) bool {
 	ct, ok := req.Header["Content-Type"]
 	if !ok {

beacon-chain/rpc/apimiddleware/custom_handlers_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -42,95 +41,6 @@ func (t testSSZResponseJson) SSZFinalized() bool {
 	return t.Finalized
 }
 
-func TestSSZRequested(t *testing.T) {
-	t.Run("ssz_requested", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{octetStreamMediaType}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("ssz_content_type_first", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{fmt.Sprintf("%s,%s", octetStreamMediaType, jsonMediaType)}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("ssz_content_type_preferred_1", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{fmt.Sprintf("%s;q=0.9,%s", jsonMediaType, octetStreamMediaType)}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("ssz_content_type_preferred_2", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{fmt.Sprintf("%s;q=0.95,%s;q=0.9", octetStreamMediaType, jsonMediaType)}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, true, result)
-	})
-
-	t.Run("other_content_type_preferred", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{fmt.Sprintf("%s,%s;q=0.9", jsonMediaType, octetStreamMediaType)}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("other_params", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{fmt.Sprintf("%s,%s;q=0.9,otherparam=xyz", jsonMediaType, octetStreamMediaType)}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("no_header", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("empty_header", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("empty_header_value", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{""}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("other_content_type", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{"application/other"}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-
-	t.Run("garbage", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", nil)
-		request.Header["Accept"] = []string{"This is Sparta!!!"}
-		result, err := sszRequested(request)
-		require.NoError(t, err)
-		assert.Equal(t, false, result)
-	})
-}
-
 func TestPrepareSSZRequestForProxying(t *testing.T) {
 	middleware := &apimiddleware.ApiProxyMiddleware{
 		GatewayAddress: "http://apimiddleware.example",

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

@@ -19,6 +19,8 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//network:go_default_library",
+        "//proto/eth/v2:go_default_library",
+        "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
@@ -33,6 +35,7 @@ go_test(
     deps = [
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//network:go_default_library",

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

@@ -15,6 +15,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/network"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
+	"github.com/prysmaticlabs/prysm/v4/proto/migration"
 	eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 )
@@ -131,6 +133,43 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 		network.WriteError(w, errJson)
 		return
 	}
+
+	ssz, err := network.SszRequested(r)
+	if err != nil {
+		errJson := &network.DefaultErrorJson{
+			Message: err.Error(),
+			Code:    http.StatusInternalServerError,
+		}
+		network.WriteError(w, errJson)
+		return
+	}
+
+	if ssz {
+		v2sidecars, err := migration.V1Alpha1BlobSidecarsToV2(sidecars)
+		if err != nil {
+			errJson := &network.DefaultErrorJson{
+				Message: err.Error(),
+				Code:    http.StatusInternalServerError,
+			}
+			network.WriteError(w, errJson)
+			return
+		}
+		sidecarResp := &ethpb.BlobSidecars{
+			Sidecars: v2sidecars,
+		}
+		sszResp, err := sidecarResp.MarshalSSZ()
+		if err != nil {
+			errJson := &network.DefaultErrorJson{
+				Message: err.Error(),
+				Code:    http.StatusInternalServerError,
+			}
+			network.WriteError(w, errJson)
+			return
+		}
+		network.WriteSsz(w, sszResp, "sidecar_response.ssz")
+		return
+	}
+
 	network.WriteJson(w, buildSidecardsResponse(sidecars))
 }
 

beacon-chain/rpc/eth/blob/handlers_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	mockChain "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing"
 	testDB "github.com/prysmaticlabs/prysm/v4/beacon-chain/db/testing"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/network"
@@ -270,4 +271,33 @@ func TestBlobs(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, "could not parse block ID"))
 	})
+	t.Run("ssz", func(t *testing.T) {
+		require.NoError(t, db.SaveBlobSidecar(context.Background(), []*eth.BlobSidecar{
+			{
+				BlockRoot:       blockroot,
+				Index:           0,
+				Slot:            3,
+				BlockParentRoot: make([]byte, fieldparams.RootLength),
+				ProposerIndex:   123,
+				Blob:            make([]byte, fieldparams.BlobLength),
+				KzgCommitment:   make([]byte, fieldparams.BLSPubkeyLength),
+				KzgProof:        make([]byte, fieldparams.BLSPubkeyLength),
+			},
+		}))
+		u := "http://foo.example/finalized?indices=0"
+		request := httptest.NewRequest("GET", u, nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s := &Server{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockroot}},
+			BeaconDB:         db,
+		}
+
+		s.Blobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, len(writer.Body.Bytes()), 131260)
+		assert.Equal(t, true, strings.HasPrefix(hexutil.Encode(writer.Body.Bytes()), "0x04000000626c6f636b726f6f7400000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000000000000000007b"))
+	})
 }

network/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "auth.go",
         "endpoint.go",
         "external_ip.go",
+        "reader.go",
         "writer.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v4/network",
@@ -25,6 +26,7 @@ go_test(
         "auth_test.go",
         "endpoint_test.go",
         "external_ip_test.go",
+        "reader_test.go",
     ],
     embed = [":go_default_library"],
     deps = [

network/reader.go

@@ -0,0 +1,51 @@
+package network
+
+import (
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// match a number with optional decimals
+var priorityRegex = regexp.MustCompile(`q=(\d+(?:\.\d+)?)`)
+
+// SszRequested takes a http request and checks to see if it should be requesting a ssz response.
+func SszRequested(req *http.Request) (bool, error) {
+	accept := req.Header.Values("Accept")
+	if len(accept) == 0 {
+		return false, nil
+	}
+	types := strings.Split(accept[0], ",")
+	currentType, currentPriority := "", 0.0
+	for _, t := range types {
+		values := strings.Split(t, ";")
+		name := values[0]
+		if name != jsonMediaType && name != octetStreamMediaType {
+			continue
+		}
+		// no params specified
+		if len(values) == 1 {
+			priority := 1.0
+			if priority > currentPriority {
+				currentType, currentPriority = name, priority
+			}
+			continue
+		}
+		params := values[1]
+
+		match := priorityRegex.FindAllStringSubmatch(params, 1)
+		if len(match) != 1 {
+			continue
+		}
+		priority, err := strconv.ParseFloat(match[0][1], 32)
+		if err != nil {
+			return false, err
+		}
+		if priority > currentPriority {
+			currentType, currentPriority = name, priority
+		}
+	}
+
+	return currentType == octetStreamMediaType, nil
+}