add happy/sad tests (#8279)

Co-authored-by: terence tsao <terence@prysmaticlabs.com>
Co-authored-by: Preston Van Loon <preston@prysmaticlabs.com>

.bazelrc

@@ -237,3 +237,6 @@ build:remote --remote_timeout=3600
 build:remote --experimental_remote_download_outputs=toplevel --experimental_inmemory_jdeps_files --experimental_inmemory_dotd_files
 
 build:remote --remote_local_fallback
+
+# Ignore GoStdLib with remote caching
+build --modify_execution_info='GoStdlib.*=+no-remote-cache'

.gitignore

@@ -33,3 +33,6 @@ dist
 # libfuzzer
 oom-*
 crash-*
+
+# deepsource cli
+bin

DEPENDENCIES.md

@@ -67,3 +67,14 @@ bazel run //:gazelle -- update-repos -from_file=go.mod -to_macro=deps.bzl%prysm_
 The deps.bzl file should have been updated with the dependency and any transitive dependencies. 
 
 Do NOT add new `go_repository` to the WORKSPACE file. All dependencies should live in deps.bzl.
+
+## Running tests
+
+To enable conditional compilation and custom configuration for tests (where compiled code has more 
+debug info, while not being completely optimized), we rely on Go's build tags/constraints mechanism 
+(see official docs on [build constraints](https://golang.org/pkg/go/build/#hdr-Build_Constraints)). 
+Therefore, whenever using `go test`, do not forget to pass in extra build tag, eg:
+
+```bash
+go test ./beacon-chain/sync/initial-sync -tags develop 
+```

WORKSPACE

@@ -76,9 +76,9 @@ http_archive(
 
 http_archive(
     name = "io_bazel_rules_docker",
-    sha256 = "1698624e878b0607052ae6131aa216d45ebb63871ec497f26c67455b34119c80",
-    strip_prefix = "rules_docker-0.15.0",
-    urls = ["https://github.com/bazelbuild/rules_docker/releases/download/v0.15.0/rules_docker-v0.15.0.tar.gz"],
+    sha256 = "1286175a94c0b1335efe1d75d22ea06e89742557d3fac2a0366f242a6eac6f5a",
+    strip_prefix = "rules_docker-ba4310833230294fa69b7d6ea1787ac684631a7d",
+    urls = ["https://github.com/bazelbuild/rules_docker/archive/ba4310833230294fa69b7d6ea1787ac684631a7d.tar.gz"],
 )
 
 http_archive(
@@ -100,14 +100,14 @@ http_archive(
 # https://github.com/gogo/protobuf/pull/582 is merged.
 git_repository(
     name = "com_github_gogo_protobuf",
-    commit = "5628607bb4c51c3157aacc3a50f0ab707582b805",
+    commit = "b03c65ea87cdc3521ede29f62fe3ce239267c1bc",
     patch_args = ["-p1"],
     patches = [
         "@io_bazel_rules_go//third_party:com_github_gogo_protobuf-gazelle.patch",
         "//third_party:com_github_gogo_protobuf-equal.patch",
     ],
     remote = "https://github.com/gogo/protobuf",
-    shallow_since = "1571033717 +0200",
+    shallow_since = "1610265707 +0000",
     # gazelle args: -go_prefix github.com/gogo/protobuf -proto legacy
 )
 
@@ -352,9 +352,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "117f5366af9cf009354ed1abe02f906168158473461d69c8056984b9b0292619",
+    sha256 = "edb80f3a695d84f6000f0e05abf7a4bbf207c03abb91219780ec97e7d6ad21c8",
     urls = [
-        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.0-beta.2/prysm-web-ui.tar.gz",
+        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.0-beta.3/prysm-web-ui.tar.gz",
     ],
 )
 

beacon-chain/BUILD.bazel

@@ -8,17 +8,20 @@ load("@io_bazel_rules_docker//contrib:push-all.bzl", "docker_push")
 go_library(
     name = "go_default_library",
     srcs = [
+        "log.go",
         "main.go",
         "usage.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
+        "//beacon-chain/db:go_default_library",
         "//beacon-chain/flags:go_default_library",
         "//beacon-chain/node:go_default_library",
         "//shared/cmd:go_default_library",
         "//shared/debug:go_default_library",
         "//shared/featureconfig:go_default_library",
+        "//shared/fileutil:go_default_library",
         "//shared/journald:go_default_library",
         "//shared/logutil:go_default_library",
         "//shared/maxprocs:go_default_library",

beacon-chain/blockchain/BUILD.bazel

@@ -79,6 +79,7 @@ go_test(
     srcs = [
         "blockchain_test.go",
         "chain_info_test.go",
+        "checktags_test.go",
         "head_test.go",
         "info_test.go",
         "metrics_test.go",
@@ -90,6 +91,7 @@ go_test(
         "weak_subjectivity_checks_test.go",
     ],
     embed = [":go_default_library"],
+    gotags = ["develop"],
     deps = [
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
@@ -126,6 +128,7 @@ go_test(
     name = "go_raceon_test",
     srcs = [
         "chain_info_norace_test.go",
+        "checktags_test.go",
         "receive_block_test.go",
         "service_norace_test.go",
     ],
@@ -137,6 +140,7 @@ go_test(
         # See: https://github.com/etcd-io/bbolt/issues/187.
         "-d=checkptr=0",
     ],
+    gotags = ["develop"],
     race = "on",
     tags = ["race_on"],
     deps = [

beacon-chain/blockchain/chain_info_norace_test.go

@@ -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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB: db,
+		beaconDB: beaconDB,
 		head:     &head{root: [32]byte{'A'}},
-		stateGen: stategen.New(db, sc),
+		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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB: db,
+		beaconDB: beaconDB,
 		head:     &head{block: &ethpb.SignedBeaconBlock{}},
-		stateGen: stategen.New(db, sc),
+		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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB: db,
-		stateGen: stategen.New(db, sc),
+		beaconDB: beaconDB,
+		stateGen: stategen.New(beaconDB),
 	}
 	go func() {
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))

beacon-chain/blockchain/chain_info_test.go

@@ -25,44 +25,44 @@ var _ TimeFetcher = (*Service)(nil)
 var _ ForkFetcher = (*Service)(nil)
 
 func TestFinalizedCheckpt_Nil(t *testing.T) {
-	db, sc := testDB.SetupDB(t)
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	genesisRoot := [32]byte{'A'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	genesisRoot := [32]byte{'C'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
-	c := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
-	c := setupBeaconChain(t, db, sc)
+	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)

beacon-chain/blockchain/checktags_test.go

@@ -0,0 +1,7 @@
+// +build !develop
+
+package blockchain
+
+func init() {
+	log.Fatal("Tests in this package require extra build tag: re-run with `-tags develop`")
+}

beacon-chain/blockchain/head.go

@@ -93,7 +93,7 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 
 	// If the head state is not available, just return nil.
 	// There's nothing to cache
-	if !s.stateGen.StateSummaryExists(ctx, headRoot) {
+	if !s.beaconDB.HasStateSummary(ctx, headRoot) {
 		return nil
 	}
 

beacon-chain/blockchain/head_test.go

@@ -15,8 +15,8 @@ import (
 )
 
 func TestSaveHead_Same(t *testing.T) {
-	db, sc := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db, sc)
+	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, sc := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db, sc)
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
 
 	b := testutil.NewBeaconBlock()
 	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), b))

beacon-chain/blockchain/info_test.go

@@ -20,17 +20,17 @@ func TestService_TreeHandler(t *testing.T) {
 	require.NoError(t, err)
 
 	ctx := context.Background()
-	db, sCache := 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, sCache),
+		StateGen: stategen.New(beaconDB),
 	}
 	s, err := NewService(ctx, cfg)
 	require.NoError(t, err)

beacon-chain/blockchain/process_attestation_test.go

@@ -21,28 +21,28 @@ import (
 
 func TestStore_OnAttestation(t *testing.T) {
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{
-		BeaconDB:        db,
+		BeaconDB:        beaconDB,
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
-		StateGen:        stategen.New(db, sc),
+		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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{
-		BeaconDB: db,
-		StateGen: stategen.New(db, sc),
+		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, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{
-		BeaconDB: db,
-		StateGen: stategen.New(db, sc),
+		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,25 +279,21 @@ 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)
 
-	d := &ethpb.AttestationData{
-		BeaconBlockRoot: make([]byte, 32),
-		Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-		Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-	}
+	d := testutil.HydrateAttestationData(&ethpb.AttestationData{})
 	assert.ErrorContains(t, "beacon block 0x000000000000 does not exist", service.verifyBeaconBlock(ctx, d))
 }
 
 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 +309,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 +327,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 +351,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 +375,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 +402,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 +429,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)
 

beacon-chain/blockchain/process_block.go

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -303,7 +304,12 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed *ethpb
 	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
-	s.stateGen.SaveStateSummary(ctx, signed, blockRoot)
+	if err := s.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{
+		Slot: signed.Block.Slot,
+		Root: blockRoot[:],
+	}); err != nil {
+		return err
+	}
 
 	// Rate limit how many blocks (2 epochs worth of blocks) a node keeps in the memory.
 	if uint64(len(s.getInitSyncBlocks())) > initialSyncBlockCacheSize {
@@ -330,7 +336,15 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed *ethpb
 
 // Epoch boundary bookkeeping such as logging epoch summaries.
 func (s *Service) handleEpochBoundary(ctx context.Context, postState *stateTrie.BeaconState) error {
-	if postState.Slot() >= s.nextEpochBoundarySlot {
+	if postState.Slot()+1 == s.nextEpochBoundarySlot {
+		// Update caches for the next epoch at epoch boundary slot - 1.
+		if err := helpers.UpdateCommitteeCache(postState, helpers.NextEpoch(postState)); err != nil {
+			return err
+		}
+		if err := helpers.UpdateProposerIndicesInCache(postState, helpers.NextEpoch(postState)); err != nil {
+			return err
+		}
+	} else if postState.Slot() >= s.nextEpochBoundarySlot {
 		if err := reportEpochMetrics(ctx, postState, s.head.state); err != nil {
 			return err
 		}
@@ -339,7 +353,9 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState *stateTrie.
 		if err != nil {
 			return err
 		}
-		// Update committees cache at epoch boundary slot.
+
+		// Update caches at epoch boundary slot.
+		// The following updates have short cut to return nil cheaply if fulfilled during boundary slot - 1.
 		if err := helpers.UpdateCommitteeCache(postState, helpers.CurrentEpoch(postState)); err != nil {
 			return err
 		}
@@ -347,21 +363,22 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState *stateTrie.
 			return err
 		}
 	}
+
 	return nil
 }
 
 // This feeds in the block and block's attestations to fork choice store. It's allows fork choice store
 // to gain information on the most current chain.
 func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Context, blk *ethpb.BeaconBlock, root [32]byte,
-	state *stateTrie.BeaconState) error {
-	fCheckpoint := state.FinalizedCheckpoint()
-	jCheckpoint := state.CurrentJustifiedCheckpoint()
+	st *stateTrie.BeaconState) error {
+	fCheckpoint := st.FinalizedCheckpoint()
+	jCheckpoint := st.CurrentJustifiedCheckpoint()
 	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
 	// Feed in block's attestations to fork choice store.
 	for _, a := range blk.Body.Attestations {
-		committee, err := helpers.BeaconCommitteeFromState(state, a.Data.Slot, a.Data.CommitteeIndex)
+		committee, err := helpers.BeaconCommitteeFromState(st, a.Data.Slot, a.Data.CommitteeIndex)
 		if err != nil {
 			return err
 		}
@@ -388,7 +405,7 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk *ethpb.B
 
 // This saves post state info to DB or cache. This also saves post state info to fork choice store.
 // Post state info consists of processed block and state. Do not call this method unless the block and state are verified.
-func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b *ethpb.SignedBeaconBlock, state *stateTrie.BeaconState, initSync bool) error {
+func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b *ethpb.SignedBeaconBlock, st *stateTrie.BeaconState, initSync bool) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.savePostStateInfo")
 	defer span.End()
 	if initSync {
@@ -396,10 +413,10 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b *ethpb.Si
 	} else if err := s.beaconDB.SaveBlock(ctx, b); err != nil {
 		return errors.Wrapf(err, "could not save block from slot %d", b.Block.Slot)
 	}
-	if err := s.stateGen.SaveState(ctx, r, state); err != nil {
+	if err := s.stateGen.SaveState(ctx, r, st); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}
-	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, b.Block, r, state); err != nil {
+	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, b.Block, r, st); err != nil {
 		return errors.Wrapf(err, "could not insert block %d to fork choice store", b.Block.Slot)
 	}
 	return nil

beacon-chain/blockchain/process_block_helpers.go

@@ -63,7 +63,7 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b *ethpb.BeaconBlock) e
 	// Loosen the check to HasBlock because state summary gets saved in batches
 	// during initial syncing. There's no risk given a state summary object is just a
 	// a subset of the block object.
-	if !s.stateGen.StateSummaryExists(ctx, parentRoot) && !s.beaconDB.HasBlock(ctx, parentRoot) {
+	if !s.beaconDB.HasStateSummary(ctx, parentRoot) && !s.beaconDB.HasBlock(ctx, parentRoot) {
 		return errors.New("could not reconstruct parent state")
 	}
 

beacon-chain/blockchain/process_block_test.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
@@ -28,28 +28,28 @@ import (
 
 func TestStore_OnBlock(t *testing.T) {
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{
-		BeaconDB:        db,
-		StateGen:        stategen.New(db, sc),
+		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[:]}))
@@ -123,18 +123,18 @@ func TestStore_OnBlock(t *testing.T) {
 
 func TestStore_OnBlockBatch(t *testing.T) {
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{
-		BeaconDB: db,
-		StateGen: stategen.New(db, sc),
+		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{
@@ -166,7 +166,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)
@@ -174,11 +174,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()
@@ -208,11 +208,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()
@@ -237,11 +237,11 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 
 func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{
-		BeaconDB: db,
-		StateGen: stategen.New(db, sc),
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
@@ -251,7 +251,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{
@@ -270,18 +270,18 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 
 func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
 	cfg := &Config{
-		BeaconDB: db,
-		StateGen: stategen.New(db, sc),
+		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{
@@ -307,20 +307,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, cache.NewStateSummaryCache())}
+	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()
@@ -338,9 +338,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'})
@@ -348,13 +348,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)
@@ -375,9 +375,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'})
@@ -385,13 +385,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)
@@ -415,9 +415,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'})
@@ -426,7 +426,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()
@@ -467,7 +467,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
@@ -531,20 +531,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
@@ -568,9 +568,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)
 
@@ -593,7 +593,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.
@@ -650,9 +650,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)
 
@@ -675,7 +675,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))
@@ -702,7 +702,7 @@ func TestEnsureRootNotZeroHashes(t *testing.T) {
 }
 
 func TestFinalizedImpliesNewJustified(t *testing.T) {
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 	type args struct {
 		cachedCheckPoint        *ethpb.Checkpoint
@@ -743,7 +743,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, sc), 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)}))
@@ -777,26 +777,25 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 }
 
 func TestVerifyBlkDescendant(t *testing.T) {
-	db, sc := 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
 		finalizedRoot [32]byte
-		finalizedSlot uint64
 	}
 	tests := []struct {
 		name      string
@@ -835,7 +834,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		service, err := NewService(ctx, &Config{BeaconDB: db, StateGen: stategen.New(db, sc), 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[:],
@@ -850,9 +849,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)
 
@@ -889,3 +888,52 @@ func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 	service.head = &head{}
 	require.ErrorContains(t, "failed to initialize precompute: nil inner state", service.handleEpochBoundary(ctx, s))
 }
+
+func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
+	ctx := context.Background()
+	cfg := &Config{}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	s, _ := testutil.DeterministicGenesisState(t, 1024)
+	service.head = &head{state: s}
+	require.NoError(t, s.SetSlot(2*params.BeaconConfig().SlotsPerEpoch))
+	require.NoError(t, service.handleEpochBoundary(ctx, s))
+	require.Equal(t, 3*params.BeaconConfig().SlotsPerEpoch, service.nextEpochBoundarySlot)
+}
+
+func TestOnBlock_CanFinalize(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	depositCache, err := depositcache.New()
+	require.NoError(t, err)
+	cfg := &Config{
+		BeaconDB:        beaconDB,
+		StateGen:        stategen.New(beaconDB),
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		DepositCache:    depositCache,
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	gs, keys := testutil.DeterministicGenesisState(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	gBlk, err := service.beaconDB.GenesisBlock(ctx)
+	require.NoError(t, err)
+	gRoot, err := gBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+
+	testState := gs.Copy()
+	for i := uint64(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
+		blk, err := testutil.GenerateFullBlock(testState, keys, testutil.DefaultBlockGenConfig(), i)
+		require.NoError(t, err)
+		r, err := blk.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, service.onBlock(ctx, blk, r))
+		testState, err = service.stateGen.StateByRoot(ctx, r)
+		require.NoError(t, err)
+	}
+	require.Equal(t, uint64(3), service.CurrentJustifiedCheckpt().Epoch)
+	require.Equal(t, uint64(2), service.FinalizedCheckpt().Epoch)
+}

beacon-chain/blockchain/receive_attestation.go

@@ -125,7 +125,7 @@ func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 					continue
 				}
 
-				hasState := s.stateGen.StateSummaryExists(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
+				hasState := s.beaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
 				hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
 				if !(hasState && hasBlock) {
 					continue

beacon-chain/blockchain/receive_attestation_test.go

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

beacon-chain/blockchain/receive_block.go

@@ -51,9 +51,10 @@ func (s *Service) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlo
 	s.stateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
-			Slot:      blockCopy.Block.Slot,
-			BlockRoot: blockRoot,
-			Verified:  true,
+			Slot:        blockCopy.Block.Slot,
+			BlockRoot:   blockRoot,
+			SignedBlock: blockCopy,
+			Verified:    true,
 		},
 	})
 
@@ -97,9 +98,10 @@ func (s *Service) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.Sign
 	s.stateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
-			Slot:      blockCopy.Block.Slot,
-			BlockRoot: blockRoot,
-			Verified:  true,
+			Slot:        blockCopy.Block.Slot,
+			BlockRoot:   blockRoot,
+			SignedBlock: blockCopy,
+			Verified:    true,
 		},
 	})
 
