HTTP validator API: beacon and account endpoints

api/BUILD.bazel

@@ -2,7 +2,10 @@ load("@prysm//tools/go:def.bzl", "go_library")
 
 go_library(
  name = "go_default_library",
- srcs = ["headers.go"],
+ srcs = [
+ "constants.go",
+ "headers.go",
+ ],
  importpath = "github.com/prysmaticlabs/prysm/v4/api",
  visibility = ["//visibility:public"],
 )

api/constants.go

@@ -0,0 +1,3 @@
+package api
+
+const WebUrlPrefix = "/v2/validator/"

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

@@ -8,6 +8,7 @@ go_library(
  "structs.go",
  "structs_blocks.go",
  "structs_blocks_conversions.go",
+ "structs_validator.go",
  ],
  importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/shared",
  visibility = ["//visibility:public"],

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

@@ -701,3 +701,107 @@ type SyncDetails struct {
 type SyncDetailsContainer struct {
  Data *SyncDetails `json:"data"`
 }
+
+// ChainHead is the response for api endpoint /beacon/chainhead
+type ChainHead struct {
+ HeadSlot string `json:"head_slot"`
+ HeadEpoch string `json:"head_epoch"`
+ HeadBlockRoot string `json:"head_block_root"`
+ FinalizedSlot string `json:"finalized_slot"`
+ FinalizedEpoch string `json:"finalized_epoch"`
+ FinalizedBlockRoot string `json:"finalized_block_root"`
+ JustifiedSlot string `json:"justified_slot"`
+ JustifiedEpoch string `json:"justified_epoch"`
+ JustifiedBlockRoot string `json:"justified_block_root"`
+ PreviousJustifiedSlot string `json:"previous_justified_slot"`
+ PreviousJustifiedEpoch string `json:"previous_justified_epoch"`
+ PreviousJustifiedBlockRoot string `json:"previous_justified_block_root"`
+ OptimisticStatus bool `json:"optimistic_status"`
+}
+
+func ChainHeadResponseFromConsensus(e *eth.ChainHead) (*ChainHead, error) {
+ if e == nil {
+ return nil, errors.New("ChainHead is empty")
+ }
+ return &ChainHead{
+ HeadSlot: fmt.Sprintf("%d", e.HeadSlot),
+ HeadEpoch: fmt.Sprintf("%d", e.HeadEpoch),
+ HeadBlockRoot: hexutil.Encode(e.HeadBlockRoot),
+ FinalizedSlot: fmt.Sprintf("%d", e.FinalizedSlot),
+ FinalizedEpoch: fmt.Sprintf("%d", e.FinalizedEpoch),
+ FinalizedBlockRoot: hexutil.Encode(e.FinalizedBlockRoot),
+ JustifiedSlot: fmt.Sprintf("%d", e.JustifiedSlot),
+ JustifiedEpoch: fmt.Sprintf("%d", e.JustifiedEpoch),
+ JustifiedBlockRoot: hexutil.Encode(e.JustifiedBlockRoot),
+ PreviousJustifiedSlot: fmt.Sprintf("%d", e.PreviousJustifiedSlot),
+ PreviousJustifiedEpoch: fmt.Sprintf("%d", e.PreviousJustifiedEpoch),
+ PreviousJustifiedBlockRoot: hexutil.Encode(e.PreviousJustifiedBlockRoot),
+ OptimisticStatus: e.OptimisticStatus,
+ }, nil
+}
+
+func (m *ChainHead) ToConsensus() (*eth.ChainHead, error) {
+ headSlot, err := strconv.ParseUint(m.HeadSlot, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "HeadSlot")
+ }
+ headEpoch, err := strconv.ParseUint(m.HeadEpoch, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "HeadEpoch")
+ }
+ headBlockRoot, err := DecodeHexWithLength(m.HeadBlockRoot, fieldparams.RootLength)
+ if err != nil {
+ return nil, NewDecodeError(err, "HeadBlockRoot")
+ }
+ finalizedSlot, err := strconv.ParseUint(m.FinalizedSlot, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "FinalizedSlot")
+ }
+ finalizedEpoch, err := strconv.ParseUint(m.FinalizedEpoch, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "FinalizedEpoch")
+ }
+ finalizedBlockRoot, err := DecodeHexWithLength(m.FinalizedBlockRoot, fieldparams.RootLength)
+ if err != nil {
+ return nil, NewDecodeError(err, "FinalizedBlockRoot")
+ }
+ justifiedSlot, err := strconv.ParseUint(m.JustifiedSlot, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "JustifiedSlot")
+ }
+ justifiedEpoch, err := strconv.ParseUint(m.JustifiedEpoch, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "JustifiedEpoch")
+ }
+ justifiedBlockRoot, err := DecodeHexWithLength(m.JustifiedBlockRoot, fieldparams.RootLength)
+ if err != nil {
+ return nil, NewDecodeError(err, "JustifiedBlockRoot")
+ }
+ previousjustifiedSlot, err := strconv.ParseUint(m.PreviousJustifiedSlot, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "PreviousJustifiedSlot")
+ }
+ previousjustifiedEpoch, err := strconv.ParseUint(m.PreviousJustifiedEpoch, 10, 64)
+ if err != nil {
+ return nil, NewDecodeError(err, "PreviousJustifiedEpoch")
+ }
+ previousjustifiedBlockRoot, err := DecodeHexWithLength(m.PreviousJustifiedBlockRoot, fieldparams.RootLength)
+ if err != nil {
+ return nil, NewDecodeError(err, "PreviousJustifiedBlockRoot")
+ }
+ return &eth.ChainHead{
+ HeadSlot: primitives.Slot(headSlot),
+ HeadEpoch: primitives.Epoch(headEpoch),
+ HeadBlockRoot: headBlockRoot,
+ FinalizedSlot: primitives.Slot(finalizedSlot),
+ FinalizedEpoch: primitives.Epoch(finalizedEpoch),
+ FinalizedBlockRoot: finalizedBlockRoot,
+ JustifiedSlot: primitives.Slot(justifiedSlot),
+ JustifiedEpoch: primitives.Epoch(justifiedEpoch),
+ JustifiedBlockRoot: justifiedBlockRoot,
+ PreviousJustifiedSlot: primitives.Slot(previousjustifiedSlot),
+ PreviousJustifiedEpoch: primitives.Epoch(previousjustifiedEpoch),
+ PreviousJustifiedBlockRoot: previousjustifiedBlockRoot,
+ OptimisticStatus: m.OptimisticStatus,
+ }, nil
+}

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

