Command to fetch validator statuses + MultipleValidatorStatus

WORKSPACE

@@ -1333,7 +1333,7 @@ go_repository(
 
 go_repository(
     name = "com_github_prysmaticlabs_ethereumapis",
-    commit = "df460bd3d84be4ff3df0658395c7dc9d2a7e7b3d",
+    commit = "3444ffb75440161e4d6b9d38edef65212474cc48",
     importpath = "github.com/prysmaticlabs/ethereumapis",
 )
 

beacon-chain/rpc/validator/server.go

@@ -77,7 +77,7 @@ type Server struct {
 // beacon state, if not, then it creates a stream which listens for canonical states which contain
 // the validator with the public key as an active validator record.
 func (vs *Server) WaitForActivation(req *ethpb.ValidatorActivationRequest, stream ethpb.BeaconNodeValidator_WaitForActivationServer) error {
-	activeValidatorExists, validatorStatuses, err := vs.multipleValidatorStatus(stream.Context(), req.PublicKeys)
+	activeValidatorExists, validatorStatuses, err := vs.activationStatus(stream.Context(), req.PublicKeys)
 	if err != nil {
 		return status.Errorf(codes.Internal, "Could not fetch validator status: %v", err)
 	}
@@ -95,7 +95,7 @@ func (vs *Server) WaitForActivation(req *ethpb.ValidatorActivationRequest, strea
 		select {
 		// Pinging every slot for activation.
 		case <-time.After(time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second):
-			activeValidatorExists, validatorStatuses, err := vs.multipleValidatorStatus(stream.Context(), req.PublicKeys)
+			activeValidatorExists, validatorStatuses, err := vs.activationStatus(stream.Context(), req.PublicKeys)
 			if err != nil {
 				return status.Errorf(codes.Internal, "Could not fetch validator status: %v", err)
 			}

beacon-chain/rpc/validator/status.go

@@ -38,9 +38,53 @@ func (vs *Server) ValidatorStatus(
 	return vs.validatorStatus(ctx, req.PublicKey, headState), nil
 }
 
-// multipleValidatorStatus returns the validator status response for the set of validators
+// MultipleValidatorStatus is the same as ValidatorStatus. Supports retrieval of multiple
+// validator statuses. Takes a list of public keys or a list of validator indices.
+func (vs *Server) MultipleValidatorStatus(
+	ctx context.Context,
+	req *ethpb.MultipleValidatorStatusRequest) (*ethpb.MultipleValidatorStatusResponse, error) {
+	if vs.SyncChecker.Syncing() {
+		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
+	}
+	headState, err := vs.HeadFetcher.HeadState(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, "Could not get head state")
+	}
+	responseCap := len(req.PublicKeys) + len(req.Indices)
+	pubkeys := make([][]byte, 0, responseCap)
+	filtered := make(map[[48]byte]bool)
+	filtered[[48]byte{}] = true // Filter out keys with all zeros.
+	// Filter out duplicate public keys.
+	for _, pubKey := range req.PublicKeys {
+		pubkeyBytes := bytesutil.ToBytes48(pubKey)
+		if !filtered[pubkeyBytes] {
+			pubkeys = append(pubkeys, pubKey)
+			filtered[pubkeyBytes] = true
+		}
+	}
+	// Convert indices to public keys.
+	for _, idx := range req.Indices {
+		pubkeyBytes := headState.PubkeyAtIndex(uint64(idx))
+		if !filtered[pubkeyBytes] {
+			pubkeys = append(pubkeys, pubkeyBytes[:])
+			filtered[pubkeyBytes] = true
+		}
+	}
+	// Fetch statuses from beacon state.
+	statuses := make([]*ethpb.ValidatorStatusResponse, len(pubkeys))
+	for i, pubKey := range pubkeys {
+		statuses[i] = vs.validatorStatus(ctx, pubKey, headState)
+	}
+
+	return &ethpb.MultipleValidatorStatusResponse{
+		PublicKeys: pubkeys,
+		Statuses:   statuses,
+	}, nil
+}
+
+// activationStatus returns the validator status response for the set of validators
 // requested by their pub keys.
-func (vs *Server) multipleValidatorStatus(
+func (vs *Server) activationStatus(
 	ctx context.Context,
 	pubkeys [][]byte,
 ) (bool, []*ethpb.ValidatorActivationResponse_Status, error) {

beacon-chain/rpc/validator/status_test.go

@@ -1,6 +1,7 @@
 package validator
 
 import (
+	"bytes"
 	"context"
 	"math/big"
 	"testing"
@@ -16,6 +17,7 @@ import (
 	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	mockSync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing"
 	pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
@@ -539,7 +541,7 @@ func TestValidatorStatus_UnknownStatus(t *testing.T) {
 	}
 }
 
-func TestMultipleValidatorStatus_OK(t *testing.T) {
+func TestActivationStatus_OK(t *testing.T) {
 	db := dbutil.SetupDB(t)
 	ctx := context.Background()
 
@@ -608,7 +610,7 @@ func TestMultipleValidatorStatus_OK(t *testing.T) {
 		DepositFetcher:     depositCache,
 		HeadFetcher:        &mockChain.ChainService{State: stateObj, Root: genesisRoot[:]},
 	}
-	activeExists, response, err := vs.multipleValidatorStatus(context.Background(), pubKeys)
+	activeExists, response, err := vs.activationStatus(context.Background(), pubKeys)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -901,3 +903,209 @@ func TestDepositBlockSlotBeforeGenesisTime(t *testing.T) {
 		t.Errorf("Wanted %v, got %v", expected, resp)
 	}
 }
+
+func TestMultipleValidatorStatus_Pubkeys(t *testing.T) {
+	db := dbutil.SetupDB(t)
+	ctx := context.Background()
+
+	pubKeys := [][]byte{pubKey(1), pubKey(2), pubKey(3), pubKey(4)}
+	stateObj, err := stateTrie.InitializeFromProtoUnsafe(&pbp2p.BeaconState{
+		Slot: 4000,
+		Validators: []*ethpb.Validator{
+			{
+				ActivationEpoch: 0,
+				ExitEpoch:       params.BeaconConfig().FarFutureEpoch,
+				PublicKey:       pubKeys[0],
+			},
+			{
+				ActivationEpoch: 0,
+				ExitEpoch:       params.BeaconConfig().FarFutureEpoch,
+				PublicKey:       pubKeys[1],
+			},
+			{
+				ActivationEligibilityEpoch: 700,
+				ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+				PublicKey:                  pubKeys[3],
+			},
+		},
+	})
+	block := blk.NewGenesisBlock([]byte{})
+	genesisRoot, err := stateutil.BlockRoot(block.Block)
+	if err != nil {
+		t.Fatalf("Could not get signing root %v", err)
+	}
+	depData := &ethpb.Deposit_Data{
+		PublicKey:             pubKey(1),
+		Signature:             []byte("hi"),
+		WithdrawalCredentials: []byte("hey"),
+		Amount:                10,
+	}
+
+	dep := &ethpb.Deposit{
+		Data: depData,
+	}
+	depositTrie, err := trieutil.NewTrie(int(params.BeaconConfig().DepositContractTreeDepth))
+	if err != nil {
+		t.Fatalf("Could not setup deposit trie: %v", err)
+	}
+	depositCache := depositcache.NewDepositCache()
+	depositCache.InsertDeposit(ctx, dep, 10 /*blockNum*/, 0, depositTrie.Root())
+	depData = &ethpb.Deposit_Data{
+		PublicKey:             pubKey(3),
+		Signature:             []byte("hi"),
+		WithdrawalCredentials: []byte("hey"),
+		Amount:                10,
+	}
+
+	dep = &ethpb.Deposit{
+		Data: depData,
+	}
+	depositTrie.Insert(dep.Data.Signature, 15)
+	depositCache.InsertDeposit(context.Background(), dep, 0, 0, depositTrie.Root())
+
+	vs := &Server{
+		BeaconDB:           db,
+		Ctx:                context.Background(),
+		CanonicalStateChan: make(chan *pbp2p.BeaconState, 1),
+		ChainStartFetcher:  &mockPOW.POWChain{},
+		BlockFetcher:       &mockPOW.POWChain{},
+		Eth1InfoFetcher:    &mockPOW.POWChain{},
+		DepositFetcher:     depositCache,
+		HeadFetcher:        &mockChain.ChainService{State: stateObj, Root: genesisRoot[:]},
+		SyncChecker:        &mockSync.Sync{IsSyncing: false},
+	}
+
+	want := []*ethpb.ValidatorStatusResponse{
+		&ethpb.ValidatorStatusResponse{
+			Status: ethpb.ValidatorStatus_ACTIVE,
+		},
+		&ethpb.ValidatorStatusResponse{
+			Status: ethpb.ValidatorStatus_ACTIVE,
+		},
+		&ethpb.ValidatorStatusResponse{
+			Status:               ethpb.ValidatorStatus_DEPOSITED,
+			DepositInclusionSlot: 53,
+			ActivationEpoch:      18446744073709551615,
+		},
+		&ethpb.ValidatorStatusResponse{
+			Status: ethpb.ValidatorStatus_DEPOSITED,
+		},
+	}
+
+	req := &ethpb.MultipleValidatorStatusRequest{PublicKeys: pubKeys}
+	response, err := vs.MultipleValidatorStatus(context.Background(), req)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(response.PublicKeys) != len(pubKeys) {
+		t.Fatalf(
+			"Recieved %d public keys, wanted %d public keys", len(response.PublicKeys), len(pubKeys))
+	}
+	for i, resp := range response.PublicKeys {
+		if !bytes.Equal(pubKeys[i], resp) {
+			t.Fatalf("Wanted: %v\n Recieved: %v\n", pubKeys[i], resp)
+		}
+	}
+	if len(response.Statuses) != len(pubKeys) {
+		t.Fatalf("Recieved %d statuses, wanted %d statuses", len(response.Statuses), len(pubKeys))
+	}
+	for i, resp := range response.Statuses {
+		if !proto.Equal(want[i], resp) {
+			t.Fatalf("Wanted %v\n Recieved: %v\n", want[i], resp)
+		}
+	}
+}
+
+func TestMultipleValidatorStatus_Indices(t *testing.T) {
+	db := dbutil.SetupDB(t)
+	slot := uint64(10000)
+	epoch := helpers.SlotToEpoch(slot)
+	pubKeys := [][]byte{pubKey(1), pubKey(2), pubKey(3), pubKey(4)}
+	beaconState := &pbp2p.BeaconState{
+		Slot: 4000,
+		Validators: []*ethpb.Validator{
+			{
+				ActivationEpoch: 0,
+				ExitEpoch:       params.BeaconConfig().FarFutureEpoch,
+				PublicKey:       pubKeys[0],
+			},
+			{
+				ActivationEpoch: 0,
+				ExitEpoch:       params.BeaconConfig().FarFutureEpoch,
+				PublicKey:       pubKeys[1],
+			},
+			{
+				ActivationEligibilityEpoch: 700,
+				ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+				PublicKey:                  pubKeys[2],
+			},
+			{
+				Slashed:   true,
+				ExitEpoch: epoch + 1,
+				PublicKey: pubKeys[3],
+			},
+		},
+	}
+	stateObj, err := stateTrie.InitializeFromProtoUnsafe(beaconState)
+	block := blk.NewGenesisBlock([]byte{})
+	genesisRoot, err := stateutil.BlockRoot(block.Block)
+	if err != nil {
+		t.Fatalf("Could not get signing root %v", err)
+	}
+
+	vs := &Server{
+		BeaconDB:           db,
+		Ctx:                context.Background(),
+		CanonicalStateChan: make(chan *pbp2p.BeaconState, 1),
+		ChainStartFetcher:  &mockPOW.POWChain{},
+		BlockFetcher:       &mockPOW.POWChain{},
+		Eth1InfoFetcher:    &mockPOW.POWChain{},
+		HeadFetcher:        &mockChain.ChainService{State: stateObj, Root: genesisRoot[:]},
+		SyncChecker:        &mockSync.Sync{IsSyncing: false},
+	}
+
+	want := []*ethpb.ValidatorStatusResponse{
+		&ethpb.ValidatorStatusResponse{
+			Status: ethpb.ValidatorStatus_ACTIVE,
+		},
+		&ethpb.ValidatorStatusResponse{
+			Status: ethpb.ValidatorStatus_ACTIVE,
+		},
+		&ethpb.ValidatorStatusResponse{
+			Status: ethpb.ValidatorStatus_DEPOSITED,
+		},
+		&ethpb.ValidatorStatusResponse{
+			Status: ethpb.ValidatorStatus_SLASHING,
+		},
+	}
+
+	// Note: Index 4 should be skipped. 
+	req := &ethpb.MultipleValidatorStatusRequest{Indices: []int64{0, 1, 2, 3, 4}}
+	response, err := vs.MultipleValidatorStatus(context.Background(), req)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(response.PublicKeys) != len(beaconState.Validators) {
+		t.Fatalf(
+			"Recieved %d public keys, wanted %d public keys",
+			len(response.PublicKeys), len(beaconState.Validators))
+	}
+	for i, resp := range response.PublicKeys {
+		expected := beaconState.Validators[i].PublicKey
+		if !bytes.Equal(expected, resp) {
+			t.Fatalf("Wanted: %v\n Recieved: %v\n", expected, resp)
+		}
+	}
+	if len(response.Statuses) != len(beaconState.Validators) {
+		t.Fatalf(
+			"Recieved %d statuses, wanted %d statuses",
+			len(response.Statuses), len(beaconState.Validators))
+	}
+	for i, resp := range response.Statuses {
+		if !proto.Equal(want[i], resp) {
+			t.Fatalf("Wanted %v\n Recieved: %v\n", want[i], resp)
+		}
+	}
+}