mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-23 11:57:18 +00:00
918129cf36
* refactor initialization to blocking startup method * require genesisSetter in blockchain, fix tests * work-around gazelle weirdness * fix dep gazelle ignores * only call SetGenesis once * fix typo * validator test setup and fix to return right error * move waitForChainStart to Start * wire up sync Service.genesisWaiter * fix p2p genesisWaiter plumbing * remove extra clock type, integrate into genesis and rename * use time.Now when no Nower is specified * remove unused ClockSetter * simplify rpc context checking * fix typo * use clock everywhere in sync; [32]byte val root * don't use DeepEqual to compare [32]byte and []byte * don't use clock in init sync, not wired up yet * use clock waiter in blockchain as well * use cancelable contexts in tests with goroutines * missed a reference to WithClockSetter * Update beacon-chain/startup/genesis.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Update beacon-chain/blockchain/service_test.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * more clear docs * doc for NewClock * move clock typedef to more logical file name * adding documentation * gaz * fixes for capella * reducing test raciness * fix races in committee cache tests * lint * add tests on Duration slot math helper * startup package test coverage * fix bad merge * set non-zero genesis time in tests that call Start * happy deepsource, happy me-epsource * replace Synced event with channel * remove unused error * remove accidental wip commit * gaz! * remove unused event constants * remove sync statefeed subscription to fix deadlock * remove state notifier * fix build --------- Co-authored-by: Kasey Kirkham <kasey@users.noreply.github.com> Co-authored-by: Radosław Kapka <rkapka@wp.pl> Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com> Co-authored-by: nisdas <nishdas93@gmail.com>
279 lines
9.5 KiB
Go
279 lines
9.5 KiB
Go
//go:build go1.18
|
|
|
|
package sync
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
pubsub "github.com/libp2p/go-libp2p-pubsub"
|
|
pb "github.com/libp2p/go-libp2p-pubsub/pb"
|
|
"github.com/libp2p/go-libp2p/core/peer"
|
|
gcache "github.com/patrickmn/go-cache"
|
|
mock "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing"
|
|
"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
|
|
"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/signing"
|
|
dbtest "github.com/prysmaticlabs/prysm/v4/beacon-chain/db/testing"
|
|
doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
|
|
"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p"
|
|
p2ptest "github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/testing"
|
|
"github.com/prysmaticlabs/prysm/v4/beacon-chain/startup"
|
|
"github.com/prysmaticlabs/prysm/v4/beacon-chain/state/stategen"
|
|
mockSync "github.com/prysmaticlabs/prysm/v4/beacon-chain/sync/initial-sync/testing"
|
|
lruwrpr "github.com/prysmaticlabs/prysm/v4/cache/lru"
|
|
"github.com/prysmaticlabs/prysm/v4/config/params"
|
|
ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
|
|
"github.com/prysmaticlabs/prysm/v4/testing/assert"
|
|
"github.com/prysmaticlabs/prysm/v4/testing/require"
|
|
"github.com/prysmaticlabs/prysm/v4/testing/util"
|
|
)
|
|
|
|
func FuzzValidateBeaconBlockPubSub_Phase0(f *testing.F) {
|
|
db := dbtest.SetupDB(f)
|
|
p := p2ptest.NewFuzzTestP2P()
|
|
ctx := context.Background()
|
|
beaconState, privKeys := util.DeterministicGenesisState(f, 100)
|
|
parentBlock := util.NewBeaconBlock()
|
|
util.SaveBlock(f, ctx, db, parentBlock)
|
|
bRoot, err := parentBlock.Block.HashTreeRoot()
|
|
require.NoError(f, err)
|
|
require.NoError(f, db.SaveState(ctx, beaconState, bRoot))
|
|
require.NoError(f, db.SaveStateSummary(ctx, ðpb.StateSummary{Root: bRoot[:]}))
|
|
copied := beaconState.Copy()
|
|
require.NoError(f, copied.SetSlot(1))
|
|
proposerIdx, err := helpers.BeaconProposerIndex(ctx, copied)
|
|
require.NoError(f, err)
|
|
msg := util.NewBeaconBlock()
|
|
msg.Block.ParentRoot = bRoot[:]
|
|
msg.Block.Slot = 1
|
|
msg.Block.ProposerIndex = proposerIdx
|
|
msg.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
|
|
require.NoError(f, err)
|
|
|
|
stateGen := stategen.New(db, doublylinkedtree.New())
|
|
chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0),
|
|
State: beaconState,
|
|
FinalizedCheckPoint: ðpb.Checkpoint{
|
|
Epoch: 0,
|
|
Root: make([]byte, 32),
|
|
},
|
|
DB: db,
|
|
}
|
|
r := &Service{
|
|
cfg: &config{
|
|
beaconDB: db,
|
|
p2p: p,
|
|
initialSync: &mockSync.Sync{IsSyncing: false},
|
|
chain: chainService,
|
|
clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
|
|
blockNotifier: chainService.BlockNotifier(),
|
|
stateGen: stateGen,
|
|
},
|
|
seenBlockCache: lruwrpr.New(10),
|
|
badBlockCache: lruwrpr.New(10),
|
|
slotToPendingBlocks: gcache.New(time.Second, 2*time.Second),
|
|
seenPendingBlocks: make(map[[32]byte]bool),
|
|
}
|
|
buf := new(bytes.Buffer)
|
|
_, err = p.Encoding().EncodeGossip(buf, msg)
|
|
require.NoError(f, err)
|
|
topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)]
|
|
digest, err := r.currentForkDigest()
|
|
assert.NoError(f, err)
|
|
topic = r.addDigestToTopic(topic, digest)
|
|
|
|
f.Add("junk", []byte("junk"), buf.Bytes(), []byte(topic))
|
|
f.Fuzz(func(t *testing.T, pid string, from, data, topic []byte) {
|
|
r.cfg.p2p = p2ptest.NewFuzzTestP2P()
|
|
r.rateLimiter = newRateLimiter(r.cfg.p2p)
|
|
cService := &mock.ChainService{
|
|
Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot*10000000), 0),
|
|
State: beaconState,
|
|
FinalizedCheckPoint: ðpb.Checkpoint{
|
|
Epoch: 0,
|
|
Root: make([]byte, 32),
|
|
},
|
|
DB: db,
|
|
}
|
|
r.cfg.chain = cService
|
|
r.cfg.blockNotifier = cService.BlockNotifier()
|
|
strTop := string(topic)
|
|
msg := &pubsub.Message{
|
|
Message: &pb.Message{
|
|
From: from,
|
|
Data: data,
|
|
Topic: &strTop,
|
|
},
|
|
}
|
|
_, err := r.validateBeaconBlockPubSub(ctx, peer.ID(pid), msg)
|
|
_ = err
|
|
})
|
|
}
|
|
|
|
func FuzzValidateBeaconBlockPubSub_Altair(f *testing.F) {
|
|
db := dbtest.SetupDB(f)
|
|
p := p2ptest.NewFuzzTestP2P()
|
|
ctx := context.Background()
|
|
beaconState, privKeys := util.DeterministicGenesisStateAltair(f, 100)
|
|
parentBlock := util.NewBeaconBlockAltair()
|
|
util.SaveBlock(f, ctx, db, parentBlock)
|
|
bRoot, err := parentBlock.Block.HashTreeRoot()
|
|
require.NoError(f, err)
|
|
require.NoError(f, db.SaveState(ctx, beaconState, bRoot))
|
|
require.NoError(f, db.SaveStateSummary(ctx, ðpb.StateSummary{Root: bRoot[:]}))
|
|
copied := beaconState.Copy()
|
|
require.NoError(f, copied.SetSlot(1))
|
|
proposerIdx, err := helpers.BeaconProposerIndex(ctx, copied)
|
|
require.NoError(f, err)
|
|
msg := util.NewBeaconBlock()
|
|
msg.Block.ParentRoot = bRoot[:]
|
|
msg.Block.Slot = 1
|
|
msg.Block.ProposerIndex = proposerIdx
|
|
msg.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
|
|
require.NoError(f, err)
|
|
|
|
stateGen := stategen.New(db, doublylinkedtree.New())
|
|
chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0),
|
|
State: beaconState,
|
|
FinalizedCheckPoint: ðpb.Checkpoint{
|
|
Epoch: 0,
|
|
Root: make([]byte, 32),
|
|
},
|
|
DB: db,
|
|
}
|
|
r := &Service{
|
|
cfg: &config{
|
|
beaconDB: db,
|
|
p2p: p,
|
|
initialSync: &mockSync.Sync{IsSyncing: false},
|
|
chain: chainService,
|
|
blockNotifier: chainService.BlockNotifier(),
|
|
stateGen: stateGen,
|
|
clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
|
|
},
|
|
seenBlockCache: lruwrpr.New(10),
|
|
badBlockCache: lruwrpr.New(10),
|
|
slotToPendingBlocks: gcache.New(time.Second, 2*time.Second),
|
|
seenPendingBlocks: make(map[[32]byte]bool),
|
|
}
|
|
buf := new(bytes.Buffer)
|
|
_, err = p.Encoding().EncodeGossip(buf, msg)
|
|
require.NoError(f, err)
|
|
topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)]
|
|
digest, err := r.currentForkDigest()
|
|
assert.NoError(f, err)
|
|
topic = r.addDigestToTopic(topic, digest)
|
|
|
|
f.Add("junk", []byte("junk"), buf.Bytes(), []byte(topic))
|
|
f.Fuzz(func(t *testing.T, pid string, from, data, topic []byte) {
|
|
r.cfg.p2p = p2ptest.NewFuzzTestP2P()
|
|
r.rateLimiter = newRateLimiter(r.cfg.p2p)
|
|
cService := &mock.ChainService{
|
|
Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot*10000000), 0),
|
|
State: beaconState,
|
|
FinalizedCheckPoint: ðpb.Checkpoint{
|
|
Epoch: 0,
|
|
Root: make([]byte, 32),
|
|
},
|
|
DB: db,
|
|
}
|
|
r.cfg.chain = cService
|
|
r.cfg.blockNotifier = cService.BlockNotifier()
|
|
strTop := string(topic)
|
|
msg := &pubsub.Message{
|
|
Message: &pb.Message{
|
|
From: from,
|
|
Data: data,
|
|
Topic: &strTop,
|
|
},
|
|
}
|
|
_, err := r.validateBeaconBlockPubSub(ctx, peer.ID(pid), msg)
|
|
_ = err
|
|
})
|
|
}
|
|
|
|
func FuzzValidateBeaconBlockPubSub_Bellatrix(f *testing.F) {
|
|
db := dbtest.SetupDB(f)
|
|
p := p2ptest.NewFuzzTestP2P()
|
|
ctx := context.Background()
|
|
beaconState, privKeys := util.DeterministicGenesisStateBellatrix(f, 100)
|
|
parentBlock := util.NewBeaconBlockBellatrix()
|
|
util.SaveBlock(f, ctx, db, parentBlock)
|
|
bRoot, err := parentBlock.Block.HashTreeRoot()
|
|
require.NoError(f, err)
|
|
require.NoError(f, db.SaveState(ctx, beaconState, bRoot))
|
|
require.NoError(f, db.SaveStateSummary(ctx, ðpb.StateSummary{Root: bRoot[:]}))
|
|
copied := beaconState.Copy()
|
|
require.NoError(f, copied.SetSlot(1))
|
|
proposerIdx, err := helpers.BeaconProposerIndex(ctx, copied)
|
|
require.NoError(f, err)
|
|
msg := util.NewBeaconBlock()
|
|
msg.Block.ParentRoot = bRoot[:]
|
|
msg.Block.Slot = 1
|
|
msg.Block.ProposerIndex = proposerIdx
|
|
msg.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
|
|
require.NoError(f, err)
|
|
|
|
stateGen := stategen.New(db, doublylinkedtree.New())
|
|
chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0),
|
|
State: beaconState,
|
|
FinalizedCheckPoint: ðpb.Checkpoint{
|
|
Epoch: 0,
|
|
Root: make([]byte, 32),
|
|
},
|
|
DB: db,
|
|
}
|
|
r := &Service{
|
|
cfg: &config{
|
|
beaconDB: db,
|
|
p2p: p,
|
|
initialSync: &mockSync.Sync{IsSyncing: false},
|
|
chain: chainService,
|
|
clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
|
|
blockNotifier: chainService.BlockNotifier(),
|
|
stateGen: stateGen,
|
|
},
|
|
seenBlockCache: lruwrpr.New(10),
|
|
badBlockCache: lruwrpr.New(10),
|
|
slotToPendingBlocks: gcache.New(time.Second, 2*time.Second),
|
|
seenPendingBlocks: make(map[[32]byte]bool),
|
|
}
|
|
buf := new(bytes.Buffer)
|
|
_, err = p.Encoding().EncodeGossip(buf, msg)
|
|
require.NoError(f, err)
|
|
topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)]
|
|
digest, err := r.currentForkDigest()
|
|
assert.NoError(f, err)
|
|
topic = r.addDigestToTopic(topic, digest)
|
|
|
|
f.Add("junk", []byte("junk"), buf.Bytes(), []byte(topic))
|
|
f.Fuzz(func(t *testing.T, pid string, from, data, topic []byte) {
|
|
r.cfg.p2p = p2ptest.NewFuzzTestP2P()
|
|
r.rateLimiter = newRateLimiter(r.cfg.p2p)
|
|
cService := &mock.ChainService{
|
|
Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot*10000000), 0),
|
|
State: beaconState,
|
|
FinalizedCheckPoint: ðpb.Checkpoint{
|
|
Epoch: 0,
|
|
Root: make([]byte, 32),
|
|
},
|
|
DB: db,
|
|
}
|
|
r.cfg.chain = cService
|
|
r.cfg.blockNotifier = cService.BlockNotifier()
|
|
strTop := string(topic)
|
|
msg := &pubsub.Message{
|
|
Message: &pb.Message{
|
|
From: from,
|
|
Data: data,
|
|
Topic: &strTop,
|
|
},
|
|
}
|
|
_, err := r.validateBeaconBlockPubSub(ctx, peer.ID(pid), msg)
|
|
_ = err
|
|
})
|
|
}
|