HTTP Beacon APIs for blocks (#13048)

* handlers

* blinded block handlers and protos

* revert SSZ and register endpoints

* remove vars

* e2e

* handler for v1 endpoint

* tests

* register GetBlock

* disable security linter

* remove unused structs

* more review comments

beacon-chain/rpc/apimiddleware/custom_handlers.go

@@ -33,14 +33,6 @@ func handleGetBeaconStateSSZ(m *apimiddleware.ApiProxyMiddleware, endpoint apimi
 	return handleGetSSZ(m, endpoint, w, req, config)
 }
 
-func handleGetBeaconBlockSSZ(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.Endpoint, w http.ResponseWriter, req *http.Request) (handled bool) {
-	config := sszConfig{
-		fileName:     "beacon_block.ssz",
-		responseJson: &SszResponseJson{},
-	}
-	return handleGetSSZ(m, endpoint, w, req, config)
-}
-
 func handleGetBeaconStateSSZV2(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.Endpoint, w http.ResponseWriter, req *http.Request) (handled bool) {
 	config := sszConfig{
 		fileName:     "beacon_state.ssz",
@@ -49,27 +41,6 @@ func handleGetBeaconStateSSZV2(m *apimiddleware.ApiProxyMiddleware, endpoint api
 	return handleGetSSZ(m, endpoint, w, req, config)
 }
 
-func handleGetBeaconBlockSSZV2(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.Endpoint, w http.ResponseWriter, req *http.Request) (handled bool) {
-	config := sszConfig{
-		fileName:     "beacon_block.ssz",
-		responseJson: &VersionedSSZResponseJson{},
-	}
-	return handleGetSSZ(m, endpoint, w, req, config)
-}
-
-func handleGetBlindedBeaconBlockSSZ(
-	m *apimiddleware.ApiProxyMiddleware,
-	endpoint apimiddleware.Endpoint,
-	w http.ResponseWriter,
-	req *http.Request,
-) (handled bool) {
-	config := sszConfig{
-		fileName:     "beacon_block.ssz",
-		responseJson: &VersionedSSZResponseJson{},
-	}
-	return handleGetSSZ(m, endpoint, w, req, config)
-}
-
 func handleProduceBlockSSZ(m *apimiddleware.ApiProxyMiddleware, endpoint apimiddleware.Endpoint, w http.ResponseWriter, req *http.Request) (handled bool) {
 	config := sszConfig{
 		fileName:     "produce_beacon_block.ssz",

beacon-chain/rpc/apimiddleware/custom_hooks.go

@@ -279,200 +279,6 @@ func preparePublishedBlindedBlock(endpoint *apimiddleware.Endpoint, _ http.Respo
 	return apimiddleware.InternalServerError(errors.New("unsupported block type"))
 }
 
-type phase0BlockResponseJson struct {
-	Version             string                 `json:"version" enum:"true"`
-	Data                *SignedBeaconBlockJson `json:"data"`
-	ExecutionOptimistic bool                   `json:"execution_optimistic"`
-	Finalized           bool                   `json:"finalized"`
-}
-
-type altairBlockResponseJson struct {
-	Version             string                       `json:"version" enum:"true"`
-	Data                *SignedBeaconBlockAltairJson `json:"data"`
-	ExecutionOptimistic bool                         `json:"execution_optimistic"`
-	Finalized           bool                         `json:"finalized"`
-}
-
-type bellatrixBlockResponseJson struct {
-	Version             string                          `json:"version" enum:"true"`
-	Data                *SignedBeaconBlockBellatrixJson `json:"data"`
-	ExecutionOptimistic bool                            `json:"execution_optimistic"`
-	Finalized           bool                            `json:"finalized"`
-}
-
-type capellaBlockResponseJson struct {
-	Version             string                        `json:"version"`
-	Data                *SignedBeaconBlockCapellaJson `json:"data"`
-	ExecutionOptimistic bool                          `json:"execution_optimistic"`
-	Finalized           bool                          `json:"finalized"`
-}
-
-type denebBlockResponseJson struct {
-	Version             string                      `json:"version"`
-	Data                *SignedBeaconBlockDenebJson `json:"data"`
-	ExecutionOptimistic bool                        `json:"execution_optimistic"`
-	Finalized           bool                        `json:"finalized"`
-}
-
-type bellatrixBlindedBlockResponseJson struct {
-	Version             string                                 `json:"version" enum:"true"`
-	Data                *SignedBlindedBeaconBlockBellatrixJson `json:"data"`
-	ExecutionOptimistic bool                                   `json:"execution_optimistic"`
-	Finalized           bool                                   `json:"finalized"`
-}
-
-type capellaBlindedBlockResponseJson struct {
-	Version             string                               `json:"version" enum:"true"`
-	Data                *SignedBlindedBeaconBlockCapellaJson `json:"data"`
-	ExecutionOptimistic bool                                 `json:"execution_optimistic"`
-	Finalized           bool                                 `json:"finalized"`
-}
-
-type denebBlindedBlockResponseJson struct {
-	Version             string                             `json:"version"`
-	Data                *SignedBlindedBeaconBlockDenebJson `json:"data"`
-	ExecutionOptimistic bool                               `json:"execution_optimistic"`
-	Finalized           bool                               `json:"finalized"`
-}
-
-func serializeV2Block(response interface{}) (apimiddleware.RunDefault, []byte, apimiddleware.ErrorJson) {
-	respContainer, ok := response.(*BlockV2ResponseJson)
-	if !ok {
-		return false, nil, apimiddleware.InternalServerError(errors.New("container is not of the correct type"))
-	}
-
-	var actualRespContainer interface{}
-	switch {
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_PHASE0.String())):
-		actualRespContainer = &phase0BlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBeaconBlockJson{
-				Message:   respContainer.Data.Phase0Block,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_ALTAIR.String())):
-		actualRespContainer = &altairBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBeaconBlockAltairJson{
-				Message:   respContainer.Data.AltairBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_BELLATRIX.String())):
-		actualRespContainer = &bellatrixBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBeaconBlockBellatrixJson{
-				Message:   respContainer.Data.BellatrixBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_CAPELLA.String())):
-		actualRespContainer = &capellaBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBeaconBlockCapellaJson{
-				Message:   respContainer.Data.CapellaBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_DENEB.String())):
-		actualRespContainer = &denebBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBeaconBlockDenebJson{
-				Message:   respContainer.Data.DenebBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	default:
-		return false, nil, apimiddleware.InternalServerError(fmt.Errorf("unsupported block version '%s'", respContainer.Version))
-	}
-
-	j, err := json.Marshal(actualRespContainer)
-	if err != nil {
-		return false, nil, apimiddleware.InternalServerErrorWithMessage(err, "could not marshal response")
-	}
-	return false, j, nil
-}
-
-func serializeBlindedBlock(response interface{}) (apimiddleware.RunDefault, []byte, apimiddleware.ErrorJson) {
-	respContainer, ok := response.(*BlindedBlockResponseJson)
-	if !ok {
-		return false, nil, apimiddleware.InternalServerError(errors.New("container is not of the correct type"))
-	}
-
-	var actualRespContainer interface{}
-	switch {
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_PHASE0.String())):
-		actualRespContainer = &phase0BlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBeaconBlockJson{
-				Message:   respContainer.Data.Phase0Block,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_ALTAIR.String())):
-		actualRespContainer = &altairBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBeaconBlockAltairJson{
-				Message:   respContainer.Data.AltairBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_BELLATRIX.String())):
-		actualRespContainer = &bellatrixBlindedBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBlindedBeaconBlockBellatrixJson{
-				Message:   respContainer.Data.BellatrixBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_CAPELLA.String())):
-		actualRespContainer = &capellaBlindedBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBlindedBeaconBlockCapellaJson{
-				Message:   respContainer.Data.CapellaBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_DENEB.String())):
-		actualRespContainer = &denebBlindedBlockResponseJson{
-			Version: respContainer.Version,
-			Data: &SignedBlindedBeaconBlockDenebJson{
-				Message:   respContainer.Data.DenebBlock,
-				Signature: respContainer.Data.Signature,
-			},
-			ExecutionOptimistic: respContainer.ExecutionOptimistic,
-			Finalized:           respContainer.Finalized,
-		}
-	default:
-		return false, nil, apimiddleware.InternalServerError(fmt.Errorf("unsupported block version '%s'", respContainer.Version))
-	}
-
-	j, err := json.Marshal(actualRespContainer)
-	if err != nil {
-		return false, nil, apimiddleware.InternalServerErrorWithMessage(err, "could not marshal response")
-	}
-	return false, j, nil
-}
-
 type phase0StateResponseJson struct {
 	Version string           `json:"version" enum:"true"`
 	Data    *BeaconStateJson `json:"data"`

beacon-chain/rpc/apimiddleware/custom_hooks_test.go

@@ -360,310 +360,6 @@ func TestPreparePublishedBlindedBlock(t *testing.T) {
 	})
 }
 