@@ -0,0 +1,166 @@
+package shared
+
+import (
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/pkg/errors"
+ eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+)
+
+type ValidatorPerformanceResponse struct {
+ CurrentEffectiveBalances []uint64 `json:"current_effective_balances"`
+ InclusionSlots []uint64 `json:"inclusion_slots"`
+ InclusionDistances []uint64 `json:"inclusion_distances"`
+ CorrectlyVotedSource []bool `json:"correctly_voted_source"`
+ CorrectlyVotedTarget []bool `json:"correctly_voted_target"`
+ CorrectlyVotedHead []bool `json:"correctly_voted_head"`
+ BalancesBeforeEpochTransition []uint64 `json:"balances_before_epoch_transition"`
+ BalancesAfterEpochTransition []uint64 `json:"balances_after_epoch_transition"`
+ MissingValidators []string `json:"missing_validators"`
+ AverageActiveValidatorBalance float32 `json:"average_active_validator_balance"`
+ PublicKeys []string `json:"public_keys"`
+ InactivityScores []uint64 `json:"inactivity_scores"`
+}
+
+func ValidatorPerformanceResponseFromConsensus(e *eth.ValidatorPerformanceResponse) (*ValidatorPerformanceResponse, error) {
+ if e == nil {
+ return nil, errors.New("ValidatorPerformanceResponse is empty")
+ }
+ inclusionSlots := make([]uint64, len(e.InclusionSlots))
+ for i, index := range e.InclusionSlots {
+ inclusionSlots[i] = uint64(index)
+ }
+ inclusionDistances := make([]uint64, len(e.InclusionDistances))
+ for i, index := range e.InclusionDistances {
+ inclusionDistances[i] = uint64(index)
+ }
+ missingValidators := make([]string, len(e.MissingValidators))
+ for i, key := range e.MissingValidators {
+ missingValidators[i] = hexutil.Encode(key)
+ }
+ publicKeys := make([]string, len(e.PublicKeys))
+ for i, key := range e.PublicKeys {
+ publicKeys[i] = hexutil.Encode(key)
+ }
+ if len(e.CurrentEffectiveBalances) == 0 {
+ e.CurrentEffectiveBalances = make([]uint64, 0)
+ }
+ if len(e.BalancesBeforeEpochTransition) == 0 {
+ e.BalancesBeforeEpochTransition = make([]uint64, 0)
+ }
+ if len(e.BalancesAfterEpochTransition) == 0 {
+ e.BalancesAfterEpochTransition = make([]uint64, 0)
+ }
+ if len(e.CorrectlyVotedSource) == 0 {
+ e.CorrectlyVotedSource = make([]bool, 0)
+ }
+ if len(e.CorrectlyVotedTarget) == 0 {
+ e.CorrectlyVotedTarget = make([]bool, 0)
+ }
+ if len(e.CorrectlyVotedHead) == 0 {
+ e.CorrectlyVotedHead = make([]bool, 0)
+ }
+ if len(e.InactivityScores) == 0 {
+ e.InactivityScores = make([]uint64, 0)
+ }
+ return &ValidatorPerformanceResponse{
+ CurrentEffectiveBalances: e.CurrentEffectiveBalances,
+ InclusionSlots: inclusionSlots,
+ InclusionDistances: inclusionDistances,
+ CorrectlyVotedSource: e.CorrectlyVotedSource,
+ CorrectlyVotedTarget: e.CorrectlyVotedTarget,
+ CorrectlyVotedHead: e.CorrectlyVotedHead,
+ BalancesBeforeEpochTransition: e.BalancesBeforeEpochTransition,
+ BalancesAfterEpochTransition: e.BalancesAfterEpochTransition,
+ MissingValidators: missingValidators,
+ AverageActiveValidatorBalance: e.AverageActiveValidatorBalance,
+ PublicKeys: publicKeys,
+ InactivityScores: e.InactivityScores,
+ }, nil
+}
+
+type ValidatorBalancesResponse struct {
+ Epoch uint64 `json:"epoch"`
+ Balances []*ValidatorBalance `json:"balances"`
+ NextPageToken string `json:"next_page_token"`
+ TotalSize int32 `json:"total_size,omitempty"`
+}
+
+type ValidatorBalance struct {
+ PublicKey string `json:"public_key"`
+ Index uint64 `json:"index"`
+ Balance uint64 `json:"balance"`
+ Status string `json:"status"`
+}
+
+func ValidatorBalancesResponseFromConsensus(e *eth.ValidatorBalances) (*ValidatorBalancesResponse, error) {
+ if e == nil {
+ return nil, errors.New("ValidatorBalances is empty")
+ }
+ balances := make([]*ValidatorBalance, len(e.Balances))
+ for i, balance := range e.Balances {
+ balances[i] = &ValidatorBalance{
+ PublicKey: hexutil.Encode(balance.PublicKey),
+ Index: uint64(balance.Index),
+ Balance: balance.Balance,
+ Status: balance.Status,
+ }
+ }
+ return &ValidatorBalancesResponse{
+ Epoch: uint64(e.Epoch),
+ Balances: balances,
+ NextPageToken: e.NextPageToken,
+ TotalSize: e.TotalSize,
+ }, nil
+}
+
+type ValidatorsResponse struct {
+ Epoch uint64 `json:"epoch"`
+ ValidatorList []*ValidatorContainer `json:"validator_list"`
+ NextPageToken string `json:"next_page_token"`
+ TotalSize int32 `json:"total_size"`
+}
+
+type ValidatorContainer struct {
+ Index uint64 `json:"index"`
+ Validator *Validator `json:"validator"`
+}
+
+type Validator struct {
+ PublicKey string `json:"public_key,omitempty"`
+ WithdrawalCredentials string `json:"withdrawal_credentials"`
+ EffectiveBalance uint64 `json:"effective_balance"`
+ Slashed bool `json:"slashed"`
+ ActivationEligibilityEpoch uint64 `json:"activation_eligibility_epoch"`
+ ActivationEpoch uint64 `json:"activation_epoch"`
+ ExitEpoch uint64 `json:"exit_epoch"`
+ WithdrawableEpoch uint64 `json:"withdrawable_epoch"`
+}
+
+func ValidatorsResponseFromConsensus(e *eth.Validators) (*ValidatorsResponse, error) {
+ if e == nil {
+ return nil, errors.New("ValidatorsResponse is empty")
+ }
+ validatorList := make([]*ValidatorContainer, len(e.ValidatorList))
+ for i, validatorContainer := range e.ValidatorList {
+ val := validatorContainer.Validator
+ validatorList[i] = &ValidatorContainer{
+ Index: uint64(validatorContainer.Index),
+ Validator: &Validator{
+ PublicKey: hexutil.Encode(val.PublicKey),
+ WithdrawalCredentials: hexutil.Encode(val.WithdrawalCredentials),
+ EffectiveBalance: val.EffectiveBalance,
+ Slashed: val.Slashed,
+ ActivationEligibilityEpoch: uint64(val.ActivationEligibilityEpoch),
+ ActivationEpoch: uint64(val.ActivationEpoch),
+ ExitEpoch: uint64(val.ExitEpoch),
+ WithdrawableEpoch: uint64(val.WithdrawableEpoch),
+ },
+ }
+ }
+ return &ValidatorsResponse{
+ Epoch: uint64(e.Epoch),
+ ValidatorList: validatorList,
+ NextPageToken: e.NextPageToken,
+ TotalSize: e.TotalSize,
+ }, nil
+}

nogo_config.json

@@ -164,7 +164,8 @@
  },
  "exclude_files": {
  ".*_test\\.go": "Tests are ok",
- "io/file/fileutil.go": "Package which defines the proper rules"
+ "io/file/fileutil.go": "Package which defines the proper rules",
+ "validator/web/site_data.go": "Generated web ui assets"
  }
  },
  "uintcast": {

proto/prysm/v1alpha1/validator-client/BUILD.bazel

@@ -20,7 +20,6 @@ proto_library(
  name = "proto",
  srcs = [
  "keymanager.proto",
- "web_api.proto",
  ],
  visibility = ["//visibility:public"],
  deps = [