test(node-api) : Beacon headers and genesis API

.mockery.yaml

@@ -68,3 +68,8 @@ packages:
  recursive: False
  with-expecter: true
  all: True
+ github.com/berachain/beacon-kit/mod/storage/pkg/block:
+ config:
+ recursive: False
+ with-expecter: true
+ all: True

mod/consensus-types/pkg/types/header.go

@@ -42,15 +42,15 @@ var (
 // BeaconBlockHeader represents the base of a beacon block header.
 type BeaconBlockHeader struct {
  // Slot represents the position of the block in the chain.
- Slot math.Slot
+ Slot math.Slot `json:"slot"`
  // ProposerIndex is the index of the validator who proposed the block.
- ProposerIndex math.ValidatorIndex
+ ProposerIndex math.ValidatorIndex `json:"proposer_index"`
  // ParentBlockRoot is the hash of the parent block
- ParentBlockRoot common.Root
+ ParentBlockRoot common.Root `json:"parent_root"`
  // StateRoot is the hash of the state at the block.
- StateRoot common.Root
+ StateRoot common.Root `json:"state_root"`
  // BodyRoot is the root of the block body.
- BodyRoot common.Root
+ BodyRoot common.Root `json:"body_root"`
 }
 
 /* -------------------------------------------------------------------------- */

mod/node-api/backend/backend.go

@@ -48,8 +48,8 @@ type Backend[
  DepositT any,
  DepositStoreT DepositStore[DepositT],
  Eth1DataT,
- ExecutionPayloadHeaderT,
- ForkT any,
+ ExecutionPayloadHeaderT any,
+ ForkT Fork[ForkT],
  NodeT Node[ContextT],
  StateStoreT any,
  StorageBackendT StorageBackend[
@@ -86,8 +86,8 @@ func New[
  DepositT any,
  DepositStoreT DepositStore[DepositT],
  Eth1DataT,
- ExecutionPayloadHeaderT,
- ForkT any,
+ ExecutionPayloadHeaderT any,
+ ForkT Fork[ForkT],
  NodeT Node[ContextT],
  StateStoreT any,
  StorageBackendT StorageBackend[
@@ -206,3 +206,23 @@ func (b *Backend[
  }
  return st, slot, err
 }
+
+// GetHeadSlot returns the head slot from the backend.
+func (b *Backend[
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+]) GetHeadSlot() (math.Slot, error) {
+ //#nosec:G701 // not an issue in practice.
+ queryCtx, err := b.node.CreateQueryContext(0, false)
+ if err != nil {
+ return 0, err
+ }
+ st := b.sb.StateFromContext(queryCtx)
+ return st.GetSlot()
+}
+
+// GetSlotByParentRoot returns the slot by a parent root from the block store.
+func (b *Backend[
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+]) GetSlotByParentRoot(root common.Root) (math.Slot, error) {
+ return b.sb.BlockStore().GetSlotByParentRoot(root)
+}

mod/node-api/backend/block.go

@@ -26,7 +26,7 @@ import (
  "github.com/berachain/beacon-kit/mod/primitives/pkg/math"
 )
 
-// BlockHeader returns the block header at the given slot.
+// BlockHeaderAtSlot returns the block header at the given slot.
 func (b Backend[
  _, _, _, BeaconBlockHeaderT, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
  _,
@@ -42,7 +42,7 @@ func (b Backend[
  return blockHeader, err
 }
 
-// GetBlockRoot returns the root of the block at the given stateID.
+// BlockRootAtSlot returns the root of the block at the given stateID.
 func (b Backend[
  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
 ]) BlockRootAtSlot(slot math.Slot) (common.Root, error) {
@@ -56,6 +56,7 @@ func (b Backend[
  return st.GetBlockRootAtIndex(slot.Unwrap() % b.cs.SlotsPerHistoricalRoot())
 }
 
+// BlockRewardsAtSlot returns the block rewards at the given slot.
 // TODO: Implement this.
 func (b Backend[
  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,

mod/node-api/backend/genesis.go

@@ -36,3 +36,18 @@ func (b Backend[
  }
  return st.GetGenesisValidatorsRoot()
 }
+
+// GetGenesisForkVersion returns the genesis fork version of the beacon chain.
+func (b Backend[
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+]) GetGenesisForkVersion(genesisSlot math.Slot) (common.Version, error) {
+ st, _, err := b.stateFromSlot(genesisSlot)
+ if err != nil {
+ return common.Version{}, err
+ }
+ fork, err := st.GetFork()
+ if err != nil {
+ return common.Version{}, err
+ }
+ return fork.GetPreviousVersion(), nil
+}

mod/node-api/backend/types.go

@@ -86,6 +86,8 @@ type BlockStore[BeaconBlockT any] interface {
  GetSlotByStateRoot(root common.Root) (math.Slot, error)
  // GetSlotByExecutionNumber retrieves the slot by a given execution number.
  GetSlotByExecutionNumber(executionNumber math.U64) (math.Slot, error)
+ // GetSlotByParentRoot retrieves the slot by a given parent root.
+ GetSlotByParentRoot(root common.Root) (math.Slot, error)
 }
 
 // DepositStore defines the interface for deposit storage.
@@ -140,3 +142,7 @@ type Withdrawal[T any] interface {
  amount math.Gwei,
  ) T
 }
+
+type Fork[ForkT any] interface {
+ GetPreviousVersion() common.Version
+}

mod/node-api/engines/echo/vaildator.go

@@ -67,6 +67,7 @@ func ConstructValidator() *validator.Validate {
  "epoch": ValidateUint64,
  "slot": ValidateUint64,
  "validator_status": ValidateValidatorStatus,
+ "parent_root": ValidateRoot,
  }
  validate := validator.New()
  for tag, fn := range validators {
@@ -144,9 +145,9 @@ func ValidateValidatorID(fl validator.FieldLevel) bool {
  return false
 }
 
-// ValidateRoot checks if the provided field is a valid root.
+// validateRoot checks if the provided field is a valid root.
 // It validates against a 32 byte hex-encoded root with "0x" prefix.
-func ValidateRoot(value string) bool {
+func validateRoot(value string) bool {
  valid, err := validateRegex(value, `^0x[0-9a-fA-F]{64}$`)
  if err != nil {
  return false
@@ -201,8 +202,14 @@ func validateStateBlockIDs(value string, allowedValues map[string]bool) bool {
  return true
  }
  // Check if value is a hex-encoded 32 byte root with "0x" prefix
- if ValidateRoot(value) {
+ if validateRoot(value) {
  return true
  }
  return false
 }
+
+// ValidateRoot checks if the provided field is a valid root.
+// It validates against a 32 byte hex-encoded root with "0x" prefix.
+func ValidateRoot(fl validator.FieldLevel) bool {
+ return validateRoot(fl.Field().String())
+}

mod/node-api/handlers/beacon/backend.go

@@ -42,10 +42,15 @@ type Backend[
  GetSlotByBlockRoot(root common.Root) (math.Slot, error)
  // GetSlotByStateRoot retrieves the slot by a given root from the store.
  GetSlotByStateRoot(root common.Root) (math.Slot, error)
+ // GetSlotByParentRoot retrieves the slot by a given root from the store.
+ GetSlotByParentRoot(root common.Root) (math.Slot, error)
+ // GetHeadSlot retrieves the head slot from the store.
+ GetHeadSlot() (math.Slot, error)
 }
 
 type GenesisBackend interface {
  GenesisValidatorsRoot(slot math.Slot) (common.Root, error)
+ GetGenesisForkVersion(genesisSlot math.Slot) (common.Version, error)
 }
 
 type HistoricalBackend[ForkT any] interface {

mod/node-api/handlers/beacon/genesis.go

@@ -21,6 +21,8 @@
 package beacon
 
 import (
+ "encoding/hex"
+
  beacontypes "github.com/berachain/beacon-kit/mod/node-api/handlers/beacon/types"
  "github.com/berachain/beacon-kit/mod/node-api/handlers/types"
  "github.com/berachain/beacon-kit/mod/node-api/handlers/utils"
@@ -34,9 +36,15 @@ func (h *Handler[_, ContextT, _, _]) GetGenesis(_ ContextT) (any, error) {
  if len(genesisRoot) == 0 {
  return nil, types.ErrNotFound
  }
+
+ genesisVersion, err := h.backend.GetGenesisForkVersion(utils.Genesis)
+ if err != nil {
+ return nil, err
+ }
+ genesisForkVersionHex := "0x" + hex.EncodeToString(genesisVersion[:])
  return types.Wrap(beacontypes.GenesisData{
  GenesisTime: "1590832934", // stub
  GenesisValidatorsRoot: genesisRoot,
- GenesisForkVersion: "0x00000000", // stub
+ GenesisForkVersion: genesisForkVersionHex,
  }), nil
 }