-func TestSerializeV2Block(t *testing.T) {
-	t.Run("Phase 0", func(t *testing.T) {
-		response := &BlockV2ResponseJson{
-			Version: ethpbv2.Version_PHASE0.String(),
-			Data: &SignedBeaconBlockContainerV2Json{
-				Phase0Block: &BeaconBlockJson{
-					Slot:          "1",
-					ProposerIndex: "1",
-					ParentRoot:    "root",
-					StateRoot:     "root",
-					Body:          &BeaconBlockBodyJson{},
-				},
-				Signature: "sig",
-			},
-			ExecutionOptimistic: true,
-		}
-		runDefault, j, errJson := serializeV2Block(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		resp := &phase0BlockResponseJson{}
-		require.NoError(t, json.Unmarshal(j, resp))
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.Message)
-		beaconBlock := resp.Data.Message
-		assert.Equal(t, "1", beaconBlock.Slot)
-		assert.Equal(t, "1", beaconBlock.ProposerIndex)
-		assert.Equal(t, "root", beaconBlock.ParentRoot)
-		assert.Equal(t, "root", beaconBlock.StateRoot)
-		assert.NotNil(t, beaconBlock.Body)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-
-	t.Run("Altair", func(t *testing.T) {
-		response := &BlockV2ResponseJson{
-			Version: ethpbv2.Version_ALTAIR.String(),
-			Data: &SignedBeaconBlockContainerV2Json{
-				AltairBlock: &BeaconBlockAltairJson{
-					Slot:          "1",
-					ProposerIndex: "1",
-					ParentRoot:    "root",
-					StateRoot:     "root",
-					Body:          &BeaconBlockBodyAltairJson{},
-				},
-				Signature: "sig",
-			},
-			ExecutionOptimistic: true,
-		}
-		runDefault, j, errJson := serializeV2Block(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		resp := &altairBlockResponseJson{}
-		require.NoError(t, json.Unmarshal(j, resp))
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.Message)
-		beaconBlock := resp.Data.Message
-		assert.Equal(t, "1", beaconBlock.Slot)
-		assert.Equal(t, "1", beaconBlock.ProposerIndex)
-		assert.Equal(t, "root", beaconBlock.ParentRoot)
-		assert.Equal(t, "root", beaconBlock.StateRoot)
-		assert.NotNil(t, beaconBlock.Body)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-
-	t.Run("Bellatrix", func(t *testing.T) {
-		response := &BlockV2ResponseJson{
-			Version: ethpbv2.Version_BELLATRIX.String(),
-			Data: &SignedBeaconBlockContainerV2Json{
-				BellatrixBlock: &BeaconBlockBellatrixJson{
-					Slot:          "1",
-					ProposerIndex: "1",
-					ParentRoot:    "root",
-					StateRoot:     "root",
-					Body:          &BeaconBlockBodyBellatrixJson{},
-				},
-				Signature: "sig",
-			},
-			ExecutionOptimistic: true,
-		}
-		runDefault, j, errJson := serializeV2Block(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		resp := &bellatrixBlockResponseJson{}
-		require.NoError(t, json.Unmarshal(j, resp))
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.Message)
-		beaconBlock := resp.Data.Message
-		assert.Equal(t, "1", beaconBlock.Slot)
-		assert.Equal(t, "1", beaconBlock.ProposerIndex)
-		assert.Equal(t, "root", beaconBlock.ParentRoot)
-		assert.Equal(t, "root", beaconBlock.StateRoot)
-		assert.NotNil(t, beaconBlock.Body)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-
-	t.Run("incorrect response type", func(t *testing.T) {
-		response := &types.Empty{}
-		runDefault, j, errJson := serializeV2Block(response)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.Equal(t, 0, len(j))
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "container is not of the correct type"))
-	})
-
-	t.Run("unsupported block version", func(t *testing.T) {
-		response := &BlockV2ResponseJson{
-			Version: "unsupported",
-		}
-		runDefault, j, errJson := serializeV2Block(response)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.Equal(t, 0, len(j))
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "unsupported block version"))
-	})
-}
-
-func TestSerializeBlindedBlock(t *testing.T) {
-	t.Run("Phase 0", func(t *testing.T) {
-		response := &BlindedBlockResponseJson{
-			Version: ethpbv2.Version_PHASE0.String(),
-			Data: &SignedBlindedBeaconBlockContainerJson{
-				Phase0Block: &BeaconBlockJson{
-					Slot:          "1",
-					ProposerIndex: "1",
-					ParentRoot:    "root",
-					StateRoot:     "root",
-					Body:          &BeaconBlockBodyJson{},
-				},
-				Signature: "sig",
-			},
-			ExecutionOptimistic: true,
-		}
-		runDefault, j, errJson := serializeBlindedBlock(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		resp := &phase0BlockResponseJson{}
-		require.NoError(t, json.Unmarshal(j, resp))
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.Message)
-		beaconBlock := resp.Data.Message
-		assert.Equal(t, "1", beaconBlock.Slot)
-		assert.Equal(t, "1", beaconBlock.ProposerIndex)
-		assert.Equal(t, "root", beaconBlock.ParentRoot)
-		assert.Equal(t, "root", beaconBlock.StateRoot)
-		assert.NotNil(t, beaconBlock.Body)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-
-	t.Run("Altair", func(t *testing.T) {
-		response := &BlindedBlockResponseJson{
-			Version: ethpbv2.Version_ALTAIR.String(),
-			Data: &SignedBlindedBeaconBlockContainerJson{
-				AltairBlock: &BeaconBlockAltairJson{
-					Slot:          "1",
-					ProposerIndex: "1",
-					ParentRoot:    "root",
-					StateRoot:     "root",
-					Body:          &BeaconBlockBodyAltairJson{},
-				},
-				Signature: "sig",
-			},
-			ExecutionOptimistic: true,
-		}
-		runDefault, j, errJson := serializeBlindedBlock(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		resp := &altairBlockResponseJson{}
-		require.NoError(t, json.Unmarshal(j, resp))
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.Message)
-		beaconBlock := resp.Data.Message
-		assert.Equal(t, "1", beaconBlock.Slot)
-		assert.Equal(t, "1", beaconBlock.ProposerIndex)
-		assert.Equal(t, "root", beaconBlock.ParentRoot)
-		assert.Equal(t, "root", beaconBlock.StateRoot)
-		assert.NotNil(t, beaconBlock.Body)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-
-	t.Run("Bellatrix", func(t *testing.T) {
-		response := &BlindedBlockResponseJson{
-			Version: ethpbv2.Version_BELLATRIX.String(),
-			Data: &SignedBlindedBeaconBlockContainerJson{
-				BellatrixBlock: &BlindedBeaconBlockBellatrixJson{
-					Slot:          "1",
-					ProposerIndex: "1",
-					ParentRoot:    "root",
-					StateRoot:     "root",
-					Body:          &BlindedBeaconBlockBodyBellatrixJson{},
-				},
-				Signature: "sig",
-			},
-			ExecutionOptimistic: true,
-		}
-		runDefault, j, errJson := serializeBlindedBlock(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		resp := &bellatrixBlindedBlockResponseJson{}
-		require.NoError(t, json.Unmarshal(j, resp))
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.Message)
-		beaconBlock := resp.Data.Message
-		assert.Equal(t, "1", beaconBlock.Slot)
-		assert.Equal(t, "1", beaconBlock.ProposerIndex)
-		assert.Equal(t, "root", beaconBlock.ParentRoot)
-		assert.Equal(t, "root", beaconBlock.StateRoot)
-		assert.NotNil(t, beaconBlock.Body)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-
-	t.Run("Capella", func(t *testing.T) {
-		response := &BlindedBlockResponseJson{
-			Version: ethpbv2.Version_CAPELLA.String(),
-			Data: &SignedBlindedBeaconBlockContainerJson{
-				CapellaBlock: &BlindedBeaconBlockCapellaJson{
-					Slot:          "1",
-					ProposerIndex: "1",
-					ParentRoot:    "root",
-					StateRoot:     "root",
-					Body: &BlindedBeaconBlockBodyCapellaJson{
-						ExecutionPayloadHeader: &ExecutionPayloadHeaderCapellaJson{
-							ParentHash:       "parent_hash",
-							FeeRecipient:     "fee_recipient",
-							StateRoot:        "state_root",
-							ReceiptsRoot:     "receipts_root",
-							LogsBloom:        "logs_bloom",
-							PrevRandao:       "prev_randao",
-							BlockNumber:      "block_number",
-							GasLimit:         "gas_limit",
-							GasUsed:          "gas_used",
-							TimeStamp:        "time_stamp",
-							ExtraData:        "extra_data",
-							BaseFeePerGas:    "base_fee_per_gas",
-							BlockHash:        "block_hash",
-							TransactionsRoot: "transactions_root",
-							WithdrawalsRoot:  "withdrawals_root",
-						},
-					},
-				},
-				Signature: "sig",
-			},
-			ExecutionOptimistic: true,
-		}
-		runDefault, j, errJson := serializeBlindedBlock(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		resp := &capellaBlindedBlockResponseJson{}
-		require.NoError(t, json.Unmarshal(j, resp))
-		require.NotNil(t, resp.Data)
-		require.NotNil(t, resp.Data.Message)
-		beaconBlock := resp.Data.Message
-		assert.Equal(t, "1", beaconBlock.Slot)
-		assert.Equal(t, "1", beaconBlock.ProposerIndex)
-		assert.Equal(t, "root", beaconBlock.ParentRoot)
-		assert.Equal(t, "root", beaconBlock.StateRoot)
-		assert.NotNil(t, beaconBlock.Body)
-		payloadHeader := beaconBlock.Body.ExecutionPayloadHeader
-		assert.NotNil(t, payloadHeader)
-		assert.Equal(t, "parent_hash", payloadHeader.ParentHash)
-		assert.Equal(t, "fee_recipient", payloadHeader.FeeRecipient)
-		assert.Equal(t, "state_root", payloadHeader.StateRoot)
-		assert.Equal(t, "receipts_root", payloadHeader.ReceiptsRoot)
-		assert.Equal(t, "logs_bloom", payloadHeader.LogsBloom)
-		assert.Equal(t, "prev_randao", payloadHeader.PrevRandao)
-		assert.Equal(t, "block_number", payloadHeader.BlockNumber)
-		assert.Equal(t, "gas_limit", payloadHeader.GasLimit)
-		assert.Equal(t, "gas_used", payloadHeader.GasUsed)
-		assert.Equal(t, "time_stamp", payloadHeader.TimeStamp)
-		assert.Equal(t, "extra_data", payloadHeader.ExtraData)
-		assert.Equal(t, "base_fee_per_gas", payloadHeader.BaseFeePerGas)
-		assert.Equal(t, "block_hash", payloadHeader.BlockHash)
-		assert.Equal(t, "transactions_root", payloadHeader.TransactionsRoot)
-		assert.Equal(t, "withdrawals_root", payloadHeader.WithdrawalsRoot)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-
-	})
-
-	t.Run("incorrect response type", func(t *testing.T) {
-		response := &types.Empty{}
-		runDefault, j, errJson := serializeBlindedBlock(response)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.Equal(t, 0, len(j))
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "container is not of the correct type"))
-	})
-
-	t.Run("unsupported block version", func(t *testing.T) {
-		response := &BlindedBlockResponseJson{
-			Version: "unsupported",
-		}
-		runDefault, j, errJson := serializeBlindedBlock(response)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.Equal(t, 0, len(j))
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "unsupported block version"))
-	})
-}
-
 func TestSerializeV2State(t *testing.T) {
 	t.Run("Phase 0", func(t *testing.T) {
 		response := &BeaconStateV2ResponseJson{

beacon-chain/rpc/apimiddleware/endpoint_factory.go

@@ -16,11 +16,6 @@ func (f *BeaconEndpointFactory) IsNil() bool {
 // Paths is a collection of all valid beacon chain API paths.
 func (_ *BeaconEndpointFactory) Paths() []string {
 	return []string{
-		"/eth/v1/beacon/blinded_blocks",
-		"/eth/v1/beacon/blocks/{block_id}",
-		"/eth/v2/beacon/blocks/{block_id}",
-		"/eth/v1/beacon/blocks/{block_id}/attestations",
-		"/eth/v1/beacon/blinded_blocks/{block_id}",
 		"/eth/v1/beacon/pool/attester_slashings",
 		"/eth/v1/beacon/pool/proposer_slashings",
 		"/eth/v1/beacon/weak_subjectivity",
@@ -42,23 +37,6 @@ func (_ *BeaconEndpointFactory) Paths() []string {
 func (_ *BeaconEndpointFactory) Create(path string) (*apimiddleware.Endpoint, error) {
 	endpoint := apimiddleware.DefaultEndpoint()
 	switch path {
-	case "/eth/v1/beacon/blocks/{block_id}":
-		endpoint.GetResponse = &BlockResponseJson{}
-		endpoint.CustomHandlers = []apimiddleware.CustomHandler{handleGetBeaconBlockSSZ}
-	case "/eth/v2/beacon/blocks/{block_id}":
-		endpoint.GetResponse = &BlockV2ResponseJson{}
-		endpoint.Hooks = apimiddleware.HookCollection{
-			OnPreSerializeMiddlewareResponseIntoJson: serializeV2Block,
-		}
-		endpoint.CustomHandlers = []apimiddleware.CustomHandler{handleGetBeaconBlockSSZV2}
-	case "/eth/v1/beacon/blocks/{block_id}/attestations":
-		endpoint.GetResponse = &BlockAttestationsResponseJson{}
-	case "/eth/v1/beacon/blinded_blocks/{block_id}":
-		endpoint.GetResponse = &BlindedBlockResponseJson{}
-		endpoint.Hooks = apimiddleware.HookCollection{
-			OnPreSerializeMiddlewareResponseIntoJson: serializeBlindedBlock,
-		}
-		endpoint.CustomHandlers = []apimiddleware.CustomHandler{handleGetBlindedBeaconBlockSSZ}
 	case "/eth/v1/beacon/pool/attester_slashings":
 		endpoint.PostRequest = &AttesterSlashingJson{}
 		endpoint.GetResponse = &AttesterSlashingsPoolResponseJson{}

beacon-chain/rpc/apimiddleware/structs.go

@@ -20,36 +20,12 @@ type WeakSubjectivityResponse struct {
 	} `json:"data"`
 }
 
-type BlockResponseJson struct {
-	Data *SignedBeaconBlockJson `json:"data"`
-}
-
-type BlockV2ResponseJson struct {
-	Version             string                            `json:"version" enum:"true"`
-	Data                *SignedBeaconBlockContainerV2Json `json:"data"`
-	ExecutionOptimistic bool                              `json:"execution_optimistic"`
-	Finalized           bool                              `json:"finalized"`
-}
-
-type BlindedBlockResponseJson struct {
-	Version             string                                 `json:"version" enum:"true"`
-	Data                *SignedBlindedBeaconBlockContainerJson `json:"data"`
-	ExecutionOptimistic bool                                   `json:"execution_optimistic"`
-	Finalized           bool                                   `json:"finalized"`
-}
-
 type BlockRootResponseJson struct {
 	Data                *BlockRootContainerJson `json:"data"`
 	ExecutionOptimistic bool                    `json:"execution_optimistic"`
 	Finalized           bool                    `json:"finalized"`
 }
 
-type BlockAttestationsResponseJson struct {
-	Data                []*AttestationJson `json:"data"`
-	ExecutionOptimistic bool               `json:"execution_optimistic"`
-	Finalized           bool               `json:"finalized"`
-}
-
 type AttesterSlashingsPoolResponseJson struct {
 	Data []*AttesterSlashingJson `json:"data"`
 }
@@ -192,32 +168,6 @@ type BeaconBlockBodyJson struct {
 	VoluntaryExits    []*SignedVoluntaryExitJson `json:"voluntary_exits"`
 }
 
-type SignedBeaconBlockContainerV2Json struct {
-	Phase0Block    *BeaconBlockJson          `json:"phase0_block"`
-	AltairBlock    *BeaconBlockAltairJson    `json:"altair_block"`
-	BellatrixBlock *BeaconBlockBellatrixJson `json:"bellatrix_block"`
-	CapellaBlock   *BeaconBlockCapellaJson   `json:"capella_block"`
-	DenebBlock     *BeaconBlockDenebJson     `json:"deneb_block"`
-	Signature      string                    `json:"signature" hex:"true"`
-}
-
-type SignedBlindedBeaconBlockContainerJson struct {
-	Phase0Block    *BeaconBlockJson                 `json:"phase0_block"`
-	AltairBlock    *BeaconBlockAltairJson           `json:"altair_block"`
-	BellatrixBlock *BlindedBeaconBlockBellatrixJson `json:"bellatrix_block"`
-	CapellaBlock   *BlindedBeaconBlockCapellaJson   `json:"capella_block"`
-	DenebBlock     *BlindedBeaconBlockDenebJson     `json:"deneb_block"`
-	Signature      string                           `json:"signature" hex:"true"`
-}
-
-type SignedBlindedBeaconBlockContentsContainerJson struct {
-	Phase0Block    *SignedBeaconBlockJson                     `json:"phase0_block"`
-	AltairBlock    *SignedBeaconBlockAltairJson               `json:"altair_block"`
-	BellatrixBlock *SignedBlindedBeaconBlockBellatrixJson     `json:"bellatrix_block"`
-	CapellaBlock   *SignedBlindedBeaconBlockCapellaJson       `json:"capella_block"`
-	DenebContents  *SignedBlindedBeaconBlockContentsDenebJson `json:"deneb_contents"`
-}
-
 type BeaconBlockContainerV2Json struct {
 	Phase0Block    *BeaconBlockJson              `json:"phase0_block"`
 	AltairBlock    *BeaconBlockAltairJson        `json:"altair_block"`

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

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "blinded_blocks.go",
         "blocks.go",
         "config.go",
         "handlers.go",
@@ -56,7 +55,6 @@ go_library(
         "//network/forks:go_default_library",
         "//network/http:go_default_library",
         "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
@@ -67,9 +65,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
-        "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
     ],
@@ -129,7 +125,6 @@ go_test(
         "//network/http:go_default_library",
         "//proto/eth/service:go_default_library",
         "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
@@ -142,11 +137,9 @@ go_test(
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_golang_mock//gomock:go_default_library",
         "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_stretchr_testify//mock:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
     ],
 )

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

@@ -1,630 +0,0 @@
-package beacon
-
-import (
-	"context"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v4/api"
-	rpchelpers "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/helpers"
-	consensus_types "github.com/prysmaticlabs/prysm/v4/consensus-types"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
-	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v4/proto/migration"
-	"github.com/prysmaticlabs/prysm/v4/runtime/version"
-	"go.opencensus.io/trace"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
-)
-
-// GetBlindedBlock retrieves blinded block for given block id.
-func (bs *Server) GetBlindedBlock(ctx context.Context, req *ethpbv1.BlockRequest) (*ethpbv2.BlindedBlockResponse, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.GetBlindedBlock")
-	defer span.End()
-
-	blk, err := bs.Blocker.Block(ctx, req.BlockId)
-	err = rpchelpers.HandleGetBlockError(blk, err)
-	if err != nil {
-		return nil, err
-	}
-	blkRoot, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	if err := grpc.SetHeader(ctx, metadata.Pairs(api.VersionHeader, version.String(blk.Version()))); err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not set "+api.VersionHeader+" header: %v", err)
-	}
-	result, err := getBlindedBlockPhase0(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-	}
-	result, err = getBlindedBlockAltair(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-	}
-	result, err = bs.getBlindedBlockBellatrix(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-	}
-	result, err = bs.getBlindedBlockCapella(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-	}
-	result, err = bs.getBlindedBlockDeneb(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get blinded block: %v", err)
-	}
-
-	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
-}
-
-// GetBlindedBlockSSZ returns the SSZ-serialized version of the blinded beacon block for given block id.
-func (bs *Server) GetBlindedBlockSSZ(ctx context.Context, req *ethpbv1.BlockRequest) (*ethpbv2.SSZContainer, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.GetBlindedBlockSSZ")
-	defer span.End()
-
-	blk, err := bs.Blocker.Block(ctx, req.BlockId)
-	err = rpchelpers.HandleGetBlockError(blk, err)
-	if err != nil {
-		return nil, err
-	}
-	blkRoot, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-
-	result, err := getSSZBlockPhase0(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = getSSZBlockAltair(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = bs.getBlindedSSZBlockBellatrix(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = bs.getBlindedSSZBlockCapella(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = bs.getBlindedSSZBlockDeneb(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-
-	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
-}
-
-func getBlindedBlockPhase0(blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlindedBlockResponse, error) {
-	phase0Blk, err := blk.PbPhase0Block()
-	if err != nil {
-		return nil, err
-	}
-	if phase0Blk == nil {
-		return nil, errNilBlock
-	}
-	v1Blk, err := migration.SignedBeaconBlock(blk)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	return &ethpbv2.BlindedBlockResponse{
-		Version: ethpbv2.Version_PHASE0,
-		Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block{Phase0Block: v1Blk.Block},
-			Signature: v1Blk.Signature,
-		},
-		ExecutionOptimistic: false,
-	}, nil
-}
-
-func getBlindedBlockAltair(blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlindedBlockResponse, error) {
-	altairBlk, err := blk.PbAltairBlock()
-	if err != nil {
-		return nil, err
-	}
-	if altairBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlindedBlockResponse{
-		Version: ethpbv2.Version_ALTAIR,
-		Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock{AltairBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: false,
-	}, nil
-}
-
-func (bs *Server) getBlindedBlockBellatrix(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlindedBlockResponse, error) {
-	bellatrixBlk, err := blk.PbBellatrixBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedBellatrixBlk, err := blk.PbBlindedBellatrixBlock(); err == nil {
-				if blindedBellatrixBlk == nil {
-					return nil, errNilBlock
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(blindedBellatrixBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not convert beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				return &ethpbv2.BlindedBlockResponse{
-					Version: ethpbv2.Version_BELLATRIX,
-					Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-						Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock{BellatrixBlock: v2Blk},
-						Signature: sig[:],
-					},
-					ExecutionOptimistic: isOptimistic,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if bellatrixBlk == nil {
-		return nil, errNilBlock
-	}
-	blindedBlkInterface, err := blk.ToBlinded()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert block to blinded block")
-	}
-	blindedBellatrixBlock, err := blindedBlkInterface.PbBlindedBellatrixBlock()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(blindedBellatrixBlock.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlindedBlockResponse{
-		Version: ethpbv2.Version_BELLATRIX,
-		Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock{BellatrixBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: isOptimistic,
-	}, nil
-}
-
-func (bs *Server) getBlindedBlockCapella(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlindedBlockResponse, error) {
-	capellaBlk, err := blk.PbCapellaBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedCapellaBlk, err := blk.PbBlindedCapellaBlock(); err == nil {
-				if blindedCapellaBlk == nil {
-					return nil, errNilBlock
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBlindedCapellaToV2Blinded(blindedCapellaBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "Could not convert beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				return &ethpbv2.BlindedBlockResponse{
-					Version: ethpbv2.Version_CAPELLA,
-					Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-						Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock{CapellaBlock: v2Blk},
-						Signature: sig[:],
-					},
-					ExecutionOptimistic: isOptimistic,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if capellaBlk == nil {
-		return nil, errNilBlock
-	}
-	blindedBlkInterface, err := blk.ToBlinded()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert block to blinded block")
-	}
-	blindedCapellaBlock, err := blindedBlkInterface.PbBlindedCapellaBlock()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBlindedCapellaToV2Blinded(blindedCapellaBlock.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlindedBlockResponse{
-		Version: ethpbv2.Version_CAPELLA,
-		Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock{CapellaBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: isOptimistic,
-	}, nil
-}
-
-func (bs *Server) getBlindedBlockDeneb(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlindedBlockResponse, error) {
-	denebBlk, err := blk.PbDenebBlock()
-	if err != nil {
-		// ErrUnsupportedGetter means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedDenebBlk, err := blk.PbBlindedDenebBlock(); err == nil {
-				if blindedDenebBlk == nil {
-					return nil, errNilBlock
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBlindedDenebToV2Blinded(blindedDenebBlk.Message)
-				if err != nil {
-					return nil, errors.Wrapf(err, "Could not convert beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				return &ethpbv2.BlindedBlockResponse{
-					Version: ethpbv2.Version_DENEB,
-					Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-						Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_DenebBlock{DenebBlock: v2Blk},
-						Signature: sig[:],
-					},
-					ExecutionOptimistic: isOptimistic,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if denebBlk == nil {
-		return nil, errNilBlock
-	}
-	blindedBlkInterface, err := blk.ToBlinded()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert block to blinded block")
-	}
-	blindedDenebBlock, err := blindedBlkInterface.PbBlindedDenebBlock()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBlindedDenebToV2Blinded(blindedDenebBlock.Message)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlindedBlockResponse{
-		Version: ethpbv2.Version_CAPELLA,
-		Data: &ethpbv2.SignedBlindedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_DenebBlock{DenebBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: isOptimistic,
-	}, nil
-}
-
-func (bs *Server) getBlindedSSZBlockBellatrix(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	bellatrixBlk, err := blk.PbBellatrixBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedBellatrixBlk, err := blk.PbBlindedBellatrixBlock(); err == nil {
-				if blindedBellatrixBlk == nil {
-					return nil, errNilBlock
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(blindedBellatrixBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				data := &ethpbv2.SignedBlindedBeaconBlockBellatrix{
-					Message:   v2Blk,
-					Signature: sig[:],
-				}
-				sszData, err := data.MarshalSSZ()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-				}
-				return &ethpbv2.SSZContainer{
-					Version:             ethpbv2.Version_BELLATRIX,
-					ExecutionOptimistic: isOptimistic,
-					Data:                sszData,
-				}, nil
-			}
-			return nil, err
-		}
-	}
-
-	if bellatrixBlk == nil {
-		return nil, errNilBlock
-	}
-	blindedBlkInterface, err := blk.ToBlinded()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert block to blinded block")
-	}
-	blindedBellatrixBlock, err := blindedBlkInterface.PbBlindedBellatrixBlock()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(blindedBellatrixBlock.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	data := &ethpbv2.SignedBlindedBeaconBlockBellatrix{
-		Message:   v2Blk,
-		Signature: sig[:],
-	}
-	sszData, err := data.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_BELLATRIX, ExecutionOptimistic: isOptimistic, Data: sszData}, nil
-}
-
-func (bs *Server) getBlindedSSZBlockCapella(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	capellaBlk, err := blk.PbCapellaBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedCapellaBlk, err := blk.PbBlindedCapellaBlock(); err == nil {
-				if blindedCapellaBlk == nil {
-					return nil, errNilBlock
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBlindedCapellaToV2Blinded(blindedCapellaBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				data := &ethpbv2.SignedBlindedBeaconBlockCapella{
-					Message:   v2Blk,
-					Signature: sig[:],
-				}
-				sszData, err := data.MarshalSSZ()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-				}
-				return &ethpbv2.SSZContainer{
-					Version:             ethpbv2.Version_CAPELLA,
-					ExecutionOptimistic: isOptimistic,
-					Data:                sszData,
-				}, nil
-			}
-			return nil, err
-		}
-	}
-
-	if capellaBlk == nil {
-		return nil, errNilBlock
-	}
-	blindedBlkInterface, err := blk.ToBlinded()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert block to blinded block")
-	}
-	blindedCapellaBlock, err := blindedBlkInterface.PbBlindedCapellaBlock()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBlindedCapellaToV2Blinded(blindedCapellaBlock.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	data := &ethpbv2.SignedBlindedBeaconBlockCapella{
-		Message:   v2Blk,
-		Signature: sig[:],
-	}
-	sszData, err := data.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_CAPELLA, ExecutionOptimistic: isOptimistic, Data: sszData}, nil
-}
-
-func (bs *Server) getBlindedSSZBlockDeneb(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	denebBlk, err := blk.PbDenebBlock()
-	if err != nil {
-		// ErrUnsupportedGetter means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedDenebBlk, err := blk.PbBlindedDenebBlock(); err == nil {
-				if blindedDenebBlk == nil {
-					return nil, errNilBlock
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBlindedDenebToV2Blinded(blindedDenebBlk.Message)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				data := &ethpbv2.SignedBlindedBeaconBlockDeneb{
-					Message:   v2Blk,
-					Signature: sig[:],
-				}
-				sszData, err := data.MarshalSSZ()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-				}
-				return &ethpbv2.SSZContainer{
-					Version:             ethpbv2.Version_DENEB,
-					ExecutionOptimistic: isOptimistic,
-					Data:                sszData,
-				}, nil
-			}
-			return nil, err
-		}
-	}
-
-	if denebBlk == nil {
-		return nil, errNilBlock
-	}
-	blindedBlkInterface, err := blk.ToBlinded()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert block to blinded block")
-	}
-	blindedDenebBlock, err := blindedBlkInterface.PbBlindedDenebBlock()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBlindedDenebToV2Blinded(blindedDenebBlock.Message)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	data := &ethpbv2.SignedBlindedBeaconBlockDeneb{
-		Message:   v2Blk,
-		Signature: sig[:],
-	}
-	sszData, err := data.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_DENEB, ExecutionOptimistic: isOptimistic, Data: sszData}, nil
-}

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

@@ -1,342 +1,2 @@
 package beacon
 
-import (
-	"context"
-	"testing"
-
-	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	mock "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/testutil"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
-	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v4/proto/migration"
-	"github.com/prysmaticlabs/prysm/v4/testing/assert"
-	"github.com/prysmaticlabs/prysm/v4/testing/require"
-	"github.com/prysmaticlabs/prysm/v4/testing/util"
-	"google.golang.org/grpc"
-)
-
-func TestServer_GetBlindedBlock(t *testing.T) {
-	stream := &runtime.ServerTransportStream{}
-	ctx := grpc.NewContextWithServerTransportStream(context.Background(), stream)
-
-	t.Run("Phase 0", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		bs := &Server{
-			FinalizationFetcher: &mock.ChainService{},
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		expected, err := migration.V1Alpha1ToV1SignedBlock(b)
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		phase0Block, ok := resp.Data.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, expected.Block, phase0Block.Phase0Block)
-		assert.Equal(t, ethpbv2.Version_PHASE0, resp.Version)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		b := util.NewBeaconBlockAltair()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		bs := &Server{
-			FinalizationFetcher: &mock.ChainService{},
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		expected, err := migration.V1Alpha1BeaconBlockAltairToV2(b.Block)
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		altairBlock, ok := resp.Data.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, expected, altairBlock.AltairBlock)
-		assert.Equal(t, ethpbv2.Version_ALTAIR, resp.Version)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockBellatrix()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		expected, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(b.Block)
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		bellatrixBlock, ok := resp.Data.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, expected, bellatrixBlock.BellatrixBlock)
-		assert.Equal(t, ethpbv2.Version_BELLATRIX, resp.Version)
-	})
-	t.Run("Capella", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockCapella()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		expected, err := migration.V1Alpha1BeaconBlockBlindedCapellaToV2Blinded(b.Block)
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		capellaBlock, ok := resp.Data.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, expected, capellaBlock.CapellaBlock)
-		assert.Equal(t, ethpbv2.Version_CAPELLA, resp.Version)
-	})
-	t.Run("Deneb", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockDeneb()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		expected, err := migration.V1Alpha1BeaconBlockBlindedDenebToV2Blinded(b.Message)
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		denebBlock, ok := resp.Data.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_DenebBlock)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, expected, denebBlock.DenebBlock)
-		assert.Equal(t, ethpbv2.Version_DENEB, resp.Version)
-	})
-	t.Run("execution optimistic", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockBellatrix()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			OptimisticRoots: map[[32]byte]bool{r: true},
-		}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-	t.Run("finalized", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		root, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{root: true},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{BlockId: root[:]})
-		require.NoError(t, err)
-		assert.Equal(t, true, resp.Finalized)
-	})
-	t.Run("not finalized", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		root, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{root: false},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		resp, err := bs.GetBlindedBlock(ctx, &ethpbv1.BlockRequest{BlockId: root[:]})
-		require.NoError(t, err)
-		assert.Equal(t, false, resp.Finalized)
-	})
-}
-
-func TestServer_GetBlindedBlockSSZ(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("Phase 0", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		bs := &Server{
-			FinalizationFetcher: &mock.ChainService{},
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		expected, err := blk.MarshalSSZ()
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		assert.DeepEqual(t, expected, resp.Data)
-		assert.Equal(t, ethpbv2.Version_PHASE0, resp.Version)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		b := util.NewBeaconBlockAltair()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		bs := &Server{
-			FinalizationFetcher: &mock.ChainService{},
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		expected, err := blk.MarshalSSZ()
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		assert.DeepEqual(t, expected, resp.Data)
-		assert.Equal(t, ethpbv2.Version_ALTAIR, resp.Version)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockBellatrix()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		expected, err := blk.MarshalSSZ()
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		assert.DeepEqual(t, expected, resp.Data)
-		assert.Equal(t, ethpbv2.Version_BELLATRIX, resp.Version)
-	})
-	t.Run("Capella", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockCapella()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		expected, err := blk.MarshalSSZ()
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		assert.DeepEqual(t, expected, resp.Data)
-		assert.Equal(t, ethpbv2.Version_CAPELLA, resp.Version)
-	})
-	t.Run("Deneb", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockDeneb()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		expected, err := blk.MarshalSSZ()
-		require.NoError(t, err)
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		assert.DeepEqual(t, expected, resp.Data)
-		assert.Equal(t, ethpbv2.Version_DENEB, resp.Version)
-	})
-	t.Run("execution optimistic", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockBellatrix()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			OptimisticRoots: map[[32]byte]bool{r: true},
-		}
-		bs := &Server{
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: blk},
-			OptimisticModeFetcher: mockChainService,
-		}
-
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-	t.Run("finalized", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		root, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{root: true},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{BlockId: root[:]})
-		require.NoError(t, err)
-		assert.Equal(t, true, resp.Finalized)
-	})
-	t.Run("not finalized", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		blk, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		root, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{root: false},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             &testutil.MockBlocker{BlockToReturn: blk},
-		}
-
-		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{BlockId: root[:]})
-		require.NoError(t, err)
-		assert.Equal(t, false, resp.Finalized)
-	})
-}

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

@@ -6,21 +6,12 @@ import (
 
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v4/api"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
 	rpchelpers "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/helpers"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
-	consensus_types "github.com/prysmaticlabs/prysm/v4/consensus-types"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v4/proto/migration"
-	"github.com/prysmaticlabs/prysm/v4/runtime/version"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
-	"go.opencensus.io/trace"
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 )
 
@@ -69,741 +60,3 @@ func (bs *Server) GetWeakSubjectivity(ctx context.Context, _ *empty.Empty) (*eth
 		},
 	}, nil
 }
-
-// GetBlock retrieves block details for given block ID.
-// DEPRECATED: please use GetBlockV2 instead
-func (bs *Server) GetBlock(ctx context.Context, req *ethpbv1.BlockRequest) (*ethpbv1.BlockResponse, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.GetBlock")
-	defer span.End()
-
-	blk, err := bs.Blocker.Block(ctx, req.BlockId)
-	err = rpchelpers.HandleGetBlockError(blk, err)
-	if err != nil {
-		return nil, err
-	}
-	signedBeaconBlock, err := migration.SignedBeaconBlock(blk)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-
-	return &ethpbv1.BlockResponse{
-		Data: &ethpbv1.BeaconBlockContainer{
-			Message:   signedBeaconBlock.Block,
-			Signature: signedBeaconBlock.Signature,
-		},
-	}, nil
-}
-
-// GetBlockSSZ returns the SSZ-serialized version of the becaon block for given block ID.
-// DEPRECATED: please use GetBlockV2SSZ instead
-func (bs *Server) GetBlockSSZ(ctx context.Context, req *ethpbv1.BlockRequest) (*ethpbv1.BlockSSZResponse, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.GetBlockSSZ")
-	defer span.End()
-
-	blk, err := bs.Blocker.Block(ctx, req.BlockId)
-	err = rpchelpers.HandleGetBlockError(blk, err)
-	if err != nil {
-		return nil, err
-	}
-	signedBeaconBlock, err := migration.SignedBeaconBlock(blk)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	sszBlock, err := signedBeaconBlock.MarshalSSZ()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not marshal block into SSZ: %v", err)
-	}
-
-	return &ethpbv1.BlockSSZResponse{Data: sszBlock}, nil
-}
-
-// GetBlockV2 retrieves block details for given block ID.
-func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (*ethpbv2.BlockResponseV2, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.GetBlockV2")
-	defer span.End()
-
-	blk, err := bs.Blocker.Block(ctx, req.BlockId)
-	err = rpchelpers.HandleGetBlockError(blk, err)
-	if err != nil {
-		return nil, err
-	}
-	blkRoot, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-
-	result, err := getBlockPhase0(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	if err := grpc.SetHeader(ctx, metadata.Pairs(api.VersionHeader, version.String(blk.Version()))); err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not set "+api.VersionHeader+" header: %v", err)
-	}
-	result, err = getBlockAltair(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = bs.getBlockBellatrix(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = bs.getBlockCapella(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-
-	result, err = bs.getBlockDeneb(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
-}
-
-// GetBlockSSZV2 returns the SSZ-serialized version of the beacon block for given block ID.
-func (bs *Server) GetBlockSSZV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (*ethpbv2.SSZContainer, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.GetBlockSSZV2")
-	defer span.End()
-
-	blk, err := bs.Blocker.Block(ctx, req.BlockId)
-	err = rpchelpers.HandleGetBlockError(blk, err)
-	if err != nil {
-		return nil, err
-	}
-	blkRoot, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-
-	result, err := getSSZBlockPhase0(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = getSSZBlockAltair(blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = bs.getSSZBlockBellatrix(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	result, err = bs.getSSZBlockCapella(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-
-	result, err = bs.getSSZBlockDeneb(ctx, blk)
-	if result != nil {
-		result.Finalized = bs.FinalizationFetcher.IsFinalized(ctx, blkRoot)
-		return result, nil
-	}
-	// ErrUnsupportedField means that we have another block type
-	if !errors.Is(err, consensus_types.ErrUnsupportedField) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-
-	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
-}
-
-// ListBlockAttestations retrieves attestation included in requested block.
-func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockRequest) (*ethpbv1.BlockAttestationsResponse, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon.ListBlockAttestations")
-	defer span.End()
-
-	blk, err := bs.Blocker.Block(ctx, req.BlockId)
-	err = rpchelpers.HandleGetBlockError(blk, err)
-	if err != nil {
-		return nil, err
-	}
-
-	v1Alpha1Attestations := blk.Block().Body().Attestations()
-	v1Attestations := make([]*ethpbv1.Attestation, 0, len(v1Alpha1Attestations))
-	for _, att := range v1Alpha1Attestations {
-		migratedAtt := migration.V1Alpha1AttestationToV1(att)
-		v1Attestations = append(v1Attestations, migratedAtt)
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get block root: %v", err)
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
-	}
-	return &ethpbv1.BlockAttestationsResponse{
-		Data:                v1Attestations,
-		ExecutionOptimistic: isOptimistic,
-		Finalized:           bs.FinalizationFetcher.IsFinalized(ctx, root),
-	}, nil
-}
-
-func getBlockPhase0(blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlockResponseV2, error) {
-	phase0Blk, err := blk.PbPhase0Block()
-	if err != nil {
-		return nil, err
-	}
-	if phase0Blk == nil {
-		return nil, errNilBlock
-	}
-	v1Blk, err := migration.SignedBeaconBlock(blk)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	return &ethpbv2.BlockResponseV2{
-		Version: ethpbv2.Version_PHASE0,
-		Data: &ethpbv2.SignedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBeaconBlockContainer_Phase0Block{Phase0Block: v1Blk.Block},
-			Signature: v1Blk.Signature,
-		},
-		ExecutionOptimistic: false,
-	}, nil
-}
-
-func getBlockAltair(blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlockResponseV2, error) {
-	altairBlk, err := blk.PbAltairBlock()
-	if err != nil {
-		return nil, err
-	}
-	if altairBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlockResponseV2{
-		Version: ethpbv2.Version_ALTAIR,
-		Data: &ethpbv2.SignedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBeaconBlockContainer_AltairBlock{AltairBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: false,
-	}, nil
-}
-
-func (bs *Server) getBlockBellatrix(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlockResponseV2, error) {
-	bellatrixBlk, err := blk.PbBellatrixBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedBellatrixBlk, err := blk.PbBlindedBellatrixBlock(); err == nil {
-				if blindedBellatrixBlk == nil {
-					return nil, errNilBlock
-				}
-				signedFullBlock, err := bs.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
-				}
-				bellatrixBlk, err = signedFullBlock.PbBellatrixBlock()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not convert beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				return &ethpbv2.BlockResponseV2{
-					Version: ethpbv2.Version_BELLATRIX,
-					Data: &ethpbv2.SignedBeaconBlockContainer{
-						Message:   &ethpbv2.SignedBeaconBlockContainer_BellatrixBlock{BellatrixBlock: v2Blk},
-						Signature: sig[:],
-					},
-					ExecutionOptimistic: isOptimistic,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if bellatrixBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlockResponseV2{
-		Version: ethpbv2.Version_BELLATRIX,
-		Data: &ethpbv2.SignedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBeaconBlockContainer_BellatrixBlock{BellatrixBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: isOptimistic,
-	}, nil
-}
-
-func (bs *Server) getBlockCapella(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlockResponseV2, error) {
-	capellaBlk, err := blk.PbCapellaBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedCapellaBlk, err := blk.PbBlindedCapellaBlock(); err == nil {
-				if blindedCapellaBlk == nil {
-					return nil, errNilBlock
-				}
-				signedFullBlock, err := bs.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
-				}
-				capellaBlk, err = signedFullBlock.PbCapellaBlock()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockCapellaToV2(capellaBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not convert beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				return &ethpbv2.BlockResponseV2{
-					Version: ethpbv2.Version_CAPELLA,
-					Data: &ethpbv2.SignedBeaconBlockContainer{
-						Message:   &ethpbv2.SignedBeaconBlockContainer_CapellaBlock{CapellaBlock: v2Blk},
-						Signature: sig[:],
-					},
-					ExecutionOptimistic: isOptimistic,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if capellaBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockCapellaToV2(capellaBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlockResponseV2{
-		Version: ethpbv2.Version_CAPELLA,
-		Data: &ethpbv2.SignedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBeaconBlockContainer_CapellaBlock{CapellaBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: isOptimistic,
-	}, nil
-}
-
-func (bs *Server) getBlockDeneb(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.BlockResponseV2, error) {
-	denebBlk, err := blk.PbDenebBlock()
-	if err != nil {
-		// ErrUnsupportedGetter means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedDenebBlk, err := blk.PbBlindedDenebBlock(); err == nil {
-				if blindedDenebBlk == nil {
-					return nil, errNilBlock
-				}
-				signedFullBlock, err := bs.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
-				}
-				denebBlk, err = signedFullBlock.PbDenebBlock()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockDenebToV2(denebBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not convert beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				return &ethpbv2.BlockResponseV2{
-					Version: ethpbv2.Version_DENEB,
-					Data: &ethpbv2.SignedBeaconBlockContainer{
-						Message:   &ethpbv2.SignedBeaconBlockContainer_DenebBlock{DenebBlock: v2Blk},
-						Signature: sig[:],
-					},
-					ExecutionOptimistic: isOptimistic,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if denebBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockDenebToV2(denebBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	return &ethpbv2.BlockResponseV2{
-		Version: ethpbv2.Version_DENEB,
-		Data: &ethpbv2.SignedBeaconBlockContainer{
-			Message:   &ethpbv2.SignedBeaconBlockContainer_DenebBlock{DenebBlock: v2Blk},
-			Signature: sig[:],
-		},
-		ExecutionOptimistic: isOptimistic,
-	}, nil
-}
-
-func getSSZBlockPhase0(blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	phase0Blk, err := blk.PbPhase0Block()
-	if err != nil {
-		return nil, err
-	}
-	if phase0Blk == nil {
-		return nil, errNilBlock
-	}
-	signedBeaconBlock, err := migration.SignedBeaconBlock(blk)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	sszBlock, err := signedBeaconBlock.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_PHASE0, ExecutionOptimistic: false, Data: sszBlock}, nil
-}
-
-func getSSZBlockAltair(blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	altairBlk, err := blk.PbAltairBlock()
-	if err != nil {
-		return nil, err
-	}
-	if altairBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get signed beacon block")
-	}
-	sig := blk.Signature()
-	data := &ethpbv2.SignedBeaconBlockAltair{
-		Message:   v2Blk,
-		Signature: sig[:],
-	}
-	sszData, err := data.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_ALTAIR, ExecutionOptimistic: false, Data: sszData}, nil
-}
-
-func (bs *Server) getSSZBlockBellatrix(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	bellatrixBlk, err := blk.PbBellatrixBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedBellatrixBlk, err := blk.PbBlindedBellatrixBlock(); err == nil {
-				if blindedBellatrixBlk == nil {
-					return nil, errNilBlock
-				}
-				signedFullBlock, err := bs.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
-				}
-				bellatrixBlk, err = signedFullBlock.PbBellatrixBlock()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not convert signed beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				data := &ethpbv2.SignedBeaconBlockBellatrix{
-					Message:   v2Blk,
-					Signature: sig[:],
-				}
-				sszData, err := data.MarshalSSZ()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-				}
-				return &ethpbv2.SSZContainer{
-					Version:             ethpbv2.Version_BELLATRIX,
-					ExecutionOptimistic: isOptimistic,
-					Data:                sszData,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if bellatrixBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert signed beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	data := &ethpbv2.SignedBeaconBlockBellatrix{
-		Message:   v2Blk,
-		Signature: sig[:],
-	}
-	sszData, err := data.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_BELLATRIX, ExecutionOptimistic: isOptimistic, Data: sszData}, nil
-}
-
-func (bs *Server) getSSZBlockCapella(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	capellaBlk, err := blk.PbCapellaBlock()
-	if err != nil {
-		// ErrUnsupportedField means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedCapellaBlk, err := blk.PbBlindedCapellaBlock(); err == nil {
-				if blindedCapellaBlk == nil {
-					return nil, errNilBlock
-				}
-				signedFullBlock, err := bs.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
-				}
-				capellaBlk, err = signedFullBlock.PbCapellaBlock()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockCapellaToV2(capellaBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not convert signed beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				data := &ethpbv2.SignedBeaconBlockCapella{
-					Message:   v2Blk,
-					Signature: sig[:],
-				}
-				sszData, err := data.MarshalSSZ()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-				}
-				return &ethpbv2.SSZContainer{
-					Version:             ethpbv2.Version_CAPELLA,
-					ExecutionOptimistic: isOptimistic,
-					Data:                sszData,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if capellaBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockCapellaToV2(capellaBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert signed beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	data := &ethpbv2.SignedBeaconBlockCapella{
-		Message:   v2Blk,
-		Signature: sig[:],
-	}
-	sszData, err := data.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_CAPELLA, ExecutionOptimistic: isOptimistic, Data: sszData}, nil
-}
-
-func (bs *Server) getSSZBlockDeneb(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.SSZContainer, error) {
-	denebBlk, err := blk.PbDenebBlock()
-	if err != nil {
-		// ErrUnsupportedGetter means that we have another block type
-		if errors.Is(err, consensus_types.ErrUnsupportedField) {
-			if blindedDenebBlk, err := blk.PbBlindedDenebBlock(); err == nil {
-				if blindedDenebBlk == nil {
-					return nil, errNilBlock
-				}
-				signedFullBlock, err := bs.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
-				}
-				denebBlk, err = signedFullBlock.PbDenebBlock()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get signed beacon block")
-				}
-				v2Blk, err := migration.V1Alpha1BeaconBlockDenebToV2(denebBlk.Block)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not convert signed beacon block")
-				}
-				root, err := blk.Block().HashTreeRoot()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not get block root")
-				}
-				isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not check if block is optimistic")
-				}
-				sig := blk.Signature()
-				data := &ethpbv2.SignedBeaconBlockDeneb{
-					Message:   v2Blk,
-					Signature: sig[:],
-				}
-				sszData, err := data.MarshalSSZ()
-				if err != nil {
-					return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-				}
-				return &ethpbv2.SSZContainer{
-					Version:             ethpbv2.Version_DENEB,
-					ExecutionOptimistic: isOptimistic,
-					Data:                sszData,
-				}, nil
-			}
-			return nil, err
-		}
-		return nil, err
-	}
-
-	if denebBlk == nil {
-		return nil, errNilBlock
-	}
-	v2Blk, err := migration.V1Alpha1BeaconBlockDenebToV2(denebBlk.Block)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not convert signed beacon block")
-	}
-	root, err := blk.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get block root")
-	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not check if block is optimistic")
-	}
-	sig := blk.Signature()
-	data := &ethpbv2.SignedBeaconBlockDeneb{
-		Message:   v2Blk,
-		Signature: sig[:],
-	}
-	sszData, err := data.MarshalSSZ()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
-	}
-	return &ethpbv2.SSZContainer{Version: ethpbv2.Version_DENEB, ExecutionOptimistic: isOptimistic, Data: sszData}, nil
-}

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

@@ -1,688 +1,2 @@
 package beacon
 
-import (
-	"context"
-	"testing"
-
-	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"github.com/prysmaticlabs/go-bitfield"
-	mock "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/testutil"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
-	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v4/proto/migration"
-	ethpbalpha "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v4/testing/assert"
-	"github.com/prysmaticlabs/prysm/v4/testing/require"
-	"github.com/prysmaticlabs/prysm/v4/testing/util"
-	"google.golang.org/grpc"
-)
-
-func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (*ethpbalpha.SignedBeaconBlock, []*ethpbalpha.BeaconBlockContainer) {
-	parentRoot := [32]byte{1, 2, 3}
-	genBlk := util.NewBeaconBlock()
-	genBlk.Block.ParentRoot = parentRoot[:]
-	root, err := genBlk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, genBlk)
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
-
-	count := primitives.Slot(100)
-	blks := make([]interfaces.ReadOnlySignedBeaconBlock, count)
-	blkContainers := make([]*ethpbalpha.BeaconBlockContainer, count)
-	for i := primitives.Slot(0); i < count; i++ {
-		b := util.NewBeaconBlock()
-		b.Block.Slot = i
-		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
-		root, err := b.Block.HashTreeRoot()
-		require.NoError(t, err)
-		blks[i], err = blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		blkContainers[i] = &ethpbalpha.BeaconBlockContainer{
-			Block:     &ethpbalpha.BeaconBlockContainer_Phase0Block{Phase0Block: b},
-			BlockRoot: root[:],
-		}
-	}
-	require.NoError(t, beaconDB.SaveBlocks(ctx, blks))
-	headRoot := bytesutil.ToBytes32(blkContainers[len(blks)-1].BlockRoot)
-	summary := &ethpbalpha.StateSummary{
-		Root: headRoot[:],
-		Slot: blkContainers[len(blks)-1].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block.Block.Slot,
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, summary))
-	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
-	return genBlk, blkContainers
-}
-
-func TestServer_GetBlock(t *testing.T) {
-	ctx := context.Background()
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 123
-	sb, err := blocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	bs := &Server{
-		Blocker: &testutil.MockBlocker{BlockToReturn: sb},
-	}
-
-	blk, err := bs.GetBlock(ctx, &ethpbv1.BlockRequest{})
-	require.NoError(t, err)
-	v1Block, err := migration.V1Alpha1ToV1SignedBlock(b)
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Block.Block, blk.Data.Message)
-}
-
-func TestServer_GetBlockV2(t *testing.T) {
-	stream := &runtime.ServerTransportStream{}
-	ctx := grpc.NewContextWithServerTransportStream(context.Background(), stream)
-	t.Run("Phase 0", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             mockBlockFetcher,
-		}
-
-		blk, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1ToV1SignedBlock(b)
-		require.NoError(t, err)
-		phase0Block, ok := blk.Data.Message.(*ethpbv2.SignedBeaconBlockContainer_Phase0Block)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, v1Block.Block, phase0Block.Phase0Block)
-		assert.Equal(t, ethpbv2.Version_PHASE0, blk.Version)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		b := util.NewBeaconBlockAltair()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             mockBlockFetcher,
-		}
-
-		blk, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1BeaconBlockAltairToV2(b.Block)
-		require.NoError(t, err)
-		altairBlock, ok := blk.Data.Message.(*ethpbv2.SignedBeaconBlockContainer_AltairBlock)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, v1Block, altairBlock.AltairBlock)
-		assert.Equal(t, ethpbv2.Version_ALTAIR, blk.Version)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		b := util.NewBeaconBlockBellatrix()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		blk, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1BeaconBlockBellatrixToV2(b.Block)
-		require.NoError(t, err)
-		bellatrixBlock, ok := blk.Data.Message.(*ethpbv2.SignedBeaconBlockContainer_BellatrixBlock)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, v1Block, bellatrixBlock.BellatrixBlock)
-		assert.Equal(t, ethpbv2.Version_BELLATRIX, blk.Version)
-	})
-	t.Run("Capella", func(t *testing.T) {
-		b := util.NewBeaconBlockCapella()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		blk, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1BeaconBlockCapellaToV2(b.Block)
-		require.NoError(t, err)
-		bellatrixBlock, ok := blk.Data.Message.(*ethpbv2.SignedBeaconBlockContainer_CapellaBlock)
-		require.Equal(t, true, ok)
-		assert.DeepEqual(t, v1Block, bellatrixBlock.CapellaBlock)
-		assert.Equal(t, ethpbv2.Version_CAPELLA, blk.Version)
-	})
-	t.Run("execution optimistic", func(t *testing.T) {
-		b := util.NewBeaconBlockBellatrix()
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := sb.Block().HashTreeRoot()
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			OptimisticRoots: map[[32]byte]bool{r: true},
-			FinalizedRoots:  map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		blk, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-		assert.Equal(t, true, blk.ExecutionOptimistic)
-	})
-	t.Run("finalized", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := sb.Block().HashTreeRoot()
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-
-		t.Run("true", func(t *testing.T) {
-			mockChainService := &mock.ChainService{FinalizedRoots: map[[32]byte]bool{r: true}}
-			bs := &Server{
-				OptimisticModeFetcher: mockChainService,
-				FinalizationFetcher:   mockChainService,
-				Blocker:               mockBlockFetcher,
-			}
-
-			header, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{BlockId: r[:]})
-			require.NoError(t, err)
-			assert.Equal(t, true, header.Finalized)
-		})
-		t.Run("false", func(t *testing.T) {
-			mockChainService := &mock.ChainService{FinalizedRoots: map[[32]byte]bool{r: false}}
-			bs := &Server{
-				OptimisticModeFetcher: mockChainService,
-				FinalizationFetcher:   mockChainService,
-				Blocker:               mockBlockFetcher,
-			}
-
-			resp, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{BlockId: r[:]})
-			require.NoError(t, err)
-			assert.Equal(t, false, resp.Finalized)
-		})
-	})
-}
-
-func TestServer_GetBlockSSZ(t *testing.T) {
-	ctx := context.Background()
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 123
-	sb, err := blocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	bs := &Server{
-		Blocker: &testutil.MockBlocker{BlockToReturn: sb},
-	}
-
-	resp, err := bs.GetBlockSSZ(ctx, &ethpbv1.BlockRequest{})
-	require.NoError(t, err)
-	assert.NotNil(t, resp)
-	sszBlock, err := b.MarshalSSZ()
-	require.NoError(t, err)
-	assert.DeepEqual(t, sszBlock, resp.Data)
-}
-
-func TestServer_GetBlockSSZV2(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("Phase 0", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		resp, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		sszBlock, err := b.MarshalSSZ()
-		require.NoError(t, err)
-		assert.DeepEqual(t, sszBlock, resp.Data)
-		assert.Equal(t, ethpbv2.Version_PHASE0, resp.Version)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		b := util.NewBeaconBlockAltair()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			FinalizationFetcher: mockChainService,
-			Blocker:             &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		resp, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		sszBlock, err := b.MarshalSSZ()
-		require.NoError(t, err)
-		assert.DeepEqual(t, sszBlock, resp.Data)
-		assert.Equal(t, ethpbv2.Version_ALTAIR, resp.Version)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		b := util.NewBeaconBlockBellatrix()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		resp, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		sszBlock, err := b.MarshalSSZ()
-		require.NoError(t, err)
-		assert.DeepEqual(t, sszBlock, resp.Data)
-		assert.Equal(t, ethpbv2.Version_BELLATRIX, resp.Version)
-	})
-	t.Run("Capella", func(t *testing.T) {
-		b := util.NewBeaconBlockCapella()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		resp, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		sszBlock, err := b.MarshalSSZ()
-		require.NoError(t, err)
-		assert.DeepEqual(t, sszBlock, resp.Data)
-		assert.Equal(t, ethpbv2.Version_CAPELLA, resp.Version)
-	})
-	t.Run("execution optimistic", func(t *testing.T) {
-		b := util.NewBeaconBlockBellatrix()
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := sb.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		mockChainService := &mock.ChainService{
-			OptimisticRoots: map[[32]byte]bool{r: true},
-			FinalizedRoots:  map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		resp, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{})
-		require.NoError(t, err)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-	t.Run("finalized", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := sb.Block().HashTreeRoot()
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-
-		t.Run("true", func(t *testing.T) {
-			mockChainService := &mock.ChainService{FinalizedRoots: map[[32]byte]bool{r: true}}
-			bs := &Server{
-				OptimisticModeFetcher: mockChainService,
-				FinalizationFetcher:   mockChainService,
-				Blocker:               mockBlockFetcher,
-			}
-
-			header, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{BlockId: r[:]})
-			require.NoError(t, err)
-			assert.Equal(t, true, header.Finalized)
-		})
-		t.Run("false", func(t *testing.T) {
-			mockChainService := &mock.ChainService{FinalizedRoots: map[[32]byte]bool{r: false}}
-			bs := &Server{
-				OptimisticModeFetcher: mockChainService,
-				FinalizationFetcher:   mockChainService,
-				Blocker:               mockBlockFetcher,
-			}
-
-			resp, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{BlockId: r[:]})
-			require.NoError(t, err)
-			assert.Equal(t, false, resp.Finalized)
-		})
-	})
-}
-
-func TestServer_ListBlockAttestations(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("Phase 0", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		b.Block.Body.Attestations = []*ethpbalpha.Attestation{
-			{
-				AggregationBits: bitfield.Bitlist{0x00},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            123,
-					CommitteeIndex:  123,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root1"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig1"), 96),
-			},
-			{
-				AggregationBits: bitfield.Bitlist{0x01},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            456,
-					CommitteeIndex:  456,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root2"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig2"), 96),
-			},
-		}
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1ToV1SignedBlock(b)
-		require.NoError(t, err)
-		assert.DeepEqual(t, v1Block.Block.Body.Attestations, resp.Data)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		b := util.NewBeaconBlockAltair()
-		b.Block.Body.Attestations = []*ethpbalpha.Attestation{
-			{
-				AggregationBits: bitfield.Bitlist{0x00},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            123,
-					CommitteeIndex:  123,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root1"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig1"), 96),
-			},
-			{
-				AggregationBits: bitfield.Bitlist{0x01},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            456,
-					CommitteeIndex:  456,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root2"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig2"), 96),
-			},
-		}
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1BeaconBlockAltairToV2(b.Block)
-		require.NoError(t, err)
-		assert.DeepEqual(t, v1Block.Body.Attestations, resp.Data)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		b := util.NewBeaconBlockBellatrix()
-		b.Block.Body.Attestations = []*ethpbalpha.Attestation{
-			{
-				AggregationBits: bitfield.Bitlist{0x00},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            123,
-					CommitteeIndex:  123,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root1"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig1"), 96),
-			},
-			{
-				AggregationBits: bitfield.Bitlist{0x01},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            456,
-					CommitteeIndex:  456,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root2"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig2"), 96),
-			},
-		}
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1BeaconBlockBellatrixToV2(b.Block)
-		require.NoError(t, err)
-		assert.DeepEqual(t, v1Block.Body.Attestations, resp.Data)
-	})
-	t.Run("Capella", func(t *testing.T) {
-		b := util.NewBeaconBlockCapella()
-		b.Block.Body.Attestations = []*ethpbalpha.Attestation{
-			{
-				AggregationBits: bitfield.Bitlist{0x00},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            123,
-					CommitteeIndex:  123,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root1"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 123,
-						Root:  bytesutil.PadTo([]byte("root1"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig1"), 96),
-			},
-			{
-				AggregationBits: bitfield.Bitlist{0x01},
-				Data: &ethpbalpha.AttestationData{
-					Slot:            456,
-					CommitteeIndex:  456,
-					BeaconBlockRoot: bytesutil.PadTo([]byte("root2"), 32),
-					Source: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-					Target: &ethpbalpha.Checkpoint{
-						Epoch: 456,
-						Root:  bytesutil.PadTo([]byte("root2"), 32),
-					},
-				},
-				Signature: bytesutil.PadTo([]byte("sig2"), 96),
-			},
-		}
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-
-		v1Block, err := migration.V1Alpha1BeaconBlockCapellaToV2(b.Block)
-		require.NoError(t, err)
-		assert.DeepEqual(t, v1Block.Body.Attestations, resp.Data)
-	})
-	t.Run("execution optimistic", func(t *testing.T) {
-		b := util.NewBeaconBlockBellatrix()
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := sb.Block().HashTreeRoot()
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &mock.ChainService{
-			OptimisticRoots: map[[32]byte]bool{r: true},
-			FinalizedRoots:  map[[32]byte]bool{},
-		}
-		bs := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{})
-		require.NoError(t, err)
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-	})
-	t.Run("finalized", func(t *testing.T) {
-		b := util.NewBeaconBlock()
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := sb.Block().HashTreeRoot()
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-
-		t.Run("true", func(t *testing.T) {
-			mockChainService := &mock.ChainService{FinalizedRoots: map[[32]byte]bool{r: true}}
-			bs := &Server{
-				OptimisticModeFetcher: mockChainService,
-				FinalizationFetcher:   mockChainService,
-				Blocker:               mockBlockFetcher,
-			}
-
-			resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{BlockId: r[:]})
-			require.NoError(t, err)
-			assert.Equal(t, true, resp.Finalized)
-		})
-		t.Run("false", func(t *testing.T) {
-			mockChainService := &mock.ChainService{FinalizedRoots: map[[32]byte]bool{r: false}}
-			bs := &Server{
-				OptimisticModeFetcher: mockChainService,
-				FinalizationFetcher:   mockChainService,
-				Blocker:               mockBlockFetcher,
-			}
-
-			resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{BlockId: r[:]})
-			require.NoError(t, err)
-			assert.Equal(t, false, resp.Finalized)
-		})
-	})
-}

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

