prysm-pulse/beacon-chain/sync/validate_proposer_slashing_test.go
Nishant Das 36c9a5665d
Implement Proposer Slashing Handler (#3273)
* validate proposer slashing

* add commetn

* add handler

* add

* remove

* gaz
2019-08-22 20:01:56 +05:30

136 lines
3.9 KiB
Go

package sync
import (
"context"
"crypto/rand"
"testing"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
)
func setupValidProposerSlashing(t *testing.T, db db.Database) *ethpb.ProposerSlashing {
ctx := context.Background()
validators := make([]*ethpb.Validator, 100)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
Slashed: false,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
ActivationEpoch: 0,
}
}
validatorBalances := make([]uint64, len(validators))
for i := 0; i < len(validatorBalances); i++ {
validatorBalances[i] = params.BeaconConfig().MaxEffectiveBalance
}
currentSlot := uint64(0)
beaconState := &pb.BeaconState{
Validators: validators,
Slot: currentSlot,
Balances: validatorBalances,
Fork: &pb.Fork{
CurrentVersion: params.BeaconConfig().GenesisForkVersion,
PreviousVersion: params.BeaconConfig().GenesisForkVersion,
Epoch: 0,
},
Slashings: make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
}
domain := helpers.Domain(
beaconState,
helpers.CurrentEpoch(beaconState),
params.BeaconConfig().DomainBeaconProposer,
)
privKey, err := bls.RandKey(rand.Reader)
if err != nil {
t.Errorf("Could not generate random private key: %v", err)
}
header1 := &ethpb.BeaconBlockHeader{
Slot: 0,
StateRoot: []byte("A"),
}
signingRoot, err := ssz.SigningRoot(header1)
if err != nil {
t.Errorf("Could not get signing root of beacon block header: %v", err)
}
header1.Signature = privKey.Sign(signingRoot[:], domain).Marshal()[:]
header2 := &ethpb.BeaconBlockHeader{
Slot: 0,
StateRoot: []byte("B"),
}
signingRoot, err = ssz.SigningRoot(header2)
if err != nil {
t.Errorf("Could not get signing root of beacon block header: %v", err)
}
header2.Signature = privKey.Sign(signingRoot[:], domain).Marshal()[:]
slashing := &ethpb.ProposerSlashing{
ProposerIndex: 1,
Header_1: header1,
Header_2: header2,
}
beaconState.Validators[1].PublicKey = privKey.PublicKey().Marshal()[:]
b := make([]byte, 32)
if _, err := rand.Read(b); err != nil {
t.Fatal(err)
}
headBlockRoot := bytesutil.ToBytes32(b)
if err := db.SaveState(ctx, beaconState, headBlockRoot); err != nil {
t.Fatal(err)
}
if err := db.SaveHeadBlockRoot(ctx, headBlockRoot); err != nil {
t.Fatal(err)
}
return slashing
}
func TestValidateProposerSlashing_ValidSlashing(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
p2p := p2ptest.NewTestP2P(t)
ctx := context.Background()
slashing := setupValidProposerSlashing(t, db)
r := &RegularSync{
p2p: p2p,
db: db,
}
if !r.validateProposerSlashing(ctx, slashing, p2p) {
t.Error("Failed validation")
}
if !p2p.BroadcastCalled {
t.Error("Broadcast was not called")
}
// A second message with the same information should not be valid for processing or
// propagation.
p2p.BroadcastCalled = false
if r.validateProposerSlashing(ctx, slashing, p2p) {
t.Error("Passed validation when should have failed")
}
if p2p.BroadcastCalled {
t.Error("broadcast was called when it should not have been called")
}
}