Skip to content

Commit

Permalink
Revert "Modify ListValidatorAssignments to use new state service (#…
Browse files Browse the repository at this point in the history 
…5365)"

This reverts commit 5a1a768.
  • Loading branch information
@terencechain
terencechain committed Apr 16, 2020
1 parent 04957cb commit b0c300c
Show file tree
Hide file tree
Showing 4 changed files with 206 additions and 72 deletions.
2 changes: 2 additions & 0 deletions beacon-chain/rpc/beacon/BUILD.bazel
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,11 +41,13 @@ go_library(
"//shared/bytesutil:go_default_library",
"//shared/event:go_default_library",
"//shared/featureconfig:go_default_library",
"//shared/hashutil:go_default_library",
"//shared/pagination:go_default_library",
"//shared/params:go_default_library",
"//shared/sliceutil:go_default_library",
"@com_github_gogo_protobuf//types:go_default_library",
"@com_github_patrickmn_go_cache//:go_default_library",
"@com_github_pkg_errors//:go_default_library",
"@com_github_prometheus_client_golang//prometheus:go_default_library",
"@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
Expand Down
161 changes: 143 additions & 18 deletions beacon-chain/rpc/beacon/assignments.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,11 +4,15 @@ import (
"context"
"strconv"

"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/flags"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/hashutil"
"github.com/prysmaticlabs/prysm/shared/pagination"
"github.com/prysmaticlabs/prysm/shared/params"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
Expand All @@ -28,9 +32,14 @@ func (bs *Server) ListValidatorAssignments(
}

var res []*ethpb.ValidatorAssignments_CommitteeAssignment
headState, err := bs.HeadFetcher.HeadState(ctx)
if err != nil {
return nil, status.Error(codes.Internal, "Could not get head state")
}
filtered := map[uint64]bool{} // track filtered validators to prevent duplication in the response.
filteredIndices := make([]uint64, 0)
var requestedEpoch uint64
requestedEpoch := helpers.CurrentEpoch(headState)

switch q := req.QueryFilter.(type) {
case *ethpb.ListValidatorAssignmentsRequest_Genesis:
if q.Genesis {
Expand All @@ -40,24 +49,18 @@ func (bs *Server) ListValidatorAssignments(
requestedEpoch = q.Epoch
}

currentEpoch := helpers.SlotToEpoch(bs.GenesisTimeFetcher.CurrentSlot())
if requestedEpoch > currentEpoch {
if requestedEpoch > helpers.CurrentEpoch(headState) {
return nil, status.Errorf(
codes.InvalidArgument,
"Cannot retrieve information about an epoch in the future, current epoch %d, requesting %d",
currentEpoch,
helpers.CurrentEpoch(headState),
requestedEpoch,
)
}

requestedState, err := bs.StateGen.StateBySlot(ctx, helpers.StartSlot(requestedEpoch))
if err != nil {
return nil, status.Errorf(codes.Internal, "Could not retrieve archived state for epoch %d: %v", requestedEpoch, err)
}

// Filter out assignments by public keys.
for _, pubKey := range req.PublicKeys {
index, ok := requestedState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
index, ok := headState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
if !ok {
return nil, status.Errorf(codes.NotFound, "Could not find validator index for public key %#x", pubKey)
}
Expand All @@ -72,7 +75,7 @@ func (bs *Server) ListValidatorAssignments(
}
}

activeIndices, err := helpers.ActiveValidatorIndices(requestedState, requestedEpoch)
activeIndices, err := helpers.ActiveValidatorIndices(headState, requestedEpoch)
if err != nil {
return nil, status.Errorf(codes.Internal, "Could not retrieve active validator indices: %v", err)
}
Expand All @@ -93,21 +96,53 @@ func (bs *Server) ListValidatorAssignments(
return nil, status.Errorf(codes.Internal, "Could not paginate results: %v", err)
}

// Initialize all committee related data.
shouldFetchFromArchive := requestedEpoch < bs.FinalizationFetcher.FinalizedCheckpt().Epoch

// initialize all committee related data.
committeeAssignments := map[uint64]*helpers.CommitteeAssignmentContainer{}
proposerIndexToSlots := make(map[uint64][]uint64)
committeeAssignments, proposerIndexToSlots, err = helpers.CommitteeAssignments(requestedState, requestedEpoch)
if err != nil {
return nil, status.Errorf(codes.Internal, "Could not compute committee assignments: %v", err)
archivedInfo := &pb.ArchivedCommitteeInfo{}
archivedBalances := make([]uint64, 0)
archivedAssignments := make(map[uint64]*ethpb.ValidatorAssignments_CommitteeAssignment)

if shouldFetchFromArchive {
archivedInfo, archivedBalances, err = bs.archivedCommitteeData(ctx, requestedEpoch)
if err != nil {
return nil, err
}
archivedAssignments, err = archivedValidatorCommittee(
requestedEpoch,
archivedInfo,
activeIndices,
archivedBalances,
)
if err != nil {
return nil, status.Errorf(codes.Internal, "Could not retrieve archived assignment for epoch %d: %v", requestedEpoch, err)
}
} else {
committeeAssignments, proposerIndexToSlots, err = helpers.CommitteeAssignments(headState, requestedEpoch)
if err != nil {
return nil, status.Errorf(codes.Internal, "Could not compute committee assignments: %v", err)
}
}

for _, index := range filteredIndices[start:end] {
if int(index) >= requestedState.NumValidators() {
if int(index) >= headState.NumValidators() {
return nil, status.Errorf(codes.OutOfRange, "Validator index %d >= validator count %d",
index, requestedState.NumValidators())
index, headState.NumValidators())
}
if shouldFetchFromArchive {
assignment, ok := archivedAssignments[index]
if !ok {
return nil, status.Errorf(codes.Internal, "Could not get archived committee assignment for index %d", index)
}
pubkey := headState.PubkeyAtIndex(index)
assignment.PublicKey = pubkey[:]
res = append(res, assignment)
continue
}
comAssignment := committeeAssignments[index]
pubkey := requestedState.PubkeyAtIndex(index)
pubkey := headState.PubkeyAtIndex(index)
assign := &ethpb.ValidatorAssignments_CommitteeAssignment{
BeaconCommittees: comAssignment.Committee,
CommitteeIndex: comAssignment.CommitteeIndex,
Expand All @@ -125,3 +160,93 @@ func (bs *Server) ListValidatorAssignments(
TotalSize: int32(len(filteredIndices)),
}, nil
}

// Computes validator assignments for an epoch and validator index using archived committee
// information, archived balances, and a set of active validators.
func archivedValidatorCommittee(
epoch uint64,
archivedInfo *pb.ArchivedCommitteeInfo,
activeIndices []uint64,
archivedBalances []uint64,
) (map[uint64]*ethpb.ValidatorAssignments_CommitteeAssignment, error) {
proposerSeed := bytesutil.ToBytes32(archivedInfo.ProposerSeed)
attesterSeed := bytesutil.ToBytes32(archivedInfo.AttesterSeed)

startSlot := helpers.StartSlot(epoch)
proposerIndexToSlots := make(map[uint64][]uint64)
activeVals := make([]*ethpb.Validator, len(archivedBalances))
for i, bal := range archivedBalances {
activeVals[i] = &ethpb.Validator{EffectiveBalance: bal}
}

for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
seedWithSlot := append(proposerSeed[:], bytesutil.Bytes8(slot)...)
seedWithSlotHash := hashutil.Hash(seedWithSlot)
i, err := helpers.ComputeProposerIndex(activeVals, activeIndices, seedWithSlotHash)
if err != nil {
return nil, errors.Wrapf(err, "could not check proposer at slot %d", slot)
}
proposerIndexToSlots[i] = append(proposerIndexToSlots[i], slot)
}

assignmentMap := make(map[uint64]*ethpb.ValidatorAssignments_CommitteeAssignment)
for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
var countAtSlot = uint64(len(activeIndices)) / params.BeaconConfig().SlotsPerEpoch / params.BeaconConfig().TargetCommitteeSize
if countAtSlot > params.BeaconConfig().MaxCommitteesPerSlot {
countAtSlot = params.BeaconConfig().MaxCommitteesPerSlot
}
if countAtSlot == 0 {
countAtSlot = 1
}
for i := uint64(0); i < countAtSlot; i++ {
committee, err := helpers.BeaconCommittee(activeIndices, attesterSeed, slot, i)
if err != nil {
return nil, errors.Wrap(err, "could not compute committee")
}
for _, index := range committee {
assignmentMap[index] = &ethpb.ValidatorAssignments_CommitteeAssignment{
BeaconCommittees: committee,
CommitteeIndex: i,
AttesterSlot: slot,
ProposerSlots: proposerIndexToSlots[index],
}
}
}
}
return assignmentMap, nil
}

func (bs *Server) archivedCommitteeData(ctx context.Context, requestedEpoch uint64) (*pb.ArchivedCommitteeInfo,
[]uint64, error) {
archivedInfo, err := bs.BeaconDB.ArchivedCommitteeInfo(ctx, requestedEpoch)
if err != nil {
return nil, nil, status.Errorf(
codes.Internal,
"Could not retrieve archived committee info for epoch %d",
requestedEpoch,
)
}
if archivedInfo == nil {
return nil, nil, status.Errorf(
codes.NotFound,
"Could not retrieve data for epoch %d, perhaps --archive in the running beacon node is disabled",
requestedEpoch,
)
}
archivedBalances, err := bs.BeaconDB.ArchivedBalances(ctx, requestedEpoch)
if err != nil {
return nil, nil, status.Errorf(
codes.Internal,
"Could not retrieve archived balances for epoch %d",
requestedEpoch,
)
}
if archivedBalances == nil {
return nil, nil, status.Errorf(
codes.NotFound,
"Could not retrieve data for epoch %d, perhaps --archive in the running beacon node is disabled",
requestedEpoch,
)
}
return archivedInfo, archivedBalances, nil
}
Loading

0 comments on commit b0c300c

Please sign in to comment.