merge devel

cl/beacon/handler/forkchoice.go

@@ -0,0 +1,39 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/ledgerwatch/erigon/cl/beacon/beaconhttp"
+)
+
+func (a *ApiHandler) GetEthV2DebugBeaconHeads(w http.ResponseWriter, r *http.Request) (*beaconResponse, error) {
+	if a.syncedData.Syncing() {
+		return nil, beaconhttp.NewEndpointError(http.StatusServiceUnavailable, "beacon node is syncing")
+	}
+	hash, slotNumber, err := a.forkchoiceStore.GetHead()
+	if err != nil {
+		return nil, err
+	}
+	return newBeaconResponse(
+		[]interface{}{
+			map[string]interface{}{
+				"slot":                 slotNumber,
+				"root":                 hash,
+				"execution_optimistic": false,
+			},
+		}), nil
+}
+
+func (a *ApiHandler) GetEthV1DebugBeaconForkChoice(w http.ResponseWriter, r *http.Request) {
+	justifiedCheckpoint := a.forkchoiceStore.JustifiedCheckpoint()
+	finalizedCheckpoint := a.forkchoiceStore.FinalizedCheckpoint()
+	forkNodes := a.forkchoiceStore.ForkNodes()
+	if err := json.NewEncoder(w).Encode(map[string]interface{}{
+		"justified_checkpoint": justifiedCheckpoint,
+		"finalized_checkpoint": finalizedCheckpoint,
+		"fork_choice_nodes":    forkNodes,
+	}); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}

cl/beacon/handler/forkchoice_test.go

