appease gh linter

Author: abi87

node-api/backend/backend.go

@@ -60,7 +60,7 @@ type Backend struct {
 	// Genesis related data
 	sp           GenesisStateProcessor // only needed to recreate genesis state upon API loading
 	db           dbm.DB                // in-memory DB to store genesis state
-	muCms        sync.RWMutex          // mutex to allow copying genesisState in a thread safe way
+	muSt         sync.RWMutex          // mutex to allow initializing and copying genesisState in a safe way
 	cms          storetypes.CommitMultiStore
 	genesisState *state.StateDB // caches genesis data to serve API requests
 }
@@ -106,33 +106,23 @@ func (b *Backend) Close() error {
 	return b.db.Close()
 }
 
-// If checkChainIsReady returns nil, we assume genesis state is created
-func (b *Backend) checkChainIsReady() error {
-	switch err := b.node.IsAppReady(); {
-	case err == nil:
-		// chain finally ready, time to loading genesis
-		return b.loadGenesisState()
-	case errors.Is(err, cometbft.ErrAppNotReady):
-		return cometbft.ErrAppNotReady
-	default:
-		return fmt.Errorf("unable to check whether app is ready: %w", err)
-	}
-}
-
 type backendKVStoreService struct {
 	ctx sdk.Context
 }
 
 func (kvs *backendKVStoreService) OpenKVStore(context.Context) corestore.KVStore {
-	//nolint:contextcheck // fine with tests
+	//nolint:contextcheck // fine with this node-api backend
 	store := sdk.UnwrapSDKContext(kvs.ctx).KVStore(backendStoreKey)
 	return kvstorage.NewKVStore(store)
 }
 