@@ -141,9 +143,10 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []*ethpb.SignedB
 		s.stateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.BlockProcessed,
 			Data: &statefeed.BlockProcessedData{
-				Slot:      blockCopy.Block.Slot,
-				BlockRoot: blkRoots[i],
-				Verified:  true,
+				Slot:        blockCopy.Block.Slot,
+				BlockRoot:   blkRoots[i],
+				SignedBlock: blockCopy,
+				Verified:    true,
 			},
 		})
 

beacon-chain/blockchain/receive_block_test.go

@@ -117,12 +117,12 @@ func TestService_ReceiveBlock(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			db, stateSummaryCache := 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, stateSummaryCache),
+				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, stateSummaryCache := 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, stateSummaryCache),
+		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, stateSummaryCache := 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, stateSummaryCache),
+				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, stateSummaryCache := 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, stateSummaryCache),
+				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, stateSummaryCache := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db, stateSummaryCache)})
+	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, stateSummaryCache := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db, stateSummaryCache)})
+	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, stateSummaryCache := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db, stateSummaryCache)})
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
 	require.NoError(t, err)
 	s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
 	s.genesisTime = time.Now()

beacon-chain/blockchain/service.go

@@ -342,11 +342,6 @@ func (s *Service) Stop() error {
 		}
 	}
 
-	// Save cached state summaries to the DB before stop.
-	if err := s.stateGen.SaveStateSummariesToDB(s.ctx); err != nil {
-		return err
-	}
-
 	// Save initial sync cached blocks to the DB before stop.
 	return s.beaconDB.SaveBlocks(s.ctx, s.getInitSyncBlocks())
 }

beacon-chain/blockchain/service_norace_test.go

@@ -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{}))

beacon-chain/blockchain/service_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -63,7 +62,7 @@ func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ *
 
 var _ p2p.Broadcaster = (*mockBroadcaster)(nil)
 
-func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummaryCache) *Service {
+func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	endpoint := "http://127.0.0.1"
 	ctx := context.Background()
 	var web3Service *powchain.Service
@@ -87,7 +86,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummary
 	require.NoError(t, err)
 	web3Service, err = powchain.NewService(ctx, &powchain.Web3ServiceConfig{
 		BeaconDB:        beaconDB,
-		HTTPEndPoint:    endpoint,
+		HTTPEndpoints:   []string{endpoint},
 		DepositContract: common.Address{},
 	})
 	require.NoError(t, err, "Unable to set up web3 service")
@@ -106,7 +105,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummary
 		P2p:               &mockBroadcaster{},
 		StateNotifier:     &mockBeaconNode{},
 		AttPool:           attestations.NewPool(),
-		StateGen:          stategen.New(beaconDB, sc),
+		StateGen:          stategen.New(beaconDB),
 		ForkChoiceStore:   protoarray.New(0, 0, params.BeaconConfig().ZeroHash),
 		OpsService:        opsService,
 	}
@@ -124,21 +123,21 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummary
 func TestChainStartStop_Initialized(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
-	chainService := setupBeaconChain(t, db, sc)
+	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()
@@ -153,18 +152,18 @@ func TestChainStartStop_Initialized(t *testing.T) {
 func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
-	chainService := setupBeaconChain(t, db, sc)
+	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()
@@ -178,10 +177,10 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 
 func TestChainService_InitializeBeaconChain(t *testing.T) {
 	helpers.ClearCache()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	bc := setupBeaconChain(t, db, sc)
+	bc := setupBeaconChain(t, beaconDB)
 	var err error
 
 	// Set up 10 deposits pre chain start for validators to register
@@ -221,20 +220,20 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 
 func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	ctx := context.Background()
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 
-	chainService := setupBeaconChain(t, db, sc)
+	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()
@@ -247,14 +246,14 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 }
 
 func TestChainService_InitializeChainInfo(t *testing.T) {
-	db, sc := 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()
@@ -265,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, sc)}
+	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)
@@ -287,14 +286,14 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 }
 
 func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
-	db, sc := 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()
@@ -305,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, sc)}
+	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)
@@ -328,21 +327,21 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 
 	hook := logTest.NewGlobal()
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
-	db, sc := 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()
@@ -350,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, sc)}
+	c := &Service{beaconDB: beaconDB, stateGen: stategen.New(beaconDB)}
 
 	require.NoError(t, c.initializeChainInfo(ctx))
 	s, err := c.HeadState(ctx)
@@ -382,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))
@@ -399,40 +398,40 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 }
 
 func TestChainService_SaveHeadNoDB(t *testing.T) {
-	db, sc := testDB.SetupDB(t)
+	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 	s := &Service{
-		beaconDB: db,
-		stateGen: stategen.New(db, sc),
+		beaconDB: beaconDB,
+		stateGen: stategen.New(beaconDB),
 	}
-	b := testutil.NewBeaconBlock()
-	b.Block.Slot = 1
-	r, err := b.HashTreeRoot()
+	blk := testutil.NewBeaconBlock()
+	blk.Block.Slot = 1
+	r, err := blk.HashTreeRoot()
 	require.NoError(t, err)
 	newState := testutil.NewBeaconState()
 	require.NoError(t, s.stateGen.SaveState(ctx, r, newState))
-	require.NoError(t, s.saveHeadNoDB(ctx, b, r, newState))
+	require.NoError(t, s.saveHeadNoDB(ctx, blk, r, newState))
 
 	newB, err := s.beaconDB.HeadBlock(ctx)
 	require.NoError(t, err)
-	if reflect.DeepEqual(newB, b) {
+	if reflect.DeepEqual(newB, blk) {
 		t.Error("head block should not be equal")
 	}
 }
 
 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()
 	require.NoError(t, err)
-	state := testutil.NewBeaconState()
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))
+	beaconState := testutil.NewBeaconState()
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, beaconState))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -440,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, cache.NewStateSummaryCache()),
+		stateGen:       stategen.New(beaconDB),
 	}
 	b := testutil.NewBeaconBlock()
 	r, err := b.Block.HashTreeRoot()
@@ -456,30 +455,11 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	require.Equal(t, true, s.beaconDB.HasBlock(ctx, r))
 }
 
-func TestServiceStop_SaveCachedStateSummaries(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	db, _ := testDB.SetupDB(t)
-	c := cache.NewStateSummaryCache()
-	s := &Service{
-		ctx:            ctx,
-		cancel:         cancel,
-		beaconDB:       db,
-		initSyncBlocks: make(map[[32]byte]*ethpb.SignedBeaconBlock),
-		stateGen:       stategen.New(db, c),
-	}
-
-	r := [32]byte{'a'}
-	ss := &pb.StateSummary{Root: r[:], Slot: 1}
-	c.Put(r, ss)
-	require.NoError(t, s.Stop())
-	require.Equal(t, true, s.beaconDB.HasStateSummary(ctx, r))
-}
-
 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))
@@ -494,19 +474,19 @@ 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()
 	require.NoError(b, err)
 	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
-	state, err := beaconstate.InitializeFromProto(bs)
+	beaconState, err := beaconstate.InitializeFromProto(bs)
 	require.NoError(b, err)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/blockchain/testing/mock.go

@@ -47,6 +47,7 @@ type ChainService struct {
 	ValidAttestation            bool
 	ForkChoiceStore             *protoarray.Store
 	VerifyBlkDescendantErr      error
+	Slot                        *uint64 // Pointer because 0 is a useful value, so checking against it can be incorrect.
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -323,6 +324,9 @@ func (ms *ChainService) GenesisValidatorRoot() [32]byte {
 
 // CurrentSlot mocks the same method in the chain service.
 func (ms *ChainService) CurrentSlot() uint64 {
+	if ms.Slot != nil {
+		return *ms.Slot
+	}
 	return uint64(time.Now().Unix()-ms.Genesis.Unix()) / params.BeaconConfig().SecondsPerSlot
 }
 

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -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,

beacon-chain/cache/BUILD.bazel

@@ -11,9 +11,7 @@ go_library(
         "committees.go",
         "common.go",
         "doc.go",
-        "hot_state_cache.go",
         "skip_slot_cache.go",
-        "state_summary.go",
         "subnet_ids.go",
         "proposer_indices_type.go",
     ] + select({
@@ -58,7 +56,6 @@ go_test(
         "committee_fuzz_test.go",
         "committee_test.go",
         "cache_test.go",
-        "hot_state_cache_test.go",
         "skip_slot_cache_test.go",
         "subnet_ids_test.go",
         "proposer_indices_test.go"

beacon-chain/cache/depositcache/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "deposits_cache.go",
+        "log.go",
         "pending_deposits.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache",

beacon-chain/cache/depositcache/deposits_cache.go

@@ -19,7 +19,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/trieutil"
-	log "github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
@@ -78,7 +78,7 @@ func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blo
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertDeposit")
 	defer span.End()
 	if d == nil {
-		log.WithFields(log.Fields{
+		log.WithFields(logrus.Fields{
 			"block":        blockNum,
 			"deposit":      d,
 			"index":        index,

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -611,8 +611,8 @@ func TestPruneProofs_Ok(t *testing.T) {
 
 	require.NoError(t, dc.PruneProofs(context.Background(), 1))
 
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[0].Deposit.Proof)
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[1].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[0].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[1].Deposit.Proof)
 	assert.NotNil(t, dc.deposits[2].Deposit.Proof)
 	assert.NotNil(t, dc.deposits[3].Deposit.Proof)
 }
@@ -654,7 +654,7 @@ func TestPruneProofs_SomeAlreadyPruned(t *testing.T) {
 
 	require.NoError(t, dc.PruneProofs(context.Background(), 2))
 
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[2].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[2].Deposit.Proof)
 }
 
 func TestPruneProofs_PruneAllWhenDepositIndexTooBig(t *testing.T) {
@@ -694,10 +694,10 @@ func TestPruneProofs_PruneAllWhenDepositIndexTooBig(t *testing.T) {
 
 	require.NoError(t, dc.PruneProofs(context.Background(), 99))
 
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[0].Deposit.Proof)
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[1].Deposit.Proof)
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[2].Deposit.Proof)
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[3].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[0].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[1].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[2].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[3].Deposit.Proof)
 }
 
 func TestPruneProofs_CorrectlyHandleLastIndex(t *testing.T) {
@@ -737,10 +737,10 @@ func TestPruneProofs_CorrectlyHandleLastIndex(t *testing.T) {
 
 	require.NoError(t, dc.PruneProofs(context.Background(), 4))
 
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[0].Deposit.Proof)
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[1].Deposit.Proof)
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[2].Deposit.Proof)
-	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[3].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[0].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[1].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[2].Deposit.Proof)
+	assert.DeepEqual(t, [][]byte(nil), dc.deposits[3].Deposit.Proof)
 }
 
 func makeDepositProof() [][]byte {

beacon-chain/cache/depositcache/log.go

@@ -0,0 +1,5 @@
+package depositcache
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "depositcache")

beacon-chain/cache/depositcache/pending_deposits.go

@@ -10,7 +10,7 @@ import (
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
 	"github.com/prysmaticlabs/prysm/shared/hashutil"
-	log "github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
@@ -33,7 +33,7 @@ func (dc *DepositCache) InsertPendingDeposit(ctx context.Context, d *ethpb.Depos
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertPendingDeposit")
 	defer span.End()
 	if d == nil {
-		log.WithFields(log.Fields{
+		log.WithFields(logrus.Fields{
 			"block":   blockNum,
 			"deposit": d,
 		}).Debug("Ignoring nil deposit insertion")

beacon-chain/cache/proposer_indices.go

@@ -63,6 +63,17 @@ func (c *ProposerIndicesCache) AddProposerIndices(p *ProposerIndices) error {
 	return nil
 }
 
+// HasProposerIndices returns the proposer indices of a block root seed.
+func (c *ProposerIndicesCache) HasProposerIndices(r [32]byte) (bool, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	_, exists, err := c.ProposerIndicesCache.GetByKey(key(r))
+	if err != nil {
+		return false, err
+	}
+	return exists, nil
+}
+
 // ProposerIndices returns the proposer indices of a block root seed.
 func (c *ProposerIndicesCache) ProposerIndices(r [32]byte) ([]uint64, error) {
 	c.lock.RLock()

beacon-chain/cache/proposer_indices_disabled.go

@@ -22,3 +22,8 @@ func (c *FakeProposerIndicesCache) AddProposerIndices(p *ProposerIndices) error
 func (c *FakeProposerIndicesCache) ProposerIndices(r [32]byte) ([]uint64, error) {
 	return nil, nil
 }
+
+// HasProposerIndices returns the proposer indices of a block root seed.
+func (c *FakeProposerIndicesCache) HasProposerIndices(r [32]byte) (bool, error) {
+	return false, nil
+}

beacon-chain/cache/proposer_indices_test.go

@@ -33,6 +33,9 @@ func TestProposerCache_AddProposerIndicesList(t *testing.T) {
 	if indices != nil {
 		t.Error("Expected committee count not to exist in empty cache")
 	}
+	has, err := cache.HasProposerIndices(bRoot)
+	require.NoError(t, err)
+	assert.Equal(t, false, has)
 	require.NoError(t, cache.AddProposerIndices(&ProposerIndices{
 		ProposerIndices: indices,
 		BlockRoot:       bRoot,
@@ -41,6 +44,9 @@ func TestProposerCache_AddProposerIndicesList(t *testing.T) {
 	received, err := cache.ProposerIndices(bRoot)
 	require.NoError(t, err)
 	assert.DeepEqual(t, received, indices)
+	has, err = cache.HasProposerIndices(bRoot)
+	require.NoError(t, err)
+	assert.Equal(t, true, has)
 
 	item := &ProposerIndices{BlockRoot: [32]byte{'B'}, ProposerIndices: []uint64{1, 2, 3, 4, 5, 6}}
 	require.NoError(t, cache.AddProposerIndices(item))
@@ -48,6 +54,10 @@ func TestProposerCache_AddProposerIndicesList(t *testing.T) {
 	received, err = cache.ProposerIndices(item.BlockRoot)
 	require.NoError(t, err)
 	assert.DeepEqual(t, item.ProposerIndices, received)
+	has, err = cache.HasProposerIndices(bRoot)
+	require.NoError(t, err)
+	assert.Equal(t, true, has)
+
 }
 
 func TestProposerCache_CanRotate(t *testing.T) {

beacon-chain/cache/subnet_ids.go

@@ -35,7 +35,7 @@ func newSubnetIDs() *subnetIDs {
 		panic(err)
 	}
 	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot)
-	subLength := epochDuration * time.Duration(params.BeaconNetworkConfig().EpochsPerRandomSubnetSubscription)
+	subLength := epochDuration * time.Duration(params.BeaconConfig().EpochsPerRandomSubnetSubscription)
 	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
 	return &subnetIDs{attester: attesterCache, aggregator: aggregatorCache, persistentSubnets: persistentCache}
 }

beacon-chain/core/blocks/BUILD.bazel

@@ -35,12 +35,12 @@ go_library(
         "//shared/hashutil:go_default_library",
         "//shared/mathutil:go_default_library",
         "//shared/params:go_default_library",
+        "//shared/slashutil:go_default_library",
         "//shared/sliceutil:go_default_library",
         "//shared/trieutil:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],

beacon-chain/core/blocks/attestation.go

@@ -12,7 +12,6 @@ import (
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bls"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )
@@ -110,10 +109,9 @@ func ProcessAttestationNoVerifySignature(
 	ctx, span := trace.StartSpan(ctx, "core.ProcessAttestationNoVerifySignature")
 	defer span.End()
 
-	if att == nil || att.Data == nil || att.Data.Target == nil {
-		return nil, errors.New("nil attestation data target")
+	if err := helpers.ValidateNilAttestation(att); err != nil {
+		return nil, err
 	}
-
 	currEpoch := helpers.SlotToEpoch(beaconState.Slot())
 	var prevEpoch uint64
 	if currEpoch == 0 {
@@ -275,8 +273,8 @@ func VerifyAttestationsSignatures(ctx context.Context, beaconState *stateTrie.Be
 // VerifyAttestationSignature converts and attestation into an indexed attestation and verifies
 // the signature in that attestation.
 func VerifyAttestationSignature(ctx context.Context, beaconState *stateTrie.BeaconState, att *ethpb.Attestation) error {
-	if att == nil || att.Data == nil || att.AggregationBits.Count() == 0 {
-		return fmt.Errorf("nil or missing attestation data: %v", att)
+	if err := helpers.ValidateNilAttestation(att); err != nil {
+		return err
 	}
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, att.Data.Slot, att.Data.CommitteeIndex)
 	if err != nil {
@@ -345,35 +343,3 @@ func verifyAttestationsSigWithDomain(ctx context.Context, beaconState *stateTrie
 	}
 	return nil
 }
-
-// VerifyAttSigUseCheckPt uses the checkpoint info object to verify attestation signature.
-func VerifyAttSigUseCheckPt(ctx context.Context, c *pb.CheckPtInfo, att *ethpb.Attestation) error {
-	if att == nil || att.Data == nil || att.AggregationBits.Count() == 0 {
-		return fmt.Errorf("nil or missing attestation data: %v", att)
-	}
-	seed := bytesutil.ToBytes32(c.Seed)
-	committee, err := helpers.BeaconCommittee(c.ActiveIndices, seed, att.Data.Slot, att.Data.CommitteeIndex)
-	if err != nil {
-		return err
-	}
-	indexedAtt := attestationutil.ConvertToIndexed(ctx, att, committee)
-	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
-		return err
-	}
-	domain, err := helpers.Domain(c.Fork, indexedAtt.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, c.GenesisRoot)
-	if err != nil {
-		return err
-	}
-	indices := indexedAtt.AttestingIndices
-	var pubkeys []bls.PublicKey
-	for i := 0; i < len(indices); i++ {
-		pubkeyAtIdx := c.PubKeys[indices[i]]
-		pk, err := bls.PublicKeyFromBytes(pubkeyAtIdx)
-		if err != nil {
-			return errors.Wrap(err, "could not deserialize validator public key")
-		}
-		pubkeys = append(pubkeys, pk)
-	}
-
-	return attestationutil.VerifyIndexedAttestationSig(ctx, indexedAtt, pubkeys, domain)
-}

beacon-chain/core/blocks/attestation_test.go

@@ -24,12 +24,12 @@ import (
 
 func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 	attestations := []*ethpb.Attestation{
-		{
+		testutil.HydrateAttestation(&ethpb.Attestation{
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 				Slot:   5,
 			},
-		},
+		}),
 	}
 	b := testutil.NewBeaconBlock()
 	b.Block = &ethpb.BeaconBlock{
@@ -50,10 +50,10 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 }
 
 func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
-	att := &ethpb.Attestation{
+	att := testutil.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
-			Target: &ethpb.Checkpoint{Epoch: 0}}}
+			Target: &ethpb.Checkpoint{Epoch: 0}}})
 
 	b := testutil.NewBeaconBlock()
 	b.Block = &ethpb.BeaconBlock{
@@ -211,15 +211,13 @@ func TestProcessAttestations_OK(t *testing.T) {
 	aggBits.SetBitAt(0, true)
 	var mockRoot [32]byte
 	copy(mockRoot[:], "hello-world")
-	att := &ethpb.Attestation{
+	att := testutil.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
-			BeaconBlockRoot: make([]byte, 32),
+			Source: &ethpb.Checkpoint{Root: mockRoot[:]},
+			Target: &ethpb.Checkpoint{Root: mockRoot[:]},
 		},
 		AggregationBits: aggBits,
-		Signature:       make([]byte, 96),
-	}
+	})
 
 	cfc := beaconState.CurrentJustifiedCheckpoint()
 	cfc.Root = mockRoot[:]
@@ -251,11 +249,10 @@ func TestProcessAttestations_OK(t *testing.T) {
 
 func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	data := &ethpb.AttestationData{
-		Source:          &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
-		Target:          &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
-		BeaconBlockRoot: make([]byte, 32),
-	}
+	data := testutil.HydrateAttestationData(&ethpb.AttestationData{
+		Source: &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
+		Target: &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
+	})
 	aggBits1 := bitfield.NewBitlist(4)
 	aggBits1.SetBitAt(0, true)
 	aggBits1.SetBitAt(1, true)
@@ -316,11 +313,10 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 
 	var mockRoot [32]byte
 	copy(mockRoot[:], "hello-world")
-	data := &ethpb.AttestationData{
-		Source:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
-		Target:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
-		BeaconBlockRoot: make([]byte, 32),
-	}
+	data := testutil.HydrateAttestationData(&ethpb.AttestationData{
+		Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+		Target: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+	})
 	aggBits1 := bitfield.NewBitlist(9)
 	aggBits1.SetBitAt(0, true)
 	aggBits1.SetBitAt(1, true)
@@ -387,12 +383,12 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 func TestProcessAttestationsNoVerify_IncorrectSlotTargetEpoch(t *testing.T) {
 	beaconState, _ := testutil.DeterministicGenesisState(t, 1)
 
-	att := &ethpb.Attestation{
+	att := testutil.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Slot:   params.BeaconConfig().SlotsPerEpoch,
 			Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
 		},
-	}
+	})
 	wanted := fmt.Sprintf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(att.Data.Slot), att.Data.Target.Epoch)
 	_, err := blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
 	assert.ErrorContains(t, wanted, err)
@@ -489,13 +485,9 @@ func TestConvertToIndexed_OK(t *testing.T) {
 
 	var sig [96]byte
 	copy(sig[:], "signed")
-	attestation := &ethpb.Attestation{
+	attestation := testutil.HydrateAttestation(&ethpb.Attestation{
 		Signature: sig[:],
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-		},
-	}
+	})
 	for _, tt := range tests {
 		attestation.AggregationBits = tt.aggregationBitfield
 		wanted := &ethpb.IndexedAttestation{
@@ -539,58 +531,39 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 		attestation *ethpb.IndexedAttestation
 	}{
 		{attestation: &ethpb.IndexedAttestation{
-			Data: &ethpb.AttestationData{
+			Data: testutil.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 2,
-					Root:  make([]byte, 32),
 				},
-				Source: &ethpb.Checkpoint{
-					Root: make([]byte, 32),
-				},
-				BeaconBlockRoot: make([]byte, 32),
-			},
+				Source: &ethpb.Checkpoint{},
+			}),
 			AttestingIndices: []uint64{1},
 			Signature:        make([]byte, 96),
 		}},
 		{attestation: &ethpb.IndexedAttestation{
-			Data: &ethpb.AttestationData{
+			Data: testutil.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 1,
-					Root:  make([]byte, 32),
 				},
-				Source: &ethpb.Checkpoint{
-					Root: make([]byte, 32),
-				},
-				BeaconBlockRoot: make([]byte, 32),
-			},
+			}),
 			AttestingIndices: []uint64{47, 99, 101},
 			Signature:        make([]byte, 96),
 		}},
 		{attestation: &ethpb.IndexedAttestation{
-			Data: &ethpb.AttestationData{
+			Data: testutil.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 4,
-					Root:  make([]byte, 32),
 				},
-				Source: &ethpb.Checkpoint{
-					Root: make([]byte, 32),
-				},
-				BeaconBlockRoot: make([]byte, 32),
-			},
+			}),
 			AttestingIndices: []uint64{21, 72},
 			Signature:        make([]byte, 96),
 		}},
 		{attestation: &ethpb.IndexedAttestation{
-			Data: &ethpb.AttestationData{
+			Data: testutil.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 7,
-					Root:  make([]byte, 32),
 				},
-				Source: &ethpb.Checkpoint{
-					Root: make([]byte, 32),
-				},
-				BeaconBlockRoot: make([]byte, 32),
-			},
+			}),
 			AttestingIndices: []uint64{100, 121, 122},
 			Signature:        make([]byte, 96),
 		}},