@@ -0,0 +1,80 @@
+package handler
+
+import (
+	"io"
+	"net/http/httptest"
+	"testing"
+
+	libcommon "github.com/ledgerwatch/erigon-lib/common"
+	"github.com/ledgerwatch/erigon/cl/clparams"
+	"github.com/ledgerwatch/erigon/cl/cltypes/solid"
+	"github.com/ledgerwatch/erigon/cl/phase1/forkchoice"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetHeads(t *testing.T) {
+	// find server
+	_, _, _, _, p, handler, _, sm, fcu := setupTestingHandler(t, clparams.Phase0Version)
+	sm.OnHeadState(p)
+	s, cancel := sm.HeadState()
+	s.SetSlot(789274827847783)
+	cancel()
+
+	fcu.HeadSlotVal = 128
+	fcu.HeadVal = libcommon.Hash{1, 2, 3}
+	server := httptest.NewServer(handler.mux)
+	defer server.Close()
+
+	// get heads
+	resp, err := server.Client().Get(server.URL + "/eth/v2/debug/beacon/heads")
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	require.Equal(t, 200, resp.StatusCode)
+	out, err := io.ReadAll(resp.Body)
+	require.NoError(t, err)
+
+	require.Equal(t, `{"data":[{"execution_optimistic":false,"root":"0x0102030000000000000000000000000000000000000000000000000000000000","slot":128}]}`+"\n", string(out))
+}
+
+func TestGetForkchoice(t *testing.T) {
+	// find server
+	_, _, _, _, p, handler, _, sm, fcu := setupTestingHandler(t, clparams.Phase0Version)
+	sm.OnHeadState(p)
+	s, cancel := sm.HeadState()
+	s.SetSlot(789274827847783)
+	cancel()
+
+	fcu.HeadSlotVal = 128
+	fcu.HeadVal = libcommon.Hash{1, 2, 3}
+	server := httptest.NewServer(handler.mux)
+	defer server.Close()
+
+	fcu.WeightsMock = []forkchoice.ForkNode{
+		{
+			BlockRoot:  libcommon.Hash{1, 2, 3},
+			ParentRoot: libcommon.Hash{1, 2, 3},
+			Slot:       128,
+			Weight:     1,
+		},
+		{
+			BlockRoot:  libcommon.Hash{1, 2, 2, 4, 5, 3},
+			ParentRoot: libcommon.Hash{1, 2, 5},
+			Slot:       128,
+			Weight:     2,
+		},
+	}
+
+	fcu.FinalizedCheckpointVal = solid.NewCheckpointFromParameters(libcommon.Hash{1, 2, 3}, 1)
+	fcu.JustifiedCheckpointVal = solid.NewCheckpointFromParameters(libcommon.Hash{1, 2, 3}, 2)
+
+	// get heads
+	resp, err := server.Client().Get(server.URL + "/eth/v1/debug/fork_choice")
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	require.Equal(t, 200, resp.StatusCode)
+	out, err := io.ReadAll(resp.Body)
+	require.NoError(t, err)
+	require.Equal(t, `{"finalized_checkpoint":{"epoch":"1","root":"0x0102030000000000000000000000000000000000000000000000000000000000"},"fork_choice_nodes":[{"slot":"128","block_root":"0x0102030000000000000000000000000000000000000000000000000000000000","parent_root":"0x0102030000000000000000000000000000000000000000000000000000000000","justified_epoch":"0","finalized_epoch":"0","weight":"1","validity":"","execution_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000"},{"slot":"128","block_root":"0x0102020405030000000000000000000000000000000000000000000000000000","parent_root":"0x0102050000000000000000000000000000000000000000000000000000000000","justified_epoch":"0","finalized_epoch":"0","weight":"2","validity":"","execution_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000"}],"justified_checkpoint":{"epoch":"2","root":"0x0102030000000000000000000000000000000000000000000000000000000000"}}`+"\n", string(out))
+}

cl/beacon/handler/handler.go

@@ -49,8 +49,11 @@ func (a *ApiHandler) init() {
 	// otterscn specific ones are commented as such
 	r.Route("/eth", func(r chi.Router) {
 		r.Route("/v1", func(r chi.Router) {
-
 			r.Get("/events", http.NotFound)
+			r.Route("/node", func(r chi.Router) {
+				r.Get("/health", a.GetEthV1NodeHealth)
+			})
+			r.Get("/debug/fork_choice", a.GetEthV1DebugBeaconForkChoice)
 			r.Route("/config", func(r chi.Router) {
 				r.Get("/spec", beaconhttp.HandleEndpointFunc(a.getSpec))
 				r.Get("/deposit_contract", beaconhttp.HandleEndpointFunc(a.getDepositContract))
@@ -125,6 +128,7 @@ func (a *ApiHandler) init() {
 			r.Route("/debug", func(r chi.Router) {
 				r.Route("/beacon", func(r chi.Router) {
 					r.Get("/states/{state_id}", beaconhttp.HandleEndpointFunc(a.getFullState))
+					r.Get("/heads", beaconhttp.HandleEndpointFunc(a.GetEthV2DebugBeaconHeads))
 				})
 			})
 			r.Route("/beacon", func(r chi.Router) {

cl/beacon/handler/node.go

@@ -0,0 +1,20 @@
+package handler
+
+import "net/http"
+
+func (a *ApiHandler) GetEthV1NodeHealth(w http.ResponseWriter, r *http.Request) {
+	syncingStatus, err := uint64FromQueryParams(r, "syncing_status")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	syncingCode := http.StatusOK
+	if syncingStatus != nil {
+		syncingCode = int(*syncingStatus)
+	}
+	if a.syncedData.Syncing() {
+		w.WriteHeader(syncingCode)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}

cl/beacon/handler/node_test.go

@@ -0,0 +1,49 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/ledgerwatch/erigon/cl/clparams"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNodeSyncing(t *testing.T) {
+	//  i just want the correct schema to be generated
+	_, _, _, _, _, handler, _, _, _ := setupTestingHandler(t, clparams.Phase0Version)
+
+	// Call GET /eth/v1/node/health
+	server := httptest.NewServer(handler.mux)
+	defer server.Close()
+
+	req, err := http.NewRequest("GET", server.URL+"/eth/v1/node/health?syncing_status=666", nil)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	require.Equal(t, 666, resp.StatusCode)
+}
+
+func TestNodeSyncingTip(t *testing.T) {
+	//  i just want the correct schema to be generated
+	_, _, _, _, post, handler, _, sm, _ := setupTestingHandler(t, clparams.Phase0Version)
+
+	// Call GET /eth/v1/node/health
+	server := httptest.NewServer(handler.mux)
+	defer server.Close()
+
+	req, err := http.NewRequest("GET", server.URL+"/eth/v1/node/health?syncing_status=666", nil)
+	require.NoError(t, err)
+
+	require.NoError(t, sm.OnHeadState(post))
+	s, cancel := sm.HeadState()
+	s.SetSlot(999999999999999)
+	cancel()
+
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	require.Equal(t, 200, resp.StatusCode)
+}

cl/beacon/synced_data/synced_data.go

@@ -32,6 +32,9 @@ func (s *SyncedDataManager) OnHeadState(newState *state.CachingBeaconState) (err
 	defer s.mu.Unlock()
 	if s.headState == nil {
 		s.headState, err = newState.Copy()
+		if err != nil {
+			return err
+		}
 	}
 	err = newState.CopyInto(s.headState)
 	if err != nil {
@@ -56,7 +59,7 @@ func (s *SyncedDataManager) Syncing() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	if s.headState == nil {
-		return false
+		return true
 	}
 
 	headEpoch := utils.GetCurrentEpoch(s.headState.GenesisTime(), s.cfg.SecondsPerSlot, s.cfg.SlotsPerEpoch)

cl/beacon/validatorapi/get.go

@@ -42,13 +42,14 @@ func (v *ValidatorApiHandler) GetEthV1NodeSyncing(w http.ResponseWriter, r *http
 	}
 
 	return map[string]any{
-		"head_slot":     strconv.FormatUint(slot, 10),
-		"sync_distance": syncDistance,
-		"is_syncing":    isSyncing,
-		"el_offline":    elOffline,
-		// TODO: figure out how to populat this field
-		"is_optimistic": true,
-	}, nil
+		"data": map[string]any{
+			"head_slot":     strconv.FormatUint(slot, 10),
+			"sync_distance": syncDistance,
+			"is_syncing":    isSyncing,
+			"el_offline":    elOffline,
+			// TODO: figure out how to populat this field
+			"is_optimistic": true,
+		}}, nil
 }
 
 func (v *ValidatorApiHandler) GetEthV1ConfigSpec(w http.ResponseWriter, r *http.Request) (*clparams.BeaconChainConfig, error) {
@@ -67,10 +68,11 @@ func (v *ValidatorApiHandler) GetEthV1BeaconGenesis(w http.ResponseWriter, r *ht
 		return nil, beaconhttp.NewEndpointError(http.StatusInternalServerError, err.Error())
 	}
 	return map[string]any{
-		"genesis_time":           v.GenesisCfg.GenesisTime,
-		"genesis_validator_root": v.GenesisCfg.GenesisValidatorRoot,
-		"genesis_fork_version":   hexutility.Bytes(digest[:]),
-	}, nil
+		"data": map[string]any{
+			"genesis_time":           v.GenesisCfg.GenesisTime,
+			"genesis_validator_root": v.GenesisCfg.GenesisValidatorRoot,
+			"genesis_fork_version":   hexutility.Bytes(digest[:]),
+		}}, nil
 }
 
 func (v *ValidatorApiHandler) GetEthV1BeaconStatesStateIdFork(w http.ResponseWriter, r *http.Request) (any, error) {

cl/persistence/state/historical_states_reader/historical_states_reader_test.go

@@ -47,19 +47,19 @@ func runTest(t *testing.T, blocks []*cltypes.SignedBeaconBlock, preState, postSt
 }
 
 func TestStateAntiquaryCapella(t *testing.T) {
-	//t.Skip()
+	t.Skip()
 	blocks, preState, postState := tests.GetCapellaRandom()
 	runTest(t, blocks, preState, postState)
 }
 
 func TestStateAntiquaryPhase0(t *testing.T) {
-	//t.Skip()
+	t.Skip()
 	blocks, preState, postState := tests.GetPhase0Random()
 	runTest(t, blocks, preState, postState)
 }
 
 func TestStateAntiquaryBellatrix(t *testing.T) {
-	//t.Skip()
+	t.Skip()
 	blocks, preState, postState := tests.GetBellatrixRandom()
 	runTest(t, blocks, preState, postState)
 }