mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-29 06:37:17 +00:00
1002 lines
30 KiB
Go
1002 lines
30 KiB
Go
package rpc
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"math/big"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gogo/protobuf/proto"
|
|
|
|
"github.com/golang/mock/gomock"
|
|
b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
|
|
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
|
|
pb "github.com/prysmaticlabs/prysm/proto/beacon/rpc/v1"
|
|
"github.com/prysmaticlabs/prysm/shared/params"
|
|
)
|
|
|
|
func genesisState(validators uint64) (*pbp2p.BeaconState, error) {
|
|
genesisTime := time.Unix(0, 0).Unix()
|
|
deposits := make([]*pbp2p.Deposit, validators)
|
|
for i := 0; i < len(deposits); i++ {
|
|
var pubKey [96]byte
|
|
copy(pubKey[:], []byte(strconv.Itoa(i)))
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey[:],
|
|
}
|
|
depositData, err := helpers.EncodeDepositData(
|
|
depositInput,
|
|
params.BeaconConfig().MaxDepositAmount,
|
|
genesisTime,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
deposits[i] = &pbp2p.Deposit{DepositData: depositData}
|
|
}
|
|
return state.GenesisBeaconState(deposits, uint64(genesisTime), nil)
|
|
}
|
|
|
|
func TestValidatorIndex_OK(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
validatorServer := &ValidatorServer{
|
|
beaconDB: db,
|
|
}
|
|
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
if _, err := validatorServer.ValidatorIndex(context.Background(), req); err != nil {
|
|
t.Errorf("Could not get validator index: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidatorIndex_InStateNotInDB(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
|
|
pubKey := []byte{'A'}
|
|
|
|
// Wanted validator with public key 'A' is in index '1'.
|
|
s := &pbp2p.BeaconState{
|
|
ValidatorRegistry: []*pbp2p.Validator{{Pubkey: []byte{0}}, {Pubkey: []byte{'A'}}, {Pubkey: []byte{'B'}}},
|
|
}
|
|
|
|
if err := db.SaveState(context.Background(), s); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
validatorServer := &ValidatorServer{
|
|
beaconDB: db,
|
|
}
|
|
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
|
|
// Verify index can be retrieved from state when it's not saved in DB.
|
|
res, err := validatorServer.ValidatorIndex(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if res.Index != 1 {
|
|
t.Errorf("Wanted index 1 got %d", res.Index)
|
|
}
|
|
|
|
// Verify index is also saved in DB.
|
|
idx, err := validatorServer.beaconDB.ValidatorIndex(pubKey)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if idx != 1 {
|
|
t.Errorf("Wanted index 1 in DB got %d", res.Index)
|
|
}
|
|
}
|
|
|
|
func TestNextEpochCommitteeAssignment_WrongPubkeyLength(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
ctx := context.Background()
|
|
defer internal.TeardownDB(t, db)
|
|
beaconState, err := genesisState(8)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := db.SaveState(context.Background(), beaconState); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
block := b.NewGenesisBlock([]byte{})
|
|
if err := db.SaveBlock(block); err != nil {
|
|
t.Fatalf("Could not save block: %v", err)
|
|
}
|
|
if err := db.UpdateChainHead(ctx, block, beaconState); err != nil {
|
|
t.Fatalf("Could not update head: %v", err)
|
|
}
|
|
validatorServer := &ValidatorServer{
|
|
beaconDB: db,
|
|
}
|
|
req := &pb.CommitteeAssignmentsRequest{
|
|
PublicKeys: [][]byte{{1}},
|
|
EpochStart: params.BeaconConfig().GenesisEpoch,
|
|
}
|
|
want := fmt.Sprintf("expected public key to have length %d", params.BeaconConfig().BLSPubkeyLength)
|
|
if _, err := validatorServer.CommitteeAssignment(context.Background(), req); err != nil && !strings.Contains(err.Error(), want) {
|
|
t.Errorf("Expected %v, received %v", want, err)
|
|
}
|
|
}
|
|
|
|
func TestNextEpochCommitteeAssignment_CantFindValidatorIdx(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
genesis := b.NewGenesisBlock([]byte{})
|
|
if err := db.SaveBlock(genesis); err != nil {
|
|
t.Fatalf("Could not save genesis block: %v", err)
|
|
}
|
|
state, err := genesisState(params.BeaconConfig().DepositsForChainStart)
|
|
if err != nil {
|
|
t.Fatalf("Could not setup genesis state: %v", err)
|
|
}
|
|
db.UpdateChainHead(ctx, genesis, state)
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
}
|
|
|
|
pubKey := make([]byte, 96)
|
|
req := &pb.CommitteeAssignmentsRequest{
|
|
PublicKeys: [][]byte{pubKey},
|
|
EpochStart: params.BeaconConfig().GenesisEpoch,
|
|
}
|
|
want := fmt.Sprintf("validator %#x does not exist", req.PublicKeys[0])
|
|
if _, err := vs.CommitteeAssignment(ctx, req); err != nil && !strings.Contains(err.Error(), want) {
|
|
t.Errorf("Expected %v, received %v", want, err)
|
|
}
|
|
}
|
|
|
|
func TestCommitteeAssignment_OK(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
genesis := b.NewGenesisBlock([]byte{})
|
|
if err := db.SaveBlock(genesis); err != nil {
|
|
t.Fatalf("Could not save genesis block: %v", err)
|
|
}
|
|
state, err := genesisState(params.BeaconConfig().DepositsForChainStart)
|
|
if err != nil {
|
|
t.Fatalf("Could not setup genesis state: %v", err)
|
|
}
|
|
if err := db.UpdateChainHead(ctx, genesis, state); err != nil {
|
|
t.Fatalf("Could not save genesis state: %v", err)
|
|
}
|
|
var wg sync.WaitGroup
|
|
numOfValidators := int(params.BeaconConfig().DepositsForChainStart)
|
|
errs := make(chan error, numOfValidators)
|
|
for i := 0; i < numOfValidators; i++ {
|
|
pubKeyBuf := make([]byte, params.BeaconConfig().BLSPubkeyLength)
|
|
copy(pubKeyBuf[:], []byte(strconv.Itoa(i)))
|
|
wg.Add(1)
|
|
go func(index int) {
|
|
errs <- db.SaveValidatorIndexBatch(pubKeyBuf, index)
|
|
wg.Done()
|
|
}(i)
|
|
}
|
|
wg.Wait()
|
|
close(errs)
|
|
for err := range errs {
|
|
if err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
}
|
|
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
}
|
|
|
|
pubKeyBuf := make([]byte, params.BeaconConfig().BLSPubkeyLength)
|
|
copy(pubKeyBuf[:], []byte(strconv.FormatUint(0, 10)))
|
|
// Test the first validator in registry.
|
|
req := &pb.CommitteeAssignmentsRequest{
|
|
PublicKeys: [][]byte{pubKeyBuf},
|
|
EpochStart: params.BeaconConfig().GenesisSlot,
|
|
}
|
|
res, err := vs.CommitteeAssignment(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not call epoch committee assignment %v", err)
|
|
}
|
|
if res.Assignment[0].Shard >= params.BeaconConfig().ShardCount {
|
|
t.Errorf("Assigned shard %d can't be higher than %d",
|
|
res.Assignment[0].Shard, params.BeaconConfig().ShardCount)
|
|
}
|
|
if res.Assignment[0].Slot > state.Slot+params.BeaconConfig().SlotsPerEpoch {
|
|
t.Errorf("Assigned slot %d can't be higher than %d",
|
|
res.Assignment[0].Slot, state.Slot+params.BeaconConfig().SlotsPerEpoch)
|
|
}
|
|
|
|
// Test the last validator in registry.
|
|
lastValidatorIndex := params.BeaconConfig().DepositsForChainStart - 1
|
|
pubKeyBuf = make([]byte, params.BeaconConfig().BLSPubkeyLength)
|
|
copy(pubKeyBuf[:], []byte(strconv.FormatUint(lastValidatorIndex, 10)))
|
|
req = &pb.CommitteeAssignmentsRequest{
|
|
PublicKeys: [][]byte{pubKeyBuf},
|
|
EpochStart: params.BeaconConfig().GenesisSlot,
|
|
}
|
|
res, err = vs.CommitteeAssignment(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not call epoch committee assignment %v", err)
|
|
}
|
|
if res.Assignment[0].Shard >= params.BeaconConfig().ShardCount {
|
|
t.Errorf("Assigned shard %d can't be higher than %d",
|
|
res.Assignment[0].Shard, params.BeaconConfig().ShardCount)
|
|
}
|
|
if res.Assignment[0].Slot > state.Slot+params.BeaconConfig().SlotsPerEpoch {
|
|
t.Errorf("Assigned slot %d can't be higher than %d",
|
|
res.Assignment[0].Slot, state.Slot+params.BeaconConfig().SlotsPerEpoch)
|
|
}
|
|
}
|
|
|
|
func TestCommitteeAssignment_multipleKeys_OK(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
genesis := b.NewGenesisBlock([]byte{})
|
|
if err := db.SaveBlock(genesis); err != nil {
|
|
t.Fatalf("Could not save genesis block: %v", err)
|
|
}
|
|
state, err := genesisState(params.BeaconConfig().DepositsForChainStart)
|
|
if err != nil {
|
|
t.Fatalf("Could not setup genesis state: %v", err)
|
|
}
|
|
if err := db.UpdateChainHead(ctx, genesis, state); err != nil {
|
|
t.Fatalf("Could not save genesis state: %v", err)
|
|
}
|
|
var wg sync.WaitGroup
|
|
numOfValidators := int(params.BeaconConfig().DepositsForChainStart)
|
|
errs := make(chan error, numOfValidators)
|
|
for i := 0; i < numOfValidators; i++ {
|
|
pubKeyBuf := make([]byte, params.BeaconConfig().BLSPubkeyLength)
|
|
copy(pubKeyBuf[:], []byte(strconv.Itoa(i)))
|
|
wg.Add(1)
|
|
go func(index int) {
|
|
errs <- db.SaveValidatorIndexBatch(pubKeyBuf, index)
|
|
wg.Done()
|
|
}(i)
|
|
}
|
|
wg.Wait()
|
|
close(errs)
|
|
for err := range errs {
|
|
if err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
}
|
|
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
}
|
|
|
|
pubKeyBuf0 := make([]byte, params.BeaconConfig().BLSPubkeyLength)
|
|
copy(pubKeyBuf0[:], []byte(strconv.Itoa(0)))
|
|
pubKeyBuf1 := make([]byte, params.BeaconConfig().BLSPubkeyLength)
|
|
copy(pubKeyBuf1[:], []byte(strconv.Itoa(1)))
|
|
// Test the first validator in registry.
|
|
req := &pb.CommitteeAssignmentsRequest{
|
|
PublicKeys: [][]byte{pubKeyBuf0, pubKeyBuf1},
|
|
EpochStart: params.BeaconConfig().GenesisSlot,
|
|
}
|
|
res, err := vs.CommitteeAssignment(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not call epoch committee assignment %v", err)
|
|
}
|
|
|
|
if len(res.Assignment) != 2 {
|
|
t.Fatalf("expected 2 assignments but got %d", len(res.Assignment))
|
|
}
|
|
}
|
|
|
|
func TestValidatorStatus_PendingActive(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
// Pending active because activation epoch is still defaulted at far future slot.
|
|
if err := db.SaveState(ctx, &pbp2p.BeaconState{ValidatorRegistry: []*pbp2p.Validator{
|
|
{ActivationEpoch: params.BeaconConfig().FarFutureEpoch, Pubkey: pubKey},
|
|
}}); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey,
|
|
ProofOfPossession: []byte("hi"),
|
|
WithdrawalCredentialsHash32: []byte("hey"),
|
|
}
|
|
depData, err := helpers.EncodeDepositData(depositInput, params.BeaconConfig().MaxDepositAmount, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deposit := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(ctx, deposit, big.NewInt(0))
|
|
|
|
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
powChainService: &mockPOWChainService{
|
|
blockTimeByHeight: map[int]uint64{
|
|
0: uint64(height),
|
|
},
|
|
},
|
|
}
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
resp, err := vs.ValidatorStatus(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not get validator status %v", err)
|
|
}
|
|
if resp.Status != pb.ValidatorStatus_PENDING_ACTIVE {
|
|
t.Errorf("Wanted %v, got %v", pb.ValidatorStatus_PENDING_ACTIVE, resp.Status)
|
|
}
|
|
}
|
|
|
|
func TestValidatorStatus_Active(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey,
|
|
ProofOfPossession: []byte("hi"),
|
|
WithdrawalCredentialsHash32: []byte("hey"),
|
|
}
|
|
depData, err := helpers.EncodeDepositData(depositInput, params.BeaconConfig().MaxDepositAmount, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deposit := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(ctx, deposit, big.NewInt(0))
|
|
|
|
// Active because activation epoch <= current epoch < exit epoch.
|
|
activeEpoch := helpers.EntryExitEffectEpoch(params.BeaconConfig().GenesisEpoch)
|
|
if err := db.SaveState(ctx, &pbp2p.BeaconState{
|
|
GenesisTime: uint64(time.Unix(0, 0).Unix()),
|
|
Slot: params.BeaconConfig().GenesisSlot + 10000,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
ActivationEpoch: activeEpoch,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
Pubkey: pubKey},
|
|
}}); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
|
|
timestamp := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
powChainService: &mockPOWChainService{
|
|
blockTimeByHeight: map[int]uint64{
|
|
int(params.BeaconConfig().Eth1FollowDistance): uint64(timestamp),
|
|
},
|
|
},
|
|
}
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
resp, err := vs.ValidatorStatus(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not get validator status %v", err)
|
|
}
|
|
|
|
expected := &pb.ValidatorStatusResponse{
|
|
Status: pb.ValidatorStatus_ACTIVE,
|
|
ActivationEpoch: 5,
|
|
DepositInclusionSlot: 3413,
|
|
}
|
|
if !proto.Equal(resp, expected) {
|
|
t.Errorf("Wanted %v, got %v", expected, resp)
|
|
}
|
|
}
|
|
|
|
func TestValidatorStatus_InitiatedExit(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
// Initiated exit because validator status flag = Validator_INITIATED_EXIT.
|
|
if err := db.SaveState(ctx, &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot + 10000,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
StatusFlags: pbp2p.Validator_INITIATED_EXIT,
|
|
Pubkey: pubKey},
|
|
}}); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey,
|
|
ProofOfPossession: []byte("hi"),
|
|
WithdrawalCredentialsHash32: []byte("hey"),
|
|
}
|
|
depData, err := helpers.EncodeDepositData(depositInput, params.BeaconConfig().MaxDepositAmount, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deposit := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(ctx, deposit, big.NewInt(0))
|
|
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
powChainService: &mockPOWChainService{
|
|
blockTimeByHeight: map[int]uint64{
|
|
0: uint64(height),
|
|
},
|
|
},
|
|
}
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
resp, err := vs.ValidatorStatus(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not get validator status %v", err)
|
|
}
|
|
if resp.Status != pb.ValidatorStatus_INITIATED_EXIT {
|
|
t.Errorf("Wanted %v, got %v", pb.ValidatorStatus_INITIATED_EXIT, resp.Status)
|
|
}
|
|
}
|
|
|
|
func TestValidatorStatus_Withdrawable(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
// Withdrawable exit because validator status flag = Validator_WITHDRAWABLE.
|
|
if err := db.SaveState(ctx, &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot + 10000,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
StatusFlags: pbp2p.Validator_WITHDRAWABLE,
|
|
Pubkey: pubKey},
|
|
}}); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey,
|
|
ProofOfPossession: []byte("hi"),
|
|
WithdrawalCredentialsHash32: []byte("hey"),
|
|
}
|
|
depData, err := helpers.EncodeDepositData(depositInput, params.BeaconConfig().MaxDepositAmount, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deposit := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(ctx, deposit, big.NewInt(0))
|
|
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
powChainService: &mockPOWChainService{
|
|
blockTimeByHeight: map[int]uint64{
|
|
0: uint64(height),
|
|
},
|
|
},
|
|
}
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
resp, err := vs.ValidatorStatus(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not get validator status %v", err)
|
|
}
|
|
if resp.Status != pb.ValidatorStatus_WITHDRAWABLE {
|
|
t.Errorf("Wanted %v, got %v", pb.ValidatorStatus_WITHDRAWABLE, resp.Status)
|
|
}
|
|
}
|
|
|
|
func TestValidatorStatus_ExitedSlashed(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
// Exit slashed because exit epoch and slashed epoch are =< current epoch.
|
|
if err := db.SaveState(ctx, &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot + 10000,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
Pubkey: pubKey},
|
|
}}); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey,
|
|
ProofOfPossession: []byte("hi"),
|
|
WithdrawalCredentialsHash32: []byte("hey"),
|
|
}
|
|
depData, err := helpers.EncodeDepositData(depositInput, params.BeaconConfig().MaxDepositAmount, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deposit := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(ctx, deposit, big.NewInt(0))
|
|
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
powChainService: &mockPOWChainService{
|
|
blockTimeByHeight: map[int]uint64{
|
|
0: uint64(height),
|
|
},
|
|
},
|
|
}
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
resp, err := vs.ValidatorStatus(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not get validator status %v", err)
|
|
}
|
|
if resp.Status != pb.ValidatorStatus_EXITED_SLASHED {
|
|
t.Errorf("Wanted %v, got %v", pb.ValidatorStatus_EXITED_SLASHED, resp.Status)
|
|
}
|
|
}
|
|
|
|
func TestValidatorStatus_Exited(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
// Exit because only exit epoch is =< current epoch.
|
|
if err := db.SaveState(ctx, &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot + 10000,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
Pubkey: pubKey,
|
|
SlashedEpoch: params.BeaconConfig().FarFutureEpoch},
|
|
}}); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey,
|
|
ProofOfPossession: []byte("hi"),
|
|
WithdrawalCredentialsHash32: []byte("hey"),
|
|
}
|
|
depData, err := helpers.EncodeDepositData(depositInput, params.BeaconConfig().MaxDepositAmount, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deposit := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(ctx, deposit, big.NewInt(0))
|
|
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
powChainService: &mockPOWChainService{
|
|
blockTimeByHeight: map[int]uint64{
|
|
0: uint64(height),
|
|
},
|
|
},
|
|
}
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
resp, err := vs.ValidatorStatus(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not get validator status %v", err)
|
|
}
|
|
if resp.Status != pb.ValidatorStatus_EXITED {
|
|
t.Errorf("Wanted %v, got %v", pb.ValidatorStatus_EXITED, resp.Status)
|
|
}
|
|
}
|
|
|
|
func TestValidatorStatus_UnknownStatus(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKey := []byte{'A'}
|
|
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
if err := db.SaveState(ctx, &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
ActivationEpoch: params.BeaconConfig().GenesisSlot,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
Pubkey: pubKey},
|
|
}}); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
|
|
depositInput := &pbp2p.DepositInput{
|
|
Pubkey: pubKey,
|
|
ProofOfPossession: []byte("hi"),
|
|
WithdrawalCredentialsHash32: []byte("hey"),
|
|
}
|
|
depData, err := helpers.EncodeDepositData(depositInput, params.BeaconConfig().MaxDepositAmount, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deposit := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(ctx, deposit, big.NewInt(0))
|
|
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
powChainService: &mockPOWChainService{
|
|
blockTimeByHeight: map[int]uint64{
|
|
0: uint64(height),
|
|
},
|
|
},
|
|
}
|
|
req := &pb.ValidatorIndexRequest{
|
|
PublicKey: pubKey,
|
|
}
|
|
resp, err := vs.ValidatorStatus(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Could not get validator status %v", err)
|
|
}
|
|
if resp.Status != pb.ValidatorStatus_UNKNOWN_STATUS {
|
|
t.Errorf("Wanted %v, got %v", pb.ValidatorStatus_UNKNOWN_STATUS, resp.Status)
|
|
}
|
|
}
|
|
|
|
func TestWaitForActivation_ContextClosed(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
beaconState := &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot,
|
|
ValidatorRegistry: []*pbp2p.Validator{},
|
|
}
|
|
if err := db.SaveState(ctx, beaconState); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
ctx: ctx,
|
|
chainService: newMockChainService(),
|
|
powChainService: &mockPOWChainService{},
|
|
canonicalStateChan: make(chan *pbp2p.BeaconState, 1),
|
|
}
|
|
req := &pb.ValidatorActivationRequest{
|
|
PublicKeys: [][]byte{[]byte("A")},
|
|
}
|
|
|
|
ctrl := gomock.NewController(t)
|
|
defer ctrl.Finish()
|
|
mockStream := internal.NewMockValidatorService_WaitForActivationServer(ctrl)
|
|
mockStream.EXPECT().Context().Return(context.Background())
|
|
mockStream.EXPECT().Send(gomock.Any()).Return(nil)
|
|
mockStream.EXPECT().Context().Return(context.Background())
|
|
exitRoutine := make(chan bool)
|
|
go func(tt *testing.T) {
|
|
want := "context closed"
|
|
if err := vs.WaitForActivation(req, mockStream); !strings.Contains(err.Error(), want) {
|
|
tt.Errorf("Could not call RPC method: %v", err)
|
|
}
|
|
<-exitRoutine
|
|
}(t)
|
|
cancel()
|
|
exitRoutine <- true
|
|
}
|
|
|
|
func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKeys := [][]byte{{'A'}, {'B'}}
|
|
if err := db.SaveValidatorIndex(pubKeys[0], 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
if err := db.SaveValidatorIndex(pubKeys[1], 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
beaconState := &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot + 4000,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
ActivationEpoch: params.BeaconConfig().GenesisEpoch,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
Pubkey: pubKeys[0]},
|
|
{
|
|
ActivationEpoch: params.BeaconConfig().GenesisEpoch,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
Pubkey: pubKeys[1]},
|
|
},
|
|
}
|
|
if err := db.SaveState(ctx, beaconState); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
depData, err := helpers.EncodeDepositData(&pbp2p.DepositInput{
|
|
Pubkey: []byte{'A'},
|
|
}, 10, 10)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
dep := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(context.Background(), dep, big.NewInt(10))
|
|
|
|
if err := db.SaveValidatorIndex(pubKeys[0], 0); err != nil {
|
|
t.Fatalf("could not save validator index: %v", err)
|
|
}
|
|
if err := db.SaveValidatorIndex(pubKeys[1], 1); err != nil {
|
|
t.Fatalf("could not save validator index: %v", err)
|
|
}
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
ctx: context.Background(),
|
|
chainService: newMockChainService(),
|
|
canonicalStateChan: make(chan *pbp2p.BeaconState, 1),
|
|
powChainService: &mockPOWChainService{},
|
|
}
|
|
req := &pb.ValidatorActivationRequest{
|
|
PublicKeys: pubKeys,
|
|
}
|
|
ctrl := gomock.NewController(t)
|
|
|
|
defer ctrl.Finish()
|
|
mockStream := internal.NewMockValidatorService_WaitForActivationServer(ctrl)
|
|
mockStream.EXPECT().Context().Return(context.Background())
|
|
mockStream.EXPECT().Send(
|
|
&pb.ValidatorActivationResponse{
|
|
Statuses: []*pb.ValidatorActivationResponse_Status{
|
|
{PublicKey: []byte{'A'},
|
|
Status: &pb.ValidatorStatusResponse{
|
|
Status: pb.ValidatorStatus_ACTIVE,
|
|
Eth1DepositBlockNumber: 10,
|
|
DepositInclusionSlot: 3413,
|
|
},
|
|
},
|
|
{PublicKey: []byte{'B'},
|
|
Status: &pb.ValidatorStatusResponse{
|
|
ActivationEpoch: params.BeaconConfig().FarFutureEpoch - params.BeaconConfig().GenesisEpoch,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
).Return(nil)
|
|
|
|
if err := vs.WaitForActivation(req, mockStream); err != nil {
|
|
t.Fatalf("Could not setup wait for activation stream: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestMultipleValidatorStatus_OK(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
ctx := context.Background()
|
|
|
|
pubKeys := [][]byte{{'A'}, {'B'}, {'C'}}
|
|
if err := db.SaveValidatorIndex(pubKeys[0], 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
if err := db.SaveValidatorIndex(pubKeys[1], 0); err != nil {
|
|
t.Fatalf("Could not save validator index: %v", err)
|
|
}
|
|
|
|
beaconState := &pbp2p.BeaconState{
|
|
Slot: params.BeaconConfig().GenesisSlot + 4000,
|
|
ValidatorRegistry: []*pbp2p.Validator{{
|
|
ActivationEpoch: params.BeaconConfig().GenesisEpoch,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
Pubkey: pubKeys[0]},
|
|
{
|
|
ActivationEpoch: params.BeaconConfig().GenesisEpoch,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
Pubkey: pubKeys[1]},
|
|
{
|
|
ActivationEpoch: params.BeaconConfig().GenesisEpoch,
|
|
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
|
|
Pubkey: pubKeys[2]},
|
|
},
|
|
}
|
|
if err := db.SaveState(ctx, beaconState); err != nil {
|
|
t.Fatalf("could not save state: %v", err)
|
|
}
|
|
depData, err := helpers.EncodeDepositData(&pbp2p.DepositInput{
|
|
Pubkey: []byte{'A'},
|
|
}, 10, 10)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
dep := &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(context.Background(), dep, big.NewInt(10))
|
|
depData, err = helpers.EncodeDepositData(&pbp2p.DepositInput{
|
|
Pubkey: []byte{'C'},
|
|
}, 10, 10)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
dep = &pbp2p.Deposit{
|
|
DepositData: depData,
|
|
}
|
|
db.InsertDeposit(context.Background(), dep, big.NewInt(15))
|
|
|
|
if err := db.SaveValidatorIndex(pubKeys[0], 0); err != nil {
|
|
t.Fatalf("could not save validator index: %v", err)
|
|
}
|
|
if err := db.SaveValidatorIndex(pubKeys[1], 1); err != nil {
|
|
t.Fatalf("could not save validator index: %v", err)
|
|
}
|
|
if err := db.SaveValidatorIndex(pubKeys[2], 2); err != nil {
|
|
t.Fatalf("could not save validator index: %v", err)
|
|
}
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
ctx: context.Background(),
|
|
chainService: newMockChainService(),
|
|
canonicalStateChan: make(chan *pbp2p.BeaconState, 1),
|
|
powChainService: &mockPOWChainService{},
|
|
}
|
|
activeExists, response, err := vs.MultipleValidatorStatus(context.Background(), pubKeys)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !activeExists {
|
|
t.Fatal("No activated validator exists when there was supposed to be 2")
|
|
}
|
|
if response[0].Status.Status != pb.ValidatorStatus_ACTIVE {
|
|
t.Errorf("Validator with pubkey %#x is not activated and instead has this status: %s",
|
|
response[0].PublicKey, response[0].Status.Status.String())
|
|
}
|
|
|
|
if response[1].Status.Status == pb.ValidatorStatus_ACTIVE {
|
|
t.Errorf("Validator with pubkey %#x was activated when not supposed to",
|
|
response[1].PublicKey)
|
|
}
|
|
|
|
if response[2].Status.Status != pb.ValidatorStatus_ACTIVE {
|
|
t.Errorf("Validator with pubkey %#x is not activated and instead has this status: %s",
|
|
response[2].PublicKey, response[2].Status.Status.String())
|
|
}
|
|
}
|
|
|
|
func TestFilterActivePublicKeys(t *testing.T) {
|
|
currentEpoch := uint64(15)
|
|
beaconState := &pbp2p.BeaconState{
|
|
Slot: helpers.StartSlot(currentEpoch),
|
|
ValidatorRegistry: []*pbp2p.Validator{
|
|
// Active validiators in our request
|
|
{
|
|
Pubkey: []byte("pk1"),
|
|
ActivationEpoch: currentEpoch - 1,
|
|
ExitEpoch: math.MaxUint64,
|
|
},
|
|
// Inactive validators in our request
|
|
{
|
|
Pubkey: []byte("pk2"),
|
|
ActivationEpoch: currentEpoch - 2,
|
|
ExitEpoch: currentEpoch - 1,
|
|
},
|
|
// Other active validators in the registry
|
|
{
|
|
Pubkey: []byte("pk3"),
|
|
ActivationEpoch: 0,
|
|
ExitEpoch: math.MaxUint64,
|
|
},
|
|
},
|
|
}
|
|
|
|
vs := &ValidatorServer{}
|
|
|
|
activeKeys := vs.filterActivePublicKeys(
|
|
beaconState,
|
|
[][]byte{
|
|
[]byte("pk1"),
|
|
[]byte("pk2"),
|
|
},
|
|
)
|
|
|
|
if len(activeKeys) != 1 || !bytes.Equal(activeKeys[0], []byte("pk1")) {
|
|
t.Error("Wrong active keys returned")
|
|
}
|
|
}
|
|
|
|
func TestAddNonActivePublicKeysAssignmentStatus(t *testing.T) {
|
|
db := internal.SetupDB(t)
|
|
defer internal.TeardownDB(t, db)
|
|
currentEpoch := uint64(15)
|
|
beaconState := &pbp2p.BeaconState{
|
|
Slot: helpers.StartSlot(currentEpoch),
|
|
ValidatorRegistry: []*pbp2p.Validator{
|
|
// Active validiators in our request
|
|
{
|
|
Pubkey: []byte("pk1"),
|
|
ActivationEpoch: currentEpoch - 1,
|
|
ExitEpoch: math.MaxUint64,
|
|
},
|
|
// Inactive validators in our request
|
|
{
|
|
Pubkey: []byte("pk2"),
|
|
ActivationEpoch: currentEpoch - 2,
|
|
ExitEpoch: currentEpoch - 1,
|
|
},
|
|
// Other active validators in the registry
|
|
{
|
|
Pubkey: []byte("pk3"),
|
|
ActivationEpoch: 0,
|
|
ExitEpoch: math.MaxUint64,
|
|
},
|
|
},
|
|
}
|
|
if err := db.SaveState(context.Background(), beaconState); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
vs := &ValidatorServer{
|
|
beaconDB: db,
|
|
}
|
|
var assignments []*pb.CommitteeAssignmentResponse_CommitteeAssignment
|
|
assignments = vs.addNonActivePublicKeysAssignmentStatus(beaconState,
|
|
[][]byte{
|
|
[]byte("pk1"),
|
|
[]byte("pk4"),
|
|
}, assignments)
|
|
if len(assignments) != 1 || assignments[0].Status != pb.ValidatorStatus_UNKNOWN_STATUS || !bytes.Equal(assignments[0].PublicKey, []byte("pk4")) {
|
|
t.Errorf("Unknown public key status wasn't returned: %v", assignments)
|
|
}
|
|
}
|