@@ -696,17 +669,12 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
 
 	comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
-	att1 := &ethpb.Attestation{
+	att1 := testutil.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  0,
-			BeaconBlockRoot: make([]byte, 32),
-			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Slot: 1,
 		},
-		Signature: make([]byte, 96),
-	}
+	})
 	domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
 	require.NoError(t, err)
 	root, err := helpers.ComputeSigningRoot(att1.Data, domain)
@@ -720,17 +688,13 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
 
 	comm2, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 1 /*committeeIndex*/)
 	require.NoError(t, err)
-	att2 := &ethpb.Attestation{
+	att2 := testutil.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  1,
-			BeaconBlockRoot: make([]byte, 32),
-			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Slot:           1,
+			CommitteeIndex: 1,
 		},
-		Signature: make([]byte, 96),
-	}
+	})
 	root, err = helpers.ComputeSigningRoot(att2.Data, domain)
 	require.NoError(t, err)
 	sigs = nil
@@ -771,17 +735,12 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 
 	comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
-	att1 := &ethpb.Attestation{
+	att1 := testutil.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  0,
-			BeaconBlockRoot: make([]byte, 32),
-			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Slot: 1,
 		},
-		Signature: make([]byte, 96),
-	}
+	})
 	prevDomain, err := helpers.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
 	require.NoError(t, err)
 	root, err := helpers.ComputeSigningRoot(att1.Data, prevDomain)
@@ -795,17 +754,13 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 
 	comm2, err := helpers.BeaconCommitteeFromState(st, 1*params.BeaconConfig().SlotsPerEpoch+1 /*slot*/, 1 /*committeeIndex*/)
 	require.NoError(t, err)
-	att2 := &ethpb.Attestation{
+	att2 := testutil.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
-			Slot:            1*params.BeaconConfig().SlotsPerEpoch + 1,
-			CommitteeIndex:  1,
-			BeaconBlockRoot: make([]byte, 32),
-			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Slot:           1*params.BeaconConfig().SlotsPerEpoch + 1,
+			CommitteeIndex: 1,
 		},
-		Signature: make([]byte, 96),
-	}
+	})
 	currDomain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
 	require.NoError(t, err)
 	root, err = helpers.ComputeSigningRoot(att2.Data, currDomain)
@@ -842,17 +797,12 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 
 	comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
-	att1 := &ethpb.Attestation{
+	att1 := testutil.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  0,
-			BeaconBlockRoot: make([]byte, 32),
-			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Slot: 1,
 		},
-		Signature: make([]byte, 96),
-	}
+	})
 	domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
 	require.NoError(t, err)
 	root, err := helpers.ComputeSigningRoot(att1.Data, domain)
@@ -866,17 +816,13 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 
 	comm2, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 1 /*committeeIndex*/)
 	require.NoError(t, err)
-	att2 := &ethpb.Attestation{
+	att2 := testutil.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  1,
-			BeaconBlockRoot: make([]byte, 32),
-			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Slot:           1,
+			CommitteeIndex: 1,
 		},
-		Signature: make([]byte, 96),
-	}
+	})
 	root, err = helpers.ComputeSigningRoot(att2.Data, domain)
 	require.NoError(t, err)
 	sigs = nil

beacon-chain/core/blocks/attester_slashing.go

@@ -10,6 +10,7 @@ import (
 	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/slashutil"
 	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 )
 
@@ -120,7 +121,10 @@ func IsSlashableAttestationData(data1, data2 *ethpb.AttestationData) bool {
 		return false
 	}
 	isDoubleVote := !attestationutil.AttDataIsEqual(data1, data2) && data1.Target.Epoch == data2.Target.Epoch
-	isSurroundVote := data1.Source.Epoch < data2.Source.Epoch && data2.Target.Epoch < data1.Target.Epoch
+	att1 := &ethpb.IndexedAttestation{Data: data1}
+	att2 := &ethpb.IndexedAttestation{Data: data2}
+	// Check if att1 is surrounding att2.
+	isSurroundVote := slashutil.IsSurround(att1, att2)
 	return isDoubleVote || isSurroundVote
 }
 

beacon-chain/core/blocks/attester_slashing_test.go

@@ -18,16 +18,14 @@ import (
 )
 
 func TestSlashableAttestationData_CanSlash(t *testing.T) {
-	att1 := &ethpb.AttestationData{
-		Target:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-		Source:          &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)},
-		BeaconBlockRoot: make([]byte, 32),
-	}
-	att2 := &ethpb.AttestationData{
-		Target:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-		Source:          &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'B'}, 32)},
-		BeaconBlockRoot: make([]byte, 32),
-	}
+	att1 := testutil.HydrateAttestationData(&ethpb.AttestationData{
+		Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+		Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)},
+	})
+	att2 := testutil.HydrateAttestationData(&ethpb.AttestationData{
+		Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+		Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'B'}, 32)},
+	})
 	assert.Equal(t, true, blocks.IsSlashableAttestationData(att1, att2), "Atts should have been slashable")
 	att1.Target.Epoch = 4
 	att1.Source.Epoch = 2
@@ -36,26 +34,14 @@ func TestSlashableAttestationData_CanSlash(t *testing.T) {
 }
 
 func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
-	slashings := []*ethpb.AttesterSlashing{
-		{
-			Attestation_1: &ethpb.IndexedAttestation{
-				Data: &ethpb.AttestationData{
-					Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-					BeaconBlockRoot: make([]byte, 32),
-				},
-				Signature: make([]byte, 96),
-			},
-			Attestation_2: &ethpb.IndexedAttestation{
-				Data: &ethpb.AttestationData{
-					Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-					Target:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-					BeaconBlockRoot: make([]byte, 32),
-				},
-				Signature: make([]byte, 96),
-			},
-		},
-	}
+	slashings := []*ethpb.AttesterSlashing{{
+		Attestation_1: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{}),
+		Attestation_2: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+			Data: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Epoch: 1},
+				Target: &ethpb.Checkpoint{Epoch: 1}},
+		})}}
+
 	var registry []*ethpb.Validator
 	currentSlot := uint64(0)
 
@@ -86,24 +72,15 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 
 	slashings := []*ethpb.AttesterSlashing{
 		{
-			Attestation_1: &ethpb.IndexedAttestation{
+			Attestation_1: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 				Data: &ethpb.AttestationData{
-					Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-					BeaconBlockRoot: make([]byte, 32),
+					Source: &ethpb.Checkpoint{Epoch: 1},
 				},
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
-				Signature:        make([]byte, 96),
-			},
-			Attestation_2: &ethpb.IndexedAttestation{
-				Data: &ethpb.AttestationData{
-					Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-					BeaconBlockRoot: make([]byte, 32),
-				},
+			}),
+			Attestation_2: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
-				Signature:        make([]byte, 96),
-			},
+			}),
 		},
 	}
 
@@ -124,14 +101,12 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		vv.WithdrawableEpoch = 1 * params.BeaconConfig().SlotsPerEpoch
 	}
 
-	att1 := &ethpb.IndexedAttestation{
+	att1 := testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			BeaconBlockRoot: make([]byte, 32),
+			Source: &ethpb.Checkpoint{Epoch: 1},
 		},
 		AttestingIndices: []uint64{0, 1},
-	}
+	})
 	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
 	require.NoError(t, err)
 	signingRoot, err := helpers.ComputeSigningRoot(att1.Data, domain)
@@ -141,14 +116,9 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
 	att1.Signature = aggregateSig.Marshal()
 
-	att2 := &ethpb.IndexedAttestation{
-		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			BeaconBlockRoot: make([]byte, 32),
-		},
+	att2 := testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		AttestingIndices: []uint64{0, 1},
-	}
+	})
 	signingRoot, err = helpers.ComputeSigningRoot(att2.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")
 	sig0 = privKeys[0].Sign(signingRoot[:])

beacon-chain/core/blocks/block_regression_test.go

@@ -38,11 +38,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 
 	root1 := [32]byte{'d', 'o', 'u', 'b', 'l', 'e', '1'}
 	att1 := &ethpb.IndexedAttestation{
-		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: root1[:]},
-			BeaconBlockRoot: make([]byte, 32),
-		},
+		Data:             testutil.HydrateAttestationData(&ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: 0, Root: root1[:]}}),
 		AttestingIndices: setA,
 		Signature:        make([]byte, 96),
 	}
@@ -60,11 +56,9 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 
 	root2 := [32]byte{'d', 'o', 'u', 'b', 'l', 'e', '2'}
 	att2 := &ethpb.IndexedAttestation{
-		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: root2[:]},
-			BeaconBlockRoot: make([]byte, 32),
-		},
+		Data: testutil.HydrateAttestationData(&ethpb.AttestationData{
+			Target: &ethpb.Checkpoint{Root: root2[:]},
+		}),
 		AttestingIndices: setB,
 		Signature:        make([]byte, 96),
 	}

beacon-chain/core/blocks/deposit.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -223,7 +222,6 @@ func verifyDeposit(beaconState *stateTrie.BeaconState, deposit *ethpb.Deposit) e
 	return nil
 }
 
-// Deprecated: This method uses deprecated ssz.SigningRoot.
 func verifyDepositDataSigningRoot(obj *ethpb.Deposit_Data, domain []byte) error {
 	return depositutil.VerifyDepositSignature(obj, domain)
 }
@@ -248,7 +246,12 @@ func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, dom
 		}
 		pks[i] = dpk
 		sigs[i] = dep.Data.Signature
-		root, err := ssz.SigningRoot(dep.Data)
+		depositMessage := &pb.DepositMessage{
+			PublicKey:             dep.Data.PublicKey,
+			WithdrawalCredentials: dep.Data.WithdrawalCredentials,
+			Amount:                dep.Data.Amount,
+		}
+		root, err := depositMessage.HashTreeRoot()
 		if err != nil {
 			return errors.Wrap(err, "could not get signing root")
 		}

beacon-chain/core/blocks/deposit_test.go

@@ -188,7 +188,7 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 }
 
 func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
-	//Similar to TestProcessDeposits_AddsNewValidatorDeposit except that this test directly calls ProcessDeposit
+	// Similar to TestProcessDeposits_AddsNewValidatorDeposit except that this test directly calls ProcessDeposit
 	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
 	require.NoError(t, err)
 	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
