mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-25 04:47:18 +00:00
57f965df50
* first * add receive details * ensure most builds * add slasherkv changes * db iface additions * build * gaz * proper todo comment * terence comments * sig check * bad sig checks * proper lock issue * fix test * fix up tests
334 lines
12 KiB
Go
334 lines
12 KiB
Go
package slasher
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
types "github.com/prysmaticlabs/eth2-types"
|
|
"github.com/prysmaticlabs/prysm/async/event"
|
|
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
|
|
dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
|
|
slashertypes "github.com/prysmaticlabs/prysm/beacon-chain/slasher/types"
|
|
params2 "github.com/prysmaticlabs/prysm/config/params"
|
|
"github.com/prysmaticlabs/prysm/encoding/bytesutil"
|
|
ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
|
|
"github.com/prysmaticlabs/prysm/testing/assert"
|
|
"github.com/prysmaticlabs/prysm/testing/require"
|
|
"github.com/prysmaticlabs/prysm/testing/util"
|
|
logTest "github.com/sirupsen/logrus/hooks/test"
|
|
)
|
|
|
|
func TestSlasher_receiveAttestations_OK(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
s := &Service{
|
|
serviceCfg: &ServiceConfig{
|
|
IndexedAttestationsFeed: new(event.Feed),
|
|
StateNotifier: &mock.MockStateNotifier{},
|
|
},
|
|
attsQueue: newAttestationsQueue(),
|
|
}
|
|
indexedAttsChan := make(chan *ethpb.IndexedAttestation)
|
|
defer close(indexedAttsChan)
|
|
|
|
exitChan := make(chan struct{})
|
|
go func() {
|
|
s.receiveAttestations(ctx, indexedAttsChan)
|
|
exitChan <- struct{}{}
|
|
}()
|
|
firstIndices := []uint64{1, 2, 3}
|
|
secondIndices := []uint64{4, 5, 6}
|
|
att1 := createAttestationWrapper(t, 1, 2, firstIndices, nil)
|
|
att2 := createAttestationWrapper(t, 1, 2, secondIndices, nil)
|
|
indexedAttsChan <- att1.IndexedAttestation
|
|
indexedAttsChan <- att2.IndexedAttestation
|
|
cancel()
|
|
<-exitChan
|
|
wanted := []*slashertypes.IndexedAttestationWrapper{
|
|
att1,
|
|
att2,
|
|
}
|
|
require.DeepEqual(t, wanted, s.attsQueue.dequeue())
|
|
}
|
|
|
|
func TestService_pruneSlasherDataWithinSlidingWindow_AttestationsPruned(t *testing.T) {
|
|
ctx := context.Background()
|
|
params := DefaultParams()
|
|
params.historyLength = 4 // 4 epochs worth of history.
|
|
slasherDB := dbtest.SetupSlasherDB(t)
|
|
s := &Service{
|
|
serviceCfg: &ServiceConfig{
|
|
Database: slasherDB,
|
|
},
|
|
params: params,
|
|
}
|
|
|
|
// Setup attestations for 2 validators at each epoch for epochs 0, 1, 2, 3.
|
|
err := slasherDB.SaveAttestationRecordsForValidators(ctx, []*slashertypes.IndexedAttestationWrapper{
|
|
createAttestationWrapper(t, 0, 0, []uint64{0}, bytesutil.PadTo([]byte("0a"), 32)),
|
|
createAttestationWrapper(t, 0, 0, []uint64{1}, bytesutil.PadTo([]byte("0b"), 32)),
|
|
createAttestationWrapper(t, 0, 1, []uint64{0}, bytesutil.PadTo([]byte("1a"), 32)),
|
|
createAttestationWrapper(t, 0, 1, []uint64{1}, bytesutil.PadTo([]byte("1b"), 32)),
|
|
createAttestationWrapper(t, 0, 2, []uint64{0}, bytesutil.PadTo([]byte("2a"), 32)),
|
|
createAttestationWrapper(t, 0, 2, []uint64{1}, bytesutil.PadTo([]byte("2b"), 32)),
|
|
createAttestationWrapper(t, 0, 3, []uint64{0}, bytesutil.PadTo([]byte("3a"), 32)),
|
|
createAttestationWrapper(t, 0, 3, []uint64{1}, bytesutil.PadTo([]byte("3b"), 32)),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to prune and discover that all data is still intact.
|
|
currentEpoch := types.Epoch(3)
|
|
err = s.pruneSlasherDataWithinSlidingWindow(ctx, currentEpoch)
|
|
require.NoError(t, err)
|
|
|
|
epochs := []types.Epoch{0, 1, 2, 3}
|
|
for _, epoch := range epochs {
|
|
att, err := slasherDB.AttestationRecordForValidator(ctx, types.ValidatorIndex(0), epoch)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, att)
|
|
att, err = slasherDB.AttestationRecordForValidator(ctx, types.ValidatorIndex(1), epoch)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, att)
|
|
}
|
|
|
|
// Setup attestations for 2 validators at epoch 4.
|
|
err = slasherDB.SaveAttestationRecordsForValidators(ctx, []*slashertypes.IndexedAttestationWrapper{
|
|
createAttestationWrapper(t, 0, 4, []uint64{0}, bytesutil.PadTo([]byte("4a"), 32)),
|
|
createAttestationWrapper(t, 0, 4, []uint64{1}, bytesutil.PadTo([]byte("4b"), 32)),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to prune again by setting current epoch to 4.
|
|
currentEpoch = types.Epoch(4)
|
|
err = s.pruneSlasherDataWithinSlidingWindow(ctx, currentEpoch)
|
|
require.NoError(t, err)
|
|
|
|
// We should now only have data for epochs 1, 2, 3, 4. We should
|
|
// have pruned data from epoch 0.
|
|
att, err := slasherDB.AttestationRecordForValidator(ctx, types.ValidatorIndex(0), 0)
|
|
require.NoError(t, err)
|
|
require.Equal(t, true, att == nil)
|
|
att, err = slasherDB.AttestationRecordForValidator(ctx, types.ValidatorIndex(1), 0)
|
|
require.NoError(t, err)
|
|
require.Equal(t, true, att == nil)
|
|
|
|
epochs = []types.Epoch{1, 2, 3, 4}
|
|
for _, epoch := range epochs {
|
|
att, err := slasherDB.AttestationRecordForValidator(ctx, types.ValidatorIndex(0), epoch)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, att)
|
|
att, err = slasherDB.AttestationRecordForValidator(ctx, types.ValidatorIndex(1), epoch)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, att)
|
|
}
|
|
}
|
|
|
|
func TestService_pruneSlasherDataWithinSlidingWindow_ProposalsPruned(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
// Override beacon config to 1 slot per epoch for easier testing.
|
|
params2.SetupTestConfigCleanup(t)
|
|
config := params2.BeaconConfig()
|
|
config.SlotsPerEpoch = 1
|
|
params2.OverrideBeaconConfig(config)
|
|
|
|
params := DefaultParams()
|
|
params.historyLength = 4 // 4 epochs worth of history.
|
|
slasherDB := dbtest.SetupSlasherDB(t)
|
|
s := &Service{
|
|
serviceCfg: &ServiceConfig{
|
|
Database: slasherDB,
|
|
},
|
|
params: params,
|
|
}
|
|
|
|
// Setup block proposals for 2 validators at each epoch for epochs 0, 1, 2, 3.
|
|
err := slasherDB.SaveBlockProposals(ctx, []*slashertypes.SignedBlockHeaderWrapper{
|
|
createProposalWrapper(t, 0, 0, bytesutil.PadTo([]byte("0a"), 32)),
|
|
createProposalWrapper(t, 0, 1, bytesutil.PadTo([]byte("0b"), 32)),
|
|
createProposalWrapper(t, 1, 0, bytesutil.PadTo([]byte("1a"), 32)),
|
|
createProposalWrapper(t, 1, 1, bytesutil.PadTo([]byte("1b"), 32)),
|
|
createProposalWrapper(t, 2, 0, bytesutil.PadTo([]byte("2a"), 32)),
|
|
createProposalWrapper(t, 2, 1, bytesutil.PadTo([]byte("2b"), 32)),
|
|
createProposalWrapper(t, 3, 0, bytesutil.PadTo([]byte("3a"), 32)),
|
|
createProposalWrapper(t, 3, 1, bytesutil.PadTo([]byte("3b"), 32)),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to prune and discover that all data is still intact.
|
|
currentEpoch := types.Epoch(3)
|
|
err = s.pruneSlasherDataWithinSlidingWindow(ctx, currentEpoch)
|
|
require.NoError(t, err)
|
|
|
|
slots := []types.Slot{0, 1, 2, 3}
|
|
for _, slot := range slots {
|
|
blk, err := slasherDB.BlockProposalForValidator(ctx, types.ValidatorIndex(0), slot)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, blk)
|
|
blk, err = slasherDB.BlockProposalForValidator(ctx, types.ValidatorIndex(1), slot)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, blk)
|
|
}
|
|
|
|
// Setup block proposals for 2 validators at epoch 4.
|
|
err = slasherDB.SaveBlockProposals(ctx, []*slashertypes.SignedBlockHeaderWrapper{
|
|
createProposalWrapper(t, 4, 0, bytesutil.PadTo([]byte("4a"), 32)),
|
|
createProposalWrapper(t, 4, 1, bytesutil.PadTo([]byte("4b"), 32)),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// Attempt to prune again by setting current epoch to 4.
|
|
currentEpoch = types.Epoch(4)
|
|
err = s.pruneSlasherDataWithinSlidingWindow(ctx, currentEpoch)
|
|
require.NoError(t, err)
|
|
|
|
// We should now only have data for epochs 1, 2, 3, 4. We should
|
|
// have pruned data from epoch 0.
|
|
blk, err := slasherDB.BlockProposalForValidator(ctx, types.ValidatorIndex(0), 0)
|
|
require.NoError(t, err)
|
|
require.Equal(t, true, blk == nil)
|
|
blk, err = slasherDB.BlockProposalForValidator(ctx, types.ValidatorIndex(1), 0)
|
|
require.NoError(t, err)
|
|
require.Equal(t, true, blk == nil)
|
|
|
|
slots = []types.Slot{1, 2, 3, 4}
|
|
for _, slot := range slots {
|
|
blk, err := slasherDB.BlockProposalForValidator(ctx, types.ValidatorIndex(0), slot)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, blk)
|
|
blk, err = slasherDB.BlockProposalForValidator(ctx, types.ValidatorIndex(1), slot)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, blk)
|
|
}
|
|
}
|
|
|
|
func TestSlasher_receiveAttestations_OnlyValidAttestations(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
s := &Service{
|
|
serviceCfg: &ServiceConfig{
|
|
IndexedAttestationsFeed: new(event.Feed),
|
|
StateNotifier: &mock.MockStateNotifier{},
|
|
},
|
|
attsQueue: newAttestationsQueue(),
|
|
}
|
|
indexedAttsChan := make(chan *ethpb.IndexedAttestation)
|
|
defer close(indexedAttsChan)
|
|
|
|
exitChan := make(chan struct{})
|
|
defer close(exitChan)
|
|
go func() {
|
|
s.receiveAttestations(ctx, indexedAttsChan)
|
|
exitChan <- struct{}{}
|
|
}()
|
|
firstIndices := []uint64{1, 2, 3}
|
|
secondIndices := []uint64{4, 5, 6}
|
|
// Add a valid attestation.
|
|
validAtt := createAttestationWrapper(t, 1, 2, firstIndices, nil)
|
|
indexedAttsChan <- validAtt.IndexedAttestation
|
|
// Send an invalid, bad attestation which will not
|
|
// pass integrity checks at it has invalid attestation data.
|
|
indexedAttsChan <- ðpb.IndexedAttestation{
|
|
AttestingIndices: secondIndices,
|
|
}
|
|
cancel()
|
|
<-exitChan
|
|
// Expect only a single, valid attestation was added to the queue.
|
|
require.Equal(t, 1, s.attsQueue.size())
|
|
wanted := []*slashertypes.IndexedAttestationWrapper{
|
|
validAtt,
|
|
}
|
|
require.DeepEqual(t, wanted, s.attsQueue.dequeue())
|
|
}
|
|
|
|
func TestSlasher_receiveBlocks_OK(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
s := &Service{
|
|
serviceCfg: &ServiceConfig{
|
|
BeaconBlockHeadersFeed: new(event.Feed),
|
|
StateNotifier: &mock.MockStateNotifier{},
|
|
},
|
|
blksQueue: newBlocksQueue(),
|
|
}
|
|
beaconBlockHeadersChan := make(chan *ethpb.SignedBeaconBlockHeader)
|
|
defer close(beaconBlockHeadersChan)
|
|
exitChan := make(chan struct{})
|
|
go func() {
|
|
s.receiveBlocks(ctx, beaconBlockHeadersChan)
|
|
exitChan <- struct{}{}
|
|
}()
|
|
|
|
block1 := createProposalWrapper(t, 0, 1, nil).SignedBeaconBlockHeader
|
|
block2 := createProposalWrapper(t, 0, 2, nil).SignedBeaconBlockHeader
|
|
beaconBlockHeadersChan <- block1
|
|
beaconBlockHeadersChan <- block2
|
|
cancel()
|
|
<-exitChan
|
|
wanted := []*slashertypes.SignedBlockHeaderWrapper{
|
|
createProposalWrapper(t, 0, block1.Header.ProposerIndex, nil),
|
|
createProposalWrapper(t, 0, block2.Header.ProposerIndex, nil),
|
|
}
|
|
require.DeepEqual(t, wanted, s.blksQueue.dequeue())
|
|
}
|
|
|
|
func TestService_processQueuedBlocks(t *testing.T) {
|
|
hook := logTest.NewGlobal()
|
|
slasherDB := dbtest.SetupSlasherDB(t)
|
|
|
|
beaconState, err := util.NewBeaconState()
|
|
require.NoError(t, err)
|
|
currentSlot := types.Slot(0)
|
|
require.NoError(t, beaconState.SetSlot(currentSlot))
|
|
mockChain := &mock.ChainService{
|
|
State: beaconState,
|
|
Slot: ¤tSlot,
|
|
}
|
|
|
|
s := &Service{
|
|
params: DefaultParams(),
|
|
serviceCfg: &ServiceConfig{
|
|
Database: slasherDB,
|
|
StateNotifier: &mock.MockStateNotifier{},
|
|
HeadStateFetcher: mockChain,
|
|
},
|
|
blksQueue: newBlocksQueue(),
|
|
}
|
|
s.blksQueue.extend([]*slashertypes.SignedBlockHeaderWrapper{
|
|
createProposalWrapper(t, 0, 1, nil),
|
|
})
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
tickerChan := make(chan types.Slot)
|
|
exitChan := make(chan struct{})
|
|
go func() {
|
|
s.processQueuedBlocks(ctx, tickerChan)
|
|
exitChan <- struct{}{}
|
|
}()
|
|
|
|
// Send a value over the ticker.
|
|
tickerChan <- 0
|
|
cancel()
|
|
<-exitChan
|
|
assert.LogsContain(t, hook, "New slot, processing queued")
|
|
}
|
|
|
|
func createProposalWrapper(t *testing.T, slot types.Slot, proposerIndex types.ValidatorIndex, signingRoot []byte) *slashertypes.SignedBlockHeaderWrapper {
|
|
header := ðpb.BeaconBlockHeader{
|
|
Slot: slot,
|
|
ProposerIndex: proposerIndex,
|
|
ParentRoot: params2.BeaconConfig().ZeroHash[:],
|
|
StateRoot: bytesutil.PadTo(signingRoot, 32),
|
|
BodyRoot: params2.BeaconConfig().ZeroHash[:],
|
|
}
|
|
signRoot, err := header.HashTreeRoot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
someSig := make([]byte, params2.BeaconConfig().BLSSignatureLength)
|
|
copy(someSig, "foobar")
|
|
return &slashertypes.SignedBlockHeaderWrapper{
|
|
SignedBeaconBlockHeader: ðpb.SignedBeaconBlockHeader{
|
|
Header: header,
|
|
Signature: someSig,
|
|
},
|
|
SigningRoot: signRoot,
|
|
}
|
|
}
|