@@ -21,6 +21,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/shared"
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
+	consensus_types "github.com/prysmaticlabs/prysm/v4/consensus-types"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
@@ -38,6 +39,908 @@ const (
 	broadcastValidationConsensusAndEquivocation = "consensus_and_equivocation"
 )
 
+type handled bool
+
+// GetBlock retrieves block details for given block ID.
+//
+// DEPRECATED: please use GetBlockV2 instead
+func (s *Server) GetBlock(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlock")
+	defer span.End()
+
+	blockId := mux.Vars(r)["block_id"]
+	if blockId == "" {
+		http2.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+	blk, err := s.Blocker.Block(ctx, []byte(blockId))
+	if !shared.WriteBlockFetchError(w, blk, err) {
+		return
+	}
+
+	if http2.SszRequested(r) {
+		s.getBlockSSZ(ctx, w, blk)
+	} else {
+		s.getBlock(ctx, w, blk)
+	}
+}
+
+// getBlock returns the JSON-serialized version of the beacon block for given block ID.
+func (s *Server) getBlock(ctx context.Context, w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock) {
+	v2Resp, err := s.getBlockPhase0(ctx, blk)
+	if err != nil {
+		http2.HandleError(w, "Could not get block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	resp := &GetBlockResponse{Data: v2Resp.Data}
+	http2.WriteJson(w, resp)
+}
+
+// getBlockSSZ returns the SSZ-serialized version of the becaon block for given block ID.
+func (s *Server) getBlockSSZ(ctx context.Context, w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock) {
+	resp, err := s.getBlockPhase0SSZ(ctx, blk)
+	if err != nil {
+		http2.HandleError(w, "Could not get block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http2.WriteSsz(w, resp, "beacon_block.ssz")
+}
+
+// GetBlockV2 retrieves block details for given block ID.
+func (s *Server) GetBlockV2(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockV2")
+	defer span.End()
+
+	blockId := mux.Vars(r)["block_id"]
+	if blockId == "" {
+		http2.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+	blk, err := s.Blocker.Block(ctx, []byte(blockId))
+	if !shared.WriteBlockFetchError(w, blk, err) {
+		return
+	}
+
+	if http2.SszRequested(r) {
+		s.getBlockSSZV2(ctx, w, blk)
+	} else {
+		s.getBlockV2(ctx, w, blk)
+	}
+}
+
+// getBlockV2 returns the JSON-serialized version of the beacon block for given block ID.
+func (s *Server) getBlockV2(ctx context.Context, w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock) {
+	blkRoot, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		http2.HandleError(w, "Could not get block root "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	finalized := s.FinalizationFetcher.IsFinalized(ctx, blkRoot)
+
+	getBlockHandler := func(get func(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error)) handled {
+		result, err := get(ctx, blk)
+		if result != nil {
+			result.Finalized = finalized
+			w.Header().Set(api.VersionHeader, result.Version)
+			http2.WriteJson(w, result)
+			return true
+		}
+		// ErrUnsupportedField means that we have another block type
+		if !errors.Is(err, consensus_types.ErrUnsupportedField) {
+			http2.HandleError(w, "Could not get signed beacon block: "+err.Error(), http.StatusInternalServerError)
+			return true
+		}
+		return false
+	}
+
+	if getBlockHandler(s.getBlockDeneb) {
+		return
+	}
+	if getBlockHandler(s.getBlockCapella) {
+		return
+	}
+	if getBlockHandler(s.getBlockBellatrix) {
+		return
+	}
+	if getBlockHandler(s.getBlockAltair) {
+		return
+	}
+	if getBlockHandler(s.getBlockPhase0) {
+		return
+	}
+	http2.HandleError(w, fmt.Sprintf("Unknown block type %T", blk), http.StatusInternalServerError)
+}
+
+// getBlockSSZV2 returns the SSZ-serialized version of the beacon block for given block ID.
+func (s *Server) getBlockSSZV2(ctx context.Context, w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock) {
+	getBlockHandler := func(get func(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) ([]byte, error), ver string) handled {
+		result, err := get(ctx, blk)
+		if result != nil {
+			w.Header().Set(api.VersionHeader, ver)
+			http2.WriteSsz(w, result, "beacon_block.ssz")
+			return true
+		}
+		// ErrUnsupportedField means that we have another block type
+		if !errors.Is(err, consensus_types.ErrUnsupportedField) {
+			http2.HandleError(w, "Could not get signed beacon block: "+err.Error(), http.StatusInternalServerError)
+			return true
+		}
+		return false
+	}
+
+	if getBlockHandler(s.getBlockDenebSSZ, version.String(version.Deneb)) {
+		return
+	}
+	if getBlockHandler(s.getBlockCapellaSSZ, version.String(version.Capella)) {
+		return
+	}
+	if getBlockHandler(s.getBlockBellatrixSSZ, version.String(version.Bellatrix)) {
+		return
+	}
+	if getBlockHandler(s.getBlockAltairSSZ, version.String(version.Altair)) {
+		return
+	}
+	if getBlockHandler(s.getBlockPhase0SSZ, version.String(version.Phase0)) {
+		return
+	}
+	http2.HandleError(w, fmt.Sprintf("Unknown block type %T", blk), http.StatusInternalServerError)
+}
+
+// GetBlindedBlock retrieves blinded block for given block id.
+func (s *Server) GetBlindedBlock(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlindedBlock")
+	defer span.End()
+
+	blockId := mux.Vars(r)["block_id"]
+	if blockId == "" {
+		http2.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+	blk, err := s.Blocker.Block(ctx, []byte(blockId))
+	if !shared.WriteBlockFetchError(w, blk, err) {
+		return
+	}
+
+	if http2.SszRequested(r) {
+		s.getBlindedBlockSSZ(ctx, w, blk)
+	} else {
+		s.getBlindedBlock(ctx, w, blk)
+	}
+}
+
+// getBlindedBlock returns the JSON-serialized version of the blinded beacon block for given block id.
+func (s *Server) getBlindedBlock(ctx context.Context, w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock) {
+	blkRoot, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		http2.HandleError(w, "Could not get block root "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	finalized := s.FinalizationFetcher.IsFinalized(ctx, blkRoot)
+
+	getBlockHandler := func(get func(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error)) handled {
+		result, err := get(ctx, blk)
+		if result != nil {
+			result.Finalized = finalized
+			w.Header().Set(api.VersionHeader, result.Version)
+			http2.WriteJson(w, result)
+			return true
+		}
+		// ErrUnsupportedField means that we have another block type
+		if !errors.Is(err, consensus_types.ErrUnsupportedField) {
+			http2.HandleError(w, "Could not get signed beacon block: "+err.Error(), http.StatusInternalServerError)
+			return true
+		}
+		return false
+	}
+
+	if getBlockHandler(s.getBlockPhase0) {
+		return
+	}
+	if getBlockHandler(s.getBlockAltair) {
+		return
+	}
+	if getBlockHandler(s.getBlindedBlockBellatrix) {
+		return
+	}
+	if getBlockHandler(s.getBlindedBlockCapella) {
+		return
+	}
+	if getBlockHandler(s.getBlindedBlockDeneb) {
+		return
+	}
+	http2.HandleError(w, fmt.Sprintf("Unknown block type %T", blk), http.StatusInternalServerError)
+}
+
+// getBlindedBlockSSZ returns the SSZ-serialized version of the blinded beacon block for given block id.
+func (s *Server) getBlindedBlockSSZ(ctx context.Context, w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock) {
+	getBlockHandler := func(get func(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) ([]byte, error), ver string) handled {
+		result, err := get(ctx, blk)
+		if result != nil {
+			w.Header().Set(api.VersionHeader, ver)
+			http2.WriteSsz(w, result, "beacon_block.ssz")
+			return true
+		}
+		// ErrUnsupportedField means that we have another block type
+		if !errors.Is(err, consensus_types.ErrUnsupportedField) {
+			http2.HandleError(w, "Could not get signed beacon block: "+err.Error(), http.StatusInternalServerError)
+			return true
+		}
+		return false
+	}
+
+	if getBlockHandler(s.getBlockPhase0SSZ, version.String(version.Phase0)) {
+		return
+	}
+	if getBlockHandler(s.getBlockAltairSSZ, version.String(version.Altair)) {
+		return
+	}
+	if getBlockHandler(s.getBlindedBlockBellatrixSSZ, version.String(version.Bellatrix)) {
+		return
+	}
+	if getBlockHandler(s.getBlindedBlockCapellaSSZ, version.String(version.Capella)) {
+		return
+	}
+	if getBlockHandler(s.getBlindedBlockDenebSSZ, version.String(version.Deneb)) {
+		return
+	}
+	http2.HandleError(w, fmt.Sprintf("Unknown block type %T", blk), http.StatusInternalServerError)
+}
+
+func (*Server) getBlockPhase0(_ context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	consensusBlk, err := blk.PbPhase0Block()
+	if err != nil {
+		return nil, err
+	}
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	respBlk, err := shared.SignedBeaconBlockFromConsensus(consensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Phase0),
+		ExecutionOptimistic: false,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (*Server) getBlockAltair(_ context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	consensusBlk, err := blk.PbAltairBlock()
+	if err != nil {
+		return nil, err
+	}
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	respBlk, err := shared.SignedBeaconBlockAltairFromConsensus(consensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Altair),
+		ExecutionOptimistic: false,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (s *Server) getBlockBellatrix(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	consensusBlk, err := blk.PbBellatrixBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			blindedConsensusBlk, err := blk.PbBlindedBellatrixBlock()
+			if err != nil {
+				return nil, err
+			}
+			if blindedConsensusBlk == nil {
+				return nil, errNilBlock
+			}
+			fullBlk, err := s.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
+			}
+			consensusBlk, err = fullBlk.PbBellatrixBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	root, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get block root")
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not check if block is optimistic")
+	}
+	respBlk, err := shared.SignedBeaconBlockBellatrixFromConsensus(consensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Bellatrix),
+		ExecutionOptimistic: isOptimistic,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (s *Server) getBlockCapella(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	consensusBlk, err := blk.PbCapellaBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			blindedConsensusBlk, err := blk.PbBlindedCapellaBlock()
+			if err != nil {
+				return nil, err
+			}
+			if blindedConsensusBlk == nil {
+				return nil, errNilBlock
+			}
+			fullBlk, err := s.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
+			}
+			consensusBlk, err = fullBlk.PbCapellaBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	root, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get block root")
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not check if block is optimistic")
+	}
+	respBlk, err := shared.SignedBeaconBlockCapellaFromConsensus(consensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Capella),
+		ExecutionOptimistic: isOptimistic,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (s *Server) getBlockDeneb(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	consensusBlk, err := blk.PbDenebBlock()
+	if err != nil {
+		// ErrUnsupportedGetter means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			blindedConsensusBlk, err := blk.PbBlindedDenebBlock()
+			if err != nil {
+				return nil, err
+			}
+			if blindedConsensusBlk == nil {
+				return nil, errNilBlock
+			}
+			fullBlk, err := s.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
+			}
+			consensusBlk, err = fullBlk.PbDenebBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	root, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get block root")
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not check if block is optimistic")
+	}
+	respBlk, err := shared.SignedBeaconBlockDenebFromConsensus(consensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Deneb),
+		ExecutionOptimistic: isOptimistic,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (*Server) getBlockPhase0SSZ(_ context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	consensusBlk, err := blk.PbPhase0Block()
+	if err != nil {
+		return nil, err
+	}
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := consensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+func (*Server) getBlockAltairSSZ(_ context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	consensusBlk, err := blk.PbAltairBlock()
+	if err != nil {
+		return nil, err
+	}
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := consensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+func (s *Server) getBlockBellatrixSSZ(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	consensusBlk, err := blk.PbBellatrixBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			blindedConsensusBlk, err := blk.PbBlindedBellatrixBlock()
+			if err != nil {
+				return nil, err
+			}
+			if blindedConsensusBlk == nil {
+				return nil, errNilBlock
+			}
+			fullBlk, err := s.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
+			}
+			consensusBlk, err = fullBlk.PbBellatrixBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := consensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+func (s *Server) getBlockCapellaSSZ(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	consensusBlk, err := blk.PbCapellaBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			blindedConsensusBlk, err := blk.PbBlindedCapellaBlock()
+			if err != nil {
+				return nil, err
+			}
+			if blindedConsensusBlk == nil {
+				return nil, errNilBlock
+			}
+			fullBlk, err := s.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
+			}
+			consensusBlk, err = fullBlk.PbCapellaBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := consensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+func (s *Server) getBlockDenebSSZ(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	consensusBlk, err := blk.PbDenebBlock()
+	if err != nil {
+		// ErrUnsupportedGetter means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			blindedConsensusBlk, err := blk.PbBlindedDenebBlock()
+			if err != nil {
+				return nil, err
+			}
+			if blindedConsensusBlk == nil {
+				return nil, errNilBlock
+			}
+			fullBlk, err := s.ExecutionPayloadReconstructor.ReconstructFullBlock(ctx, blk)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block")
+			}
+			consensusBlk, err = fullBlk.PbDenebBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if consensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := consensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+func (s *Server) getBlindedBlockBellatrix(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	blindedConsensusBlk, err := blk.PbBlindedBellatrixBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			consensusBlk, err := blk.PbBellatrixBlock()
+			if err != nil {
+				return nil, err
+			}
+			if consensusBlk == nil {
+				return nil, errNilBlock
+			}
+			blkInterface, err := blk.ToBlinded()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not convert block to blinded block")
+			}
+			blindedConsensusBlk, err = blkInterface.PbBlindedBellatrixBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if blindedConsensusBlk == nil {
+		return nil, errNilBlock
+	}
+	root, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get block root")
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not check if block is optimistic")
+	}
+	respBlk, err := shared.SignedBlindedBeaconBlockBellatrixFromConsensus(blindedConsensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Bellatrix),
+		ExecutionOptimistic: isOptimistic,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (s *Server) getBlindedBlockCapella(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	blindedConsensusBlk, err := blk.PbBlindedCapellaBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			consensusBlk, err := blk.PbCapellaBlock()
+			if err != nil {
+				return nil, err
+			}
+			if consensusBlk == nil {
+				return nil, errNilBlock
+			}
+			blkInterface, err := blk.ToBlinded()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not convert block to blinded block")
+			}
+			blindedConsensusBlk, err = blkInterface.PbBlindedCapellaBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if blindedConsensusBlk == nil {
+		return nil, errNilBlock
+	}
+	root, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get block root")
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not check if block is optimistic")
+	}
+	respBlk, err := shared.SignedBlindedBeaconBlockCapellaFromConsensus(blindedConsensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Capella),
+		ExecutionOptimistic: isOptimistic,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (s *Server) getBlindedBlockDeneb(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*GetBlockV2Response, error) {
+	blindedConsensusBlk, err := blk.PbBlindedDenebBlock()
+	if err != nil {
+		// ErrUnsupportedGetter means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			consensusBlk, err := blk.PbDenebBlock()
+			if err != nil {
+				return nil, err
+			}
+			if consensusBlk == nil {
+				return nil, errNilBlock
+			}
+			blkInterface, err := blk.ToBlinded()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not convert block to blinded block")
+			}
+			blindedConsensusBlk, err = blkInterface.PbBlindedDenebBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if blindedConsensusBlk == nil {
+		return nil, errNilBlock
+	}
+	root, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get block root")
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not check if block is optimistic")
+	}
+	respBlk, err := shared.SignedBlindedBeaconBlockDenebFromConsensus(blindedConsensusBlk)
+	if err != nil {
+		return nil, err
+	}
+	jsonBytes, err := json.Marshal(respBlk.Message)
+	if err != nil {
+		return nil, err
+	}
+	return &GetBlockV2Response{
+		Version:             version.String(version.Deneb),
+		ExecutionOptimistic: isOptimistic,
+		Data: &SignedBlock{
+			Message:   jsonBytes,
+			Signature: respBlk.Signature,
+		},
+	}, nil
+}
+
+func (*Server) getBlindedBlockBellatrixSSZ(_ context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	blindedConsensusBlk, err := blk.PbBlindedBellatrixBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			consensusBlk, err := blk.PbBellatrixBlock()
+			if err != nil {
+				return nil, err
+			}
+			if consensusBlk == nil {
+				return nil, errNilBlock
+			}
+			blkInterface, err := blk.ToBlinded()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not convert block to blinded block")
+			}
+			blindedConsensusBlk, err = blkInterface.PbBlindedBellatrixBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if blindedConsensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := blindedConsensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+func (*Server) getBlindedBlockCapellaSSZ(_ context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	blindedConsensusBlk, err := blk.PbBlindedCapellaBlock()
+	if err != nil {
+		// ErrUnsupportedField means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			consensusBlk, err := blk.PbCapellaBlock()
+			if err != nil {
+				return nil, err
+			}
+			if consensusBlk == nil {
+				return nil, errNilBlock
+			}
+			blkInterface, err := blk.ToBlinded()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not convert block to blinded block")
+			}
+			blindedConsensusBlk, err = blkInterface.PbBlindedCapellaBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if blindedConsensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := blindedConsensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+func (*Server) getBlindedBlockDenebSSZ(_ context.Context, blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
+	blindedConsensusBlk, err := blk.PbBlindedDenebBlock()
+	if err != nil {
+		// ErrUnsupportedGetter means that we have another block type
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			consensusBlk, err := blk.PbDenebBlock()
+			if err != nil {
+				return nil, err
+			}
+			if consensusBlk == nil {
+				return nil, errNilBlock
+			}
+			blkInterface, err := blk.ToBlinded()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not convert block to blinded block")
+			}
+			blindedConsensusBlk, err = blkInterface.PbBlindedDenebBlock()
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not get signed beacon block")
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	if blindedConsensusBlk == nil {
+		return nil, errNilBlock
+	}
+	sszData, err := blindedConsensusBlk.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not marshal block into SSZ")
+	}
+	return sszData, nil
+}
+
+// GetBlockAttestations retrieves attestation included in requested block.
+func (s *Server) GetBlockAttestations(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockAttestations")
+	defer span.End()
+
+	blockId := mux.Vars(r)["block_id"]
+	if blockId == "" {
+		http2.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+	blk, err := s.Blocker.Block(ctx, []byte(blockId))
+	if !shared.WriteBlockFetchError(w, blk, err) {
+		return
+	}
+
+	consensusAtts := blk.Block().Body().Attestations()
+	atts := make([]*shared.Attestation, len(consensusAtts))
+	for i, att := range consensusAtts {
+		atts[i] = shared.AttestationFromConsensus(att)
+	}
+	root, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		http2.HandleError(w, "Could not get block root: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	if err != nil {
+		http2.HandleError(w, "Could not check if block is optimistic: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	resp := &GetBlockAttestationsResponse{
+		Data:                atts,
+		ExecutionOptimistic: isOptimistic,
+		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, root),
+	}
+	http2.WriteJson(w, resp)
+}
+
 // PublishBlindedBlock instructs the beacon node to use the components of the `SignedBlindedBeaconBlock` to construct
 // and publish a SignedBeaconBlock by swapping out the transactions_root for the corresponding full list of `transactions`.
 // The beacon node should broadcast a newly constructed SignedBeaconBlock to the beacon network, to be included in the

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

@@ -16,9 +16,11 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v4/api"
 	chainMock "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
 	dbTest "github.com/prysmaticlabs/prysm/v4/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/shared"
@@ -44,6 +46,944 @@ import (
 	"github.com/stretchr/testify/mock"
 )
 
+func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (*eth.SignedBeaconBlock, []*eth.BeaconBlockContainer) {
+	parentRoot := [32]byte{1, 2, 3}
+	genBlk := util.NewBeaconBlock()
+	genBlk.Block.ParentRoot = parentRoot[:]
+	root, err := genBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	util.SaveBlock(t, ctx, beaconDB, genBlk)
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
+
+	count := primitives.Slot(100)
+	blks := make([]interfaces.ReadOnlySignedBeaconBlock, count)
+	blkContainers := make([]*eth.BeaconBlockContainer, count)
+	for i := primitives.Slot(0); i < count; i++ {
+		b := util.NewBeaconBlock()
+		b.Block.Slot = i
+		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
+		root, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		blks[i], err = blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		blkContainers[i] = &eth.BeaconBlockContainer{
+			Block:     &eth.BeaconBlockContainer_Phase0Block{Phase0Block: b},
+			BlockRoot: root[:],
+		}
+	}
+	require.NoError(t, beaconDB.SaveBlocks(ctx, blks))
+	headRoot := bytesutil.ToBytes32(blkContainers[len(blks)-1].BlockRoot)
+	summary := &eth.StateSummary{
+		Root: headRoot[:],
+		Slot: blkContainers[len(blks)-1].Block.(*eth.BeaconBlockContainer_Phase0Block).Phase0Block.Block.Slot,
+	}
+	require.NoError(t, beaconDB.SaveStateSummary(ctx, summary))
+	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
+	return genBlk, blkContainers
+}
+
+func TestGetBlock(t *testing.T) {
+	b := util.NewBeaconBlock()
+	b.Block.Slot = 123
+	sb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	s := &Server{
+		Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+	}
+
+	request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+	request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetBlock(writer, request)
+	require.Equal(t, http.StatusOK, writer.Code)
+	resp := &GetBlockResponse{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	sbb := &shared.SignedBeaconBlock{Message: &shared.BeaconBlock{}}
+	require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+	sbb.Signature = resp.Data.Signature
+	genericBlk, err := sbb.ToGeneric()
+	require.NoError(t, err)
+	blk := genericBlk.GetPhase0()
+	require.NoError(t, err)
+	assert.DeepEqual(t, blk, b)
+}
+
+func TestGetBlockSSZ(t *testing.T) {
+	b := util.NewBeaconBlock()
+	b.Block.Slot = 123
+	sb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	s := &Server{
+		Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+	}
+
+	request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+	request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+	request.Header.Set("Accept", api.OctetStreamMediaType)
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetBlock(writer, request)
+	require.Equal(t, http.StatusOK, writer.Code)
+	sszExpected, err := b.MarshalSSZ()
+	require.NoError(t, err)
+	assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+}
+
+func TestGetBlockV2(t *testing.T) {
+	t.Run("phase0", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		s := &Server{
+			FinalizationFetcher: mockChainService,
+			Blocker:             mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Phase0), resp.Version)
+		sbb := &shared.SignedBeaconBlock{Message: &shared.BeaconBlock{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetPhase0()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("altair", func(t *testing.T) {
+		b := util.NewBeaconBlockAltair()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		s := &Server{
+			FinalizationFetcher: mockChainService,
+			Blocker:             mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Altair), resp.Version)
+		sbb := &shared.SignedBeaconBlockAltair{Message: &shared.BeaconBlockAltair{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetAltair()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("bellatrix", func(t *testing.T) {
+		b := util.NewBeaconBlockBellatrix()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Bellatrix), resp.Version)
+		sbb := &shared.SignedBeaconBlockBellatrix{Message: &shared.BeaconBlockBellatrix{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetBellatrix()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("capella", func(t *testing.T) {
+		b := util.NewBeaconBlockCapella()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Capella), resp.Version)
+		sbb := &shared.SignedBeaconBlockCapella{Message: &shared.BeaconBlockCapella{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetCapella()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("deneb", func(t *testing.T) {
+		b := util.NewBeaconBlockDeneb()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Deneb), resp.Version)
+		sbb := &shared.SignedBeaconBlockDeneb{Message: &shared.BeaconBlockDeneb{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		blk, err := sbb.ToConsensus()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("execution optimistic", func(t *testing.T) {
+		b := util.NewBeaconBlockBellatrix()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		r, err := sb.Block().HashTreeRoot()
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			OptimisticRoots: map[[32]byte]bool{r: true},
+			FinalizedRoots:  map[[32]byte]bool{},
+		}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
+	t.Run("finalized", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		r, err := sb.Block().HashTreeRoot()
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+
+		t.Run("true", func(t *testing.T) {
+			mockChainService := &chainMock.ChainService{FinalizedRoots: map[[32]byte]bool{r: true}}
+			s := &Server{
+				OptimisticModeFetcher: mockChainService,
+				FinalizationFetcher:   mockChainService,
+				Blocker:               mockBlockFetcher,
+			}
+
+			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+			request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(r[:])})
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.GetBlockV2(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			resp := &GetBlockV2Response{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+			assert.Equal(t, true, resp.Finalized)
+		})
+		t.Run("false", func(t *testing.T) {
+			mockChainService := &chainMock.ChainService{FinalizedRoots: map[[32]byte]bool{r: false}}
+			s := &Server{
+				OptimisticModeFetcher: mockChainService,
+				FinalizationFetcher:   mockChainService,
+				Blocker:               mockBlockFetcher,
+			}
+
+			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+			request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(r[:])})
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.GetBlockV2(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			resp := &GetBlockV2Response{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+			assert.Equal(t, false, resp.Finalized)
+		})
+	})
+}
+
+func TestGetBlockSSZV2(t *testing.T) {
+	t.Run("phase0", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Phase0), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("altair", func(t *testing.T) {
+		b := util.NewBeaconBlockAltair()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Altair), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("bellatrix", func(t *testing.T) {
+		b := util.NewBeaconBlockBellatrix()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Bellatrix), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("capella", func(t *testing.T) {
+		b := util.NewBeaconBlockCapella()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Capella), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("deneb", func(t *testing.T) {
+		b := util.NewBeaconBlockDeneb()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Deneb), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+
+}
+
+func TestGetBlockAttestations(t *testing.T) {
+	t.Run("ok", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		b.Block.Body.Attestations = []*eth.Attestation{
+			{
+				AggregationBits: bitfield.Bitlist{0x00},
+				Data: &eth.AttestationData{
+					Slot:            123,
+					CommitteeIndex:  123,
+					BeaconBlockRoot: bytesutil.PadTo([]byte("root1"), 32),
+					Source: &eth.Checkpoint{
+						Epoch: 123,
+						Root:  bytesutil.PadTo([]byte("root1"), 32),
+					},
+					Target: &eth.Checkpoint{
+						Epoch: 123,
+						Root:  bytesutil.PadTo([]byte("root1"), 32),
+					},
+				},
+				Signature: bytesutil.PadTo([]byte("sig1"), 96),
+			},
+			{
+				AggregationBits: bitfield.Bitlist{0x01},
+				Data: &eth.AttestationData{
+					Slot:            456,
+					CommitteeIndex:  456,
+					BeaconBlockRoot: bytesutil.PadTo([]byte("root2"), 32),
+					Source: &eth.Checkpoint{
+						Epoch: 456,
+						Root:  bytesutil.PadTo([]byte("root2"), 32),
+					},
+					Target: &eth.Checkpoint{
+						Epoch: 456,
+						Root:  bytesutil.PadTo([]byte("root2"), 32),
+					},
+				},
+				Signature: bytesutil.PadTo([]byte("sig2"), 96),
+			},
+		}
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}/attestations", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockAttestations(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockAttestationsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, len(b.Block.Body.Attestations), len(resp.Data))
+		atts := make([]*eth.Attestation, len(b.Block.Body.Attestations))
+		for i, a := range resp.Data {
+			atts[i], err = a.ToConsensus()
+			require.NoError(t, err)
+		}
+		assert.DeepEqual(t, b.Block.Body.Attestations, atts)
+	})
+	t.Run("execution optimistic", func(t *testing.T) {
+		b := util.NewBeaconBlockBellatrix()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		r, err := sb.Block().HashTreeRoot()
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			OptimisticRoots: map[[32]byte]bool{r: true},
+			FinalizedRoots:  map[[32]byte]bool{},
+		}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}/attestations", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockAttestations(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockAttestationsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
+	t.Run("finalized", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		r, err := sb.Block().HashTreeRoot()
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+
+		t.Run("true", func(t *testing.T) {
+			mockChainService := &chainMock.ChainService{FinalizedRoots: map[[32]byte]bool{r: true}}
+			s := &Server{
+				OptimisticModeFetcher: mockChainService,
+				FinalizationFetcher:   mockChainService,
+				Blocker:               mockBlockFetcher,
+			}
+
+			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}/attestations", nil)
+			request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.GetBlockAttestations(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			resp := &GetBlockAttestationsResponse{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+			assert.Equal(t, true, resp.Finalized)
+		})
+		t.Run("false", func(t *testing.T) {
+			mockChainService := &chainMock.ChainService{FinalizedRoots: map[[32]byte]bool{r: false}}
+			s := &Server{
+				OptimisticModeFetcher: mockChainService,
+				FinalizationFetcher:   mockChainService,
+				Blocker:               mockBlockFetcher,
+			}
+
+			request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blocks/{block_id}/attestations", nil)
+			request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+			writer := httptest.NewRecorder()
+			writer.Body = &bytes.Buffer{}
+
+			s.GetBlockAttestations(writer, request)
+			require.Equal(t, http.StatusOK, writer.Code)
+			resp := &GetBlockAttestationsResponse{}
+			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+			assert.Equal(t, false, resp.ExecutionOptimistic)
+		})
+	})
+}
+
+func TestGetBlindedBlock(t *testing.T) {
+	t.Run("phase0", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			FinalizationFetcher: &chainMock.ChainService{},
+			Blocker:             &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Phase0), resp.Version)
+		sbb := &shared.SignedBeaconBlock{Message: &shared.BeaconBlock{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetPhase0()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("altair", func(t *testing.T) {
+		b := util.NewBeaconBlockAltair()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			FinalizationFetcher: &chainMock.ChainService{},
+			Blocker:             &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Altair), resp.Version)
+		sbb := &shared.SignedBeaconBlockAltair{Message: &shared.BeaconBlockAltair{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetAltair()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("bellatrix", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockBellatrix()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		mockChainService := &chainMock.ChainService{}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Bellatrix), resp.Version)
+		sbb := &shared.SignedBlindedBeaconBlockBellatrix{Message: &shared.BlindedBeaconBlockBellatrix{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetBlindedBellatrix()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("capella", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockCapella()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		mockChainService := &chainMock.ChainService{}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Capella), resp.Version)
+		sbb := &shared.SignedBlindedBeaconBlockCapella{Message: &shared.BlindedBeaconBlockCapella{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		genericBlk, err := sbb.ToGeneric()
+		require.NoError(t, err)
+		blk := genericBlk.GetBlindedCapella()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("deneb", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockDeneb()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		mockChainService := &chainMock.ChainService{}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Deneb), resp.Version)
+		sbb := &shared.SignedBlindedBeaconBlockDeneb{Message: &shared.BlindedBeaconBlockDeneb{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		blk, err := sbb.ToConsensus()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
+	t.Run("execution optimistic", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockBellatrix()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		r, err := sb.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		mockChainService := &chainMock.ChainService{
+			OptimisticRoots: map[[32]byte]bool{r: true},
+		}
+		s := &Server{
+			FinalizationFetcher:   mockChainService,
+			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
+			OptimisticModeFetcher: mockChainService,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
+	t.Run("finalized", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		root, err := sb.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{root: true},
+		}
+		s := &Server{
+			FinalizationFetcher: mockChainService,
+			Blocker:             &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(root[:])})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, true, resp.Finalized)
+	})
+	t.Run("not finalized", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		root, err := sb.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{root: false},
+		}
+		s := &Server{
+			FinalizationFetcher: mockChainService,
+			Blocker:             &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": hexutil.Encode(root[:])})
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, false, resp.Finalized)
+	})
+}
+
+func TestGetBlindedBlockSSZ(t *testing.T) {
+	t.Run("phase0", func(t *testing.T) {
+		b := util.NewBeaconBlock()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Phase0), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("Altair", func(t *testing.T) {
+		b := util.NewBeaconBlockAltair()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Altair), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("Bellatrix", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockBellatrix()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Bellatrix), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("Capella", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockCapella()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Capella), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+	t.Run("Deneb", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockDeneb()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request = mux.SetURLVars(request, map[string]string{"block_id": "head"})
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Deneb), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
+}
+
 func TestPublishBlock(t *testing.T) {
 	ctrl := gomock.NewController(t)
 

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

@@ -1,6 +1,8 @@
 package beacon
 
 import (
+	"encoding/json"
+
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/shared"
 )
 
@@ -122,6 +124,28 @@ type ValidatorBalance struct {
 	Balance string `json:"balance"`
 }
 
+type GetBlockResponse struct {
+	Data *SignedBlock `json:"data"`
+}
+
+type GetBlockV2Response struct {
+	Version             string       `json:"version"`
+	ExecutionOptimistic bool         `json:"execution_optimistic"`
+	Finalized           bool         `json:"finalized"`
+	Data                *SignedBlock `json:"data"`
+}
+
+type SignedBlock struct {
+	Message   json.RawMessage `json:"message"` // represents the block values based on the version
+	Signature string          `json:"signature"`
+}
+
+type GetBlockAttestationsResponse struct {
+	ExecutionOptimistic bool                  `json:"execution_optimistic"`
+	Finalized           bool                  `json:"finalized"`
+	Data                []*shared.Attestation `json:"data"`
+}
+
 type GetStateRootResponse struct {
 	ExecutionOptimistic bool       `json:"execution_optimistic"`
 	Finalized           bool       `json:"finalized"`

beacon-chain/rpc/eth/shared/structs_blocks_conversions.go

@@ -1256,7 +1256,7 @@ func (b *SignedBlindedBeaconBlockContentsDeneb) ToGeneric() (*eth.GenericSignedB
 		}
 		signedBlindedBlobSidecars = make([]*eth.SignedBlindedBlobSidecar, len(b.SignedBlindedBlobSidecars))
 		for i := range b.SignedBlindedBlobSidecars {
-			signedBlob, err := b.SignedBlindedBlobSidecars[i].ToConensus(i)
+			signedBlob, err := b.SignedBlindedBlobSidecars[i].ToConsensus()
 			if err != nil {
 				return nil, NewDecodeError(err, fmt.Sprintf("SignedBlindedBlobSidecars[%d]", i))
 			}
@@ -1926,7 +1926,7 @@ func (b *BlindedBeaconBlockDeneb) ToConsensus() (*eth.BlindedBeaconBlockDeneb, e
 	}, nil
 }
 
-func (s *SignedBlindedBlobSidecar) ToConensus(i int) (*eth.SignedBlindedBlobSidecar, error) {
+func (s *SignedBlindedBlobSidecar) ToConsensus() (*eth.SignedBlindedBlobSidecar, error) {
 	if s == nil {
 		return nil, errNilValue
 	}
@@ -2047,6 +2047,17 @@ func BeaconBlockFromConsensus(b *eth.BeaconBlock) (*BeaconBlock, error) {
 	}, nil
 }
 
+func SignedBeaconBlockFromConsensus(b *eth.SignedBeaconBlock) (*SignedBeaconBlock, error) {
+	block, err := BeaconBlockFromConsensus(b.Block)
+	if err != nil {
+		return nil, err
+	}
+	return &SignedBeaconBlock{
+		Message:   block,
+		Signature: hexutil.Encode(b.Signature),
+	}, nil
+}
+
 func BeaconBlockAltairFromConsensus(b *eth.BeaconBlockAltair) (*BeaconBlockAltair, error) {
 	proposerSlashings, err := ProposerSlashingsFromConsensus(b.Body.ProposerSlashings)
 	if err != nil {
@@ -2095,6 +2106,17 @@ func BeaconBlockAltairFromConsensus(b *eth.BeaconBlockAltair) (*BeaconBlockAltai
 	}, nil
 }
 
+func SignedBeaconBlockAltairFromConsensus(b *eth.SignedBeaconBlockAltair) (*SignedBeaconBlockAltair, error) {
+	block, err := BeaconBlockAltairFromConsensus(b.Block)
+	if err != nil {
+		return nil, err
+	}
+	return &SignedBeaconBlockAltair{
+		Message:   block,
+		Signature: hexutil.Encode(b.Signature),
+	}, nil
+}
+
 func BlindedBeaconBlockBellatrixFromConsensus(b *eth.BlindedBeaconBlockBellatrix) (*BlindedBeaconBlockBellatrix, error) {
 	proposerSlashings, err := ProposerSlashingsFromConsensus(b.Body.ProposerSlashings)
 	if err != nil {
@@ -2244,6 +2266,17 @@ func BeaconBlockBellatrixFromConsensus(b *eth.BeaconBlockBellatrix) (*BeaconBloc
 	}, nil
 }
 
+func SignedBeaconBlockBellatrixFromConsensus(b *eth.SignedBeaconBlockBellatrix) (*SignedBeaconBlockBellatrix, error) {
+	block, err := BeaconBlockBellatrixFromConsensus(b.Block)
+	if err != nil {
+		return nil, err
+	}
+	return &SignedBeaconBlockBellatrix{
+		Message:   block,
+		Signature: hexutil.Encode(b.Signature),
+	}, nil
+}
+
 func BlindedBeaconBlockCapellaFromConsensus(b *eth.BlindedBeaconBlockCapella) (*BlindedBeaconBlockCapella, error) {
 	proposerSlashings, err := ProposerSlashingsFromConsensus(b.Body.ProposerSlashings)
 	if err != nil {
@@ -2415,6 +2448,17 @@ func BeaconBlockCapellaFromConsensus(b *eth.BeaconBlockCapella) (*BeaconBlockCap
 	}, nil
 }
 
+func SignedBeaconBlockCapellaFromConsensus(b *eth.SignedBeaconBlockCapella) (*SignedBeaconBlockCapella, error) {
+	block, err := BeaconBlockCapellaFromConsensus(b.Block)
+	if err != nil {
+		return nil, err
+	}
+	return &SignedBeaconBlockCapella{
+		Message:   block,
+		Signature: hexutil.Encode(b.Signature),
+	}, nil
+}
+
 func BlindedBeaconBlockContentsDenebFromConsensus(b *eth.BlindedBeaconBlockAndBlobsDeneb) (*BlindedBeaconBlockContentsDeneb, error) {
 	var blindedBlobSidecars []*BlindedBlobSidecar
 	if len(b.Blobs) != 0 {

beacon-chain/rpc/service.go

@@ -446,6 +446,10 @@ func (s *Service) Start() {
 	s.cfg.Router.HandleFunc("/eth/v1/beacon/blinded_blocks", beaconChainServerV1.PublishBlindedBlock).Methods(http.MethodPost)
 	s.cfg.Router.HandleFunc("/eth/v2/beacon/blocks", beaconChainServerV1.PublishBlockV2).Methods(http.MethodPost)
 	s.cfg.Router.HandleFunc("/eth/v2/beacon/blinded_blocks", beaconChainServerV1.PublishBlindedBlockV2).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blocks/{block_id}", beaconChainServerV1.GetBlock).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v2/beacon/blocks/{block_id}", beaconChainServerV1.GetBlockV2).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v2/beacon/blocks/{block_id}/attestations", beaconChainServerV1.GetBlockAttestations).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blinded_blocks/{block_id}", beaconChainServerV1.GetBlindedBlock).Methods(http.MethodGet)
 	s.cfg.Router.HandleFunc("/eth/v1/beacon/blocks/{block_id}/root", beaconChainServerV1.GetBlockRoot).Methods(http.MethodGet)
 	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/attestations", beaconChainServerV1.ListAttestations).Methods(http.MethodGet)
 	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/attestations", beaconChainServerV1.SubmitAttestations).Methods(http.MethodPost)

proto/eth/service/beacon_chain_service.pb.go

@@ -11,7 +11,6 @@ import (
 	reflect "reflect"
 
 	v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
-	v2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
 	_ "google.golang.org/genproto/googleapis/api/annotations"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -46,200 +45,112 @@ var file_proto_eth_service_beacon_chain_service_proto_rawDesc = []byte{
 	0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f,
 	0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31,
 	0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76,
+	0x6f, 0x74, 0x6f, 0x32, 0xe8, 0x07, 0x0a, 0x0b, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x43, 0x68,
-	0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70,
+	0x61, 0x69, 0x6e, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x57, 0x65, 0x61, 0x6b, 0x53,
-	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x16, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f,
+	0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x12, 0x16, 0x2e, 0x67, 0x6f,
-	0x76, 0x32, 0x2f, 0x73, 0x73, 0x7a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0xd1, 0x0f, 0x0a,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d,
-	0x0b, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x8e, 0x01, 0x0a,
+	0x70, 0x74, 0x79, 0x1a, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
-	0x13, 0x47, 0x65, 0x74, 0x57, 0x65, 0x61, 0x6b, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69,
+	0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x65, 0x61, 0x6b, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63,
-	0x76, 0x69, 0x74, 0x79, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x29, 0x2e, 0x65,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x57,
+	0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f,
-	0x65, 0x61, 0x6b, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x52,
+	0x77, 0x65, 0x61, 0x6b, 0x5f, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12,
+	0x79, 0x88, 0x02, 0x01, 0x12, 0x9c, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6f,
-	0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76,
+	0x6c, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e,
-	0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x73, 0x75,
+	0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x88, 0x02, 0x01, 0x12, 0x7f, 0x0a,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2e, 0x2e, 0x65, 0x74, 0x68,
-	0x08, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65,
+	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x74, 0x74,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63,
+	0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x50, 0x6f,
-	0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
+	0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3, 0xe4, 0x93,
-	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
+	0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b,
+	0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c,
-	0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f,
+	0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69,
-	0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73,
+	0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x41, 0x74,
-	0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x88, 0x02, 0x01, 0x12, 0x89,
+	0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x12, 0x21,
-	0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x12, 0x1d,
 	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
-	0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e,
+	0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e,
-	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e,
+	0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x22, 0x38, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2f, 0x12, 0x2d, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72,
+	0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
-	0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f,
-	0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
-	0x69, 0x64, 0x7d, 0x2f, 0x73, 0x73, 0x7a, 0x88, 0x02, 0x01, 0x12, 0x82, 0x01, 0x0a, 0x0a, 0x47,
-	0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x32, 0x12, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f, 0x63,
-	0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x32, 0x1a, 0x20, 0x2e, 0x65, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f,
-	0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, 0x32, 0x22, 0x31, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
-	0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c,
-	0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x12,
-	0x92, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c,
-	0x6f, 0x63, 0x6b, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
-	0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
-	0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63,
-	0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x39, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x33, 0x12, 0x31, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68,
-	0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64,
-	0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x5f, 0x69, 0x64, 0x7d, 0x12, 0x91, 0x01, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x69, 0x6e,
-	0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c,
-	0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a,
-	0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x37, 0x12, 0x35, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68,
-	0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64,
-	0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0x86, 0x01, 0x0a, 0x0d, 0x47, 0x65, 0x74,
-	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x56, 0x32, 0x12, 0x1f, 0x2e, 0x65, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f,
-	0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x32, 0x1a, 0x1d, 0x2e, 0x65, 0x74,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53,
-	0x5a, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x35, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x2f, 0x12, 0x2d, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74,
-	0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x73,
-	0x7a, 0x12, 0xa2, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x41,
-	0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x2e, 0x65, 0x74,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c,
-	0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x65, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f,
-	0x63, 0x6b, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36,
-	0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31,
-	0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b,
-	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x9c, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x50,
-	0x6f, 0x6f, 0x6c, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68,
-	0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2e, 0x2e, 0x65,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41,
-	0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73,
-	0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
 	0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f,
 	0x6f, 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73,
-	0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74,
+	0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x9b, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f,
-	0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+	0x6f, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69,
-	0x12, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
+	0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
-	0x76, 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2d, 0x2e, 0x65, 0x74,
-	0x69, 0x6e, 0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4,
+	0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x50, 0x6f,
-	0x93, 0x02, 0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
+	0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3, 0xe4, 0x93,
-	0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f,
+	0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74,
-	0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x6c,
+	0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c,
-	0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x9b, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74,
+	0x2f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69,
-	0x50, 0x6f, 0x6f, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73,
+	0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72,
-	0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x12, 0x21,
-	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2d, 0x2e,
+	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
-	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e,
+	0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e,
-	0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+	0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3,
+	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0xe4, 0x93, 0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
+	0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
 	0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f,
 	0x6f, 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73,
-	0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74,
+	0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x6b,
-	0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+	0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x12, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79,
-	0x76, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68,
+	0x1a, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
-	0x69, 0x6e, 0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x76, 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12,
-	0x93, 0x02, 0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
+	0x25, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76,
-	0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f,
+	0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x73, 0x63,
-	0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x6c,
+	0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x66, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x53, 0x70, 0x65,
-	0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x46, 0x6f,
+	0x63, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x72, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70,
+	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x65, 0x63,
-	0x74, 0x79, 0x1a, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e,
-	0x68, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c,
+	0x12, 0x1c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x73, 0x70, 0x65, 0x63, 0x42, 0x98,
-	0x27, 0x12, 0x25, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68,
+	0x01, 0x0a, 0x18, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e,
-	0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x66, 0x6f, 0x72, 0x6b, 0x5f,
+	0x65, 0x74, 0x68, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0x17, 0x42, 0x65, 0x61,
-	0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x66, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x53,
+	0x63, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50,
-	0x70, 0x65, 0x63, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1d, 0x2e, 0x65, 0x74,
+	0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70,
+	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x34, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
-	0x65, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93,
+	0x65, 0x74, 0x68, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xaa, 0x02, 0x14, 0x45, 0x74,
-	0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69,
-	0x68, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x73, 0x70, 0x65, 0x63,
+	0x63, 0x65, 0xca, 0x02, 0x14, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74,
-	0x42, 0x98, 0x01, 0x0a, 0x18, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x68, 0x5c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0x17, 0x42,
+	0x33,
-	0x65, 0x61, 0x63, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x33, 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, 0x34, 0x2f, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xaa, 0x02, 0x14,
-	0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x53, 0x65, 0x72,
-	0x76, 0x69, 0x63, 0x65, 0xca, 0x02, 0x14, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c,
-	0x45, 0x74, 0x68, 0x5c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
 }
 
 var file_proto_eth_service_beacon_chain_service_proto_goTypes = []interface{}{
 	(*emptypb.Empty)(nil),                    // 0: google.protobuf.Empty
-	(*v1.BlockRequest)(nil),                  // 1: ethereum.eth.v1.BlockRequest
+	(*v1.AttesterSlashing)(nil),              // 1: ethereum.eth.v1.AttesterSlashing
-	(*v2.BlockRequestV2)(nil),                // 2: ethereum.eth.v2.BlockRequestV2
+	(*v1.ProposerSlashing)(nil),              // 2: ethereum.eth.v1.ProposerSlashing
-	(*v1.AttesterSlashing)(nil),              // 3: ethereum.eth.v1.AttesterSlashing
+	(*v1.WeakSubjectivityResponse)(nil),      // 3: ethereum.eth.v1.WeakSubjectivityResponse
-	(*v1.ProposerSlashing)(nil),              // 4: ethereum.eth.v1.ProposerSlashing
+	(*v1.AttesterSlashingsPoolResponse)(nil), // 4: ethereum.eth.v1.AttesterSlashingsPoolResponse
-	(*v1.WeakSubjectivityResponse)(nil),      // 5: ethereum.eth.v1.WeakSubjectivityResponse
+	(*v1.ProposerSlashingPoolResponse)(nil),  // 5: ethereum.eth.v1.ProposerSlashingPoolResponse
-	(*v1.BlockResponse)(nil),                 // 6: ethereum.eth.v1.BlockResponse
+	(*v1.ForkScheduleResponse)(nil),          // 6: ethereum.eth.v1.ForkScheduleResponse
-	(*v1.BlockSSZResponse)(nil),              // 7: ethereum.eth.v1.BlockSSZResponse
+	(*v1.SpecResponse)(nil),                  // 7: ethereum.eth.v1.SpecResponse
-	(*v2.BlockResponseV2)(nil),               // 8: ethereum.eth.v2.BlockResponseV2
-	(*v2.BlindedBlockResponse)(nil),          // 9: ethereum.eth.v2.BlindedBlockResponse
-	(*v2.SSZContainer)(nil),                  // 10: ethereum.eth.v2.SSZContainer
-	(*v1.BlockAttestationsResponse)(nil),     // 11: ethereum.eth.v1.BlockAttestationsResponse
-	(*v1.AttesterSlashingsPoolResponse)(nil), // 12: ethereum.eth.v1.AttesterSlashingsPoolResponse
-	(*v1.ProposerSlashingPoolResponse)(nil),  // 13: ethereum.eth.v1.ProposerSlashingPoolResponse
-	(*v1.ForkScheduleResponse)(nil),          // 14: ethereum.eth.v1.ForkScheduleResponse
-	(*v1.SpecResponse)(nil),                  // 15: ethereum.eth.v1.SpecResponse
 }
 var file_proto_eth_service_beacon_chain_service_proto_depIdxs = []int32{
-	0,  // 0: ethereum.eth.service.BeaconChain.GetWeakSubjectivity:input_type -> google.protobuf.Empty
+	0, // 0: ethereum.eth.service.BeaconChain.GetWeakSubjectivity:input_type -> google.protobuf.Empty
-	1,  // 1: ethereum.eth.service.BeaconChain.GetBlock:input_type -> ethereum.eth.v1.BlockRequest
+	0, // 1: ethereum.eth.service.BeaconChain.ListPoolAttesterSlashings:input_type -> google.protobuf.Empty
-	1,  // 2: ethereum.eth.service.BeaconChain.GetBlockSSZ:input_type -> ethereum.eth.v1.BlockRequest
+	1, // 2: ethereum.eth.service.BeaconChain.SubmitAttesterSlashing:input_type -> ethereum.eth.v1.AttesterSlashing
-	2,  // 3: ethereum.eth.service.BeaconChain.GetBlockV2:input_type -> ethereum.eth.v2.BlockRequestV2
+	0, // 3: ethereum.eth.service.BeaconChain.ListPoolProposerSlashings:input_type -> google.protobuf.Empty
-	1,  // 4: ethereum.eth.service.BeaconChain.GetBlindedBlock:input_type -> ethereum.eth.v1.BlockRequest
+	2, // 4: ethereum.eth.service.BeaconChain.SubmitProposerSlashing:input_type -> ethereum.eth.v1.ProposerSlashing
-	1,  // 5: ethereum.eth.service.BeaconChain.GetBlindedBlockSSZ:input_type -> ethereum.eth.v1.BlockRequest
+	0, // 5: ethereum.eth.service.BeaconChain.GetForkSchedule:input_type -> google.protobuf.Empty
-	2,  // 6: ethereum.eth.service.BeaconChain.GetBlockSSZV2:input_type -> ethereum.eth.v2.BlockRequestV2
+	0, // 6: ethereum.eth.service.BeaconChain.GetSpec:input_type -> google.protobuf.Empty
-	1,  // 7: ethereum.eth.service.BeaconChain.ListBlockAttestations:input_type -> ethereum.eth.v1.BlockRequest
+	3, // 7: ethereum.eth.service.BeaconChain.GetWeakSubjectivity:output_type -> ethereum.eth.v1.WeakSubjectivityResponse
-	0,  // 8: ethereum.eth.service.BeaconChain.ListPoolAttesterSlashings:input_type -> google.protobuf.Empty
+	4, // 8: ethereum.eth.service.BeaconChain.ListPoolAttesterSlashings:output_type -> ethereum.eth.v1.AttesterSlashingsPoolResponse
-	3,  // 9: ethereum.eth.service.BeaconChain.SubmitAttesterSlashing:input_type -> ethereum.eth.v1.AttesterSlashing
+	0, // 9: ethereum.eth.service.BeaconChain.SubmitAttesterSlashing:output_type -> google.protobuf.Empty
-	0,  // 10: ethereum.eth.service.BeaconChain.ListPoolProposerSlashings:input_type -> google.protobuf.Empty
+	5, // 10: ethereum.eth.service.BeaconChain.ListPoolProposerSlashings:output_type -> ethereum.eth.v1.ProposerSlashingPoolResponse
-	4,  // 11: ethereum.eth.service.BeaconChain.SubmitProposerSlashing:input_type -> ethereum.eth.v1.ProposerSlashing
+	0, // 11: ethereum.eth.service.BeaconChain.SubmitProposerSlashing:output_type -> google.protobuf.Empty
-	0,  // 12: ethereum.eth.service.BeaconChain.GetForkSchedule:input_type -> google.protobuf.Empty
+	6, // 12: ethereum.eth.service.BeaconChain.GetForkSchedule:output_type -> ethereum.eth.v1.ForkScheduleResponse
-	0,  // 13: ethereum.eth.service.BeaconChain.GetSpec:input_type -> google.protobuf.Empty
+	7, // 13: ethereum.eth.service.BeaconChain.GetSpec:output_type -> ethereum.eth.v1.SpecResponse
-	5,  // 14: ethereum.eth.service.BeaconChain.GetWeakSubjectivity:output_type -> ethereum.eth.v1.WeakSubjectivityResponse
+	7, // [7:14] is the sub-list for method output_type
-	6,  // 15: ethereum.eth.service.BeaconChain.GetBlock:output_type -> ethereum.eth.v1.BlockResponse
+	0, // [0:7] is the sub-list for method input_type
-	7,  // 16: ethereum.eth.service.BeaconChain.GetBlockSSZ:output_type -> ethereum.eth.v1.BlockSSZResponse
+	0, // [0:0] is the sub-list for extension type_name
-	8,  // 17: ethereum.eth.service.BeaconChain.GetBlockV2:output_type -> ethereum.eth.v2.BlockResponseV2
+	0, // [0:0] is the sub-list for extension extendee
-	9,  // 18: ethereum.eth.service.BeaconChain.GetBlindedBlock:output_type -> ethereum.eth.v2.BlindedBlockResponse
+	0, // [0:0] is the sub-list for field type_name
-	10, // 19: ethereum.eth.service.BeaconChain.GetBlindedBlockSSZ:output_type -> ethereum.eth.v2.SSZContainer
-	10, // 20: ethereum.eth.service.BeaconChain.GetBlockSSZV2:output_type -> ethereum.eth.v2.SSZContainer
-	11, // 21: ethereum.eth.service.BeaconChain.ListBlockAttestations:output_type -> ethereum.eth.v1.BlockAttestationsResponse
-	12, // 22: ethereum.eth.service.BeaconChain.ListPoolAttesterSlashings:output_type -> ethereum.eth.v1.AttesterSlashingsPoolResponse
-	0,  // 23: ethereum.eth.service.BeaconChain.SubmitAttesterSlashing:output_type -> google.protobuf.Empty
-	13, // 24: ethereum.eth.service.BeaconChain.ListPoolProposerSlashings:output_type -> ethereum.eth.v1.ProposerSlashingPoolResponse
-	0,  // 25: ethereum.eth.service.BeaconChain.SubmitProposerSlashing:output_type -> google.protobuf.Empty
-	14, // 26: ethereum.eth.service.BeaconChain.GetForkSchedule:output_type -> ethereum.eth.v1.ForkScheduleResponse
-	15, // 27: ethereum.eth.service.BeaconChain.GetSpec:output_type -> ethereum.eth.v1.SpecResponse
-	14, // [14:28] is the sub-list for method output_type
-	0,  // [0:14] is the sub-list for method input_type
-	0,  // [0:0] is the sub-list for extension type_name
-	0,  // [0:0] is the sub-list for extension extendee
-	0,  // [0:0] is the sub-list for field type_name
 }
 
 func init() { file_proto_eth_service_beacon_chain_service_proto_init() }
@@ -280,15 +191,6 @@ const _ = grpc.SupportPackageIsVersion6
 type BeaconChainClient interface {
 	// Deprecated: Do not use.
 	GetWeakSubjectivity(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*v1.WeakSubjectivityResponse, error)
-	// Deprecated: Do not use.
-	GetBlock(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v1.BlockResponse, error)
-	// Deprecated: Do not use.
-	GetBlockSSZ(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v1.BlockSSZResponse, error)
-	GetBlockV2(ctx context.Context, in *v2.BlockRequestV2, opts ...grpc.CallOption) (*v2.BlockResponseV2, error)
-	GetBlindedBlock(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v2.BlindedBlockResponse, error)
-	GetBlindedBlockSSZ(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v2.SSZContainer, error)
-	GetBlockSSZV2(ctx context.Context, in *v2.BlockRequestV2, opts ...grpc.CallOption) (*v2.SSZContainer, error)
-	ListBlockAttestations(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v1.BlockAttestationsResponse, error)
 	ListPoolAttesterSlashings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*v1.AttesterSlashingsPoolResponse, error)
 	SubmitAttesterSlashing(ctx context.Context, in *v1.AttesterSlashing, opts ...grpc.CallOption) (*emptypb.Empty, error)
 	ListPoolProposerSlashings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*v1.ProposerSlashingPoolResponse, error)
@@ -315,71 +217,6 @@ func (c *beaconChainClient) GetWeakSubjectivity(ctx context.Context, in *emptypb
 	return out, nil
 }
 
-// Deprecated: Do not use.
-func (c *beaconChainClient) GetBlock(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v1.BlockResponse, error) {
-	out := new(v1.BlockResponse)
-	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetBlock", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// Deprecated: Do not use.
-func (c *beaconChainClient) GetBlockSSZ(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v1.BlockSSZResponse, error) {
-	out := new(v1.BlockSSZResponse)
-	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetBlockSSZ", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *beaconChainClient) GetBlockV2(ctx context.Context, in *v2.BlockRequestV2, opts ...grpc.CallOption) (*v2.BlockResponseV2, error) {
-	out := new(v2.BlockResponseV2)
-	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetBlockV2", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *beaconChainClient) GetBlindedBlock(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v2.BlindedBlockResponse, error) {
-	out := new(v2.BlindedBlockResponse)
-	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetBlindedBlock", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *beaconChainClient) GetBlindedBlockSSZ(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v2.SSZContainer, error) {
-	out := new(v2.SSZContainer)
-	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetBlindedBlockSSZ", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *beaconChainClient) GetBlockSSZV2(ctx context.Context, in *v2.BlockRequestV2, opts ...grpc.CallOption) (*v2.SSZContainer, error) {
-	out := new(v2.SSZContainer)
-	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetBlockSSZV2", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *beaconChainClient) ListBlockAttestations(ctx context.Context, in *v1.BlockRequest, opts ...grpc.CallOption) (*v1.BlockAttestationsResponse, error) {
-	out := new(v1.BlockAttestationsResponse)
-	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/ListBlockAttestations", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *beaconChainClient) ListPoolAttesterSlashings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*v1.AttesterSlashingsPoolResponse, error) {
 	out := new(v1.AttesterSlashingsPoolResponse)
 	err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/ListPoolAttesterSlashings", in, out, opts...)
@@ -438,15 +275,6 @@ func (c *beaconChainClient) GetSpec(ctx context.Context, in *emptypb.Empty, opts
 type BeaconChainServer interface {
 	// Deprecated: Do not use.
 	GetWeakSubjectivity(context.Context, *emptypb.Empty) (*v1.WeakSubjectivityResponse, error)
-	// Deprecated: Do not use.
-	GetBlock(context.Context, *v1.BlockRequest) (*v1.BlockResponse, error)
-	// Deprecated: Do not use.
-	GetBlockSSZ(context.Context, *v1.BlockRequest) (*v1.BlockSSZResponse, error)
-	GetBlockV2(context.Context, *v2.BlockRequestV2) (*v2.BlockResponseV2, error)
-	GetBlindedBlock(context.Context, *v1.BlockRequest) (*v2.BlindedBlockResponse, error)
-	GetBlindedBlockSSZ(context.Context, *v1.BlockRequest) (*v2.SSZContainer, error)
-	GetBlockSSZV2(context.Context, *v2.BlockRequestV2) (*v2.SSZContainer, error)
-	ListBlockAttestations(context.Context, *v1.BlockRequest) (*v1.BlockAttestationsResponse, error)
 	ListPoolAttesterSlashings(context.Context, *emptypb.Empty) (*v1.AttesterSlashingsPoolResponse, error)
 	SubmitAttesterSlashing(context.Context, *v1.AttesterSlashing) (*emptypb.Empty, error)
 	ListPoolProposerSlashings(context.Context, *emptypb.Empty) (*v1.ProposerSlashingPoolResponse, error)
@@ -462,27 +290,6 @@ type UnimplementedBeaconChainServer struct {
 func (*UnimplementedBeaconChainServer) GetWeakSubjectivity(context.Context, *emptypb.Empty) (*v1.WeakSubjectivityResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetWeakSubjectivity not implemented")
 }
-func (*UnimplementedBeaconChainServer) GetBlock(context.Context, *v1.BlockRequest) (*v1.BlockResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetBlock not implemented")
-}
-func (*UnimplementedBeaconChainServer) GetBlockSSZ(context.Context, *v1.BlockRequest) (*v1.BlockSSZResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetBlockSSZ not implemented")
-}
-func (*UnimplementedBeaconChainServer) GetBlockV2(context.Context, *v2.BlockRequestV2) (*v2.BlockResponseV2, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetBlockV2 not implemented")
-}
-func (*UnimplementedBeaconChainServer) GetBlindedBlock(context.Context, *v1.BlockRequest) (*v2.BlindedBlockResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetBlindedBlock not implemented")
-}
-func (*UnimplementedBeaconChainServer) GetBlindedBlockSSZ(context.Context, *v1.BlockRequest) (*v2.SSZContainer, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetBlindedBlockSSZ not implemented")
-}
-func (*UnimplementedBeaconChainServer) GetBlockSSZV2(context.Context, *v2.BlockRequestV2) (*v2.SSZContainer, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetBlockSSZV2 not implemented")
-}
-func (*UnimplementedBeaconChainServer) ListBlockAttestations(context.Context, *v1.BlockRequest) (*v1.BlockAttestationsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListBlockAttestations not implemented")
-}
 func (*UnimplementedBeaconChainServer) ListPoolAttesterSlashings(context.Context, *emptypb.Empty) (*v1.AttesterSlashingsPoolResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ListPoolAttesterSlashings not implemented")
 }
@@ -524,132 +331,6 @@ func _BeaconChain_GetWeakSubjectivity_Handler(srv interface{}, ctx context.Conte
 	return interceptor(ctx, in, info, handler)
 }
 
-func _BeaconChain_GetBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v1.BlockRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BeaconChainServer).GetBlock(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethereum.eth.service.BeaconChain/GetBlock",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BeaconChainServer).GetBlock(ctx, req.(*v1.BlockRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _BeaconChain_GetBlockSSZ_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v1.BlockRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BeaconChainServer).GetBlockSSZ(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethereum.eth.service.BeaconChain/GetBlockSSZ",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BeaconChainServer).GetBlockSSZ(ctx, req.(*v1.BlockRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _BeaconChain_GetBlockV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v2.BlockRequestV2)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BeaconChainServer).GetBlockV2(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethereum.eth.service.BeaconChain/GetBlockV2",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BeaconChainServer).GetBlockV2(ctx, req.(*v2.BlockRequestV2))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _BeaconChain_GetBlindedBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v1.BlockRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BeaconChainServer).GetBlindedBlock(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethereum.eth.service.BeaconChain/GetBlindedBlock",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BeaconChainServer).GetBlindedBlock(ctx, req.(*v1.BlockRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _BeaconChain_GetBlindedBlockSSZ_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v1.BlockRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BeaconChainServer).GetBlindedBlockSSZ(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethereum.eth.service.BeaconChain/GetBlindedBlockSSZ",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BeaconChainServer).GetBlindedBlockSSZ(ctx, req.(*v1.BlockRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _BeaconChain_GetBlockSSZV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v2.BlockRequestV2)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BeaconChainServer).GetBlockSSZV2(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethereum.eth.service.BeaconChain/GetBlockSSZV2",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BeaconChainServer).GetBlockSSZV2(ctx, req.(*v2.BlockRequestV2))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _BeaconChain_ListBlockAttestations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v1.BlockRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BeaconChainServer).ListBlockAttestations(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/ethereum.eth.service.BeaconChain/ListBlockAttestations",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BeaconChainServer).ListBlockAttestations(ctx, req.(*v1.BlockRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _BeaconChain_ListPoolAttesterSlashings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(emptypb.Empty)
 	if err := dec(in); err != nil {
@@ -766,34 +447,6 @@ var _BeaconChain_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetWeakSubjectivity",
 			Handler:    _BeaconChain_GetWeakSubjectivity_Handler,
 		},
-		{
-			MethodName: "GetBlock",
-			Handler:    _BeaconChain_GetBlock_Handler,
-		},
-		{
-			MethodName: "GetBlockSSZ",
-			Handler:    _BeaconChain_GetBlockSSZ_Handler,
-		},
-		{
-			MethodName: "GetBlockV2",
-			Handler:    _BeaconChain_GetBlockV2_Handler,
-		},
-		{
-			MethodName: "GetBlindedBlock",
-			Handler:    _BeaconChain_GetBlindedBlock_Handler,
-		},
-		{
-			MethodName: "GetBlindedBlockSSZ",
-			Handler:    _BeaconChain_GetBlindedBlockSSZ_Handler,
-		},
-		{
-			MethodName: "GetBlockSSZV2",
-			Handler:    _BeaconChain_GetBlockSSZV2_Handler,
-		},
-		{
-			MethodName: "ListBlockAttestations",
-			Handler:    _BeaconChain_ListBlockAttestations_Handler,
-		},
 		{
 			MethodName: "ListPoolAttesterSlashings",
 			Handler:    _BeaconChain_ListPoolAttesterSlashings_Handler,

proto/eth/service/beacon_chain_service.pb.gw.go

@@ -17,7 +17,6 @@ import (
 	"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
 	github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
-	"github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/grpclog"
@@ -55,384 +54,6 @@ func local_request_BeaconChain_GetWeakSubjectivity_0(ctx context.Context, marsha
 
 }
 
-func request_BeaconChain_GetBlock_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := client.GetBlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_BeaconChain_GetBlock_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := server.GetBlock(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
-func request_BeaconChain_GetBlockSSZ_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := client.GetBlockSSZ(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_BeaconChain_GetBlockSSZ_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := server.GetBlockSSZ(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
-func request_BeaconChain_GetBlockV2_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq eth.BlockRequestV2
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := client.GetBlockV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_BeaconChain_GetBlockV2_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq eth.BlockRequestV2
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := server.GetBlockV2(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
-func request_BeaconChain_GetBlindedBlock_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := client.GetBlindedBlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_BeaconChain_GetBlindedBlock_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := server.GetBlindedBlock(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
-func request_BeaconChain_GetBlindedBlockSSZ_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := client.GetBlindedBlockSSZ(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_BeaconChain_GetBlindedBlockSSZ_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := server.GetBlindedBlockSSZ(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
-func request_BeaconChain_GetBlockSSZV2_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq eth.BlockRequestV2
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := client.GetBlockSSZV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_BeaconChain_GetBlockSSZV2_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq eth.BlockRequestV2
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := server.GetBlockSSZV2(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
-func request_BeaconChain_ListBlockAttestations_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := client.ListBlockAttestations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_BeaconChain_ListBlockAttestations_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq v1.BlockRequest
-	var metadata runtime.ServerMetadata
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["block_id"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_id")
-	}
-
-	block_id, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_id", err)
-	}
-	protoReq.BlockId = (block_id)
-
-	msg, err := server.ListBlockAttestations(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
 func request_BeaconChain_ListPoolAttesterSlashings_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq emptypb.Empty
 	var metadata runtime.ServerMetadata
@@ -602,167 +223,6 @@ func RegisterBeaconChainHandlerServer(ctx context.Context, mux *runtime.ServeMux
 
 	})
 
-	mux.Handle("GET", pattern_BeaconChain_GetBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlock")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_BeaconChain_GetBlock_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlockSSZ_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlockSSZ")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_BeaconChain_GetBlockSSZ_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlockSSZ_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlockV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlockV2")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_BeaconChain_GetBlockV2_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlockV2_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlindedBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlindedBlock")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_BeaconChain_GetBlindedBlock_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlindedBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlindedBlockSSZ_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlindedBlockSSZ")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_BeaconChain_GetBlindedBlockSSZ_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlindedBlockSSZ_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlockSSZV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlockSSZV2")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_BeaconChain_GetBlockSSZV2_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlockSSZV2_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_ListBlockAttestations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/ListBlockAttestations")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_BeaconChain_ListBlockAttestations_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_ListBlockAttestations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	mux.Handle("GET", pattern_BeaconChain_ListPoolAttesterSlashings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -962,146 +422,6 @@ func RegisterBeaconChainHandlerClient(ctx context.Context, mux *runtime.ServeMux
 
 	})
 
-	mux.Handle("GET", pattern_BeaconChain_GetBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlock")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_BeaconChain_GetBlock_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlockSSZ_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlockSSZ")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_BeaconChain_GetBlockSSZ_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlockSSZ_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlockV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlockV2")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_BeaconChain_GetBlockV2_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlockV2_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlindedBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlindedBlock")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_BeaconChain_GetBlindedBlock_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlindedBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlindedBlockSSZ_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlindedBlockSSZ")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_BeaconChain_GetBlindedBlockSSZ_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlindedBlockSSZ_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_GetBlockSSZV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetBlockSSZV2")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_BeaconChain_GetBlockSSZV2_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_GetBlockSSZV2_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
-	mux.Handle("GET", pattern_BeaconChain_ListBlockAttestations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/ListBlockAttestations")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_BeaconChain_ListBlockAttestations_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_BeaconChain_ListBlockAttestations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	mux.Handle("GET", pattern_BeaconChain_ListPoolAttesterSlashings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1228,20 +548,6 @@ func RegisterBeaconChainHandlerClient(ctx context.Context, mux *runtime.ServeMux
 var (
 	pattern_BeaconChain_GetWeakSubjectivity_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"internal", "eth", "v1", "beacon", "weak_subjectivity"}, ""))
 
-	pattern_BeaconChain_GetBlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"internal", "eth", "v1", "beacon", "blocks", "block_id"}, ""))
-
-	pattern_BeaconChain_GetBlockSSZ_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6}, []string{"internal", "eth", "v1", "beacon", "blocks", "block_id", "ssz"}, ""))
-
-	pattern_BeaconChain_GetBlockV2_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"internal", "eth", "v2", "beacon", "blocks", "block_id"}, ""))
-
-	pattern_BeaconChain_GetBlindedBlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"internal", "eth", "v1", "beacon", "blinded_blocks", "block_id"}, ""))
-
-	pattern_BeaconChain_GetBlindedBlockSSZ_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6}, []string{"internal", "eth", "v1", "beacon", "blinded_blocks", "block_id", "ssz"}, ""))
-
-	pattern_BeaconChain_GetBlockSSZV2_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6}, []string{"internal", "eth", "v2", "beacon", "blocks", "block_id", "ssz"}, ""))
-
-	pattern_BeaconChain_ListBlockAttestations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6}, []string{"internal", "eth", "v1", "beacon", "blocks", "block_id", "attestations"}, ""))
-
 	pattern_BeaconChain_ListPoolAttesterSlashings_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"internal", "eth", "v1", "beacon", "pool", "attester_slashings"}, ""))
 
 	pattern_BeaconChain_SubmitAttesterSlashing_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"internal", "eth", "v1", "beacon", "pool", "attester_slashings"}, ""))
@@ -1258,20 +564,6 @@ var (
 var (
 	forward_BeaconChain_GetWeakSubjectivity_0 = runtime.ForwardResponseMessage
 
-	forward_BeaconChain_GetBlock_0 = runtime.ForwardResponseMessage
-
-	forward_BeaconChain_GetBlockSSZ_0 = runtime.ForwardResponseMessage
-
-	forward_BeaconChain_GetBlockV2_0 = runtime.ForwardResponseMessage
-
-	forward_BeaconChain_GetBlindedBlock_0 = runtime.ForwardResponseMessage
-
-	forward_BeaconChain_GetBlindedBlockSSZ_0 = runtime.ForwardResponseMessage
-
-	forward_BeaconChain_GetBlockSSZV2_0 = runtime.ForwardResponseMessage
-
-	forward_BeaconChain_ListBlockAttestations_0 = runtime.ForwardResponseMessage
-
 	forward_BeaconChain_ListPoolAttesterSlashings_0 = runtime.ForwardResponseMessage
 
 	forward_BeaconChain_SubmitAttesterSlashing_0 = runtime.ForwardResponseMessage

proto/eth/service/beacon_chain_service.proto

@@ -21,8 +21,6 @@ import "google/protobuf/empty.proto";
 
 import "proto/eth/v1/beacon_block.proto";
 import "proto/eth/v1/beacon_chain.proto";
-import "proto/eth/v2/beacon_block.proto";
-import "proto/eth/v2/ssz.proto";
 
 option csharp_namespace = "Ethereum.Eth.Service";
 option go_package = "github.com/prysmaticlabs/prysm/v4/proto/eth/service";
@@ -48,73 +46,6 @@ service BeaconChain {
     option (google.api.http) = {get: "/internal/eth/v1/beacon/weak_subjectivity"};
   }
 
-  // GetBlock retrieves block details for given block id.
-  //
-  // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=v2.3.0#/Beacon/getBlock
-  // DEPRECATED: GetBlock is deprecated in favor of GetBlockV2
-  rpc GetBlock(v1.BlockRequest) returns (v1.BlockResponse) {
-    option deprecated = true;
-    option (google.api.http) = {
-      get: "/internal/eth/v1/beacon/blocks/{block_id}"
-    };
-  }
-
-  // GetBlockSSZ returns the SSZ-serialized version of block details for given block id.
-  //
-  // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=v2.3.0#/Beacon/getBlock
-  // DEPRECATED: GetBlockSSZ is deprecated in favor of GetBlockV2SSZ
-  rpc GetBlockSSZ(v1.BlockRequest) returns (v1.BlockSSZResponse) {
-    option deprecated = true;
-    option (google.api.http) = {
-      get: "/internal/eth/v1/beacon/blocks/{block_id}/ssz"
-    };
-  }
-
-  // GetBlockV2 retrieves block details for given block id.
-  //
-  // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=v2.3.0#/Beacon/getBlockV2
-  rpc GetBlockV2(v2.BlockRequestV2) returns (v2.BlockResponseV2) {
-    option (google.api.http) = {
-      get: "/internal/eth/v2/beacon/blocks/{block_id}"
-    };
-  }
-
-  // GetBlindedBlock retrieves blinded block for given block id.
-  //
-  // https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlindedBlock
-  rpc GetBlindedBlock(v1.BlockRequest) returns (v2.BlindedBlockResponse) {
-    option (google.api.http) = {
-      get: "/internal/eth/v1/beacon/blinded_blocks/{block_id}"
-    };
-  }
-
-  // GetBlindedBlockSSZ returns the SSZ-serialized version of blinded block details for given block id.
-  //
-  // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlindedBlock
-  rpc GetBlindedBlockSSZ(v1.BlockRequest) returns (v2.SSZContainer) {
-    option (google.api.http) = {
-      get: "/internal/eth/v1/beacon/blinded_blocks/{block_id}/ssz"
-    };
-  }
-
-  // GetBlockSSZV2 returns the SSZ-serialized version of block details for given block id.
-  //
-  // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=v2.3.0#/Beacon/getBlockV2
-  rpc GetBlockSSZV2(v2.BlockRequestV2) returns (v2.SSZContainer) {
-    option (google.api.http) = {
-      get: "/internal/eth/v2/beacon/blocks/{block_id}/ssz"
-    };
-  }
-
-  // ListBlockAttestations retrieves attestation included in requested block.
-  //
-  // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=v2.3.0#/Beacon/getBlockAttestations
-  rpc ListBlockAttestations(v1.BlockRequest) returns (v1.BlockAttestationsResponse) {
-    option (google.api.http) = {
-      get: "/internal/eth/v1/beacon/blocks/{block_id}/attestations"
-    };
-  }
-
   // Beacon pools API related endpoints.
 
   // ListPoolAttesterSlashings retrieves attester slashings known by the node but

proto/eth/v1/beacon_chain.proto

@@ -37,35 +37,6 @@ message StateRequest {
     bytes state_id = 1;
 }
 
-// Beacon Block API related messages.
-
-message BlockAttestationsResponse {
-    repeated ethereum.eth.v1.Attestation data = 1;
-    bool execution_optimistic = 2;
-    bool finalized  = 3;
-}
-
-message BlockRequest {
-    // The block identifier. Can be one of: "head" (canonical head in node's view), "genesis",
-    // "finalized", <slot>, <hex encoded blockRoot with 0x prefix>.
-    bytes block_id = 1;
-}
-
-message BlockResponse {
-    BeaconBlockContainer data = 1;
-}
-
-message BlockSSZResponse {
-    bytes data = 1;
-}
-
-message BeaconBlockContainer {
-    BeaconBlock message = 1;
-
-    // 96 byte BLS signature from the validator that produced this block.
-    bytes signature = 2 [(ethereum.eth.ext.ssz_size) = "96"];
-}
-
 // Beacon Pool related API service.
 
 message AttesterSlashingsPoolResponse {

proto/eth/v2/beacon_block.proto

@@ -19,7 +19,6 @@ import "proto/eth/ext/options.proto";
 import "proto/eth/v1/attestation.proto";
 import "proto/eth/v1/beacon_block.proto";
 import "proto/eth/v2/blobs.proto";
-import "proto/eth/v2/version.proto";
 import "proto/eth/v2/withdrawals.proto";
 import "proto/engine/v1/execution_engine.proto";
 
@@ -30,26 +29,6 @@ option java_outer_classname = "SyncCommitteeProto";
 option java_package = "org.ethereum.eth.v2";
 option php_namespace = "Ethereum\\Eth\\v2";
 
-message BlockRequestV2 {
-  // The block identifier. Can be one of: "head" (canonical head in node's view), "genesis",
-  // "finalized", <slot>, <hex encoded blockRoot with 0x prefix>.
-  bytes block_id = 1;
-}
-
-message BlockResponseV2 {
-  v2.Version version = 1;
-  SignedBeaconBlockContainer data = 2;
-  bool execution_optimistic = 3;
-  bool finalized = 4;
-}
-
-message BlindedBlockResponse {
-  v2.Version version = 1;
-  SignedBlindedBeaconBlockContainer data = 2;
-  bool execution_optimistic = 3;
-  bool finalized = 4;
-}
-
 message BeaconBlockContainerV2 {
   oneof block {
     v1.BeaconBlock phase0_block = 1;

testing/endtoend/evaluators/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/rpc/eth/beacon:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -37,10 +38,9 @@ go_library(
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/detect:go_default_library",
-        "//math:go_default_library",
         "//network/forks:go_default_library",
+        "//network/http:go_default_library",
         "//proto/eth/service:go_default_library",
-        "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/interop:go_default_library",

testing/endtoend/evaluators/beaconapi_evaluators/beacon_api.go

@@ -81,11 +81,11 @@ var beaconPathsAndObjects = map[string]metadata{
 
 		},
 		prysmResps: map[string]interface{}{
-			"json": &apimiddleware.BlockResponseJson{},
+			"json": &beacon.GetBlockV2Response{},
 			"ssz":  []byte{},
 		},
 		lighthouseResps: map[string]interface{}{
-			"json": &apimiddleware.BlockResponseJson{},
+			"json": &beacon.GetBlockV2Response{},
 			"ssz":  []byte{},
 		},
 	},

testing/endtoend/evaluators/execution_engine.go

@@ -1,15 +1,18 @@
 package evaluators
 
 import (
-	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
 	"strconv"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/beacon"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/shared"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
-	mathutil "github.com/prysmaticlabs/prysm/v4/math"
+	http2 "github.com/prysmaticlabs/prysm/v4/network/http"
-	"github.com/prysmaticlabs/prysm/v4/proto/eth/service"
+	"github.com/prysmaticlabs/prysm/v4/runtime/version"
-	v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
+	"github.com/prysmaticlabs/prysm/v4/testing/endtoend/params"
-	v2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v4/testing/endtoend/policies"
 	"github.com/prysmaticlabs/prysm/v4/testing/endtoend/types"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
@@ -24,22 +27,61 @@ var OptimisticSyncEnabled = types.Evaluator{
 }
 
 func optimisticSyncEnabled(_ *types.EvaluationContext, conns ...*grpc.ClientConn) error {
-	for _, conn := range conns {
+	for nodeIndex := range conns {
-		client := service.NewBeaconChainClient(conn)
+		path := fmt.Sprintf("http://localhost:%d/eth/v1/beacon/blinded_blocks/head", params.TestParams.Ports.PrysmBeaconNodeGatewayPort+nodeIndex)
-		head, err := client.GetBlindedBlock(context.Background(), &v1.BlockRequest{BlockId: []byte("head")})
+		resp := beacon.GetBlockV2Response{}
+		httpResp, err := http.Get(path) // #nosec G107 -- path can't be constant because it depends on port param and node index
 		if err != nil {
 			return err
 		}
+		if httpResp.StatusCode != http.StatusOK {
+			e := http2.DefaultErrorJson{}
+			if err = json.NewDecoder(httpResp.Body).Decode(&e); err != nil {
+				return err
+			}
+			return fmt.Errorf("%s (status code %d)", e.Message, e.Code)
+		}
+		if err = json.NewDecoder(httpResp.Body).Decode(&resp); err != nil {
+			return err
+		}
 		headSlot := uint64(0)
-		switch hb := head.Data.Message.(type) {
+		switch resp.Version {
-		case *v2.SignedBlindedBeaconBlockContainer_Phase0Block:
+		case version.String(version.Phase0):
-			headSlot = uint64(hb.Phase0Block.Slot)
+			b := &shared.BeaconBlock{}
-		case *v2.SignedBlindedBeaconBlockContainer_AltairBlock:
+			if err := json.Unmarshal(resp.Data.Message, b); err != nil {
-			headSlot = uint64(hb.AltairBlock.Slot)
+				return err
-		case *v2.SignedBlindedBeaconBlockContainer_BellatrixBlock:
+			}
-			headSlot = uint64(hb.BellatrixBlock.Slot)
+			headSlot, err = strconv.ParseUint(b.Slot, 10, 64)
-		case *v2.SignedBlindedBeaconBlockContainer_CapellaBlock:
+			if err != nil {
-			headSlot = uint64(hb.CapellaBlock.Slot)
+				return err
+			}
+		case version.String(version.Altair):
+			b := &shared.BeaconBlockAltair{}
+			if err := json.Unmarshal(resp.Data.Message, b); err != nil {
+				return err
+			}
+			headSlot, err = strconv.ParseUint(b.Slot, 10, 64)
+			if err != nil {
+				return err
+			}
+		case version.String(version.Bellatrix):
+			b := &shared.BeaconBlockBellatrix{}
+			if err := json.Unmarshal(resp.Data.Message, b); err != nil {
+				return err
+			}
+			headSlot, err = strconv.ParseUint(b.Slot, 10, 64)
+			if err != nil {
+				return err
+			}
+		case version.String(version.Capella):
+			b := &shared.BeaconBlockCapella{}
+			if err := json.Unmarshal(resp.Data.Message, b); err != nil {
+				return err
+			}
+			headSlot, err = strconv.ParseUint(b.Slot, 10, 64)
+			if err != nil {
+				return err
+			}
 		default:
 			return errors.New("no valid block type retrieved")
 		}
@@ -50,16 +92,27 @@ func optimisticSyncEnabled(_ *types.EvaluationContext, conns ...*grpc.ClientConn
 		}
 		isOptimistic := false
 		for i := startSlot; i <= primitives.Slot(headSlot); i++ {
-			castI, err := mathutil.Int(uint64(i))
+			path = fmt.Sprintf("http://localhost:%d/eth/v1/beacon/blinded_blocks/%d", params.TestParams.Ports.PrysmBeaconNodeGatewayPort+nodeIndex, i)
+			resp = beacon.GetBlockV2Response{}
+			httpResp, err = http.Get(path) // #nosec G107 -- path can't be constant because it depends on port param and node index
 			if err != nil {
 				return err
 			}
-			block, err := client.GetBlindedBlock(context.Background(), &v1.BlockRequest{BlockId: []byte(strconv.Itoa(castI))})
+			if httpResp.StatusCode == http.StatusNotFound {
-			if err != nil {
 				// Continue in the event of non-existent blocks.
 				continue
 			}
-			if !block.ExecutionOptimistic {
+			if httpResp.StatusCode != http.StatusOK {
+				e := http2.DefaultErrorJson{}
+				if err = json.NewDecoder(httpResp.Body).Decode(&e); err != nil {
+					return err
+				}
+				return fmt.Errorf("%s (status code %d)", e.Message, e.Code)
+			}
+			if err = json.NewDecoder(httpResp.Body).Decode(&resp); err != nil {
+				return err
+			}
+			if !resp.ExecutionOptimistic {
 				return errors.New("expected block to be optimistic, but it is not")
 			}
 			isOptimistic = true