@@ -277,9 +277,7 @@ func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) {
 	testutil.ResetCache()
 	dep, _, err := testutil.DeterministicDepositsAndKeys(100)
 	require.NoError(t, err)
-	defer func() {
-		testutil.ResetCache()
-	}()
+	defer testutil.ResetCache()
 	dep[0].Data.Signature = make([]byte, 96)
 	trie, _, err := testutil.DepositTrieFromDeposits(dep)
 	require.NoError(t, err)

beacon-chain/core/blocks/header_test.go

@@ -37,12 +37,9 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetSlot(10))
 	require.NoError(t, state.SetValidators(validators))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:       10, // Must be less than block.Slot
-		ParentRoot: make([]byte, 32),
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	}))
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 10, // Must be less than block.Slot
+	})))
 
 	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -74,12 +71,9 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 	testutil.ResetCache()
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	require.NoError(t, beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:       9,
-		ParentRoot: make([]byte, 32),
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	}))
+	require.NoError(t, beaconState.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 9,
+	})))
 	require.NoError(t, beaconState.SetSlot(10))
 
 	lbhdr, err := beaconState.LatestBlockHeader().HashTreeRoot()
@@ -115,13 +109,9 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:          9,
-		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}))
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 9,
+	})))
 
 	lbhsr, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -239,13 +229,9 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:          9,
-		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}))
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 9,
+	})))
 
 	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -300,13 +286,10 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
 		Slot:          9,
 		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}))
+	})))
 
 	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -141,27 +141,21 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 	proposerIdx := uint64(1)
 
 	header1 := &ethpb.SignedBeaconBlockHeader{
-		Header: &ethpb.BeaconBlockHeader{
+		Header: testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerIdx,
-			Slot:          0,
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 			StateRoot:     bytesutil.PadTo([]byte("A"), 32),
-		},
+		}),
 	}
 	var err error
 	header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
 
-	header2 := &ethpb.SignedBeaconBlockHeader{
+	header2 := testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerIdx,
-			Slot:          0,
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 			StateRoot:     bytesutil.PadTo([]byte("B"), 32),
 		},
-	}
+	})
 	header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
 
@@ -211,24 +205,18 @@ func TestVerifyProposerSlashing(t *testing.T) {
 			name: "same header, same slot as state",
 			args: args{
 				slashing: &ethpb.ProposerSlashing{
-					Header_1: &ethpb.SignedBeaconBlockHeader{
+					Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
 							Slot:          currentSlot,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
-					},
-					Header_2: &ethpb.SignedBeaconBlockHeader{
+					}),
+					Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
 							Slot:          currentSlot,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
-					},
+					}),
 				},
 				beaconState: beaconState,
 			},
@@ -238,26 +226,18 @@ func TestVerifyProposerSlashing(t *testing.T) {
 			name: "same header, different signatures",
 			args: args{
 				slashing: &ethpb.ProposerSlashing{
-					Header_1: &ethpb.SignedBeaconBlockHeader{
+					Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
-							Slot:          0,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
 						Signature: sig1,
-					},
-					Header_2: &ethpb.SignedBeaconBlockHeader{
+					}),
+					Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
-							Slot:          0,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
 						Signature: sig2,
-					},
+					}),
 				},
 				beaconState: beaconState,
 			},

beacon-chain/core/epoch/epoch_processing_test.go

@@ -1,6 +1,7 @@
 package epoch_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -40,10 +41,10 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
 		Validators:  validators,
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	indices, err := epoch.UnslashedAttestingIndices(state, atts)
+	indices, err := epoch.UnslashedAttestingIndices(beaconState, atts)
 	require.NoError(t, err)
 	for i := 0; i < len(indices)-1; i++ {
 		if indices[i] >= indices[i+1] {
@@ -53,10 +54,10 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
 
 	// Verify the slashed validator is filtered.
 	slashedValidator := indices[0]
-	validators = state.Validators()
+	validators = beaconState.Validators()
 	validators[slashedValidator].Slashed = true
-	require.NoError(t, state.SetValidators(validators))
-	indices, err = epoch.UnslashedAttestingIndices(state, atts)
+	require.NoError(t, beaconState.SetValidators(validators))
+	indices, err = epoch.UnslashedAttestingIndices(beaconState, atts)
 	require.NoError(t, err)
 	for i := 0; i < len(indices); i++ {
 		assert.NotEqual(t, slashedValidator, indices[i], "Slashed validator %d is not filtered", slashedValidator)
@@ -86,10 +87,10 @@ func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
 		Validators:  validators,
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	indices, err := epoch.UnslashedAttestingIndices(state, atts)
+	indices, err := epoch.UnslashedAttestingIndices(beaconState, atts)
 	require.NoError(t, err)
 
 	for i := 0; i < len(indices)-1; i++ {
@@ -132,10 +133,10 @@ func TestAttestingBalance_CorrectBalance(t *testing.T) {
 		Validators: validators,
 		Balances:   balances,
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	balance, err := epoch.AttestingBalance(state, atts)
+	balance, err := epoch.AttestingBalance(beaconState, atts)
 	require.NoError(t, err)
 	wanted := 256 * params.BeaconConfig().MaxEffectiveBalance
 	assert.Equal(t, wanted, balance)
@@ -158,9 +159,9 @@ func TestBaseReward_AccurateRewards(t *testing.T) {
 				{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: tt.b}},
 			Balances: []uint64{tt.a},
 		}
-		state, err := state.InitializeFromProto(base)
+		beaconState, err := state.InitializeFromProto(base)
 		require.NoError(t, err)
-		c, err := epoch.BaseReward(state, 0)
+		c, err := epoch.BaseReward(beaconState, 0)
 		require.NoError(t, err)
 		assert.Equal(t, tt.c, c, "epoch.BaseReward(%d)", tt.a)
 	}
@@ -249,7 +250,7 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		t.Run(string(i), func(t *testing.T) {
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
 			original := proto.Clone(tt.state)
 			s, err := state.InitializeFromProto(tt.state)
 			require.NoError(t, err)
@@ -309,9 +310,9 @@ func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
 		},
 		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d", i)
@@ -332,10 +333,10 @@ func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
 			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
 		})
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	currentEpoch := helpers.CurrentEpoch(state)
-	newState, err := epoch.ProcessRegistryUpdates(state)
+	currentEpoch := helpers.CurrentEpoch(beaconState)
+	newState, err := epoch.ProcessRegistryUpdates(beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, currentEpoch+1, validator.ActivationEligibilityEpoch, "Could not update registry %d, unexpected activation eligibility epoch", i)
@@ -361,9 +362,9 @@ func TestProcessRegistryUpdates_ActivationCompletes(t *testing.T) {
 		},
 		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
@@ -385,9 +386,9 @@ func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
 		},
 		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, params.BeaconConfig().MaxSeedLookahead+1, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
@@ -410,9 +411,9 @@ func TestProcessRegistryUpdates_CanExits(t *testing.T) {
 		},
 		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, exitEpoch, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)

beacon-chain/core/epoch/precompute/reward_penalty_test.go

@@ -33,24 +33,24 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 	}
 	base.PreviousEpochAttestations = atts
 
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	vp, bp, err := New(context.Background(), state)
+	vp, bp, err := New(context.Background(), beaconState)
 	require.NoError(t, err)
-	vp, bp, err = ProcessAttestations(context.Background(), state, vp, bp)
+	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
 	require.NoError(t, err)
 
-	state, err = ProcessRewardsAndPenaltiesPrecompute(state, bp, vp)
+	beaconState, err = ProcessRewardsAndPenaltiesPrecompute(beaconState, bp, vp)
 	require.NoError(t, err)
 
 	// Indices that voted everything except for head, lost a bit money
 	wanted := uint64(31999810265)
-	assert.Equal(t, wanted, state.Balances()[4], "Unexpected balance")
+	assert.Equal(t, wanted, beaconState.Balances()[4], "Unexpected balance")
 
 	// Indices that did not vote, lost more money
 	wanted = uint64(31999873505)
-	assert.Equal(t, wanted, state.Balances()[0], "Unexpected balance")
+	assert.Equal(t, wanted, beaconState.Balances()[0], "Unexpected balance")
 }
 
 func TestAttestationDeltaPrecompute(t *testing.T) {
@@ -75,34 +75,34 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 		}
 	}
 	base.PreviousEpochAttestations = atts
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 	slashedAttestedIndices := []uint64{1413}
 	for _, i := range slashedAttestedIndices {
-		vs := state.Validators()
+		vs := beaconState.Validators()
 		vs[i].Slashed = true
-		require.Equal(t, nil, state.SetValidators(vs))
+		require.Equal(t, nil, beaconState.SetValidators(vs))
 	}
 
-	vp, bp, err := New(context.Background(), state)
+	vp, bp, err := New(context.Background(), beaconState)
 	require.NoError(t, err)
-	vp, bp, err = ProcessAttestations(context.Background(), state, vp, bp)
+	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
 	require.NoError(t, err)
 
 	// Add some variances to target and head balances.
 	// See: https://github.com/prysmaticlabs/prysm/issues/5593
 	bp.PrevEpochTargetAttested = bp.PrevEpochTargetAttested / 2
 	bp.PrevEpochHeadAttested = bp.PrevEpochHeadAttested * 2 / 3
-	rewards, penalties, err := AttestationsDelta(state, bp, vp)
+	rewards, penalties, err := AttestationsDelta(beaconState, bp, vp)
 	require.NoError(t, err)
-	attestedBalance, err := epoch.AttestingBalance(state, atts)
+	attestedBalance, err := epoch.AttestingBalance(beaconState, atts)
 	require.NoError(t, err)
-	totalBalance, err := helpers.TotalActiveBalance(state)
+	totalBalance, err := helpers.TotalActiveBalance(beaconState)
 	require.NoError(t, err)
 
 	attestedIndices := []uint64{55, 1339, 1746, 1811, 1569}
 	for _, i := range attestedIndices {
-		base, err := epoch.BaseReward(state, i)
+		base, err := epoch.BaseReward(beaconState, i)
 		require.NoError(t, err, "Could not get base reward")
 
 		// Base rewards for getting source right
@@ -119,7 +119,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 	}
 
 	for _, i := range slashedAttestedIndices {
-		base, err := epoch.BaseReward(state, i)
+		base, err := epoch.BaseReward(beaconState, i)
 		assert.NoError(t, err, "Could not get base reward")
 		assert.Equal(t, uint64(0), rewards[i], "Unexpected slashed indices reward balance")
 		assert.Equal(t, 3*base, penalties[i], "Unexpected slashed indices penalty balance")
@@ -127,7 +127,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 
 	nonAttestedIndices := []uint64{434, 677, 872, 791}
 	for _, i := range nonAttestedIndices {
-		base, err := epoch.BaseReward(state, i)
+		base, err := epoch.BaseReward(beaconState, i)
 		assert.NoError(t, err, "Could not get base reward")
 		wanted := 3 * base
 		// Since all these validators did not attest, they shouldn't get rewarded.
@@ -159,17 +159,17 @@ func TestAttestationDeltas_ZeroEpoch(t *testing.T) {
 		}
 	}
 	base.PreviousEpochAttestations = atts
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	pVals, pBal, err := New(context.Background(), state)
+	pVals, pBal, err := New(context.Background(), beaconState)
 	assert.NoError(t, err)
-	pVals, pBal, err = ProcessAttestations(context.Background(), state, pVals, pBal)
+	pVals, pBal, err = ProcessAttestations(context.Background(), beaconState, pVals, pBal)
 	require.NoError(t, err)
 
 	pBal.ActiveCurrentEpoch = 0 // Could cause a divide by zero panic.
 
-	_, _, err = AttestationsDelta(state, pBal, pVals)
+	_, _, err = AttestationsDelta(beaconState, pBal, pVals)
 	require.NoError(t, err)
 }
 
@@ -197,12 +197,12 @@ func TestAttestationDeltas_ZeroInclusionDelay(t *testing.T) {
 		}
 	}
 	base.PreviousEpochAttestations = atts
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	pVals, pBal, err := New(context.Background(), state)
+	pVals, pBal, err := New(context.Background(), beaconState)
 	require.NoError(t, err)
-	_, _, err = ProcessAttestations(context.Background(), state, pVals, pBal)
+	_, _, err = ProcessAttestations(context.Background(), beaconState, pVals, pBal)
 	require.ErrorContains(t, "attestation with inclusion delay of 0", err)
 }
 
@@ -223,27 +223,27 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 	}
 	base.PreviousEpochAttestations = atts
 
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch*10))
+	require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch*10))
 
 	slashedAttestedIndices := []uint64{14, 37, 68, 77, 139}
 	for _, i := range slashedAttestedIndices {
-		vs := state.Validators()
+		vs := beaconState.Validators()
 		vs[i].Slashed = true
-		require.NoError(t, state.SetValidators(vs))
+		require.NoError(t, beaconState.SetValidators(vs))
 	}
 
-	vp, bp, err := New(context.Background(), state)
+	vp, bp, err := New(context.Background(), beaconState)
 	require.NoError(t, err)
-	vp, bp, err = ProcessAttestations(context.Background(), state, vp, bp)
+	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
 	require.NoError(t, err)
-	rewards, penalties, err := AttestationsDelta(state, bp, vp)
+	rewards, penalties, err := AttestationsDelta(beaconState, bp, vp)
 	require.NoError(t, err)
 
-	finalityDelay := helpers.PrevEpoch(state) - state.FinalizedCheckpointEpoch()
+	finalityDelay := helpers.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch()
 	for _, i := range slashedAttestedIndices {
-		base, err := epoch.BaseReward(state, i)
+		base, err := epoch.BaseReward(beaconState, i)
 		require.NoError(t, err, "Could not get base reward")
 		penalty := 3 * base
 		proposerReward := base / params.BeaconConfig().ProposerRewardQuotient
@@ -297,7 +297,7 @@ func TestProposerDeltaPrecompute_HappyCase(t *testing.T) {
 	e := params.BeaconConfig().SlotsPerEpoch
 	validatorCount := uint64(10)
 	base := buildState(e, validatorCount)
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
 	proposerIndex := uint64(1)
@@ -305,7 +305,7 @@ func TestProposerDeltaPrecompute_HappyCase(t *testing.T) {
 	v := []*Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex},
 	}
-	r, err := ProposersDelta(state, b, v)
+	r, err := ProposersDelta(beaconState, b, v)
 	require.NoError(t, err)
 
 	baseReward := v[0].CurrentEpochEffectiveBalance * params.BeaconConfig().BaseRewardFactor /
@@ -319,7 +319,7 @@ func TestProposerDeltaPrecompute_ValidatorIndexOutOfRange(t *testing.T) {
 	e := params.BeaconConfig().SlotsPerEpoch
 	validatorCount := uint64(10)
 	base := buildState(e, validatorCount)
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
 	proposerIndex := validatorCount
@@ -327,7 +327,7 @@ func TestProposerDeltaPrecompute_ValidatorIndexOutOfRange(t *testing.T) {
 	v := []*Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex},
 	}
-	_, err = ProposersDelta(state, b, v)
+	_, err = ProposersDelta(beaconState, b, v)
 	assert.ErrorContains(t, "proposer index out of range", err)
 }
 
@@ -335,7 +335,7 @@ func TestProposerDeltaPrecompute_SlashedCase(t *testing.T) {
 	e := params.BeaconConfig().SlotsPerEpoch
 	validatorCount := uint64(10)
 	base := buildState(e, validatorCount)
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
 	proposerIndex := uint64(1)
@@ -343,7 +343,7 @@ func TestProposerDeltaPrecompute_SlashedCase(t *testing.T) {
 	v := []*Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex, IsSlashed: true},
 	}
-	r, err := ProposersDelta(state, b, v)
+	r, err := ProposersDelta(beaconState, b, v)
 	require.NoError(t, err)
 	assert.Equal(t, uint64(0), r[proposerIndex], "Unexpected proposer reward for slashed")
 }
@@ -351,51 +351,51 @@ func TestProposerDeltaPrecompute_SlashedCase(t *testing.T) {
 func TestFinalityDelay(t *testing.T) {
 	base := buildState(params.BeaconConfig().SlotsPerEpoch*10, 1)
 	base.FinalizedCheckpoint = &ethpb.Checkpoint{Epoch: 3}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 	prevEpoch := uint64(0)
 	finalizedEpoch := uint64(0)
 	// Set values for each test case
 	setVal := func() {
-		prevEpoch = helpers.PrevEpoch(state)
-		finalizedEpoch = state.FinalizedCheckpointEpoch()
+		prevEpoch = helpers.PrevEpoch(beaconState)
+		finalizedEpoch = beaconState.FinalizedCheckpointEpoch()
 	}
 	setVal()
 	d := finalityDelay(prevEpoch, finalizedEpoch)
-	w := helpers.PrevEpoch(state) - state.FinalizedCheckpointEpoch()
+	w := helpers.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch()
 	assert.Equal(t, w, d, "Did not get wanted finality delay")
 
-	require.NoError(t, state.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 4}))
+	require.NoError(t, beaconState.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 4}))
 	setVal()
 	d = finalityDelay(prevEpoch, finalizedEpoch)
-	w = helpers.PrevEpoch(state) - state.FinalizedCheckpointEpoch()
+	w = helpers.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch()
 	assert.Equal(t, w, d, "Did not get wanted finality delay")
 