-//nolint:gochecknoglobals // todo: fix later
+//nolint:gochecknoglobals // fine with this node-api backend
 var backendStoreKey = storetypes.NewKVStoreKey("backend-genesis")
 
 func (b *Backend) loadGenesisState() error {
+	b.muSt.Lock()
+	defer b.muSt.Unlock()
+
 	if b.genesisState != nil {
 		// genesis state already initialized, we're fine
 		return nil

node-api/backend/getters.go

@@ -21,10 +21,12 @@
 package backend
 
 import (
+	"errors"
 	"fmt"
 	"runtime"
 
 	"cosmossdk.io/log"
+	cometbft "github.com/berachain/beacon-kit/consensus/cometbft/service"
 	datypes "github.com/berachain/beacon-kit/da/types"
 	"github.com/berachain/beacon-kit/primitives/common"
 	"github.com/berachain/beacon-kit/primitives/math"
@@ -43,13 +45,20 @@ func (b *Backend) StateAndSlotFromHeight(height int64) (ReadOnlyBeaconState, mat
 		return nil, 0, fmt.Errorf("expected height, must be non-negative or -1 to request tip, got %d", height)
 	}
 	if height == 0 {
-		// genesis requested. Serve it from the genesis state recreated locally by node-api
-		if err := b.checkChainIsReady(); err != nil {
-			return nil, 0, err
+		switch err := b.node.IsAppReady(); {
+		case err == nil:
+			// chain finally ready, time to loading genesis
+			if err = b.loadGenesisState(); err != nil {
+				return nil, 0, fmt.Errorf("failed loading genesis state: %w", err)
+			}
+		case errors.Is(err, cometbft.ErrAppNotReady):
+			return nil, 0, cometbft.ErrAppNotReady
+		default:
+			return nil, 0, fmt.Errorf("unable to check whether app is ready: %w", err)
 		}
 
-		b.muCms.Lock()
-		defer b.muCms.Unlock()
+		b.muSt.Lock()
+		defer b.muSt.Unlock()
 
 		// Copy the state to ensure clients potential changes won't pollute the state
 		// Also we make sure to create the copy in a thread-safe way via the muCms mutex.

node-api/handlers/beacon/header.go

@@ -23,6 +23,7 @@ package beacon
 import (
 	"errors"
 	"fmt"
+	stdmath "math"
 
 	"github.com/berachain/beacon-kit/node-api/handlers"
 	beacontypes "github.com/berachain/beacon-kit/node-api/handlers/beacon/types"
@@ -42,7 +43,7 @@ func (h *Handler) GetBlockHeaders(c handlers.Context) (any, error) {
 	switch {
 	case len(req.Slot) == 0 && len(req.ParentRoot) == 0:
 		// no parameter specified, pick chain HEAD
-		// by requesting special height 0.
+		// by requesting special height -1.
 		height := utils.Head
 		return h.makeBlockHeaderResponse(height, true /*resultsInList*/)
 
@@ -52,15 +53,20 @@ func (h *Handler) GetBlockHeaders(c handlers.Context) (any, error) {
 		if errSlot != nil {
 			return nil, fmt.Errorf("failed retrieving slot from input parameters: %w", errSlot)
 		}
-		return h.makeBlockHeaderResponse(int64(slot), true /*resultsInList*/) //#nosec: G115 // practically safe
+		if slot > stdmath.MaxInt64 { // appease linters
+			return 0, fmt.Errorf("%w: slot %d", utils.ErrFailedMappingHeightTooHigh, slot)
+		}
+		return h.makeBlockHeaderResponse(int64(slot), true /*resultsInList*/) //#nosec: G115 // safe
 
 	case len(req.Slot) == 0 && len(req.ParentRoot) != 0:
-		parentSlot, errParent := utils.BlockIDToHeight(req.ParentRoot, h.backend)
+		parentHeight, errParent := utils.BlockIDToHeight(req.ParentRoot, h.backend)
 		if errParent != nil {
 			return nil, fmt.Errorf("%w, failed retrieving parent root with error: %w", handlertypes.ErrNotFound, errParent)
 		}
-		// TODO ABENEGIA: what happens here if HEAD is requested. Should be already broken??
-		height := parentSlot + 1
+		if parentHeight == utils.Head {
+			return nil, fmt.Errorf("%w, requested header of tip's child", handlertypes.ErrNotFound)
+		}
+		height := parentHeight + 1
 		return h.makeBlockHeaderResponse(height, true /*resultsInList*/)
 
 	default:
@@ -72,7 +78,10 @@ func (h *Handler) GetBlockHeaders(c handlers.Context) (any, error) {
 			return nil, err
 		}
 
-		height := int64(slot) //#nosec: G115 // practically safe
+		if slot > stdmath.MaxInt64 { // appease linters
+			return 0, fmt.Errorf("%w: slot %d", utils.ErrFailedMappingHeightTooHigh, slot)
+		}
+		height := int64(slot) //#nosec: G115 // safe
 		if height != parentSlot+1 {
 			return nil, fmt.Errorf("%w: request slot %d, parent block slot %d", ErrMismatchedSlotAndParentBlock, slot, parentSlot)
 		}

node-api/handlers/utils/mappings.go

@@ -21,14 +21,19 @@
 package utils
 
 import (
+	"fmt"
+	stdmath "math"
 	"strings"
 
 	"github.com/berachain/beacon-kit/errors"
 	"github.com/berachain/beacon-kit/primitives/common"
 	"github.com/berachain/beacon-kit/primitives/math"
 )
 
-var ErrNoSlotForStateRoot = errors.New("slot not found at state root")
+var (
+	ErrNoSlotForStateRoot         = errors.New("slot not found at state root")
+	ErrFailedMappingHeightTooHigh = errors.New("failed mapping height too high")
+)
 
 // TODO: define unique types for each of the query-able IDs (state & block from
 // spec, execution unique to beacon-kit). For each type define validation
@@ -54,6 +59,9 @@ func StateIDToHeight[StorageBackendT interface {
 	if err != nil {
 		return 0, ErrNoSlotForStateRoot
 	}
+	if slot > stdmath.MaxInt64 { // appease linters
+		return 0, fmt.Errorf("%w: slot %d", ErrFailedMappingHeightTooHigh, slot)
+	}
 	return int64(slot), nil //#nosec: G115 // practically safe
 }
 
@@ -74,6 +82,9 @@ func BlockIDToHeight[StorageBackendT interface {
 		return 0, err
 	}
 	slot, err := storage.GetSlotByBlockRoot(root)
+	if slot > stdmath.MaxInt64 { // appease linters
+		return 0, fmt.Errorf("%w: slot %d", ErrFailedMappingHeightTooHigh, slot)
+	}
 	return int64(slot), err //#nosec: G115 // practically safe
 }
 
@@ -104,6 +115,9 @@ func TimestampIDToParentHeight[StorageBackendT interface {
 		)
 	}
 	slot, err := storage.GetParentSlotByTimestamp(timestamp)
+	if slot > stdmath.MaxInt64 { // appease linters
+		return 0, fmt.Errorf("%w: slot %d", ErrFailedMappingHeightTooHigh, slot)
+	}
 	return int64(slot), err //#nosec: G115 // practically safe
 }
 
@@ -128,6 +142,9 @@ func stateIDToHeight(id string) (int64, error) {
 		if err != nil {
 			return 0, errors.Wrapf(err, "failed mapping stateID %q to slot", id)
 		}
+		if slot > stdmath.MaxInt64 { // appease linters
+			return 0, fmt.Errorf("%w: slot %d", ErrFailedMappingHeightTooHigh, slot)
+		}
 		return int64(slot), nil //#nosec: G115 // practically safe
 	}
 }