AtHeartEngineer/prysm
1
0
Fork 0
mirror of https://github.com/OffchainLabs/prysm.git synced 2026-01-08 21:08:10 -05:00
Code Issues Packages Projects Releases Wiki Activity

Fix import shadowing of db package (#8158)

Browse Source 
Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
This commit is contained in:
Victor Farazdagi
2020-12-18 11:12:30 -08:00
committed by GitHub
parent ea88799585
commit d8c31b79df
19 changed files with 560 additions and 560 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
beacon-chain/blockchain/chain_info_norace_test.go
View File

@@ -11,9 +11,9 @@ import (
)
func TestHeadSlot_DataRace(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
s := &Service{
beaconDB: db,
beaconDB: beaconDB,
}
go func() {
require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
@@ -22,11 +22,11 @@ func TestHeadSlot_DataRace(t *testing.T) {
}
func TestHeadRoot_DataRace(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
s := &Service{
beaconDB: db,
beaconDB: beaconDB,
head: &head{root: [32]byte{'A'}},
stateGen: stategen.New(db),
stateGen: stategen.New(beaconDB),
}
go func() {
require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
@@ -36,11 +36,11 @@ func TestHeadRoot_DataRace(t *testing.T) {
}
func TestHeadBlock_DataRace(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
s := &Service{
beaconDB: db,
beaconDB: beaconDB,
head: &head{block: &ethpb.SignedBeaconBlock{}},
stateGen: stategen.New(db),
stateGen: stategen.New(beaconDB),
}
go func() {
require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
@@ -50,10 +50,10 @@ func TestHeadBlock_DataRace(t *testing.T) {
}
func TestHeadState_DataRace(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
s := &Service{
beaconDB: db,
stateGen: stategen.New(db),
beaconDB: beaconDB,
stateGen: stategen.New(beaconDB),
}
go func() {
require.NoError(t, s.saveHead(context.Background(), [32]byte{}))

54
beacon-chain/blockchain/chain_info_test.go
View File

@@ -25,44 +25,44 @@ var _ TimeFetcher = (*Service)(nil)
var _ ForkFetcher = (*Service)(nil)
func TestFinalizedCheckpt_Nil(t *testing.T) {
db := testDB.SetupDB(t)
c := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
c := setupBeaconChain(t, beaconDB)
assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], c.FinalizedCheckpt().Root, "Incorrect pre chain start value")
}
func TestHeadRoot_Nil(t *testing.T) {
db := testDB.SetupDB(t)
c := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
c := setupBeaconChain(t, beaconDB)
headRoot, err := c.HeadRoot(context.Background())
require.NoError(t, err)
assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
}
func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
c := setupBeaconChain(t, db)
c := setupBeaconChain(t, beaconDB)
c.finalizedCheckpt = cp
assert.Equal(t, cp.Epoch, c.FinalizedCheckpt().Epoch, "Unexpected finalized epoch")
}
func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
genesisRoot := [32]byte{'A'}
cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
c := setupBeaconChain(t, db)
c := setupBeaconChain(t, beaconDB)
c.finalizedCheckpt = cp
c.genesisRoot = genesisRoot
assert.DeepEqual(t, c.genesisRoot[:], c.FinalizedCheckpt().Root)
}
func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
c := setupBeaconChain(t, db)
c := setupBeaconChain(t, beaconDB)
assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
c.justifiedCheckpt = cp
@@ -70,9 +70,9 @@ func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
}
func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
c := setupBeaconChain(t, db)
c := setupBeaconChain(t, beaconDB)
genesisRoot := [32]byte{'B'}
cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
c.justifiedCheckpt = cp
@@ -81,21 +81,21 @@ func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
}
func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
c := setupBeaconChain(t, db)
c := setupBeaconChain(t, beaconDB)
assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
c.prevJustifiedCheckpt = cp
assert.Equal(t, cp.Epoch, c.PreviousJustifiedCheckpt().Epoch, "Unexpected previous justified epoch")
}
func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
genesisRoot := [32]byte{'C'}
cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
c := setupBeaconChain(t, db)
c := setupBeaconChain(t, beaconDB)
c.prevJustifiedCheckpt = cp
c.genesisRoot = genesisRoot
assert.DeepEqual(t, c.genesisRoot[:], c.PreviousJustifiedCheckpt().Root)
@@ -118,15 +118,15 @@ func TestHeadRoot_CanRetrieve(t *testing.T) {
}
func TestHeadRoot_UseDB(t *testing.T) {
db := testDB.SetupDB(t)
c := &Service{beaconDB: db}
beaconDB := testDB.SetupDB(t)
c := &Service{beaconDB: beaconDB}
c.head = &head{root: params.BeaconConfig().ZeroHash}
b := testutil.NewBeaconBlock()
br, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), b))
require.NoError(t, db.SaveStateSummary(context.Background(), &pb.StateSummary{Root: br[:]}))
require.NoError(t, db.SaveHeadBlockRoot(context.Background(), br))
require.NoError(t, beaconDB.SaveBlock(context.Background(), b))
require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Root: br[:]}))
require.NoError(t, beaconDB.SaveHeadBlockRoot(context.Background(), br))
r, err := c.HeadRoot(context.Background())
require.NoError(t, err)
assert.Equal(t, br, bytesutil.ToBytes32(r))
@@ -195,8 +195,8 @@ func TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
}
func TestHeadETH1Data_Nil(t *testing.T) {
db := testDB.SetupDB(t)
c := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
c := setupBeaconChain(t, beaconDB)
assert.DeepEqual(t, &ethpb.Eth1Data{}, c.HeadETH1Data(), "Incorrect pre chain start value")
}
@@ -213,15 +213,15 @@ func TestHeadETH1Data_CanRetrieve(t *testing.T) {
func TestIsCanonical_Ok(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
c := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
c := setupBeaconChain(t, beaconDB)
blk := testutil.NewBeaconBlock()
blk.Block.Slot = 0
root, err := blk.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, blk))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
require.NoError(t, beaconDB.SaveBlock(ctx, blk))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
can, err := c.IsCanonical(ctx, root)
require.NoError(t, err)
assert.Equal(t, true, can)

20
beacon-chain/blockchain/head_test.go
View File