-	require.NoError(t, state.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 5}))
+	require.NoError(t, beaconState.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 5}))
 	setVal()
 	d = finalityDelay(prevEpoch, finalizedEpoch)
-	w = helpers.PrevEpoch(state) - state.FinalizedCheckpointEpoch()
+	w = helpers.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch()
 	assert.Equal(t, w, d, "Did not get wanted finality delay")
 }
 
 func TestIsInInactivityLeak(t *testing.T) {
 	base := buildState(params.BeaconConfig().SlotsPerEpoch*10, 1)
 	base.FinalizedCheckpoint = &ethpb.Checkpoint{Epoch: 3}
-	state, err := state.InitializeFromProto(base)
+	beaconState, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 	prevEpoch := uint64(0)
 	finalizedEpoch := uint64(0)
 	// Set values for each test case
 	setVal := func() {
-		prevEpoch = helpers.PrevEpoch(state)
-		finalizedEpoch = state.FinalizedCheckpointEpoch()
+		prevEpoch = helpers.PrevEpoch(beaconState)
+		finalizedEpoch = beaconState.FinalizedCheckpointEpoch()
 	}
 	setVal()
 	assert.Equal(t, true, isInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak true")
-	require.NoError(t, state.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 4}))
+	require.NoError(t, beaconState.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 4}))
 	setVal()
 	assert.Equal(t, true, isInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak true")
-	require.NoError(t, state.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 5}))
+	require.NoError(t, beaconState.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 5}))
 	setVal()
 	assert.Equal(t, false, isInInactivityLeak(prevEpoch, finalizedEpoch), "Wanted inactivity leak false")
 }

beacon-chain/core/epoch/precompute/slashing_test.go

@@ -1,6 +1,7 @@
 package precompute_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -111,7 +112,7 @@ func TestProcessSlashingsPrecompute_SlashedLess(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		t.Run(string(i), func(t *testing.T) {
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
 			ab := uint64(0)
 			for i, b := range tt.state.Balances {
 				// Skip validator 0 since it's slashed

beacon-chain/core/epoch/precompute/spectest/rewards_penalties_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/ghodss/yaml"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -44,7 +43,7 @@ func runPrecomputeRewardsAndPenaltiesTest(t *testing.T, testFolderPath string) {
 	preBeaconStateFile, err := testutil.BazelFileBytes(path.Join(testFolderPath, "pre.ssz"))
 	require.NoError(t, err)
 	preBeaconStateBase := &pb.BeaconState{}
-	require.NoError(t, ssz.Unmarshal(preBeaconStateFile, preBeaconStateBase), "Failed to unmarshal")
+	require.NoError(t, preBeaconStateBase.UnmarshalSSZ(preBeaconStateFile), "Failed to unmarshal")
 	preBeaconState, err := beaconstate.InitializeFromProto(preBeaconStateBase)
 	require.NoError(t, err)
 

beacon-chain/core/epoch/spectest/justification_and_finalization_test.go

@@ -25,15 +25,15 @@ func runJustificationAndFinalizationTests(t *testing.T, config string) {
 	}
 }
 
-func processJustificationAndFinalizationPrecomputeWrapper(t *testing.T, state *state.BeaconState) (*state.BeaconState, error) {
+func processJustificationAndFinalizationPrecomputeWrapper(t *testing.T, st *state.BeaconState) (*state.BeaconState, error) {
 	ctx := context.Background()
-	vp, bp, err := precompute.New(ctx, state)
+	vp, bp, err := precompute.New(ctx, st)
 	require.NoError(t, err)
-	_, bp, err = precompute.ProcessAttestations(ctx, state, vp, bp)
+	_, bp, err = precompute.ProcessAttestations(ctx, st, vp, bp)
 	require.NoError(t, err)
 
-	state, err = precompute.ProcessJustificationAndFinalizationPreCompute(state, bp)
+	st, err = precompute.ProcessJustificationAndFinalizationPreCompute(st, bp)
 	require.NoError(t, err, "Could not process justification")
 
-	return state, nil
+	return st, nil
 }

beacon-chain/core/epoch/spectest/rewards_and_penalties_test.go

@@ -27,15 +27,15 @@ func runRewardsAndPenaltiesTests(t *testing.T, config string) {
 	}
 }
 
-func processRewardsAndPenaltiesPrecomputeWrapper(t *testing.T, state *state.BeaconState) (*state.BeaconState, error) {
+func processRewardsAndPenaltiesPrecomputeWrapper(t *testing.T, st *state.BeaconState) (*state.BeaconState, error) {
 	ctx := context.Background()
-	vp, bp, err := precompute.New(ctx, state)
+	vp, bp, err := precompute.New(ctx, st)
 	require.NoError(t, err)
-	vp, bp, err = precompute.ProcessAttestations(ctx, state, vp, bp)
+	vp, bp, err = precompute.ProcessAttestations(ctx, st, vp, bp)
 	require.NoError(t, err)
 
-	state, err = precompute.ProcessRewardsAndPenaltiesPrecompute(state, bp, vp)
+	st, err = precompute.ProcessRewardsAndPenaltiesPrecompute(st, bp, vp)
 	require.NoError(t, err, "Could not process reward")
 
-	return state, nil
+	return st, nil
 }

beacon-chain/core/feed/state/BUILD.bazel

@@ -8,5 +8,8 @@ go_library(
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state",
     visibility = ["//beacon-chain:__subpackages__"],
-    deps = ["//shared/event:go_default_library"],
+    deps = [
+        "//shared/event:go_default_library",
+        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
+    ],
 )

beacon-chain/core/feed/state/events.go

@@ -3,7 +3,11 @@
 // and chain start.
 package state
 
-import "time"
+import (
+	"time"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+)
 
 const (
 	// BlockProcessed is sent after a block has been processed and updated the state database.
@@ -25,6 +29,8 @@ type BlockProcessedData struct {
 	Slot uint64
 	// BlockRoot of the processed block.
 	BlockRoot [32]byte
+	// SignedBlock is the physical processed block.
+	SignedBlock *ethpb.SignedBeaconBlock
 	// Verified is true if the block's BLS contents have been verified.
 	Verified bool
 }

beacon-chain/core/helpers/attestation.go

@@ -2,6 +2,7 @@ package helpers
 
 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"time"
 
@@ -12,6 +13,28 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/timeutils"
 )
 
+// ValidateNilAttestation checks if any composite field of input attestation is nil.
+// Access to these nil fields will result in run time panic,
+// it is recommended to run these checks as first line of defense.
+func ValidateNilAttestation(attestation *ethpb.Attestation) error {
+	if attestation == nil {
+		return errors.New("attestation can't be nil")
+	}
+	if attestation.Data == nil {
+		return errors.New("attestation's data can't be nil")
+	}
+	if attestation.Data.Source == nil {
+		return errors.New("attestation's source can't be nil")
+	}
+	if attestation.Data.Target == nil {
+		return errors.New("attestation's target can't be nil")
+	}
+	if attestation.AggregationBits == nil {
+		return errors.New("attestation's bitfield can't be nil")
+	}
+	return nil
+}
+
 // IsAggregator returns true if the signature is from the input validator. The committee
 // count is provided as an argument rather than imported implementation from spec. Having
 // committee count as an argument allows cheaper computation at run time.

beacon-chain/core/helpers/attestation_test.go

@@ -225,3 +225,72 @@ func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
 	assert.Equal(t, false, helpers.VerifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 4}, genesis))
 	assert.Equal(t, false, helpers.VerifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 2}, genesis))
 }
+
+func TestValidateNilAttestation(t *testing.T) {
+	tests := []struct {
+		name        string
+		attestation *ethpb.Attestation
+		errString   string
+	}{
+		{
+			name:        "nil attestation",
+			attestation: nil,
+			errString:   "attestation can't be nil",
+		},
+		{
+			name:        "nil attestation data",
+			attestation: &ethpb.Attestation{},
+			errString:   "attestation's data can't be nil",
+		},
+		{
+			name: "nil attestation source",
+			attestation: &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					Source: nil,
+					Target: &ethpb.Checkpoint{},
+				},
+			},
+			errString: "attestation's source can't be nil",
+		},
+		{
+			name: "nil attestation target",
+			attestation: &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					Target: nil,
+					Source: &ethpb.Checkpoint{},
+				},
+			},
+			errString: "attestation's target can't be nil",
+		},
+		{
+			name: "nil attestation bitfield",
+			attestation: &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					Target: &ethpb.Checkpoint{},
+					Source: &ethpb.Checkpoint{},
+				},
+			},
+			errString: "attestation's bitfield can't be nil",
+		},
+		{
+			name: "good attestation",
+			attestation: &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					Target: &ethpb.Checkpoint{},
+					Source: &ethpb.Checkpoint{},
+				},
+				AggregationBits: []byte{},
+			},
+			errString: "",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.errString != "" {
+				require.ErrorContains(t, tt.errString, helpers.ValidateNilAttestation(tt.attestation))
+			} else {
+				require.NoError(t, helpers.ValidateNilAttestation(tt.attestation))
+			}
+		})
+	}
+}

beacon-chain/core/helpers/committee.go

@@ -337,14 +337,6 @@ func UpdateProposerIndicesInCache(state *stateTrie.BeaconState, epoch uint64) er
 		return nil
 	}
 
-	indices, err := ActiveValidatorIndices(state, epoch)
-	if err != nil {
-		return err
-	}
-	proposerIndices, err := precomputeProposerIndices(state, indices)
-	if err != nil {
-		return err
-	}
 	// Use state root from (current_epoch - 1 - lookahead))
 	wantedEpoch := PrevEpoch(state)
 	if wantedEpoch >= params.BeaconConfig().MinSeedLookahead {
@@ -358,10 +350,27 @@ func UpdateProposerIndicesInCache(state *stateTrie.BeaconState, epoch uint64) er
 	if err != nil {
 		return err
 	}
-	// Skip Cache if we have an invalid key
+	// Skip cache update if we have an invalid key
 	if r == nil || bytes.Equal(r, params.BeaconConfig().ZeroHash[:]) {
 		return nil
 	}
+	// Skip cache update if the key already exists
+	exists, err := proposerIndicesCache.HasProposerIndices(bytesutil.ToBytes32(r))
+	if err != nil {
+		return err
+	}
+	if exists {
+		return nil
+	}
+
+	indices, err := ActiveValidatorIndices(state, epoch)
+	if err != nil {
+		return err
+	}
+	proposerIndices, err := precomputeProposerIndices(state, indices)
+	if err != nil {
+		return err
+	}
 	return proposerIndicesCache.AddProposerIndices(&cache.ProposerIndices{
 		BlockRoot:       bytesutil.ToBytes32(r),
 		ProposerIndices: proposerIndices,

beacon-chain/core/helpers/committee_test.go

@@ -659,8 +659,8 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	assert.DeepEqual(t, wantedProposerIndices, proposerIndices, "Did not precompute proposer indices correctly")
 }
 
-func TestUpdateProposerIndicesInCache_CouldNotGetActiveIndices(t *testing.T) {
+func TestUpdateProposerIndicesInCache_SlotOutOfBound(t *testing.T) {
 	err := UpdateProposerIndicesInCache(&beaconstate.BeaconState{}, 2)
-	want := "nil inner state"
+	want := "out of bound"
 	require.ErrorContains(t, want, err)
 }

beacon-chain/core/helpers/signing_root.go

@@ -23,8 +23,8 @@ const DomainByteLength = 4
 var ErrSigFailedToVerify = errors.New("signature did not verify")
 
 // ComputeDomainAndSign computes the domain and signing root and sign it using the passed in private key.
-func ComputeDomainAndSign(state *state.BeaconState, epoch uint64, obj interface{}, domain [4]byte, key bls.SecretKey) ([]byte, error) {
-	d, err := Domain(state.Fork(), epoch, domain, state.GenesisValidatorRoot())
+func ComputeDomainAndSign(st *state.BeaconState, epoch uint64, obj interface{}, domain [4]byte, key bls.SecretKey) ([]byte, error) {
+	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
 	if err != nil {
 		return nil, err
 	}
@@ -73,12 +73,12 @@ func signingData(rootFunc func() ([32]byte, error), domain []byte) ([32]byte, er
 }
 
 // ComputeDomainVerifySigningRoot computes domain and verifies signing root of an object given the beacon state, validator index and signature.
-func ComputeDomainVerifySigningRoot(state *state.BeaconState, index, epoch uint64, obj interface{}, domain [4]byte, sig []byte) error {
-	v, err := state.ValidatorAtIndex(index)
+func ComputeDomainVerifySigningRoot(st *state.BeaconState, index, epoch uint64, obj interface{}, domain [4]byte, sig []byte) error {
+	v, err := st.ValidatorAtIndex(index)
 	if err != nil {
 		return err
 	}
-	d, err := Domain(state.Fork(), epoch, domain, state.GenesisValidatorRoot())
+	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
 	if err != nil {
 		return err
 	}

beacon-chain/core/state/BUILD.bazel

@@ -6,6 +6,7 @@ load("@io_bazel_rules_go//go:def.bzl", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "log.go",
         "skip_slot_cache.go",
         "state.go",
         "transition.go",
@@ -73,6 +74,7 @@ go_test(
         "//shared/bytesutil:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/params:go_default_library",
+        "//shared/sszutil:go_default_library",
         "//shared/testutil:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
@@ -81,7 +83,6 @@ go_test(
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/core/state/log.go

@@ -0,0 +1,5 @@
+package state
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "state")

beacon-chain/core/state/skip_slot_cache_test.go

@@ -6,10 +6,10 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/sszutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
@@ -34,7 +34,7 @@ func TestSkipSlotCache_OK(t *testing.T) {
 	bState, err = state.ExecuteStateTransition(context.Background(), bState, blk)
 	require.NoError(t, err, "Could not process state transition")
 
-	if !ssz.DeepEqual(originalState.CloneInnerState(), bState.CloneInnerState()) {
+	if !sszutil.DeepEqual(originalState.CloneInnerState(), bState.CloneInnerState()) {
 		t.Fatal("Skipped slots cache leads to different states")
 	}
 }

beacon-chain/core/state/transition.go

@@ -21,7 +21,6 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/mathutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/traceutil"
-	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
@@ -312,7 +311,7 @@ func ProcessSlots(ctx context.Context, state *stateTrie.BeaconState, slot uint64
 	defer func() {
 		if err := SkipSlotCache.MarkNotInProgress(key); err != nil {
 			traceutil.AnnotateError(span, err)
-			logrus.WithError(err).Error("Failed to mark skip slot no longer in progress")
+			log.WithError(err).Error("Failed to mark skip slot no longer in progress")
 		}
 	}()
 
@@ -322,7 +321,7 @@ func ProcessSlots(ctx context.Context, state *stateTrie.BeaconState, slot uint64
 			// Cache last best value.
 			if highestSlot < state.Slot() {
 				if err := SkipSlotCache.Put(ctx, key, state); err != nil {
-					logrus.WithError(err).Error("Failed to put skip slot cache value")
+					log.WithError(err).Error("Failed to put skip slot cache value")
 				}
 			}
 			return nil, ctx.Err()
@@ -347,7 +346,7 @@ func ProcessSlots(ctx context.Context, state *stateTrie.BeaconState, slot uint64
 
 	if highestSlot < state.Slot() {
 		if err := SkipSlotCache.Put(ctx, key, state); err != nil {
-			logrus.WithError(err).Error("Failed to put skip slot cache value")
+			log.WithError(err).Error("Failed to put skip slot cache value")
 			traceutil.AnnotateError(span, err)
 		}
 	}

beacon-chain/core/state/transition_test.go

@@ -164,24 +164,16 @@ func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
 	block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, 1)
 	require.NoError(t, err)
 	slashing := &ethpb.ProposerSlashing{
-		Header_1: &ethpb.SignedBeaconBlockHeader{
+		Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
-				Slot:       params.BeaconConfig().SlotsPerEpoch,
-				ParentRoot: make([]byte, 32),
-				StateRoot:  make([]byte, 32),
-				BodyRoot:   make([]byte, 32),
+				Slot: params.BeaconConfig().SlotsPerEpoch,
 			},
-			Signature: make([]byte, 96),
-		},
-		Header_2: &ethpb.SignedBeaconBlockHeader{
+		}),
+		Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
-				Slot:       params.BeaconConfig().SlotsPerEpoch * 2,
-				ParentRoot: make([]byte, 32),
-				StateRoot:  make([]byte, 32),
-				BodyRoot:   make([]byte, 32),
+				Slot: params.BeaconConfig().SlotsPerEpoch * 2,
 			},
-			Signature: make([]byte, 96),
-		},
+		}),
 	}
 	block.Block.Body.ProposerSlashings = []*ethpb.ProposerSlashing{slashing}
 
@@ -203,15 +195,10 @@ func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			BeaconBlockRoot: make([]byte, 32),
-		},
+	att := testutil.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(3),
 		Signature:       priv.Sign([]byte("foo")).Marshal(),
-	}
+	})
 
 	block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, 1)
 	require.NoError(t, err)
@@ -236,43 +223,31 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 
 	proposerSlashings := []*ethpb.ProposerSlashing{
 		{
-			Header_1: &ethpb.SignedBeaconBlockHeader{
+			Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 3,
 					Slot:          1,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
 				Signature: bytesutil.PadTo([]byte("A"), 96),
-			},
-			Header_2: &ethpb.SignedBeaconBlockHeader{
+			}),
+			Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 3,
 					Slot:          1,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
 				Signature: bytesutil.PadTo([]byte("B"), 96),
-			},
+			}),
 		},
 	}
 	attesterSlashings := []*ethpb.AttesterSlashing{
 		{
 			Attestation_1: &ethpb.IndexedAttestation{
-				Data: &ethpb.AttestationData{
-					Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-					Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-				},
+				Data:             testutil.HydrateAttestationData(&ethpb.AttestationData{}),
 				AttestingIndices: []uint64{0, 1},
 				Signature:        make([]byte, 96),
 			},
 			Attestation_2: &ethpb.IndexedAttestation{
-				Data: &ethpb.AttestationData{
-					Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-					Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-				},
+				Data:             testutil.HydrateAttestationData(&ethpb.AttestationData{}),
 				AttestingIndices: []uint64{0, 1},
 				Signature:        make([]byte, 96),
 			},
@@ -283,15 +258,12 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 		blockRoots = append(blockRoots, []byte{byte(i)})
 	}
 	require.NoError(t, beaconState.SetBlockRoots(blockRoots))
-	blockAtt := &ethpb.Attestation{
+	blockAtt := testutil.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
-			BeaconBlockRoot: make([]byte, 32),
+			Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("hello-world"), 32)},
 		},
 		AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
