chore(node-api): Validator balance endpoints - WIP

consensus-types/types/validator.go

@@ -364,6 +364,5 @@ func (v *Validator) Status(currentEpoch math.Epoch) (string, error) {
 		}
 		return constants.ValidatorStatusWithdrawalDone, nil
 	}
-
 	return "", ErrInvalidValidatorStatus
 }

node-api/backend/validator.go

@@ -24,6 +24,7 @@ import (
 	"slices"
 	"strconv"
 
+	"cosmossdk.io/collections"
 	"github.com/berachain/beacon-kit/consensus-types/types"
 	"github.com/berachain/beacon-kit/errors"
 	"github.com/berachain/beacon-kit/node-api/backend/utils"
@@ -33,6 +34,9 @@ import (
 	statedb "github.com/berachain/beacon-kit/state-transition/core/state"
 )
 
+// ErrValidatorNotFound is an error for when a validator is not found.
+var ErrValidatorNotFound = errors.New("validator not found")
+
 // ErrStatusFilterMismatch is an error for when a validator status does not
 // match the status filter.
 var ErrStatusFilterMismatch = errors.New("validator status does not match status filter")
@@ -200,11 +204,21 @@ func (b Backend) ValidatorByID(
 		return nil, errors.Wrapf(err, "failed to get state from slot %d", slot)
 	}
 	index, err := utils.ValidatorIndexByID(st, id)
-	if err != nil {
+	switch {
+	case err == nil:
+		// continue processing
+	case errors.Is(err, collections.ErrNotFound):
+		return nil, ErrValidatorNotFound
+	default:
 		return nil, errors.Wrapf(err, "failed to get validator index by id %s", id)
 	}
 	validator, err := st.ValidatorByIndex(index)
-	if err != nil {
+	switch {
+	case err == nil:
+		// continue processing
+	case errors.Is(err, collections.ErrNotFound):
+		return nil, ErrValidatorNotFound
+	default:
 		return nil, errors.Wrapf(err, "failed to get validator by index %d", index)
 	}
 	balance, err := st.GetBalance(index)
@@ -228,21 +242,49 @@ func (b Backend) ValidatorByID(
 func (b Backend) ValidatorBalancesByIDs(
 	slot math.Slot, ids []string,
 ) ([]*beacontypes.ValidatorBalanceData, error) {
-	var index math.U64
 	st, _, err := b.stateFromSlot(slot)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to get state from slot %d", slot)
 	}
+
+	// If no IDs provided, return all validator balances
+	if len(ids) == 0 {
+		rawBalances, errInBalances := st.GetBalances()
+		if errInBalances != nil {
+			return nil, errInBalances
+		}
+		// Convert []uint64 to []*ValidatorBalanceData as per the API spec
+		balances := make([]*beacontypes.ValidatorBalanceData, len(rawBalances))
+		for i, balance := range rawBalances {
+			balances[i] = &beacontypes.ValidatorBalanceData{
+				Index:   uint64(i), // #nosec:G115 // Safe as i comes from range loop
+				Balance: balance,
+			}
+		}
+		return balances, nil
+	}
+
 	balances := make([]*beacontypes.ValidatorBalanceData, 0)
+	var index math.U64
+
 	for _, id := range ids {
 		index, err = utils.ValidatorIndexByID(st, id)
 		if err != nil {
+			// If public key as id is not found in the state, do not return an error.
+			if errors.Is(err, collections.ErrNotFound) {
+				continue
+			}
 			return nil, errors.Wrapf(err, "failed to get validator index by id %s", id)
 		}
 		var balance math.U64
-		// TODO: same issue as above, shouldn't error on not found.
 		balance, err = st.GetBalance(index)
+
 		if err != nil {
+			// if index does not exist and GetBalance returns an error containing "collections: not found"
+			// do not return an error.
+			if errors.Is(err, collections.ErrNotFound) {
+				continue
+			}
 			return nil, errors.Wrapf(err, "failed to get validator balance for validator index %d", index)
 		}
 		balances = append(balances, &beacontypes.ValidatorBalanceData{

node-api/handlers/beacon/types/request.go

@@ -57,7 +57,7 @@ type PostStateValidatorsRequest struct {
 
 type GetStateValidatorRequest struct {
 	types.StateIDRequest
-	ValidatorID string `query:"validator_id" validate:"required,validator_id"`
+	ValidatorID string `param:"validator_id" validate:"required,validator_id"`
 }
 
 type GetValidatorBalancesRequest struct {
@@ -67,7 +67,7 @@ type GetValidatorBalancesRequest struct {
 
 type PostValidatorBalancesRequest struct {
 	types.StateIDRequest
-	IDs []string `validate:"dive,validator_id"`
+	IDs []string `json:"-" validate:"dive,validator_id"`
 }
 
 type GetStateCommitteesRequest struct {

node-api/handlers/beacon/validators.go

@@ -21,8 +21,14 @@
 package beacon
 
 import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/berachain/beacon-kit/node-api/backend"
 	"github.com/berachain/beacon-kit/node-api/handlers"
 	beacontypes "github.com/berachain/beacon-kit/node-api/handlers/beacon/types"
+	types "github.com/berachain/beacon-kit/node-api/handlers/types"
 	"github.com/berachain/beacon-kit/node-api/handlers/utils"
 )
 
@@ -81,10 +87,17 @@ func (h *Handler) GetStateValidator(c handlers.Context) (any, error) {
 		slot,
 		req.ValidatorID,
 	)
-	if err != nil {
+	switch {
+	case errors.Is(err, backend.ErrValidatorNotFound):
+		return &handlers.HTTPError{
+			Code:    http.StatusNotFound,
+			Message: "Validator not found",
+		}, nil
+	case err != nil:
 		return nil, err
+	default:
+		return beacontypes.NewResponse(validator), nil
 	}
-	return validator, nil
 }
 
 func (h *Handler) GetStateValidatorBalances(c handlers.Context) (any, error) {
@@ -95,7 +108,15 @@ func (h *Handler) GetStateValidatorBalances(c handlers.Context) (any, error) {
 		return nil, err
 	}
 	slot, err := utils.SlotFromStateID(req.StateID, h.backend)
+
+	// Check for error message "slot not found at state root"
 	if err != nil {
+		if strings.Contains(err.Error(), "slot not found at state root") {
+			return nil, &handlers.HTTPError{
+				Code:    http.StatusNotFound,
+				Message: "State not found",
+			}
+		}
 		return nil, err
 	}
 	balances, err := h.backend.ValidatorBalancesByIDs(
@@ -109,12 +130,20 @@ func (h *Handler) GetStateValidatorBalances(c handlers.Context) (any, error) {
 }
 
 func (h *Handler) PostStateValidatorBalances(c handlers.Context) (any, error) {
-	req, err := utils.BindAndValidate[beacontypes.PostValidatorBalancesRequest](
-		c, h.Logger(),
-	)
-	if err != nil {
-		return nil, err
+	var ids []string
+	if err := c.Bind(&ids); err != nil {
+		return nil, types.ErrInvalidRequest
+	}
+	// Get state_id from URL path parameter
+	req := beacontypes.PostValidatorBalancesRequest{
+		StateIDRequest: types.StateIDRequest{StateID: c.Param("state_id")},
+		IDs:            ids,
 	}
+
+	if err := c.Validate(&req); err != nil {
+		return nil, types.ErrInvalidRequest
+	}
+
 	slot, err := utils.SlotFromStateID(req.StateID, h.backend)
 	if err != nil {
 		return nil, err

node-api/handlers/error.go

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: BUSL-1.1
+//
+// Copyright (C) 2025, Berachain Foundation. All rights reserved.
+// Use of this software is governed by the Business Source License included
+// in the LICENSE file of this repository and at www.mariadb.com/bsl11.
+//
+// ANY USE OF THE LICENSED WORK IN VIOLATION OF THIS LICENSE WILL AUTOMATICALLY
+// TERMINATE YOUR RIGHTS UNDER THIS LICENSE FOR THE CURRENT AND ALL OTHER
+// VERSIONS OF THE LICENSED WORK.
+//
+// THIS LICENSE DOES NOT GRANT YOU ANY RIGHT IN ANY TRADEMARK OR LOGO OF
+// LICENSOR OR ITS AFFILIATES (PROVIDED THAT YOU MAY USE A TRADEMARK OR LOGO OF
+// LICENSOR AS EXPRESSLY REQUIRED BY THIS LICENSE).
+//
+// TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+// AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+// EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+// TITLE.
+
+package handlers
+
+// HTTPError represents an HTTP error response.
+type HTTPError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+// NewHTTPError creates a new HTTPError.
+func NewHTTPError(code int, message string) *HTTPError {
+	return &HTTPError{
+		Code:    code,
+		Message: message,
+	}
+}
+
+// Error implements the error interface.
+func (e *HTTPError) Error() string {
+	return e.Message
+}
+
+// StatusCode returns the HTTP status code.
+func (e *HTTPError) StatusCode() int {
+	return e.Code
+}