@@ -15,8 +15,8 @@ import (
)
func TestSaveHead_Same(t *testing.T) {
db := testDB.SetupDB(t)
service := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
service := setupBeaconChain(t, beaconDB)
r := [32]byte{'A'}
service.head = &head{slot: 0, root: r}
@@ -28,8 +28,8 @@ func TestSaveHead_Same(t *testing.T) {
func TestSaveHead_Different(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
service := setupBeaconChain(t, beaconDB)
oldRoot := [32]byte{'A'}
service.head = &head{slot: 0, root: oldRoot}
@@ -61,8 +61,8 @@ func TestSaveHead_Different(t *testing.T) {
func TestSaveHead_Different_Reorg(t *testing.T) {
ctx := context.Background()
hook := logTest.NewGlobal()
db := testDB.SetupDB(t)
service := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
service := setupBeaconChain(t, beaconDB)
oldRoot := [32]byte{'A'}
service.head = &head{slot: 0, root: oldRoot}
@@ -95,8 +95,8 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
}
func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
db := testDB.SetupDB(t)
service := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
service := setupBeaconChain(t, beaconDB)
state, _ := testutil.DeterministicGenesisState(t, 100)
r := [32]byte{'a'}
@@ -107,8 +107,8 @@ func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
}
func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
db := testDB.SetupDB(t)
service := setupBeaconChain(t, db)
beaconDB := testDB.SetupDB(t)
service := setupBeaconChain(t, beaconDB)
b := testutil.NewBeaconBlock()
require.NoError(t, service.beaconDB.SaveBlock(context.Background(), b))

6
beacon-chain/blockchain/info_test.go
View File

@@ -20,17 +20,17 @@ func TestService_TreeHandler(t *testing.T) {
require.NoError(t, err)
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
headState := testutil.NewBeaconState()
require.NoError(t, headState.SetBalances([]uint64{params.BeaconConfig().GweiPerEth}))
cfg := &Config{
BeaconDB: db,
BeaconDB: beaconDB,
ForkChoiceStore: protoarray.New(
0, // justifiedEpoch
0, // finalizedEpoch
[32]byte{'a'},
),
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
s, err := NewService(ctx, cfg)
require.NoError(t, err)

70
beacon-chain/blockchain/process_attestation_test.go
View File

@@ -21,28 +21,28 @@ import (
func TestStore_OnAttestation(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{
BeaconDB: db,
BeaconDB: beaconDB,
ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
_, err = blockTree1(db, []byte{'g'})
_, err = blockTree1(beaconDB, []byte{'g'})
require.NoError(t, err)
BlkWithOutState := testutil.NewBeaconBlock()
BlkWithOutState.Block.Slot = 0
require.NoError(t, db.SaveBlock(ctx, BlkWithOutState))
require.NoError(t, beaconDB.SaveBlock(ctx, BlkWithOutState))
BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
require.NoError(t, err)
BlkWithStateBadAtt := testutil.NewBeaconBlock()
BlkWithStateBadAtt.Block.Slot = 1
require.NoError(t, db.SaveBlock(ctx, BlkWithStateBadAtt))
require.NoError(t, beaconDB.SaveBlock(ctx, BlkWithStateBadAtt))
BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
require.NoError(t, err)
@@ -52,7 +52,7 @@ func TestStore_OnAttestation(t *testing.T) {
BlkWithValidState := testutil.NewBeaconBlock()
BlkWithValidState.Block.Slot = 2
require.NoError(t, db.SaveBlock(ctx, BlkWithValidState))
require.NoError(t, beaconDB.SaveBlock(ctx, BlkWithValidState))
BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
require.NoError(t, err)
@@ -130,11 +130,11 @@ func TestStore_OnAttestation(t *testing.T) {
func TestStore_SaveCheckpointState(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{
BeaconDB: db,
StateGen: stategen.New(db),
BeaconDB: beaconDB,
StateGen: stategen.New(beaconDB),
}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -201,11 +201,11 @@ func TestStore_SaveCheckpointState(t *testing.T) {
func TestStore_UpdateCheckpointState(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{
BeaconDB: db,
StateGen: stategen.New(db),
BeaconDB: beaconDB,
StateGen: stategen.New(beaconDB),
}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -242,9 +242,9 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -254,9 +254,9 @@ func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -266,9 +266,9 @@ func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
func TestAttEpoch_NotMatch(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -279,9 +279,9 @@ func TestAttEpoch_NotMatch(t *testing.T) {
func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -295,9 +295,9 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -313,9 +313,9 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
func TestVerifyBeaconBlock_OK(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -331,9 +331,9 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -355,9 +355,9 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -379,9 +379,9 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -406,9 +406,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
func TestVerifyFinalizedConsistency_OK(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -433,9 +433,9 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)

116
beacon-chain/blockchain/process_block_test.go
View File

@@ -27,28 +27,28 @@ import (
func TestStore_OnBlock(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{
BeaconDB: db,
StateGen: stategen.New(db),
BeaconDB: beaconDB,
StateGen: stategen.New(beaconDB),
ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
st := testutil.NewBeaconState()
require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
roots, err := blockTree1(db, validGenesisRoot[:])
roots, err := blockTree1(beaconDB, validGenesisRoot[:])
require.NoError(t, err)
random := testutil.NewBeaconBlock()
random.Block.Slot = 1
random.Block.ParentRoot = validGenesisRoot[:]
assert.NoError(t, db.SaveBlock(ctx, random))
assert.NoError(t, beaconDB.SaveBlock(ctx, random))
randomParentRoot, err := random.Block.HashTreeRoot()
assert.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
@@ -122,18 +122,18 @@ func TestStore_OnBlock(t *testing.T) {
func TestStore_OnBlockBatch(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{
BeaconDB: db,
StateGen: stategen.New(db),
BeaconDB: beaconDB,
StateGen: stategen.New(beaconDB),
}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
service.finalizedCheckpt = &ethpb.Checkpoint{
@@ -165,7 +165,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
}
blks[0].Block.ParentRoot = gRoot[:]
require.NoError(t, db.SaveBlock(context.Background(), blks[0]))
require.NoError(t, beaconDB.SaveBlock(context.Background(), blks[0]))
require.NoError(t, service.stateGen.SaveState(ctx, blkRoots[0], firstState))
_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
require.NoError(t, err)
@@ -173,11 +173,11 @@ func TestStore_OnBlockBatch(t *testing.T) {
func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
params.UseMinimalConfig()
defer params.UseMainnetConfig()
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
service.genesisTime = time.Now()
@@ -207,11 +207,11 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
params.UseMinimalConfig()
defer params.UseMainnetConfig()
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
lastJustifiedBlk := testutil.NewBeaconBlock()
@@ -236,11 +236,11 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{
BeaconDB: db,
StateGen: stategen.New(db),
BeaconDB: beaconDB,
StateGen: stategen.New(beaconDB),
}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -250,7 +250,7 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
service.finalizedCheckpt = &ethpb.Checkpoint{
@@ -269,18 +269,18 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
func TestCachedPreState_CanGetFromDB(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{
BeaconDB: db,
StateGen: stategen.New(db),
BeaconDB: beaconDB,
StateGen: stategen.New(beaconDB),
}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
service.finalizedCheckpt = &ethpb.Checkpoint{
@@ -306,20 +306,20 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, StateGen: stategen.New(db)}
cfg := &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
signedBlock := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, signedBlock))
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlock))
r, err := signedBlock.Block.HashTreeRoot()
require.NoError(t, err)
service.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
st := testutil.NewBeaconState()
require.NoError(t, db.SaveState(ctx, st.Copy(), r))
require.NoError(t, beaconDB.SaveState(ctx, st.Copy(), r))
// Could update
s := testutil.NewBeaconState()
@@ -337,9 +337,9 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
@@ -347,13 +347,13 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
require.NoError(t, db.SaveBlock(ctx, genesis))
require.NoError(t, beaconDB.SaveBlock(ctx, genesis))
validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
st := testutil.NewBeaconState()
require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
roots, err := blockTree1(db, validGenesisRoot[:])
roots, err := blockTree1(beaconDB, validGenesisRoot[:])
require.NoError(t, err)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
@@ -374,9 +374,9 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
@@ -384,13 +384,13 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
require.NoError(t, db.SaveBlock(ctx, genesis))
require.NoError(t, beaconDB.SaveBlock(ctx, genesis))
validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
st := testutil.NewBeaconState()
require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
roots, err := blockTree1(db, validGenesisRoot[:])
roots, err := blockTree1(beaconDB, validGenesisRoot[:])
require.NoError(t, err)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
@@ -414,9 +414,9 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
@@ -425,7 +425,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
validGenesisRoot, err := genesis.Block.HashTreeRoot()
assert.NoError(t, err)
st := testutil.NewBeaconState()
@@ -466,7 +466,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
// B0 /- B5 - B7
// \- B3 - B4 - B6 - B8
// (B1, and B3 are all from the same slots)
func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
func blockTree1(beaconDB db.Database, genesisRoot []byte) ([][]byte, error) {
genesisRoot = bytesutil.PadTo(genesisRoot, 32)
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
@@ -530,20 +530,20 @@ func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
if err := beaconDB.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
return nil, errors.Wrap(err, "could not save state")
}
}
if err := db.SaveState(context.Background(), st.Copy(), r1); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), r1); err != nil {
return nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), r7); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), r7); err != nil {
return nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), r8); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), r8); err != nil {
return nil, err
}
return [][]byte{r0[:], r1[:], nil, r3[:], r4[:], r5[:], r6[:], r7[:], r8[:]}, nil
@@ -567,9 +567,9 @@ func TestAncestorByDB_CtxErr(t *testing.T) {
func TestAncestor_HandleSkipSlot(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -592,7 +592,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
require.NoError(t, db.SaveBlock(context.Background(), beaconBlock))
require.NoError(t, beaconDB.SaveBlock(context.Background(), beaconBlock))
}
// Slots 100 to 200 are skip slots. Requesting root at 150 will yield root at 100. The last physical block.
@@ -649,9 +649,9 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
func TestAncestor_CanUseDB(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
service, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -674,7 +674,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
require.NoError(t, db.SaveBlock(context.Background(), beaconBlock)) // Saves blocks to DB.
require.NoError(t, beaconDB.SaveBlock(context.Background(), beaconBlock)) // Saves blocks to DB.
}
require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), 200, r200, r200, [32]byte{}, 0, 0))
@@ -701,7 +701,7 @@ func TestEnsureRootNotZeroHashes(t *testing.T) {
}
func TestFinalizedImpliesNewJustified(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
type args struct {
cachedCheckPoint *ethpb.Checkpoint
@@ -742,7 +742,7 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
for _, test := range tests {
beaconState := testutil.NewBeaconState()
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(test.args.stateCheckPoint))
service, err := NewService(ctx, &Config{BeaconDB: db, StateGen: stategen.New(db), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
service, err := NewService(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
require.NoError(t, err)
service.justifiedCheckpt = test.args.cachedCheckPoint
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
@@ -776,21 +776,21 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
}
func TestVerifyBlkDescendant(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
r, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32)
r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, b1))
require.NoError(t, beaconDB.SaveBlock(ctx, b1))
type args struct {
parentRoot [32]byte
@@ -833,7 +833,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
},
}
for _, tt := range tests {
service, err := NewService(ctx, &Config{BeaconDB: db, StateGen: stategen.New(db), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
service, err := NewService(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
require.NoError(t, err)
service.finalizedCheckpt = &ethpb.Checkpoint{
Root: tt.args.finalizedRoot[:],
@@ -848,9 +848,9 @@ func TestVerifyBlkDescendant(t *testing.T) {
}
func TestUpdateJustifiedInitSync(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
cfg := &Config{BeaconDB: db}
cfg := &Config{BeaconDB: beaconDB}
service, err := NewService(ctx, cfg)
require.NoError(t, err)

4
beacon-chain/blockchain/receive_attestation_test.go
View File

@@ -14,9 +14,9 @@ import (
func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
helpers.ClearCache()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
chainService := setupBeaconChain(t, db)
chainService := setupBeaconChain(t, beaconDB)
chainService.genesisTime = time.Now()
e := helpers.MaxSlotBuffer/params.BeaconConfig().SlotsPerEpoch + 1

40
beacon-chain/blockchain/receive_block_test.go
View File

@@ -117,12 +117,12 @@ func TestService_ReceiveBlock(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
genesisBlockRoot := bytesutil.ToBytes32(nil)
require.NoError(t, db.SaveState(ctx, genesis, genesisBlockRoot))
require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
cfg := &Config{
BeaconDB: db,
BeaconDB: beaconDB,
ForkChoiceStore: protoarray.New(
0, // justifiedEpoch
0, // finalizedEpoch
@@ -131,7 +131,7 @@ func TestService_ReceiveBlock(t *testing.T) {
AttPool: attestations.NewPool(),
ExitPool: voluntaryexits.NewPool(),
StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
s, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -159,11 +159,11 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
genesis, keys := testutil.DeterministicGenesisState(t, 64)
b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
assert.NoError(t, err)
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
genesisBlockRoot := bytesutil.ToBytes32(nil)
require.NoError(t, db.SaveState(ctx, genesis, genesisBlockRoot))
require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
cfg := &Config{
BeaconDB: db,
BeaconDB: beaconDB,
ForkChoiceStore: protoarray.New(
0, // justifiedEpoch
0, // finalizedEpoch
@@ -172,7 +172,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
AttPool: attestations.NewPool(),
ExitPool: voluntaryexits.NewPool(),
StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
s, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -242,18 +242,18 @@ func TestService_ReceiveBlockInitialSync(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
genesisBlockRoot := bytesutil.ToBytes32(nil)
cfg := &Config{
BeaconDB: db,
BeaconDB: beaconDB,
ForkChoiceStore: protoarray.New(
0, // justifiedEpoch
0, // finalizedEpoch
genesisBlockRoot,
),
StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
s, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -323,18 +323,18 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
require.NoError(t, err)
cfg := &Config{
BeaconDB: db,
BeaconDB: beaconDB,
ForkChoiceStore: protoarray.New(
0, // justifiedEpoch
0, // finalizedEpoch
genesisBlockRoot,
),
StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
s, err := NewService(ctx, cfg)
require.NoError(t, err)
@@ -375,9 +375,9 @@ func TestService_HasInitSyncBlock(t *testing.T) {
}
func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
hook := logTest.NewGlobal()
s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db)})
s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
require.NoError(t, err)
st := params.BeaconConfig().SlotsPerEpoch * uint64(epochsSinceFinalitySaveHotStateDB)
s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
@@ -388,9 +388,9 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
}
func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
hook := logTest.NewGlobal()
s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db)})
s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
require.NoError(t, err)
s.finalizedCheckpt = &ethpb.Checkpoint{}
require.NoError(t, s.checkSaveHotStateDB(context.Background()))
@@ -401,9 +401,9 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
}
func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
hook := logTest.NewGlobal()
s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db)})
s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
require.NoError(t, err)
s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
s.genesisTime = time.Now()

4
beacon-chain/blockchain/service_norace_test.go
View File

@@ -16,9 +16,9 @@ func init() {
}
func TestChainService_SaveHead_DataRace(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
s := &Service{
beaconDB: db,
beaconDB: beaconDB,
}
go func() {
require.NoError(t, s.saveHead(context.Background(), [32]byte{}))

128
beacon-chain/blockchain/service_test.go
View File

@@ -123,21 +123,21 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
func TestChainStartStop_Initialized(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
chainService := setupBeaconChain(t, db)
chainService := setupBeaconChain(t, beaconDB)
genesisBlk := testutil.NewBeaconBlock()
blkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, genesisBlk))
require.NoError(t, beaconDB.SaveBlock(ctx, genesisBlk))
s := testutil.NewBeaconState()
require.NoError(t, s.SetSlot(1))
require.NoError(t, db.SaveState(ctx, s, blkRoot))
require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, blkRoot))
require.NoError(t, db.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
require.NoError(t, db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
// Test the start function.
chainService.Start()
@@ -152,18 +152,18 @@ func TestChainStartStop_Initialized(t *testing.T) {
func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
chainService := setupBeaconChain(t, db)
chainService := setupBeaconChain(t, beaconDB)
genesisBlk := testutil.NewBeaconBlock()
blkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, genesisBlk))
require.NoError(t, beaconDB.SaveBlock(ctx, genesisBlk))
s := testutil.NewBeaconState()
require.NoError(t, db.SaveState(ctx, s, blkRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, blkRoot))
require.NoError(t, db.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}))
require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}))
// Test the start function.
chainService.Start()
@@ -177,10 +177,10 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
func TestChainService_InitializeBeaconChain(t *testing.T) {
helpers.ClearCache()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
bc := setupBeaconChain(t, db)
bc := setupBeaconChain(t, beaconDB)
var err error
// Set up 10 deposits pre chain start for validators to register
@@ -220,20 +220,20 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
func TestChainService_CorrectGenesisRoots(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
chainService := setupBeaconChain(t, db)
chainService := setupBeaconChain(t, beaconDB)
genesisBlk := testutil.NewBeaconBlock()
blkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, genesisBlk))
require.NoError(t, beaconDB.SaveBlock(ctx, genesisBlk))
s := testutil.NewBeaconState()
require.NoError(t, s.SetSlot(0))
require.NoError(t, db.SaveState(ctx, s, blkRoot))
require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, blkRoot))
require.NoError(t, db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
// Test the start function.
chainService.Start()
@@ -246,14 +246,14 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
}
func TestChainService_InitializeChainInfo(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
genesis := testutil.NewBeaconBlock()
genesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, db.SaveBlock(ctx, genesis))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, genesis))
finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
headBlock := testutil.NewBeaconBlock()
@@ -264,11 +264,11 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
headRoot, err := headBlock.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, headState, headRoot))
require.NoError(t, db.SaveState(ctx, headState, genesisRoot))
require.NoError(t, db.SaveBlock(ctx, headBlock))
require.NoError(t, db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: helpers.SlotToEpoch(finalizedSlot), Root: headRoot[:]}))
c := &Service{beaconDB: db, stateGen: stategen.New(db)}
require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, headBlock))
require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: helpers.SlotToEpoch(finalizedSlot), Root: headRoot[:]}))
c := &Service{beaconDB: beaconDB, stateGen: stategen.New(beaconDB)}
require.NoError(t, c.initializeChainInfo(ctx))
headBlk, err := c.HeadBlock(ctx)
require.NoError(t, err)
@@ -286,14 +286,14 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
}
func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
genesis := testutil.NewBeaconBlock()
genesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, db.SaveBlock(ctx, genesis))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, genesis))
finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
headBlock := testutil.NewBeaconBlock()
@@ -304,10 +304,10 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
headRoot, err := headBlock.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, headState, headRoot))
require.NoError(t, db.SaveState(ctx, headState, genesisRoot))
require.NoError(t, db.SaveBlock(ctx, headBlock))
c := &Service{beaconDB: db, stateGen: stategen.New(db)}
require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, headBlock))
c := &Service{beaconDB: beaconDB, stateGen: stategen.New(beaconDB)}
require.NoError(t, c.initializeChainInfo(ctx))
s, err := c.HeadState(ctx)
require.NoError(t, err)
@@ -327,21 +327,21 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
hook := logTest.NewGlobal()
finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
genesisBlock := testutil.NewBeaconBlock()
genesisRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, db.SaveBlock(ctx, genesisBlock))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, genesisBlock))
finalizedBlock := testutil.NewBeaconBlock()
finalizedBlock.Block.Slot = finalizedSlot
finalizedBlock.Block.ParentRoot = genesisRoot[:]
finalizedRoot, err := finalizedBlock.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, finalizedBlock))
require.NoError(t, beaconDB.SaveBlock(ctx, finalizedBlock))
// Set head slot close to the finalization point, no head sync is triggered.
headBlock := testutil.NewBeaconBlock()
@@ -349,21 +349,21 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
headBlock.Block.ParentRoot = finalizedRoot[:]
headRoot, err := headBlock.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, headBlock))
require.NoError(t, beaconDB.SaveBlock(ctx, headBlock))
headState := testutil.NewBeaconState()
require.NoError(t, headState.SetSlot(headBlock.Block.Slot))
require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
require.NoError(t, db.SaveState(ctx, headState, genesisRoot))
require.NoError(t, db.SaveState(ctx, headState, finalizedRoot))
require.NoError(t, db.SaveState(ctx, headState, headRoot))
require.NoError(t, db.SaveHeadBlockRoot(ctx, headRoot))
require.NoError(t, db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, finalizedRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
Epoch: helpers.SlotToEpoch(finalizedBlock.Block.Slot),
Root: finalizedRoot[:],
}))
c := &Service{beaconDB: db, stateGen: stategen.New(db)}
c := &Service{beaconDB: beaconDB, stateGen: stategen.New(beaconDB)}
require.NoError(t, c.initializeChainInfo(ctx))
s, err := c.HeadState(ctx)
@@ -381,9 +381,9 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
headBlock.Block.ParentRoot = finalizedRoot[:]
headRoot, err = headBlock.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, headBlock))
require.NoError(t, db.SaveState(ctx, headState, headRoot))
require.NoError(t, db.SaveHeadBlockRoot(ctx, headRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, headBlock))
require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
hook.Reset()
require.NoError(t, c.initializeChainInfo(ctx))
@@ -398,11 +398,11 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
}
func TestChainService_SaveHeadNoDB(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &Service{
beaconDB: db,
stateGen: stategen.New(db),
beaconDB: beaconDB,
stateGen: stategen.New(beaconDB),
}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
@@ -421,11 +421,11 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
s := &Service{
forkChoiceStore: protoarray.New(0, 0, [32]byte{}),
finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
beaconDB: db,
beaconDB: beaconDB,
}
block := testutil.NewBeaconBlock()
r, err := block.Block.HashTreeRoot()
@@ -439,13 +439,13 @@ func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
func TestServiceStop_SaveCachedBlocks(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
s := &Service{
ctx: ctx,
cancel: cancel,
beaconDB: db,
beaconDB: beaconDB,
initSyncBlocks: make(map[[32]byte]*ethpb.SignedBeaconBlock),
stateGen: stategen.New(db),
stateGen: stategen.New(beaconDB),
}
b := testutil.NewBeaconBlock()
r, err := b.Block.HashTreeRoot()
@@ -456,10 +456,10 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
}
func BenchmarkHasBlockDB(b *testing.B) {
db := testDB.SetupDB(b)
beaconDB := testDB.SetupDB(b)
ctx := context.Background()
s := &Service{
beaconDB: db,
beaconDB: beaconDB,
}
block := testutil.NewBeaconBlock()
require.NoError(b, s.beaconDB.SaveBlock(ctx, block))
@@ -474,11 +474,11 @@ func BenchmarkHasBlockDB(b *testing.B) {
func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
ctx := context.Background()
db := testDB.SetupDB(b)
beaconDB := testDB.SetupDB(b)
s := &Service{
forkChoiceStore: protoarray.New(0, 0, [32]byte{}),
finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
beaconDB: db,
beaconDB: beaconDB,
}
block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
r, err := block.Block.HashTreeRoot()

6
beacon-chain/blockchain/weak_subjectivity_checks_test.go
View File

@@ -11,11 +11,11 @@ import (
)
func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
b := testutil.NewBeaconBlock()
b.Block.Slot = 32
require.NoError(t, db.SaveBlock(context.Background(), b))
require.NoError(t, beaconDB.SaveBlock(context.Background(), b))
r, err := b.Block.HashTreeRoot()
require.NoError(t, err)
tests := []struct {
@@ -71,7 +71,7 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := &Service{
beaconDB: db,
beaconDB: beaconDB,
wsRoot: tt.wsRoot[:],
wsEpoch: tt.wsEpoch,
wsVerified: tt.wsVerified,

254
beacon-chain/rpc/beacon/validators_test.go
View File

@@ -32,7 +32,7 @@ import (
)
func TestServer_GetValidatorActiveSetChanges_CannotRequestFutureEpoch(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(0))
@@ -41,7 +41,7 @@ func TestServer_GetValidatorActiveSetChanges_CannotRequestFutureEpoch(t *testing
HeadFetcher: &mock.ChainService{
State: st,
},
BeaconDB: db,
BeaconDB: beaconDB,
}
wanted := "Cannot retrieve information about an epoch in the future"
@@ -57,13 +57,13 @@ func TestServer_GetValidatorActiveSetChanges_CannotRequestFutureEpoch(t *testing
}
func TestServer_ListValidatorBalances_CannotRequestFutureEpoch(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(0))
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
HeadFetcher: &mock.ChainService{
State: st,
},
@@ -83,23 +83,23 @@ func TestServer_ListValidatorBalances_CannotRequestFutureEpoch(t *testing.T) {
}
func TestServer_ListValidatorBalances_NoResults(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(0))
bs := &Server{
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
headState := testutil.NewBeaconState()
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, headState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
wanted := &ethpb.ValidatorBalances{
Balances: make([]*ethpb.ValidatorBalances_Balance, 0),
@@ -121,7 +121,7 @@ func TestServer_ListValidatorBalances_NoResults(t *testing.T) {
}
func TestServer_ListValidatorBalances_DefaultResponse_NoArchive(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
numItems := 100
@@ -146,14 +146,14 @@ func TestServer_ListValidatorBalances_DefaultResponse_NoArchive(t *testing.T) {
require.NoError(t, st.SetValidators(validators))
require.NoError(t, st.SetBalances(balances))
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, st, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
bs := &Server{
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
HeadFetcher: &mock.ChainService{
State: st,
},
@@ -169,19 +169,19 @@ func TestServer_ListValidatorBalances_DefaultResponse_NoArchive(t *testing.T) {
}
func TestServer_ListValidatorBalances_PaginationOutOfRange(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
_, _, headState := setupValidators(t, db, 100)
_, _, headState := setupValidators(t, beaconDB, 100)
b := testutil.NewBeaconBlock()
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, headState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
bs := &Server{
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
HeadFetcher: &mock.ChainService{
State: headState,
},
@@ -217,19 +217,19 @@ func pubKey(i uint64) []byte {
}
func TestServer_ListValidatorBalances_Pagination_Default(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
_, _, headState := setupValidators(t, db, 100)
_, _, headState := setupValidators(t, beaconDB, 100)
b := testutil.NewBeaconBlock()
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, headState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
bs := &Server{
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
HeadFetcher: &mock.ChainService{
State: headState,
},
@@ -299,20 +299,20 @@ func TestServer_ListValidatorBalances_Pagination_Default(t *testing.T) {
}
func TestServer_ListValidatorBalances_Pagination_CustomPageSizes(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
count := 1000
_, _, headState := setupValidators(t, db, count)
_, _, headState := setupValidators(t, beaconDB, count)
b := testutil.NewBeaconBlock()
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, headState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
bs := &Server{
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
HeadFetcher: &mock.ChainService{
State: headState,
},
@@ -367,20 +367,20 @@ func TestServer_ListValidatorBalances_Pagination_CustomPageSizes(t *testing.T) {
}
func TestServer_ListValidatorBalances_ResponseOutOfBound(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
count := 10
_, _, headState := setupValidators(t, db, count)
_, _, headState := setupValidators(t, beaconDB, count)
b := testutil.NewBeaconBlock()
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, headState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
bs := &Server{
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
HeadFetcher: &mock.ChainService{
State: headState,
},
@@ -392,19 +392,19 @@ func TestServer_ListValidatorBalances_ResponseOutOfBound(t *testing.T) {
}
func TestServer_ListValidatorBalances_OutOfRange(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
_, _, headState := setupValidators(t, db, 1)
_, _, headState := setupValidators(t, beaconDB, 1)
b := testutil.NewBeaconBlock()
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, headState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
bs := &Server{
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
HeadFetcher: &mock.ChainService{
State: headState,
},
@@ -417,13 +417,13 @@ func TestServer_ListValidatorBalances_OutOfRange(t *testing.T) {
}
func TestServer_ListValidators_CannotRequestFutureEpoch(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(0))
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
GenesisTimeFetcher: &mock.ChainService{
// We are in epoch 0.
Genesis: time.Now(),
@@ -446,16 +446,16 @@ func TestServer_ListValidators_CannotRequestFutureEpoch(t *testing.T) {
}
func TestServer_ListValidators_NoResults(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(0))
gRoot := [32]byte{'g'}
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, st, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
GenesisTimeFetcher: &mock.ChainService{
// We are in epoch 0.
Genesis: time.Now(),
@@ -463,7 +463,7 @@ func TestServer_ListValidators_NoResults(t *testing.T) {
HeadFetcher: &mock.ChainService{
State: st,
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
wanted := &ethpb.Validators{
ValidatorList: make([]*ethpb.Validators_ValidatorContainer, 0),
@@ -486,7 +486,7 @@ func TestServer_ListValidators_NoResults(t *testing.T) {
func TestServer_ListValidators_OnlyActiveValidators(t *testing.T) {
ctx := context.Background()
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
count := 100
balances := make([]uint64, count)
validators := make([]*ethpb.Validator, count)
@@ -529,15 +529,15 @@ func TestServer_ListValidators_OnlyActiveValidators(t *testing.T) {
// We are in epoch 0.
Genesis: time.Now(),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, st, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
received, err := bs.ListValidators(ctx, &ethpb.ListValidatorsRequest{
Active: true,
@@ -548,7 +548,7 @@ func TestServer_ListValidators_OnlyActiveValidators(t *testing.T) {
func TestServer_ListValidators_InactiveInTheMiddle(t *testing.T) {
ctx := context.Background()
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
count := 100
balances := make([]uint64, count)
validators := make([]*ethpb.Validator, count)
@@ -596,15 +596,15 @@ func TestServer_ListValidators_InactiveInTheMiddle(t *testing.T) {
// We are in epoch 0.
Genesis: time.Now(),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, st, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
received, err := bs.ListValidators(ctx, &ethpb.ListValidatorsRequest{
Active: true,
@@ -616,9 +616,9 @@ func TestServer_ListValidators_InactiveInTheMiddle(t *testing.T) {
}
func TestServer_ListValidators_NoPagination(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
validators, _, headState := setupValidators(t, db, 100)
validators, _, headState := setupValidators(t, beaconDB, 100)
want := make([]*ethpb.Validators_ValidatorContainer, len(validators))
for i := 0; i < len(validators); i++ {
want[i] = &ethpb.Validators_ValidatorContainer{
@@ -640,7 +640,7 @@ func TestServer_ListValidators_NoPagination(t *testing.T) {
Epoch: 0,
},
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
received, err := bs.ListValidators(context.Background(), &ethpb.ListValidatorsRequest{})
@@ -649,9 +649,9 @@ func TestServer_ListValidators_NoPagination(t *testing.T) {
}
func TestServer_ListValidators_StategenNotUsed(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
validators, _, headState := setupValidators(t, db, 100)
validators, _, headState := setupValidators(t, beaconDB, 100)
want := make([]*ethpb.Validators_ValidatorContainer, len(validators))
for i := 0; i < len(validators); i++ {
want[i] = &ethpb.Validators_ValidatorContainer{
@@ -676,9 +676,9 @@ func TestServer_ListValidators_StategenNotUsed(t *testing.T) {
}
func TestServer_ListValidators_IndicesPubKeys(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
validators, _, headState := setupValidators(t, db, 100)
validators, _, headState := setupValidators(t, beaconDB, 100)
indicesWanted := []uint64{2, 7, 11, 17}
pubkeyIndicesWanted := []uint64{3, 5, 9, 15}
allIndicesWanted := append(indicesWanted, pubkeyIndicesWanted...)
@@ -706,7 +706,7 @@ func TestServer_ListValidators_IndicesPubKeys(t *testing.T) {
// We are in epoch 0.
Genesis: time.Now(),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
pubKeysWanted := make([][]byte, len(pubkeyIndicesWanted))
@@ -723,13 +723,13 @@ func TestServer_ListValidators_IndicesPubKeys(t *testing.T) {
}
func TestServer_ListValidators_Pagination(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
count := 100
_, _, headState := setupValidators(t, db, count)
_, _, headState := setupValidators(t, beaconDB, count)
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
HeadFetcher: &mock.ChainService{
State: headState,
},
@@ -742,7 +742,7 @@ func TestServer_ListValidators_Pagination(t *testing.T) {
// We are in epoch 0.
Genesis: time.Now(),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
tests := []struct {
@@ -861,10 +861,10 @@ func TestServer_ListValidators_Pagination(t *testing.T) {
}
func TestServer_ListValidators_PaginationOutOfRange(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
count := 1
validators, _, headState := setupValidators(t, db, count)
validators, _, headState := setupValidators(t, beaconDB, count)
bs := &Server{
HeadFetcher: &mock.ChainService{
@@ -879,7 +879,7 @@ func TestServer_ListValidators_PaginationOutOfRange(t *testing.T) {
// We are in epoch 0.
Genesis: time.Now(),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
req := &ethpb.ListValidatorsRequest{PageToken: strconv.Itoa(1), PageSize: 100}
@@ -899,9 +899,9 @@ func TestServer_ListValidators_ExceedsMaxPageSize(t *testing.T) {
}
func TestServer_ListValidators_DefaultPageSize(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
validators, _, headState := setupValidators(t, db, 1000)
validators, _, headState := setupValidators(t, beaconDB, 1000)
want := make([]*ethpb.Validators_ValidatorContainer, len(validators))
for i := 0; i < len(validators); i++ {
want[i] = &ethpb.Validators_ValidatorContainer{
@@ -923,7 +923,7 @@ func TestServer_ListValidators_DefaultPageSize(t *testing.T) {
// We are in epoch 0.
Genesis: time.Now(),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
req := &ethpb.ListValidatorsRequest{}
@@ -936,7 +936,7 @@ func TestServer_ListValidators_DefaultPageSize(t *testing.T) {
}
func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
numEpochs := 30
@@ -960,11 +960,11 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
require.NoError(t, st.SetSlot(20*params.BeaconConfig().SlotsPerEpoch))
require.NoError(t, st.SetValidators(validators))
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, st, gRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
secondsPerEpoch := params.BeaconConfig().SecondsPerSlot * params.BeaconConfig().SlotsPerEpoch
bs := &Server{
HeadFetcher: &mock.ChainService{
@@ -974,7 +974,7 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
// We are in epoch 30
Genesis: time.Now().Add(time.Duration(-1*int64(30*secondsPerEpoch)) * time.Second),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
req := &ethpb.ListValidatorsRequest{
@@ -999,7 +999,7 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
func TestServer_ListValidators_ProcessHeadStateSlots(t *testing.T) {
params.UseMinimalConfig()
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
headSlot := uint64(32)
@@ -1028,11 +1028,11 @@ func TestServer_ListValidators_ProcessHeadStateSlots(t *testing.T) {
require.NoError(t, st.SetValidators(validators))
require.NoError(t, st.SetBalances(balances))
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, st, gRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
secondsPerEpoch := params.BeaconConfig().SecondsPerSlot * params.BeaconConfig().SlotsPerEpoch
bs := &Server{
HeadFetcher: &mock.ChainService{
@@ -1041,7 +1041,7 @@ func TestServer_ListValidators_ProcessHeadStateSlots(t *testing.T) {
GenesisTimeFetcher: &mock.ChainService{
Genesis: time.Now().Add(time.Duration(-1*int64(secondsPerEpoch)) * time.Second),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
req := &ethpb.ListValidatorsRequest{
@@ -1138,7 +1138,7 @@ func TestServer_GetValidator(t *testing.T) {
}
func TestServer_GetValidatorActiveSetChanges(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
validators := make([]*ethpb.Validator, 8)
@@ -1180,19 +1180,19 @@ func TestServer_GetValidatorActiveSetChanges(t *testing.T) {
require.NoError(t, err)
}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, db.SaveState(ctx, headState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
bs := &Server{
FinalizationFetcher: &mock.ChainService{
FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
res, err := bs.GetValidatorActiveSetChanges(ctx, &ethpb.GetValidatorActiveSetChangesRequest{
QueryFilter: &ethpb.GetValidatorActiveSetChangesRequest_Genesis{Genesis: true},
@@ -1383,18 +1383,18 @@ func TestServer_GetValidatorQueue_PendingExit(t *testing.T) {
}
func TestServer_GetValidatorParticipation_CannotRequestFutureEpoch(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
headState := testutil.NewBeaconState()
require.NoError(t, headState.SetSlot(0))
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
HeadFetcher: &mock.ChainService{
State: headState,
},
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
wanted := "Cannot retrieve information about an epoch"
@@ -1410,7 +1410,7 @@ func TestServer_GetValidatorParticipation_CannotRequestFutureEpoch(t *testing.T)
}
func TestServer_GetValidatorParticipation_UnknownState(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
headState := testutil.NewBeaconState()
@@ -1418,14 +1418,14 @@ func TestServer_GetValidatorParticipation_UnknownState(t *testing.T) {
epoch := uint64(50)
slots := epoch * params.BeaconConfig().SlotsPerEpoch
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
HeadFetcher: &mock.ChainService{
State: headState,
},
GenesisTimeFetcher: &mock.ChainService{
Genesis: time.Now().Add(time.Duration(-1*int64(slots)) * time.Second),
},
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
}
wanted := "failed to initialize precompute: nil inner state"
@@ -1441,7 +1441,7 @@ func TestServer_GetValidatorParticipation_UnknownState(t *testing.T) {
}
func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
validatorCount := uint64(100)
@@ -1480,19 +1480,19 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
b := testutil.NewBeaconBlock()
b.Block.Slot = 16
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, db.SaveStateSummary(ctx, &pb.StateSummary{Root: bRoot[:]}))
require.NoError(t, db.SaveStateSummary(ctx, &pb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]}))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, bRoot))
require.NoError(t, beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bRoot[:]}))
require.NoError(t, beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]}))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, headState, bRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, bRoot))
m := &mock.ChainService{State: headState}
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
HeadFetcher: m,
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
GenesisTimeFetcher: &mock.ChainService{
Genesis: timeutils.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot)) * time.Second),
},
@@ -1524,7 +1524,7 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
}
func TestServer_GetValidatorParticipation_OrphanedUntilGenesis(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
validatorCount := uint64(100)
@@ -1562,19 +1562,19 @@ func TestServer_GetValidatorParticipation_OrphanedUntilGenesis(t *testing.T) {
require.NoError(t, headState.SetPreviousEpochAttestations(atts))
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, db.SaveStateSummary(ctx, &pb.StateSummary{Root: bRoot[:]}))
require.NoError(t, db.SaveStateSummary(ctx, &pb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]}))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, bRoot))
require.NoError(t, beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bRoot[:]}))
require.NoError(t, beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]}))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, headState, bRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, bRoot))
m := &mock.ChainService{State: headState}
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
HeadFetcher: m,
StateGen: stategen.New(db),
StateGen: stategen.New(beaconDB),
GenesisTimeFetcher: &mock.ChainService{
Genesis: timeutils.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot)) * time.Second),
},
@@ -1831,11 +1831,11 @@ func TestGetValidatorPerformance_IndicesPubkeys(t *testing.T) {
func BenchmarkListValidatorBalances(b *testing.B) {
b.StopTimer()
db := dbTest.SetupDB(b)
beaconDB := dbTest.SetupDB(b)
ctx := context.Background()
count := 1000
_, _, headState := setupValidators(b, db, count)
_, _, headState := setupValidators(b, beaconDB, count)
bs := &Server{
HeadFetcher: &mock.ChainService{
State: headState,
@@ -1850,7 +1850,7 @@ func BenchmarkListValidatorBalances(b *testing.B) {
}
}
func setupValidators(t testing.TB, db db.Database, count int) ([]*ethpb.Validator, []uint64, *stateTrie.BeaconState) {
func setupValidators(t testing.TB, _ db.Database, count int) ([]*ethpb.Validator, []uint64, *stateTrie.BeaconState) {
balances := make([]uint64, count)
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
@@ -1881,7 +1881,7 @@ func TestServer_GetIndividualVotes_ValidatorsDontExist(t *testing.T) {
params.UseMinimalConfig()
defer params.UseMainnetConfig()
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
validators := uint64(64)
@@ -1892,13 +1892,13 @@ func TestServer_GetIndividualVotes_ValidatorsDontExist(t *testing.T) {
b := testutil.NewBeaconBlock()
b.Block.Slot = params.BeaconConfig().SlotsPerEpoch
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
gen := stategen.New(db)
gen := stategen.New(beaconDB)
require.NoError(t, gen.SaveState(ctx, gRoot, beaconState))
require.NoError(t, db.SaveState(ctx, beaconState, gRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, beaconState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
bs := &Server{
StateGen: gen,
GenesisTimeFetcher: &mock.ChainService{},
@@ -1953,7 +1953,7 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
params.UseMinimalConfig()
defer params.UseMainnetConfig()
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
validators := uint64(64)
@@ -1987,13 +1987,13 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
b := testutil.NewBeaconBlock()
b.Block.Slot = params.BeaconConfig().SlotsPerEpoch
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
gen := stategen.New(db)
gen := stategen.New(beaconDB)
require.NoError(t, gen.SaveState(ctx, gRoot, beaconState))
require.NoError(t, db.SaveState(ctx, beaconState, gRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveState(ctx, beaconState, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
bs := &Server{
StateGen: gen,
GenesisTimeFetcher: &mock.ChainService{},
@@ -2099,14 +2099,14 @@ func Test_validatorStatus(t *testing.T) {
}
func TestServer_isSlotCanonical(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
var roots [][32]byte
cRoots := map[[32]byte]bool{}
for i := 1; i < 100; i++ {
b := testutil.NewBeaconBlock()
b.Block.Slot = uint64(i)
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
br, err := b.Block.HashTreeRoot()
require.NoError(t, err)
if i%2 == 0 {
@@ -2116,7 +2116,7 @@ func TestServer_isSlotCanonical(t *testing.T) {
}
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
CanonicalFetcher: &mock.ChainService{
CanonicalRoots: cRoots,
},

86
beacon-chain/rpc/beaconv1/blocks_test.go
View File

@@ -23,14 +23,14 @@ import (
"github.com/prysmaticlabs/prysm/shared/testutil/require"
)
func fillDBTestBlocks(ctx context.Context, t *testing.T, db db.Database) (*ethpb_alpha.SignedBeaconBlock, []*ethpb_alpha.BeaconBlockContainer) {
func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (*ethpb_alpha.SignedBeaconBlock, []*ethpb_alpha.BeaconBlockContainer) {
parentRoot := [32]byte{1, 2, 3}
genBlk := testutil.NewBeaconBlock()
genBlk.Block.ParentRoot = parentRoot[:]
root, err := genBlk.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, genBlk))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
require.NoError(t, beaconDB.SaveBlock(ctx, genBlk))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
count := uint64(100)
blks := make([]*ethpb_alpha.SignedBeaconBlock, count)
@@ -51,22 +51,22 @@ func fillDBTestBlocks(ctx context.Context, t *testing.T, db db.Database) (*ethpb
blks[i] = b
blkContainers[i] = &ethpb_alpha.BeaconBlockContainer{Block: b, BlockRoot: root[:]}
}
require.NoError(t, db.SaveBlocks(ctx, blks))
require.NoError(t, beaconDB.SaveBlocks(ctx, blks))
headRoot := bytesutil.ToBytes32(blkContainers[len(blks)-1].BlockRoot)
summary := &p2ppb.StateSummary{
Root: headRoot[:],
Slot: blkContainers[len(blks)-1].Block.Block.Slot,
}
require.NoError(t, db.SaveStateSummary(ctx, summary))
require.NoError(t, db.SaveHeadBlockRoot(ctx, headRoot))
require.NoError(t, beaconDB.SaveStateSummary(ctx, summary))
require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
return genBlk, blkContainers
}
func TestServer_GetBlockHeader(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
genBlk, blkContainers := fillDBTestBlocks(ctx, t, db)
genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
root, err := genBlk.Block.HashTreeRoot()
require.NoError(t, err)
headBlock := blkContainers[len(blkContainers)-1]
@@ -74,16 +74,16 @@ func TestServer_GetBlockHeader(t *testing.T) {
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, db.SaveBlock(ctx, b2))
require.NoError(t, beaconDB.SaveBlock(ctx, b2))
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, db.SaveBlock(ctx, b3))
require.NoError(t, beaconDB.SaveBlock(ctx, b3))
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{
DB: db,
DB: beaconDB,
Block: headBlock.Block,
Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpb_alpha.Checkpoint{Root: blkContainers[64].BlockRoot},
@@ -160,15 +160,15 @@ func TestServer_GetBlockHeader(t *testing.T) {
}
func TestServer_ListBlockHeaders(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
_, blkContainers := fillDBTestBlocks(ctx, t, db)
_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1]
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{
DB: db,
DB: beaconDB,
Block: headBlock.Block,
Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpb_alpha.Checkpoint{Root: blkContainers[64].BlockRoot},
@@ -178,19 +178,19 @@ func TestServer_ListBlockHeaders(t *testing.T) {
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, db.SaveBlock(ctx, b2))
require.NoError(t, beaconDB.SaveBlock(ctx, b2))
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, db.SaveBlock(ctx, b3))
require.NoError(t, beaconDB.SaveBlock(ctx, b3))
b4 := testutil.NewBeaconBlock()
b4.Block.Slot = 31
b4.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, db.SaveBlock(ctx, b4))
require.NoError(t, beaconDB.SaveBlock(ctx, b4))
b5 := testutil.NewBeaconBlock()
b5.Block.Slot = 28
b5.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, db.SaveBlock(ctx, b5))
require.NoError(t, beaconDB.SaveBlock(ctx, b5))
tests := []struct {
name string
@@ -241,13 +241,13 @@ func TestServer_ListBlockHeaders(t *testing.T) {
}
func TestServer_ProposeBlock_OK(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
params.SetupTestConfigCleanup(t)
params.OverrideBeaconConfig(params.MainnetConfig())
genesis := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), genesis), "Could not save genesis block")
require.NoError(t, beaconDB.SaveBlock(context.Background(), genesis), "Could not save genesis block")
numDeposits := uint64(64)
beaconState, _ := testutil.DeterministicGenesisState(t, numDeposits)
@@ -255,11 +255,11 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
require.NoError(t, err)
genesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
beaconChainServer := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
ChainStartFetcher: &mockPOW.POWChain{},
BlockReceiver: c,
ChainInfoFetcher: c,
@@ -271,7 +271,7 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
req.Block.ParentRoot = bsRoot[:]
v1Block, err := migration.V1Alpha1ToV1Block(req)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, req))
require.NoError(t, beaconDB.SaveBlock(ctx, req))
blockReq := &ethpb.BeaconBlockContainer{
Message: v1Block.Block,
Signature: v1Block.Signature,
@@ -281,32 +281,32 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
}
func TestServer_GetBlock(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
_, blkContainers := fillDBTestBlocks(ctx, t, db)
_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1]
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, db.SaveBlock(ctx, b2))
require.NoError(t, beaconDB.SaveBlock(ctx, b2))
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, db.SaveBlock(ctx, b3))
require.NoError(t, beaconDB.SaveBlock(ctx, b3))
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{
DB: db,
DB: beaconDB,
Block: headBlock.Block,
Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpb_alpha.Checkpoint{Root: blkContainers[64].BlockRoot},
},
}
genBlk, blkContainers := fillDBTestBlocks(ctx, t, db)
genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
root, err := genBlk.Block.HashTreeRoot()
require.NoError(t, err)
@@ -394,24 +394,24 @@ func TestServer_GetBlock(t *testing.T) {
}
func TestServer_GetBlockRoot(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
genBlk, blkContainers := fillDBTestBlocks(ctx, t, db)
genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1]
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, db.SaveBlock(ctx, b2))
require.NoError(t, beaconDB.SaveBlock(ctx, b2))
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, db.SaveBlock(ctx, b3))
require.NoError(t, beaconDB.SaveBlock(ctx, b3))
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{
DB: db,
DB: beaconDB,
Block: headBlock.Block,
Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpb_alpha.Checkpoint{Root: blkContainers[64].BlockRoot},
@@ -497,22 +497,22 @@ func TestServer_GetBlockRoot(t *testing.T) {
}
func TestServer_ListBlockAttestations(t *testing.T) {
db := dbTest.SetupDB(t)
beaconDB := dbTest.SetupDB(t)
ctx := context.Background()
_, blkContainers := fillDBTestBlocks(ctx, t, db)
_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1]
bs := &Server{
BeaconDB: db,
BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{
DB: db,
DB: beaconDB,
Block: headBlock.Block,
Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpb_alpha.Checkpoint{Root: blkContainers[64].BlockRoot},
},
}
genBlk, blkContainers := fillDBTestBlocks(ctx, t, db)
genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
root, err := genBlk.Block.HashTreeRoot()
require.NoError(t, err)

106
beacon-chain/state/stategen/getter_test.go
View File

@@ -18,15 +18,15 @@ import (
func TestStateByRoot_ColdState(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
service.finalizedInfo.slot = 2
service.slotsPerArchivedPoint = 1
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
@@ -43,9 +43,9 @@ func TestStateByRoot_ColdState(t *testing.T) {
func TestStateByRoot_HotStateUsingEpochBoundaryCacheNoReplay(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(10))
@@ -61,9 +61,9 @@ func TestStateByRoot_HotStateUsingEpochBoundaryCacheNoReplay(t *testing.T) {
func TestStateByRoot_HotStateUsingEpochBoundaryCacheWithReplay(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
blk := testutil.NewBeaconBlock()
@@ -86,9 +86,9 @@ func TestStateByRoot_HotStateUsingEpochBoundaryCacheWithReplay(t *testing.T) {
func TestStateByRoot_HotStateCached(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
r := [32]byte{'A'}
@@ -104,9 +104,9 @@ func TestStateByRoot_HotStateCached(t *testing.T) {
func TestStateByRootInitialSync_UseEpochStateCache(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
targetSlot := uint64(10)
@@ -122,9 +122,9 @@ func TestStateByRootInitialSync_UseEpochStateCache(t *testing.T) {
func TestStateByRootInitialSync_UseCache(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
r := [32]byte{'A'}
@@ -143,8 +143,8 @@ func TestStateByRootInitialSync_UseCache(t *testing.T) {
func TestStateByRootInitialSync_CanProcessUpTo(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
blk := testutil.NewBeaconBlock()
@@ -167,9 +167,9 @@ func TestStateByRootInitialSync_CanProcessUpTo(t *testing.T) {
func TestStateBySlot_ColdState(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
service.slotsPerArchivedPoint = params.BeaconConfig().SlotsPerEpoch * 2
service.finalizedInfo.slot = service.slotsPerArchivedPoint + 1
@@ -177,19 +177,19 @@ func TestStateBySlot_ColdState(t *testing.T) {
genesisStateRoot, err := beaconState.HashTreeRoot(ctx)
require.NoError(t, err)
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
assert.NoError(t, db.SaveState(ctx, beaconState, gRoot))
assert.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
assert.NoError(t, beaconDB.SaveState(ctx, beaconState, gRoot))
assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
b, err := testutil.GenerateFullBlock(beaconState, pks, testutil.DefaultBlockGenConfig(), 1)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, bRoot))
require.NoError(t, beaconDB.SaveState(ctx, beaconState, bRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
r := [32]byte{}
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: service.slotsPerArchivedPoint, Root: r[:]}))
@@ -202,19 +202,19 @@ func TestStateBySlot_ColdState(t *testing.T) {
func TestStateBySlot_HotStateDB(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
genesisStateRoot, err := beaconState.HashTreeRoot(ctx)
require.NoError(t, err)
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
assert.NoError(t, db.SaveState(ctx, beaconState, gRoot))
assert.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
assert.NoError(t, beaconDB.SaveState(ctx, beaconState, gRoot))
assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
slot := uint64(10)
loadedState, err := service.StateBySlot(ctx, slot)
@@ -224,8 +224,8 @@ func TestStateBySlot_HotStateDB(t *testing.T) {
func TestLoadeStateByRoot_Cached(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
r := [32]byte{'A'}
@@ -242,14 +242,14 @@ func TestLoadeStateByRoot_Cached(t *testing.T) {
func TestLoadeStateByRoot_FinalizedState(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
genesisStateRoot, err := beaconState.HashTreeRoot(ctx)
require.NoError(t, err)
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 0, Root: gRoot[:]}))
@@ -269,8 +269,8 @@ func TestLoadeStateByRoot_FinalizedState(t *testing.T) {
func TestLoadeStateByRoot_EpochBoundaryStateCanProcess(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
gBlk := testutil.NewBeaconBlock()
@@ -295,8 +295,8 @@ func TestLoadeStateByRoot_EpochBoundaryStateCanProcess(t *testing.T) {
func TestLoadeStateByRoot_FromDBBoundaryCase(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
gBlk := testutil.NewBeaconBlock()
@@ -321,8 +321,8 @@ func TestLoadeStateByRoot_FromDBBoundaryCase(t *testing.T) {
func TestLoadeStateBySlot_CanAdvanceSlotUsingDB(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
b := testutil.NewBeaconBlock()
require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
@@ -339,22 +339,22 @@ func TestLoadeStateBySlot_CanAdvanceSlotUsingDB(t *testing.T) {
func TestLoadeStateBySlot_CanReplayBlock(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
genesis, keys := testutil.DeterministicGenesisState(t, 64)
genesisBlockRoot := bytesutil.ToBytes32(nil)
require.NoError(t, db.SaveState(ctx, genesis, genesisBlockRoot))
require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
stateRoot, err := genesis.HashTreeRoot(ctx)
require.NoError(t, err)
genesisBlk := blocks.NewGenesisBlock(stateRoot[:])
require.NoError(t, db.SaveBlock(ctx, genesisBlk))
require.NoError(t, beaconDB.SaveBlock(ctx, genesisBlk))
genesisBlkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisBlkRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisBlkRoot))
b1, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
assert.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, b1))
require.NoError(t, beaconDB.SaveBlock(ctx, b1))
r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: r1[:]}))
@@ -367,8 +367,8 @@ func TestLoadeStateBySlot_CanReplayBlock(t *testing.T) {
func TestLastAncestorState_CanGetUsingDB(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
b0 := testutil.NewBeaconBlock()
b0.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
@@ -406,8 +406,8 @@ func TestLastAncestorState_CanGetUsingDB(t *testing.T) {
func TestLastAncestorState_CanGetUsingCache(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
b0 := testutil.NewBeaconBlock()
b0.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
@@ -445,8 +445,8 @@ func TestLastAncestorState_CanGetUsingCache(t *testing.T) {
func TestState_HasState(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
s := testutil.NewBeaconState()
rHit1 := [32]byte{1}
rHit2 := [32]byte{2}
@@ -476,8 +476,8 @@ func TestState_HasState(t *testing.T) {
func TestState_HasStateInCache(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
s := testutil.NewBeaconState()
rHit1 := [32]byte{1}
rHit2 := [32]byte{2}

22
beacon-chain/state/stategen/migrate_test.go
View File

@@ -15,8 +15,8 @@ import (
func TestMigrateToCold_CanSaveFinalizedInfo(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
@@ -33,9 +33,9 @@ func TestMigrateToCold_CanSaveFinalizedInfo(t *testing.T) {
func TestMigrateToCold_HappyPath(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
service.slotsPerArchivedPoint = 1
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
stateSlot := uint64(1)
@@ -63,19 +63,19 @@ func TestMigrateToCold_HappyPath(t *testing.T) {
func TestMigrateToCold_RegeneratePath(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
service.slotsPerArchivedPoint = 1
beaconState, pks := testutil.DeterministicGenesisState(t, 32)
genesisStateRoot, err := beaconState.HashTreeRoot(ctx)
require.NoError(t, err)
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, db.SaveBlock(ctx, genesis))
assert.NoError(t, beaconDB.SaveBlock(ctx, genesis))
gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err)
assert.NoError(t, db.SaveState(ctx, beaconState, gRoot))
assert.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
assert.NoError(t, beaconDB.SaveState(ctx, beaconState, gRoot))
assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
b1, err := testutil.GenerateFullBlock(beaconState, pks, testutil.DefaultBlockGenConfig(), 1)
require.NoError(t, err)
@@ -113,9 +113,9 @@ func TestMigrateToCold_RegeneratePath(t *testing.T) {
func TestMigrateToCold_StateExistsInDB(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
service.slotsPerArchivedPoint = 1
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
stateSlot := uint64(1)

114
beacon-chain/state/stategen/replay_test.go
View File

@@ -18,7 +18,7 @@ import (
)
func TestReplayBlocks_AllSkipSlots(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
genesisBlock := blocks.NewGenesisBlock([]byte{})
@@ -39,7 +39,7 @@ func TestReplayBlocks_AllSkipSlots(t *testing.T) {
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp))
require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
service := New(db)
service := New(beaconDB)
targetSlot := params.BeaconConfig().SlotsPerEpoch - 1
newState, err := service.ReplayBlocks(context.Background(), beaconState, []*ethpb.SignedBeaconBlock{}, targetSlot)
require.NoError(t, err)
@@ -47,7 +47,7 @@ func TestReplayBlocks_AllSkipSlots(t *testing.T) {
}
func TestReplayBlocks_SameSlot(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
genesisBlock := blocks.NewGenesisBlock([]byte{})
@@ -68,7 +68,7 @@ func TestReplayBlocks_SameSlot(t *testing.T) {
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp))
require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
service := New(db)
service := New(beaconDB)
targetSlot := beaconState.Slot()
newState, err := service.ReplayBlocks(context.Background(), beaconState, []*ethpb.SignedBeaconBlock{}, targetSlot)
require.NoError(t, err)
@@ -76,7 +76,7 @@ func TestReplayBlocks_SameSlot(t *testing.T) {
}
func TestReplayBlocks_LowerSlotBlock(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(1))
@@ -98,7 +98,7 @@ func TestReplayBlocks_LowerSlotBlock(t *testing.T) {
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp))
require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
service := New(db)
service := New(beaconDB)
targetSlot := beaconState.Slot()
b := testutil.NewBeaconBlock()
b.Block.Slot = beaconState.Slot() - 1
@@ -108,13 +108,13 @@ func TestReplayBlocks_LowerSlotBlock(t *testing.T) {
}
func TestLoadBlocks_FirstBranch(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
roots, savedBlocks, err := tree1(db, bytesutil.PadTo([]byte{'A'}, 32))
roots, savedBlocks, err := tree1(beaconDB, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 8, roots[len(roots)-1])
@@ -137,13 +137,13 @@ func TestLoadBlocks_FirstBranch(t *testing.T) {
}
func TestLoadBlocks_SecondBranch(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
roots, savedBlocks, err := tree1(db, bytesutil.PadTo([]byte{'A'}, 32))
roots, savedBlocks, err := tree1(beaconDB, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 5, roots[5])
@@ -164,13 +164,13 @@ func TestLoadBlocks_SecondBranch(t *testing.T) {
}
func TestLoadBlocks_ThirdBranch(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
roots, savedBlocks, err := tree1(db, bytesutil.PadTo([]byte{'A'}, 32))
roots, savedBlocks, err := tree1(beaconDB, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 7, roots[7])
@@ -193,13 +193,13 @@ func TestLoadBlocks_ThirdBranch(t *testing.T) {
}
func TestLoadBlocks_SameSlots(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
roots, savedBlocks, err := tree2(db, bytesutil.PadTo([]byte{'A'}, 32))
roots, savedBlocks, err := tree2(beaconDB, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 3, roots[6])
@@ -220,13 +220,13 @@ func TestLoadBlocks_SameSlots(t *testing.T) {
}
func TestLoadBlocks_SameEndSlots(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
roots, savedBlocks, err := tree3(db, bytesutil.PadTo([]byte{'A'}, 32))
roots, savedBlocks, err := tree3(beaconDB, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 2, roots[2])
@@ -246,13 +246,13 @@ func TestLoadBlocks_SameEndSlots(t *testing.T) {
}
func TestLoadBlocks_SameEndSlotsWith2blocks(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
roots, savedBlocks, err := tree4(db, bytesutil.PadTo([]byte{'A'}, 32))
roots, savedBlocks, err := tree4(beaconDB, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 2, roots[1])
@@ -271,23 +271,23 @@ func TestLoadBlocks_SameEndSlotsWith2blocks(t *testing.T) {
}
func TestLoadBlocks_BadStart(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
roots, _, err := tree1(db, bytesutil.PadTo([]byte{'A'}, 32))
roots, _, err := tree1(beaconDB, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
_, err = s.LoadBlocks(ctx, 0, 5, roots[8])
assert.ErrorContains(t, "end block roots don't match", err)
}
func TestLastSavedBlock_Genesis(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
finalizedInfo: &finalizedInfo{slot: 128},
}
@@ -304,10 +304,10 @@ func TestLastSavedBlock_Genesis(t *testing.T) {
}
func TestLastSavedBlock_CanGet(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
finalizedInfo: &finalizedInfo{slot: 128},
}
@@ -330,10 +330,10 @@ func TestLastSavedBlock_CanGet(t *testing.T) {
}
func TestLastSavedBlock_NoSavedBlock(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
finalizedInfo: &finalizedInfo{slot: 128},
}
@@ -345,10 +345,10 @@ func TestLastSavedBlock_NoSavedBlock(t *testing.T) {
}
func TestLastSavedState_Genesis(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
finalizedInfo: &finalizedInfo{slot: 128},
}
@@ -366,10 +366,10 @@ func TestLastSavedState_Genesis(t *testing.T) {
}
func TestLastSavedState_CanGet(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
finalizedInfo: &finalizedInfo{slot: 128},
}
@@ -397,10 +397,10 @@ func TestLastSavedState_CanGet(t *testing.T) {
}
func TestLastSavedState_NoSavedBlockState(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
finalizedInfo: &finalizedInfo{slot: 128},
}
@@ -416,7 +416,7 @@ func TestLastSavedState_NoSavedBlockState(t *testing.T) {
// B0 - B1 - - B3 -- B5
// \- B2 -- B4 -- B6 ----- B8
// \- B7
func tree1(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
func tree1(beaconDB db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
@@ -487,10 +487,10 @@ func tree1(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
if err := beaconDB.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
return nil, nil, err
}
returnedBlocks = append(returnedBlocks, beaconBlock)
@@ -504,7 +504,7 @@ func tree1(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
// \- B2
// \- B2
// \- B2 -- B3
func tree2(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
func tree2(beaconDB db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
@@ -566,10 +566,10 @@ func tree2(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
if err := beaconDB.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
return nil, nil, err
}
returnedBlocks = append(returnedBlocks, beaconBlock)
@@ -583,7 +583,7 @@ func tree2(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
// \- B2
// \- B2
// \- B2
func tree3(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
func tree3(beaconDB db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
@@ -638,10 +638,10 @@ func tree3(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
if err := beaconDB.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
return nil, nil, err
}
returnedBlocks = append(returnedBlocks, beaconBlock)
@@ -656,7 +656,7 @@ func tree3(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
// \- B2
// \- B2
// \- B2
func tree4(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
func tree4(beaconDB db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
@@ -704,10 +704,10 @@ func tree4(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
if err := beaconDB.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
return nil, nil, err
}
returnedBlocks = append(returnedBlocks, beaconBlock)
@@ -717,23 +717,23 @@ func tree4(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
}
func TestLoadFinalizedBlocks(t *testing.T) {
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
ctx := context.Background()
s := &State{
beaconDB: db,
beaconDB: beaconDB,
}
gBlock := testutil.NewBeaconBlock()
gRoot, err := gBlock.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, gBlock))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, [32]byte{}))
roots, _, err := tree1(db, gRoot[:])
require.NoError(t, beaconDB.SaveBlock(ctx, gBlock))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, [32]byte{}))
roots, _, err := tree1(beaconDB, gRoot[:])
require.NoError(t, err)
filteredBlocks, err := s.loadFinalizedBlocks(ctx, 0, 8)
require.NoError(t, err)
require.Equal(t, 0, len(filteredBlocks))
require.NoError(t, db.SaveStateSummary(ctx, &pb.StateSummary{Root: roots[8][:]}))
require.NoError(t, beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: roots[8][:]}))
require.NoError(t, s.beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: roots[8][:]}))
filteredBlocks, err = s.loadFinalizedBlocks(ctx, 0, 8)

4
beacon-chain/state/stategen/service.go
View File

@@ -48,9 +48,9 @@ type finalizedInfo struct {
}
// New returns a new state management object.
func New(db db.NoHeadAccessDatabase) *State {
func New(beaconDB db.NoHeadAccessDatabase) *State {
return &State{
beaconDB: db,
beaconDB: beaconDB,
hotStateCache: newHotStateCache(),
finalizedInfo: &finalizedInfo{slot: 0, root: params.BeaconConfig().ZeroHash},
slotsPerArchivedPoint: params.BeaconConfig().SlotsPerArchivedPoint,

4
beacon-chain/state/stategen/service_test.go
View File

@@ -15,9 +15,9 @@ import (
func TestResume(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
b := testutil.NewBeaconBlock()
require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
root, err := b.Block.HashTreeRoot()

60
beacon-chain/state/stategen/setter_test.go
View File

@@ -14,9 +14,9 @@ import (
func TestSaveState_HotStateCanBeSaved(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
service.slotsPerArchivedPoint = 1
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
// This goes to hot section, verify it can save on epoch boundary.
@@ -35,9 +35,9 @@ func TestSaveState_HotStateCanBeSaved(t *testing.T) {
func TestSaveState_HotStateCached(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
service := New(db)
service := New(beaconDB)
service.slotsPerArchivedPoint = 1
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
@@ -55,18 +55,18 @@ func TestSaveState_HotStateCached(t *testing.T) {
func TestState_ForceCheckpoint_SavesStateToDatabase(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
beaconDB := testDB.SetupDB(t)
svc := New(db)
svc := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
r := [32]byte{'a'}
svc.hotStateCache.put(r, beaconState)
require.Equal(t, false, db.HasState(ctx, r), "Database has state stored already")
require.Equal(t, false, beaconDB.HasState(ctx, r), "Database has state stored already")
assert.NoError(t, svc.ForceCheckpoint(ctx, r[:]))
assert.Equal(t, true, db.HasState(ctx, r), "Did not save checkpoint to database")
assert.Equal(t, true, beaconDB.HasState(ctx, r), "Did not save checkpoint to database")
// Should not panic with genesis finalized root.
assert.NoError(t, svc.ForceCheckpoint(ctx, params.BeaconConfig().ZeroHash[:]))
@@ -75,8 +75,8 @@ func TestState_ForceCheckpoint_SavesStateToDatabase(t *testing.T) {
func TestSaveState_Alreadyhas(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
@@ -94,8 +94,8 @@ func TestSaveState_Alreadyhas(t *testing.T) {
func TestSaveState_CanSaveOnEpochBoundary(t *testing.T) {
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
@@ -109,23 +109,23 @@ func TestSaveState_CanSaveOnEpochBoundary(t *testing.T) {
require.Equal(t, true, ok, "Did not save epoch boundary state")
assert.Equal(t, true, service.beaconDB.HasStateSummary(ctx, r), "Should have saved the state summary")
// Should have not been saved in DB.
require.Equal(t, false, db.HasState(ctx, r))
require.Equal(t, false, beaconDB.HasState(ctx, r))
}
func TestSaveState_NoSaveNotEpochBoundary(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch-1))
r := [32]byte{'A'}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, service.SaveState(ctx, r, beaconState))
// Should only save state summary.
@@ -133,14 +133,14 @@ func TestSaveState_NoSaveNotEpochBoundary(t *testing.T) {
assert.Equal(t, true, service.beaconDB.HasStateSummary(ctx, r), "Should have saved the state summary")
require.LogsDoNotContain(t, hook, "Saved full state on epoch boundary")
// Should have not been saved in DB.
require.Equal(t, false, db.HasState(ctx, r))
require.Equal(t, false, beaconDB.HasState(ctx, r))
}
func TestSaveState_CanSaveHotStateToDB(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
service.EnableSaveHotStateToDB(ctx)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(defaultHotStateDBInterval))
@@ -150,14 +150,14 @@ func TestSaveState_CanSaveHotStateToDB(t *testing.T) {
require.LogsContain(t, hook, "Saving hot state to DB")
// Should have saved in DB.
require.Equal(t, true, db.HasState(ctx, r))
require.Equal(t, true, beaconDB.HasState(ctx, r))
}
func TestEnableSaveHotStateToDB_Enabled(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
service.EnableSaveHotStateToDB(ctx)
require.LogsContain(t, hook, "Entering mode to save hot states in DB")
@@ -167,8 +167,8 @@ func TestEnableSaveHotStateToDB_Enabled(t *testing.T) {
func TestEnableSaveHotStateToDB_AlreadyEnabled(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
service.saveHotStateDB.enabled = true
service.EnableSaveHotStateToDB(ctx)
require.LogsDoNotContain(t, hook, "Entering mode to save hot states in DB")
@@ -178,11 +178,11 @@ func TestEnableSaveHotStateToDB_AlreadyEnabled(t *testing.T) {
func TestEnableSaveHotStateToDB_Disabled(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
service.saveHotStateDB.enabled = true
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
require.NoError(t, beaconDB.SaveBlock(ctx, b))
r, err := b.Block.HashTreeRoot()
require.NoError(t, err)
service.saveHotStateDB.savedStateRoots = [][32]byte{r}
@@ -195,8 +195,8 @@ func TestEnableSaveHotStateToDB_Disabled(t *testing.T) {
func TestEnableSaveHotStateToDB_AlreadyDisabled(t *testing.T) {
hook := logTest.NewGlobal()
ctx := context.Background()
db := testDB.SetupDB(t)
service := New(db)
beaconDB := testDB.SetupDB(t)
service := New(beaconDB)
require.NoError(t, service.DisableSaveHotStateToDB(ctx))
require.LogsDoNotContain(t, hook, "Exiting mode to save hot states in DB")
require.Equal(t, false, service.saveHotStateDB.enabled)