-		Signature:       make([]byte, 96),
-	}
+	})
 	attestations := []*ethpb.Attestation{blockAtt}
 	var exits []*ethpb.SignedVoluntaryExit
 	for i := uint64(0); i < params.BeaconConfig().MaxVoluntaryExits+1; i++ {
@@ -300,12 +272,11 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 	genesisBlock := blocks.NewGenesisBlock([]byte{})
 	bodyRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+	err = beaconState.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
 		Slot:       genesisBlock.Block.Slot,
 		ParentRoot: genesisBlock.Block.ParentRoot,
 		BodyRoot:   bodyRoot[:],
-		StateRoot:  make([]byte, 32),
-	})
+	}))
 	require.NoError(t, err)
 	parentRoot, err := beaconState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -357,27 +328,23 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 	require.NoError(t, err)
 
 	currentEpoch := helpers.CurrentEpoch(beaconState)
-	header1 := &ethpb.SignedBeaconBlockHeader{
+	header1 := testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerSlashIdx,
 			Slot:          1,
 			StateRoot:     bytesutil.PadTo([]byte("A"), 32),
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 		},
-	}
+	})
 	header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, currentEpoch, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
 	require.NoError(t, err)
 
-	header2 := &ethpb.SignedBeaconBlockHeader{
+	header2 := testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerSlashIdx,
 			Slot:          1,
 			StateRoot:     bytesutil.PadTo([]byte("B"), 32),
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 		},
-	}
+	})
 	header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, helpers.CurrentEpoch(beaconState), header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
 	require.NoError(t, err)
 
@@ -392,15 +359,12 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 	require.NoError(t, beaconState.SetValidators(validators))
 
 	mockRoot2 := [32]byte{'A'}
-	att1 := &ethpb.IndexedAttestation{
+	att1 := testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot2[:]},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			BeaconBlockRoot: make([]byte, 32),
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot2[:]},
 		},
 		AttestingIndices: []uint64{0, 1},
-		Signature:        make([]byte, 96),
-	}
+	})
 	domain, err := helpers.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := helpers.ComputeSigningRoot(att1.Data, domain)
@@ -411,15 +375,13 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 	att1.Signature = aggregateSig.Marshal()
 
 	mockRoot3 := [32]byte{'B'}
-	att2 := &ethpb.IndexedAttestation{
+	att2 := testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot3[:]},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			BeaconBlockRoot: make([]byte, 32),
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot3[:]},
+			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 		},
 		AttestingIndices: []uint64{0, 1},
-		Signature:        make([]byte, 96),
-	}
+	})
 
 	hashTreeRoot, err = helpers.ComputeSigningRoot(att2.Data, domain)
 	require.NoError(t, err)
@@ -443,18 +405,13 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 
 	aggBits := bitfield.NewBitlist(1)
 	aggBits.SetBitAt(0, true)
-	blockAtt := &ethpb.Attestation{
+	blockAtt := testutil.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
-			Slot:            beaconState.Slot(),
-			BeaconBlockRoot: make([]byte, 32),
-			Target:          &ethpb.Checkpoint{Epoch: helpers.CurrentEpoch(beaconState), Root: make([]byte, 32)},
-			Source: &ethpb.Checkpoint{
-				Epoch: 0,
-				Root:  mockRoot[:],
-			}},
+			Slot:   beaconState.Slot(),
+			Target: &ethpb.Checkpoint{Epoch: helpers.CurrentEpoch(beaconState)},
+			Source: &ethpb.Checkpoint{Root: mockRoot[:]}},
 		AggregationBits: aggBits,
-		Signature:       make([]byte, 96),
-	}
+	})
 
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, blockAtt.Data.Slot, blockAtt.Data.CommitteeIndex)
 	assert.NoError(t, err)
@@ -491,25 +448,20 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 	require.NoError(t, err)
 	proposerIndex, err := helpers.BeaconProposerIndex(copied)
 	require.NoError(t, err)
-	block := &ethpb.SignedBeaconBlock{
+	block := testutil.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{
 		Block: &ethpb.BeaconBlock{
 			ParentRoot:    parentRoot[:],
 			Slot:          beaconState.Slot() + 1,
 			ProposerIndex: proposerIndex,
 			Body: &ethpb.BeaconBlockBody{
-				Graffiti:          make([]byte, 32),
 				RandaoReveal:      randaoReveal,
 				ProposerSlashings: proposerSlashings,
 				AttesterSlashings: attesterSlashings,
 				Attestations:      []*ethpb.Attestation{blockAtt},
 				VoluntaryExits:    []*ethpb.SignedVoluntaryExit{exit},
-				Eth1Data: &ethpb.Eth1Data{
-					DepositRoot: bytesutil.PadTo([]byte{2}, 32),
-					BlockHash:   bytesutil.PadTo([]byte{3}, 32),
-				},
 			},
 		},
-	}
+	})
 
 	sig, err := testutil.BlockSignature(beaconState, block.Block, privKeys)
 	require.NoError(t, err)
@@ -638,22 +590,12 @@ func BenchmarkProcessBlk_65536Validators_FullBlock(b *testing.B) {
 	// Set up attester slashing object for block
 	attesterSlashings := []*ethpb.AttesterSlashing{
 		{
-			Attestation_1: &ethpb.IndexedAttestation{
-				Data: &ethpb.AttestationData{
-					BeaconBlockRoot: make([]byte, 32),
-					Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-					Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-				},
+			Attestation_1: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 				AttestingIndices: []uint64{2, 3},
-			},
-			Attestation_2: &ethpb.IndexedAttestation{
-				Data: &ethpb.AttestationData{
-					BeaconBlockRoot: make([]byte, 32),
-					Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-					Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
-				},
+			}),
+			Attestation_2: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 				AttestingIndices: []uint64{2, 3},
-			},
+			}),
 		},
 	}
 
@@ -763,16 +705,10 @@ func TestProcessBlk_AttsBasedOnValidatorCount(t *testing.T) {
 	atts := make([]*ethpb.Attestation, 1)
 
 	for i := 0; i < len(atts); i++ {
-		att := &ethpb.Attestation{
-			Data: &ethpb.AttestationData{
-				Slot:            1,
-				Source:          &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]},
-				Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-				BeaconBlockRoot: make([]byte, 32),
-			},
+		att := testutil.HydrateAttestation(&ethpb.Attestation{
+			Data:            &ethpb.AttestationData{Slot: 1},
 			AggregationBits: aggBits,
-			Signature:       make([]byte, 96),
-		}
+		})
 
 		committee, err := helpers.BeaconCommitteeFromState(s, att.Data.Slot, att.Data.CommitteeIndex)
 		assert.NoError(t, err)

beacon-chain/core/validators/validator_test.go

@@ -77,7 +77,7 @@ func TestInitiateValidatorExit_ChurnOverflow(t *testing.T) {
 		{ExitEpoch: exitedEpoch + 2},
 		{ExitEpoch: exitedEpoch + 2},
 		{ExitEpoch: exitedEpoch + 2},
-		{ExitEpoch: exitedEpoch + 2}, //over flow here
+		{ExitEpoch: exitedEpoch + 2}, // overflow here
 		{ExitEpoch: params.BeaconConfig().FarFutureEpoch},
 	}}
 	state, err := beaconstate.InitializeFromProto(base)

beacon-chain/db/BUILD.bazel

@@ -11,6 +11,9 @@ go_library(
     name = "go_default_library",
     srcs = [
         "alias.go",
+        "cmd.go",
+        "log.go",
+        "restore.go",
     ] + select({
         ":kafka_disabled": [
             "db.go",
@@ -29,7 +32,13 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
+        "//shared/cmd:go_default_library",
+        "//shared/fileutil:go_default_library",
+        "//shared/promptutil:go_default_library",
+        "//shared/tos:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_urfave_cli_v2//:go_default_library",
     ] + select({
         "//conditions:default": [
             "//beacon-chain/db/kafka:go_default_library",

beacon-chain/db/cmd.go

@@ -0,0 +1,31 @@
+package db
+
+import (
+	"github.com/prysmaticlabs/prysm/shared/cmd"
+	"github.com/prysmaticlabs/prysm/shared/tos"
+	"github.com/urfave/cli/v2"
+)
+
+// DatabaseCommands for Prysm beacon node.
+var DatabaseCommands = &cli.Command{
+	Name:     "db",
+	Category: "db",
+	Usage:    "defines commands for interacting with eth2 beacon node database",
+	Subcommands: []*cli.Command{
+		{
+			Name:        "restore",
+			Description: `restores a database from a backup file`,
+			Flags: cmd.WrapFlags([]cli.Flag{
+				cmd.RestoreSourceFileFlag,
+				cmd.RestoreTargetDirFlag,
+			}),
+			Before: tos.VerifyTosAcceptedOrPrompt,
+			Action: func(cliCtx *cli.Context) error {
+				if err := restore(cliCtx); err != nil {
+					log.Fatalf("Could not restore database: %v", err)
+				}
+				return nil
+			},
+		},
+	},
+}

beacon-chain/db/db.go

@@ -3,11 +3,12 @@
 package db
 
 import (
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	"context"
+
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
 )
 
 // NewDB initializes a new DB.
-func NewDB(dirPath string, stateSummaryCache *cache.StateSummaryCache) (Database, error) {
-	return kv.NewKVStore(dirPath, stateSummaryCache)
+func NewDB(ctx context.Context, dirPath string) (Database, error) {
+	return kv.NewKVStore(ctx, dirPath)
 }

beacon-chain/db/db_kafka_wrapped.go

@@ -3,13 +3,12 @@
 package db
 
 import (
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/kafka"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
 )
 
 // NewDB initializes a new DB with kafka wrapper.
-func NewDB(dirPath string, stateSummaryCache *cache.StateSummaryCache) (Database, error) {
+func NewDB(dirPath string, stateSummaryCache *kv.stateSummaryCache) (Database, error) {
 	db, err := kv.NewKVStore(dirPath, stateSummaryCache)
 	if err != nil {
 		return nil, err

beacon-chain/db/iface/interface.go

@@ -22,6 +22,8 @@ type ReadOnlyDatabase interface {
 	Block(ctx context.Context, blockRoot [32]byte) (*eth.SignedBeaconBlock, error)
 	Blocks(ctx context.Context, f *filters.QueryFilter) ([]*eth.SignedBeaconBlock, [][32]byte, error)
 	BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]byte, error)
+	BlocksBySlot(ctx context.Context, slot uint64) (bool, []*eth.SignedBeaconBlock, error)
+	BlockRootsBySlot(ctx context.Context, slot uint64) (bool, [][32]byte, error)
 	HasBlock(ctx context.Context, blockRoot [32]byte) bool
 	GenesisBlock(ctx context.Context) (*eth.SignedBeaconBlock, error)
 	IsFinalizedBlock(ctx context.Context, blockRoot [32]byte) bool

beacon-chain/db/kafka/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "export_wrapper.go",
+        "log.go",
         "passthrough.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/db/kafka",

beacon-chain/db/kafka/export_wrapper.go

@@ -14,14 +14,12 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/iface"
 	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/traceutil"
-	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 	"gopkg.in/confluentinc/confluent-kafka-go.v1/kafka"
 	_ "gopkg.in/confluentinc/confluent-kafka-go.v1/kafka/librdkafka" // Required for c++ kafka library.
 )
 
 var _ iface.Database = (*Exporter)(nil)
-var log = logrus.WithField("prefix", "exporter")
 var marshaler = &jsonpb.Marshaler{}
 
 // Exporter wraps a database interface and exports certain objects to kafka topics.

beacon-chain/db/kafka/log.go

@@ -0,0 +1,5 @@
+package kafka
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "exporter")

beacon-chain/db/kafka/passthrough.go

@@ -46,6 +46,16 @@ func (e Exporter) BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32
 	return e.db.BlockRoots(ctx, f)
 }
 
+// BlocksBySlot -- passthrough.
+func (e Exporter) BlocksBySlot(ctx context.Context, slot uint64) (bool, []*eth.SignedBeaconBlock, error) {
+	return e.db.BlocksBySlot(ctx, slot)
+}
+
+// BlockRootsBySlot -- passthrough.
+func (e Exporter) BlockRootsBySlot(ctx context.Context, slot uint64) (bool, [][32]byte, error) {
+	return e.db.BlockRootsBySlot(ctx, slot)
+}
+
 // HasBlock -- passthrough.
 func (e Exporter) HasBlock(ctx context.Context, blockRoot [32]byte) bool {
 	return e.db.HasBlock(ctx, blockRoot)
@@ -127,8 +137,8 @@ func (e Exporter) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte)
 }
 
 // SaveState -- passthrough.
-func (e Exporter) SaveState(ctx context.Context, state *state.BeaconState, blockRoot [32]byte) error {
-	return e.db.SaveState(ctx, state, blockRoot)
+func (e Exporter) SaveState(ctx context.Context, st *state.BeaconState, blockRoot [32]byte) error {
+	return e.db.SaveState(ctx, st, blockRoot)
 }
 
 // SaveStateSummary -- passthrough.

beacon-chain/db/kv/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "encoding.go",
         "finalized_block_roots.go",
         "kv.go",
+        "log.go",
         "migration.go",
         "migration_archived_index.go",
         "migration_block_slot_index.go",
@@ -21,12 +22,12 @@ go_library(
         "slashings.go",
         "state.go",
         "state_summary.go",
+        "state_summary_cache.go",
         "utils.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/db/kv",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
@@ -75,7 +76,6 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/cache:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//proto/beacon/db:go_default_library",

beacon-chain/db/kv/backup.go

@@ -8,7 +8,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/shared/fileutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/sirupsen/logrus"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
 )
@@ -43,7 +42,7 @@ func (s *Store) Backup(ctx context.Context, outputDir string) error {
 		return err
 	}
 	backupPath := path.Join(backupsDir, fmt.Sprintf("prysm_beacondb_at_slot_%07d.backup", head.Block.Slot))
-	logrus.WithField("prefix", "db").WithField("backup", backupPath).Info("Writing backup database.")
+	log.WithField("backup", backupPath).Info("Writing backup database.")
 
 	copyDB, err := bolt.Open(
 		backupPath,
@@ -55,13 +54,13 @@ func (s *Store) Backup(ctx context.Context, outputDir string) error {
 	}
 	defer func() {
 		if err := copyDB.Close(); err != nil {
-			logrus.WithError(err).Error("Failed to close backup database")
+			log.WithError(err).Error("Failed to close backup database")
 		}
 	}()
 
 	return s.db.View(func(tx *bolt.Tx) error {
 		return tx.ForEach(func(name []byte, b *bolt.Bucket) error {
-			logrus.Debugf("Copying bucket %s\n", name)
+			log.Debugf("Copying bucket %s\n", name)
 			return copyDB.Update(func(tx2 *bolt.Tx) error {
 				b2, err := tx2.CreateBucketIfNotExists(name)
 				if err != nil {

beacon-chain/db/kv/backup_test.go

@@ -12,7 +12,8 @@ import (
 )
 
 func TestStore_Backup(t *testing.T) {
-	db := setupDB(t)
+	db, err := NewKVStore(context.Background(), t.TempDir())
+	require.NoError(t, err, "Failed to instantiate DB")
 	ctx := context.Background()
 
 	head := testutil.NewBeaconBlock()
@@ -34,12 +35,12 @@ func TestStore_Backup(t *testing.T) {
 	require.NoError(t, db.Close(), "Failed to close database")
 
 	oldFilePath := filepath.Join(backupsPath, files[0].Name())
-	newFilePath := filepath.Join(backupsPath, databaseFileName)
+	newFilePath := filepath.Join(backupsPath, DatabaseFileName)
 	// We rename the file to match the database file name
 	// our NewKVStore function expects when opening a database.
 	require.NoError(t, os.Rename(oldFilePath, newFilePath))
 
-	backedDB, err := NewKVStore(backupsPath, nil)
+	backedDB, err := NewKVStore(ctx, backupsPath)
 	require.NoError(t, err, "Failed to instantiate DB")
 	t.Cleanup(func() {
 		require.NoError(t, backedDB.Close(), "Failed to close database")

beacon-chain/db/kv/blocks.go

@@ -134,6 +134,55 @@ func (s *Store) HasBlock(ctx context.Context, blockRoot [32]byte) bool {
 	return exists
 }
 
+// BlocksBySlot retrieves a list of beacon blocks and its respective roots by slot.
+func (s *Store) BlocksBySlot(ctx context.Context, slot uint64) (bool, []*ethpb.SignedBeaconBlock, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.BlocksBySlot")
+	defer span.End()
+	blocks := make([]*ethpb.SignedBeaconBlock, 0)
+
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(blocksBucket)
+
+		keys, err := getBlockRootsBySlot(ctx, tx, slot)
+		if err != nil {
+			return err
+		}
+
+		for i := 0; i < len(keys); i++ {
+			encoded := bkt.Get(keys[i])
+			block := &ethpb.SignedBeaconBlock{}
+			if err := decode(ctx, encoded, block); err != nil {
+				return err
+			}
+			blocks = append(blocks, block)
+		}
+		return nil
+	})
+	return len(blocks) > 0, blocks, err
+}
+
+// BlockRootsBySlot retrieves a list of beacon block roots by slot
+func (s *Store) BlockRootsBySlot(ctx context.Context, slot uint64) (bool, [][32]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.BlockRootsBySlot")
+	defer span.End()
+	blockRoots := make([][32]byte, 0)
+	err := s.db.View(func(tx *bolt.Tx) error {
+		keys, err := getBlockRootsBySlot(ctx, tx, slot)
+		if err != nil {
+			return err
+		}
+
+		for i := 0; i < len(keys); i++ {
+			blockRoots = append(blockRoots, bytesutil.ToBytes32(keys[i]))
+		}
+		return nil
+	})
+	if err != nil {
+		return false, nil, errors.Wrap(err, "could not retrieve block roots by slot")
+	}
+	return len(blockRoots) > 0, blockRoots, nil
+}
+
 // deleteBlock by block root.
 func (s *Store) deleteBlock(ctx context.Context, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteBlock")
@@ -240,10 +289,9 @@ func (s *Store) SaveHeadBlockRoot(ctx context.Context, blockRoot [32]byte) error
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveHeadBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
-		hasStateSummaryInCache := s.stateSummaryCache.Has(blockRoot)
-		hasStateSummaryInDB := tx.Bucket(stateSummaryBucket).Get(blockRoot[:]) != nil
+		hasStateSummaryInDB := s.HasStateSummary(ctx, blockRoot)
 		hasStateInDB := tx.Bucket(stateBucket).Get(blockRoot[:]) != nil
-		if !(hasStateInDB || hasStateSummaryInDB || hasStateSummaryInCache) {
+		if !(hasStateInDB || hasStateSummaryInDB) {
 			return errors.New("no state or state summary found with head block root")
 		}
 
@@ -394,6 +442,11 @@ func fetchBlockRootsBySlotRange(
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.fetchBlockRootsBySlotRange")
 	defer span.End()
 
+	// Return nothing when all slot parameters are missing
+	if startSlotEncoded == nil && endSlotEncoded == nil && startEpochEncoded == nil && endEpochEncoded == nil {
+		return [][]byte{}, nil
+	}
+
 	var startSlot, endSlot, step uint64
 	var ok bool
 	if startSlot, ok = startSlotEncoded.(uint64); !ok {
@@ -428,10 +481,6 @@ func fetchBlockRootsBySlotRange(
 	if endSlot < startSlot {
 		return nil, errInvalidSlotRange
 	}
-	// Return nothing with an end slot of 0.
-	if endSlot == 0 {
-		return [][]byte{}, nil
-	}
 	rootsRange := (endSlot - startSlot) / step
 	roots := make([][]byte, 0, rootsRange)
 	c := bkt.Cursor()
@@ -452,6 +501,24 @@ func fetchBlockRootsBySlotRange(
 	return roots, nil
 }
 
+// getBlockRootsByFilter retrieves the block roots by slot
+func getBlockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot uint64) ([][]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.getBlockRootsBySlot")
+	defer span.End()
+
+	roots := make([][]byte, 0)
+	bkt := tx.Bucket(blockSlotIndicesBucket)
+	key := bytesutil.Uint64ToBytesBigEndian(slot)
+	c := bkt.Cursor()
+	k, v := c.Seek(key)
+	if k != nil && bytes.Equal(k, key) {
+		for i := 0; i < len(v); i += 32 {
+			roots = append(roots, v[i:i+32])
+		}
+	}
+	return roots, nil
+}
+
 // createBlockIndicesFromBlock takes in a beacon block and returns
 // a map of bolt DB index buckets corresponding to each particular key for indices for
 // data, such as (shard indices bucket -> shard 5).

beacon-chain/db/kv/blocks_test.go

@@ -118,7 +118,7 @@ func TestStore_BlocksHandleZeroCase(t *testing.T) {
 	zeroFilter := filters.NewFilter().SetStartSlot(0).SetEndSlot(0)
 	retrieved, _, err := db.Blocks(ctx, zeroFilter)
 	require.NoError(t, err)
-	assert.Equal(t, 0, len(retrieved), "Unexpected number of blocks received, expected none")
+	assert.Equal(t, 1, len(retrieved), "Unexpected number of blocks received, expected one")
 }
 
 func TestStore_BlocksHandleInvalidEndSlot(t *testing.T) {
@@ -450,3 +450,54 @@ func TestStore_SaveBlocks_HasRootsMatched(t *testing.T) {
 		assert.Equal(t, roots[i], rt, "mismatch of block roots")
 	}
 }
+
+func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	b1 := testutil.NewBeaconBlock()
+	b1.Block.Slot = 20
+	require.NoError(t, db.SaveBlock(ctx, b1))
+	b2 := testutil.NewBeaconBlock()
+	b2.Block.Slot = 100
+	b2.Block.ParentRoot = bytesutil.PadTo([]byte("parent1"), 32)
+	require.NoError(t, db.SaveBlock(ctx, b2))
+	b3 := testutil.NewBeaconBlock()
+	b3.Block.Slot = 100
+	b3.Block.ParentRoot = bytesutil.PadTo([]byte("parent2"), 32)
+	require.NoError(t, db.SaveBlock(ctx, b3))
+
+	r1, err := b1.Block.HashTreeRoot()
+	require.NoError(t, err)
+	r2, err := b2.Block.HashTreeRoot()
+	require.NoError(t, err)
+	r3, err := b3.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	hasBlocks, retrievedBlocks, err := db.BlocksBySlot(ctx, 1)
+	require.NoError(t, err)
+	assert.Equal(t, 0, len(retrievedBlocks), "Unexpected number of blocks received, expected none")
+	assert.Equal(t, false, hasBlocks, "Expected no blocks")
+	hasBlocks, retrievedBlocks, err = db.BlocksBySlot(ctx, 20)
+	require.NoError(t, err)
+	assert.Equal(t, true, proto.Equal(b1, retrievedBlocks[0]), "Wanted: %v, received: %v", b1, retrievedBlocks[0])
+	assert.Equal(t, true, hasBlocks, "Expected to have blocks")
+	hasBlocks, retrievedBlocks, err = db.BlocksBySlot(ctx, 100)
+	require.NoError(t, err)
+	assert.Equal(t, true, proto.Equal(b2, retrievedBlocks[0]), "Wanted: %v, received: %v", b2, retrievedBlocks[0])
+	assert.Equal(t, true, proto.Equal(b3, retrievedBlocks[1]), "Wanted: %v, received: %v", b3, retrievedBlocks[1])
+	assert.Equal(t, true, hasBlocks, "Expected to have blocks")
+
+	hasBlockRoots, retrievedBlockRoots, err := db.BlockRootsBySlot(ctx, 1)
+	require.NoError(t, err)
+	assert.DeepEqual(t, [][32]byte{}, retrievedBlockRoots)
+	assert.Equal(t, false, hasBlockRoots, "Expected no block roots")
+	hasBlockRoots, retrievedBlockRoots, err = db.BlockRootsBySlot(ctx, 20)
+	require.NoError(t, err)
+	assert.DeepEqual(t, [][32]byte{r1}, retrievedBlockRoots)
+	assert.Equal(t, true, hasBlockRoots, "Expected no block roots")
+	hasBlockRoots, retrievedBlockRoots, err = db.BlockRootsBySlot(ctx, 100)
+	require.NoError(t, err)
+	assert.DeepEqual(t, [][32]byte{r2, r3}, retrievedBlockRoots)
+	assert.Equal(t, true, hasBlockRoots, "Expected no block roots")
+}

beacon-chain/db/kv/checkpoint.go

@@ -60,10 +60,9 @@ func (s *Store) SaveJustifiedCheckpoint(ctx context.Context, checkpoint *ethpb.C
 	}
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(checkpointBucket)
-		hasStateSummaryInDB := tx.Bucket(stateSummaryBucket).Get(checkpoint.Root) != nil
-		hasStateSummaryInCache := s.stateSummaryCache.Has(bytesutil.ToBytes32(checkpoint.Root))
+		hasStateSummaryInDB := s.HasStateSummary(ctx, bytesutil.ToBytes32(checkpoint.Root))
 		hasStateInDB := tx.Bucket(stateBucket).Get(checkpoint.Root) != nil
-		if !(hasStateInDB || hasStateSummaryInDB || hasStateSummaryInCache) {
+		if !(hasStateInDB || hasStateSummaryInDB) {
 			return errMissingStateForCheckpoint
 		}
 		return bucket.Put(justifiedCheckpointKey, enc)
@@ -81,10 +80,9 @@ func (s *Store) SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.C
 	}
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(checkpointBucket)
-		hasStateSummaryInDB := tx.Bucket(stateSummaryBucket).Get(checkpoint.Root) != nil
-		hasStateSummaryInCache := s.stateSummaryCache.Has(bytesutil.ToBytes32(checkpoint.Root))
+		hasStateSummaryInDB := s.HasStateSummary(ctx, bytesutil.ToBytes32(checkpoint.Root))
 		hasStateInDB := tx.Bucket(stateBucket).Get(checkpoint.Root) != nil
-		if !(hasStateInDB || hasStateSummaryInDB || hasStateSummaryInCache) {
+		if !(hasStateInDB || hasStateSummaryInDB) {
 			return errMissingStateForCheckpoint
 		}
 		if err := bucket.Put(finalizedCheckpointKey, enc); err != nil {

beacon-chain/db/kv/deposit_contract_test.go

@@ -15,7 +15,7 @@ func TestStore_DepositContract(t *testing.T) {
 	contractAddress := common.Address{1, 2, 3}
 	retrieved, err := db.DepositContractAddress(ctx)
 	require.NoError(t, err)
-	assert.DeepEqual(t, ([]uint8)(nil), retrieved, "Expected nil contract address")
+	assert.DeepEqual(t, []uint8(nil), retrieved, "Expected nil contract address")
 	require.NoError(t, db.SaveDepositContractAddress(ctx, contractAddress))
 	retrieved, err = db.DepositContractAddress(ctx)
 	require.NoError(t, err)

beacon-chain/db/kv/kv.go

@@ -3,6 +3,7 @@
 package kv
 
 import (
+	"context"
 	"os"
 	"path"
 	"time"
@@ -11,7 +12,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	prombolt "github.com/prysmaticlabs/prombbolt"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/iface"
 	"github.com/prysmaticlabs/prysm/shared/fileutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -24,9 +24,13 @@ const (
 	// VotesCacheSize with 1M validators will be 8MB.
 	VotesCacheSize = 1 << 23
 	// NumOfVotes specifies the vote cache size.
-	NumOfVotes       = 1 << 20
-	databaseFileName = "beaconchain.db"
-	boltAllocSize    = 8 * 1024 * 1024
+	NumOfVotes = 1 << 20
+	// BeaconNodeDbDirName is the name of the directory containing the beacon node database.
+	BeaconNodeDbDirName = "beaconchaindata"
+	// DatabaseFileName is the name of the beacon node database.
+	DatabaseFileName = "beaconchain.db"
+
+	boltAllocSize = 8 * 1024 * 1024
 )
 
 // BlockCacheSize specifies 1000 slots worth of blocks cached, which
@@ -40,13 +44,14 @@ type Store struct {
 	databasePath        string
 	blockCache          *ristretto.Cache
 	validatorIndexCache *ristretto.Cache
-	stateSummaryCache   *cache.StateSummaryCache
+	stateSummaryCache   *stateSummaryCache
+	ctx                 context.Context
 }
 
 // NewKVStore initializes a new boltDB key-value store at the directory
 // path specified, creates the kv-buckets based on the schema, and stores
 // an open connection db object as a property of the Store struct.
-func NewKVStore(dirPath string, stateSummaryCache *cache.StateSummaryCache) (*Store, error) {
+func NewKVStore(ctx context.Context, dirPath string) (*Store, error) {
 	hasDir, err := fileutil.HasDir(dirPath)
 	if err != nil {
 		return nil, err
@@ -56,7 +61,7 @@ func NewKVStore(dirPath string, stateSummaryCache *cache.StateSummaryCache) (*St
 			return nil, err
 		}
 	}
-	datafile := path.Join(dirPath, databaseFileName)
+	datafile := path.Join(dirPath, DatabaseFileName)
 	boltDB, err := bolt.Open(datafile, params.BeaconIoConfig().ReadWritePermissions, &bolt.Options{Timeout: 1 * time.Second, InitialMmapSize: 10e6})
 	if err != nil {
 		if errors.Is(err, bolt.ErrTimeout) {
@@ -88,7 +93,8 @@ func NewKVStore(dirPath string, stateSummaryCache *cache.StateSummaryCache) (*St
 		databasePath:        dirPath,
 		blockCache:          blockCache,
 		validatorIndexCache: validatorCache,
-		stateSummaryCache:   stateSummaryCache,
+		stateSummaryCache:   newStateSummaryCache(),
+		ctx:                 ctx,
 	}
 
 	if err := kv.db.Update(func(tx *bolt.Tx) error {
@@ -134,7 +140,7 @@ func (s *Store) ClearDB() error {
 		return nil
 	}
 	prometheus.Unregister(createBoltCollector(s.db))
-	if err := os.Remove(path.Join(s.databasePath, databaseFileName)); err != nil {
+	if err := os.Remove(path.Join(s.databasePath, DatabaseFileName)); err != nil {
 		return errors.Wrap(err, "could not remove database file")
 	}
 	return nil
@@ -143,6 +149,12 @@ func (s *Store) ClearDB() error {
 // Close closes the underlying BoltDB database.
 func (s *Store) Close() error {
 	prometheus.Unregister(createBoltCollector(s.db))
+
+	// Before DB closes, we should dump the cached state summary objects to DB.
+	if err := s.saveCachedStateSummariesDB(s.ctx); err != nil {
+		return err
+	}
+
 	return s.db.Close()
 }
 

beacon-chain/db/kv/kv_test.go

@@ -1,15 +1,15 @@
 package kv
 
 import (
+	"context"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 // setupDB instantiates and returns a Store instance.
 func setupDB(t testing.TB) *Store {
-	db, err := NewKVStore(t.TempDir(), cache.NewStateSummaryCache())
+	db, err := NewKVStore(context.Background(), t.TempDir())
 	require.NoError(t, err, "Failed to instantiate DB")
 	t.Cleanup(func() {
 		require.NoError(t, db.Close(), "Failed to close database")

beacon-chain/db/kv/log.go

@@ -0,0 +1,5 @@
+package kv
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "db")

beacon-chain/db/kv/slashings_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
@@ -14,24 +15,16 @@ func TestStore_ProposerSlashing_CRUD(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
 	prop := &ethpb.ProposerSlashing{
-		Header_1: &ethpb.SignedBeaconBlockHeader{
+		Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
 				ProposerIndex: 5,
-				BodyRoot:      make([]byte, 32),
-				ParentRoot:    make([]byte, 32),
-				StateRoot:     make([]byte, 32),
 			},
-			Signature: make([]byte, 96),
-		},
-		Header_2: &ethpb.SignedBeaconBlockHeader{
+		}),
+		Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
 				ProposerIndex: 5,
-				BodyRoot:      make([]byte, 32),
-				ParentRoot:    make([]byte, 32),
-				StateRoot:     make([]byte, 32),
 			},
-			Signature: make([]byte, 96),
-		},
+		}),
 	}
 	slashingRoot, err := prop.HashTreeRoot()
 	require.NoError(t, err)
@@ -51,37 +44,14 @@ func TestStore_AttesterSlashing_CRUD(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
 	att := &ethpb.AttesterSlashing{
-		Attestation_1: &ethpb.IndexedAttestation{
+		Attestation_1: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 			Data: &ethpb.AttestationData{
-				BeaconBlockRoot: make([]byte, 32),
-				Slot:            5,
-				Source: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  make([]byte, 32),
-				},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  make([]byte, 32),
-				},
-			},
-			Signature: make([]byte, 96),
-		},
-		Attestation_2: &ethpb.IndexedAttestation{
+				Slot: 5,
+			}}),
+		Attestation_2: testutil.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 			Data: &ethpb.AttestationData{
-				BeaconBlockRoot: make([]byte, 32),
-				Slot:            7,
-				Source: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  make([]byte, 32),
-				},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  make([]byte, 32),
-				},
-			},
-			Signature: make([]byte, 96),
-		},
-	}
+				Slot: 7,
+			}})}
 	slashingRoot, err := att.HashTreeRoot()
 	require.NoError(t, err)
 	retrieved, err := db.AttesterSlashing(ctx, slashingRoot)

beacon-chain/db/kv/state.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	log "github.com/sirupsen/logrus"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
 )

beacon-chain/db/kv/state_summary.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
 )
@@ -21,25 +22,30 @@ func (s *Store) SaveStateSummaries(ctx context.Context, summaries []*pb.StateSum
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveStateSummaries")
 	defer span.End()
 
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(stateSummaryBucket)
-		for _, summary := range summaries {
-			enc, err := encode(ctx, summary)
-			if err != nil {
-				return err
-			}
-			if err := bucket.Put(summary.Root, enc); err != nil {
-				return err
-			}
+	// When we reach the state summary cache prune count,
+	// dump the cached state summaries to the DB.
+	if s.stateSummaryCache.len() >= stateSummaryCachePruneCount {
+		if err := s.saveCachedStateSummariesDB(ctx); err != nil {
+			return err
 		}
-		return nil
-	})
+	}
+
+	for _, ss := range summaries {
+		s.stateSummaryCache.put(bytesutil.ToBytes32(ss.Root), ss)
+	}
+
+	return nil
 }
 
 // StateSummary returns the state summary object from the db using input block root.
 func (s *Store) StateSummary(ctx context.Context, blockRoot [32]byte) (*pb.StateSummary, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.StateSummary")
 	defer span.End()
+
+	if s.stateSummaryCache.has(blockRoot) {
+		return s.stateSummaryCache.get(blockRoot), nil
+	}
+
 	enc, err := s.stateSummaryBytes(ctx, blockRoot)
 	if err != nil {
 		return nil, err
@@ -58,6 +64,11 @@ func (s *Store) StateSummary(ctx context.Context, blockRoot [32]byte) (*pb.State
 func (s *Store) HasStateSummary(ctx context.Context, blockRoot [32]byte) bool {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasStateSummary")
 	defer span.End()
+
+	if s.stateSummaryCache.has(blockRoot) {
+		return true
+	}
+
 	enc, err := s.stateSummaryBytes(ctx, blockRoot)
 	if err != nil {
 		panic(err)
@@ -78,3 +89,29 @@ func (s *Store) stateSummaryBytes(ctx context.Context, blockRoot [32]byte) ([]by
 
 	return enc, err
 }
+
+// This saves all cached state summary objects to DB, and clears up the cache.
+func (s *Store) saveCachedStateSummariesDB(ctx context.Context) error {
+	summaries := s.stateSummaryCache.getAll()
+	encs := make([][]byte, len(summaries))
+	for i, s := range summaries {
+		enc, err := encode(ctx, s)
+		if err != nil {
+			return err
+		}
+		encs[i] = enc
+	}
+	if err := s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(stateSummaryBucket)
+		for i, s := range summaries {
+			if err := bucket.Put(s.Root, encs[i]); err != nil {
+				return err
+			}
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+	s.stateSummaryCache.clear()
+	return nil
+}

beacon-chain/db/kv/state_summary_cache.go

@@ -1,4 +1,4 @@
-package cache
+package kv
 
 import (
 	"sync"
@@ -6,47 +6,56 @@ import (
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 )
 
-// StateSummaryCache caches state summary object.
-type StateSummaryCache struct {
+const stateSummaryCachePruneCount = 128
+
+// stateSummaryCache caches state summary object.
+type stateSummaryCache struct {
 	initSyncStateSummaries     map[[32]byte]*pb.StateSummary
 	initSyncStateSummariesLock sync.RWMutex
 }
 
-// NewStateSummaryCache creates a new state summary cache.
-func NewStateSummaryCache() *StateSummaryCache {
-	return &StateSummaryCache{
+// newStateSummaryCache creates a new state summary cache.
+func newStateSummaryCache() *stateSummaryCache {
+	return &stateSummaryCache{
 		initSyncStateSummaries: make(map[[32]byte]*pb.StateSummary),
 	}
 }
 
-// Put saves a state summary to the initial sync state summaries cache.
-func (s *StateSummaryCache) Put(r [32]byte, b *pb.StateSummary) {
+// put saves a state summary to the initial sync state summaries cache.
+func (s *stateSummaryCache) put(r [32]byte, b *pb.StateSummary) {
 	s.initSyncStateSummariesLock.Lock()
 	defer s.initSyncStateSummariesLock.Unlock()
 	s.initSyncStateSummaries[r] = b
 }
 
-// Has checks if a state summary exists in the initial sync state summaries cache using the root
+// has checks if a state summary exists in the initial sync state summaries cache using the root
 // of the block.
-func (s *StateSummaryCache) Has(r [32]byte) bool {
+func (s *stateSummaryCache) has(r [32]byte) bool {
 	s.initSyncStateSummariesLock.RLock()
 	defer s.initSyncStateSummariesLock.RUnlock()
 	_, ok := s.initSyncStateSummaries[r]
 	return ok
 }
 
-// Get retrieves a state summary from the initial sync state summaries cache using the root of
+// get retrieves a state summary from the initial sync state summaries cache using the root of
 // the block.
-func (s *StateSummaryCache) Get(r [32]byte) *pb.StateSummary {
+func (s *stateSummaryCache) get(r [32]byte) *pb.StateSummary {
 	s.initSyncStateSummariesLock.RLock()
 	defer s.initSyncStateSummariesLock.RUnlock()
 	b := s.initSyncStateSummaries[r]
 	return b
 }
 
+// len retrieves the state summary count from the state summaries cache.
+func (s *stateSummaryCache) len() int {
+	s.initSyncStateSummariesLock.RLock()
+	defer s.initSyncStateSummariesLock.RUnlock()
+	return len(s.initSyncStateSummaries)
+}
+
 // GetAll retrieves all the beacon state summaries from the initial sync state summaries cache, the returned
 // state summaries are unordered.
-func (s *StateSummaryCache) GetAll() []*pb.StateSummary {
+func (s *stateSummaryCache) getAll() []*pb.StateSummary {
 	s.initSyncStateSummariesLock.RLock()
 	defer s.initSyncStateSummariesLock.RUnlock()
 
@@ -58,7 +67,7 @@ func (s *StateSummaryCache) GetAll() []*pb.StateSummary {
 }
 
 // Clear clears out the initial sync state summaries cache.
-func (s *StateSummaryCache) Clear() {
+func (s *stateSummaryCache) clear() {
 	s.initSyncStateSummariesLock.Lock()
 	defer s.initSyncStateSummariesLock.Unlock()
 	s.initSyncStateSummaries = make(map[[32]byte]*pb.StateSummary)

beacon-chain/db/kv/state_summary_test.go

@@ -38,3 +38,26 @@ func TestStateSummary_CanSaveRretrieve(t *testing.T) {
 	require.NoError(t, err)
 	assert.DeepEqual(t, s2, saved, "State summary does not equal")
 }
+
+func TestStateSummary_CacheToDB(t *testing.T) {
+	db := setupDB(t)
+
+	summaries := make([]*pb.StateSummary, stateSummaryCachePruneCount-1)
+	for i := range summaries {
+		summaries[i] = &pb.StateSummary{Slot: uint64(i), Root: bytesutil.PadTo(bytesutil.Uint64ToBytesLittleEndian(uint64(i)), 32)}
+	}
+
+	require.NoError(t, db.SaveStateSummaries(context.Background(), summaries))
+	require.Equal(t, db.stateSummaryCache.len(), stateSummaryCachePruneCount-1)
+
+	require.NoError(t, db.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1000, Root: []byte{'a', 'b'}}))
+	require.Equal(t, db.stateSummaryCache.len(), stateSummaryCachePruneCount)
+
+	require.NoError(t, db.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1001, Root: []byte{'c', 'd'}}))
+	require.Equal(t, db.stateSummaryCache.len(), 1)
+
+	for i := range summaries {
+		r := bytesutil.Uint64ToBytesLittleEndian(uint64(i))
+		require.Equal(t, true, db.HasStateSummary(context.Background(), bytesutil.ToBytes32(r)))
+	}
+}

beacon-chain/db/kv/state_test.go

@@ -299,7 +299,7 @@ func TestStore_CleanUpDirtyStates_DontDeleteNonFinalized(t *testing.T) {
 	require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), genesisRoot))
 	require.NoError(t, db.SaveState(context.Background(), genesisState, genesisRoot))
 
-	unfinalizedRoots := [][32]byte{}
+	var unfinalizedRoots [][32]byte
 	for i := uint64(1); i <= params.BeaconConfig().SlotsPerEpoch; i++ {
 		b := testutil.NewBeaconBlock()
 		b.Block.Slot = i

beacon-chain/db/log.go

@@ -0,0 +1,5 @@
+package db
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "db")

beacon-chain/db/restore.go

@@ -0,0 +1,45 @@
+package db
+
+import (
+	"os"
+	"path"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
+	"github.com/prysmaticlabs/prysm/shared/cmd"
+	"github.com/prysmaticlabs/prysm/shared/fileutil"
+	"github.com/prysmaticlabs/prysm/shared/promptutil"
+	"github.com/urfave/cli/v2"
+)
+
+const dbExistsYesNoPrompt = "A database file already exists in the target directory. " +
+	"Are you sure that you want to overwrite it? [y/n]"
+
+func restore(cliCtx *cli.Context) error {
+	sourceFile := cliCtx.String(cmd.RestoreSourceFileFlag.Name)
+	targetDir := cliCtx.String(cmd.RestoreTargetDirFlag.Name)
+
+	restoreDir := path.Join(targetDir, kv.BeaconNodeDbDirName)
+	if fileutil.FileExists(path.Join(restoreDir, kv.DatabaseFileName)) {
+		resp, err := promptutil.ValidatePrompt(
+			os.Stdin, dbExistsYesNoPrompt, promptutil.ValidateYesOrNo,
+		)
+		if err != nil {
+			return errors.Wrap(err, "could not validate choice")
+		}
+		if strings.EqualFold(resp, "n") {
+			log.Info("Restore aborted")
+			return nil
+		}
+	}
+	if err := fileutil.MkdirAll(restoreDir); err != nil {
+		return err
+	}
+	if err := fileutil.CopyFile(sourceFile, path.Join(restoreDir, kv.DatabaseFileName)); err != nil {
+		return err
+	}
+
+	log.Info("Restore completed successfully")
+	return nil
+}

beacon-chain/db/restore_test.go

@@ -0,0 +1,70 @@
+package db
+
+import (
+	"context"
+	"flag"
+	"io/ioutil"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
+	"github.com/prysmaticlabs/prysm/shared/cmd"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+	"github.com/urfave/cli/v2"
+)
+
+func TestRestore(t *testing.T) {
+	logHook := logTest.NewGlobal()
+	ctx := context.Background()
+
+	backupDb, err := kv.NewKVStore(context.Background(), t.TempDir())
+	defer func() {
+		require.NoError(t, backupDb.Close())
+	}()
+	require.NoError(t, err)
+	head := testutil.NewBeaconBlock()
+	head.Block.Slot = 5000
+	require.NoError(t, backupDb.SaveBlock(ctx, head))
+	root, err := head.Block.HashTreeRoot()
+	require.NoError(t, err)
+	st := testutil.NewBeaconState()
+	require.NoError(t, backupDb.SaveState(ctx, st, root))
+	require.NoError(t, backupDb.SaveHeadBlockRoot(ctx, root))
+	require.NoError(t, err)
+	require.NoError(t, backupDb.Close())
+	// We rename the backup file so that we can later verify
+	// whether the restored db has been renamed correctly.
+	require.NoError(t, os.Rename(
+		path.Join(backupDb.DatabasePath(), kv.DatabaseFileName),
+		path.Join(backupDb.DatabasePath(), "backup.db")))
+
+	restoreDir := t.TempDir()
+	app := cli.App{}
+	set := flag.NewFlagSet("test", 0)
+	set.String(cmd.RestoreSourceFileFlag.Name, "", "")
+	set.String(cmd.RestoreTargetDirFlag.Name, "", "")
+	require.NoError(t, set.Set(cmd.RestoreSourceFileFlag.Name, path.Join(backupDb.DatabasePath(), "backup.db")))
+	require.NoError(t, set.Set(cmd.RestoreTargetDirFlag.Name, restoreDir))
+	cliCtx := cli.NewContext(&app, set, nil)
+
+	assert.NoError(t, restore(cliCtx))
+
+	files, err := ioutil.ReadDir(path.Join(restoreDir, kv.BeaconNodeDbDirName))
+	require.NoError(t, err)
+	assert.Equal(t, 1, len(files))
+	assert.Equal(t, kv.DatabaseFileName, files[0].Name())
+	restoredDb, err := kv.NewKVStore(context.Background(), path.Join(restoreDir, kv.BeaconNodeDbDirName))
+	defer func() {
+		require.NoError(t, restoredDb.Close())
+	}()
+	require.NoError(t, err)
+	headBlock, err := restoredDb.HeadBlock(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, uint64(5000), headBlock.Block.Slot, "Restored database has incorrect data")
+	assert.LogsContain(t, logHook, "Restore completed successfully")
+
+}

beacon-chain/db/testing/BUILD.bazel

@@ -7,7 +7,6 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/db/testing",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//beacon-chain/cache:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
     ],

beacon-chain/db/testing/setup_db.go

@@ -3,17 +3,16 @@
 package testing
 
 import (
+	"context"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
 )
 
 // SetupDB instantiates and returns database backed by key value store.
-func SetupDB(t testing.TB) (db.Database, *cache.StateSummaryCache) {
-	sc := cache.NewStateSummaryCache()
-	s, err := kv.NewKVStore(t.TempDir(), sc)
+func SetupDB(t testing.TB) db.Database {
+	s, err := kv.NewKVStore(context.Background(), t.TempDir())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -22,5 +21,5 @@ func SetupDB(t testing.TB) (db.Database, *cache.StateSummaryCache) {
 			t.Fatalf("failed to close database: %v", err)
 		}
 	})
-	return s, sc
+	return s
 }

beacon-chain/flags/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "base.go",
         "config.go",
         "interop.go",
+        "log.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/flags",
     visibility = ["//beacon-chain:__subpackages__"],

beacon-chain/flags/base.go

@@ -11,14 +11,17 @@ var (
 	// HTTPWeb3ProviderFlag provides an HTTP access endpoint to an ETH 1.0 RPC.
 	HTTPWeb3ProviderFlag = &cli.StringFlag{
 		Name:  "http-web3provider",
-		Usage: "A mainchain web3 provider string http endpoint",
-		Value: "",
+		Usage: "A mainchain web3 provider string http endpoint. This is our primary web3 provider",
+	}
+	FallbackWeb3ProviderFlag = &cli.StringSliceFlag{
+		Name:  "fallback-web3provider",
+		Usage: "A mainchain web3 provider string http endpoint. This is our fallback web3 provider, this flag maybe used multiple times.",
 	}
 	// DepositContractFlag defines a flag for the deposit contract address.
 	DepositContractFlag = &cli.StringFlag{
 		Name:  "deposit-contract",
 		Usage: "Deposit contract address. Beacon chain node will listen logs coming from the deposit contract to determine when validator is eligible to participate.",
-		Value: params.BeaconNetworkConfig().DepositContractAddress,
+		Value: params.BeaconConfig().DepositContractAddress,
 	}
 	// RPCHost defines the host on which the RPC server should listen.
 	RPCHost = &cli.StringFlag{

beacon-chain/flags/config.go

@@ -2,7 +2,6 @@ package flags
 
 import (
 	"github.com/prysmaticlabs/prysm/shared/cmd"
-	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 

beacon-chain/flags/log.go

@@ -0,0 +1,5 @@
+package flags
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "flags")

beacon-chain/forkchoice/protoarray/BUILD.bazel

@@ -9,7 +9,6 @@ go_library(
         "helpers.go",
         "metrics.go",
         "node.go",
-        "nodes.go",
         "store.go",
         "types.go",
     ],
@@ -33,7 +32,8 @@ go_test(
         "ffg_update_test.go",
         "helpers_test.go",
         "no_vote_test.go",
-        "nodes_test.go",
+        "node_test.go",
+        "store_test.go",
         "vote_test.go",
     ],
     embed = [":go_default_library"],

beacon-chain/forkchoice/protoarray/node_test.go

@@ -0,0 +1,40 @@
+package protoarray
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestNode_Getters(t *testing.T) {
+	slot := uint64(100)
+	root := [32]byte{'a'}
+	parent := uint64(10)
+	jEpoch := uint64(20)
+	fEpoch := uint64(30)
+	weight := uint64(10000)
+	bestChild := uint64(5)
+	bestDescendant := uint64(4)
+	graffiti := [32]byte{'b'}
+	n := &Node{
+		slot:           slot,
+		root:           root,
+		parent:         parent,
+		justifiedEpoch: jEpoch,
+		finalizedEpoch: fEpoch,
+		weight:         weight,
+		bestChild:      bestChild,
+		bestDescendant: bestDescendant,
+		graffiti:       graffiti,
+	}
+
+	require.Equal(t, slot, n.Slot())
+	require.Equal(t, root, n.Root())
+	require.Equal(t, parent, n.Parent())
+	require.Equal(t, jEpoch, n.JustifiedEpoch())
+	require.Equal(t, fEpoch, n.FinalizedEpoch())
+	require.Equal(t, weight, n.Weight())
+	require.Equal(t, bestChild, n.BestChild())
+	require.Equal(t, bestDescendant, n.BestDescendant())
+	require.Equal(t, graffiti, n.Graffiti())
+}