Update Herumi with a fix for older intel chips. #8410

* Configurable testutil's BeaconState

* fix shared and fuzz tests

* return state copy

* use mainnet config values for default state

* handle error in block fuzz

* goimports

Co-authored-by: Raul Jordan <raul@prysmaticlabs.com>

.bazelrc

@@ -17,9 +17,12 @@ test --host_force_python=PY2
 run --host_force_python=PY2
 
 # Networking is blocked for tests by default, add "requires-network" tag to your test if networking
-# is required within the sandbox. This flag is no longer experimental after 0.29.0.
-# Network sandboxing only works on linux.
---experimental_sandbox_default_allow_network=false
+# is required within the sandbox. Network sandboxing only works on linux.
+build --sandbox_default_allow_network=false
+
+# Stamp binaries with git information
+build --workspace_status_command=./scripts/workspace_status.sh
+build --stamp
 
 # Use mainnet protobufs at runtime
 run --define ssz=mainnet
@@ -48,8 +51,6 @@ build:blst_enabled --define blst_enabled=true
 build:blst_enabled --define gotags=blst_enabled
 
 # Release flags
-build:release --workspace_status_command=./scripts/workspace_status.sh
-build:release --stamp
 build:release --compilation_mode=opt
 build:release --config=llvm
 
@@ -237,3 +238,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 
+```

README.md

@@ -5,7 +5,7 @@
 [![ETH2.0_Spec_Version 1.0.0](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v1.0.0-blue.svg)](https://github.com/ethereum/eth2.0-specs/tree/v1.0.0)
 [![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
 
-This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the Ethereum 2.0 specification, developed by [Prysmatic Labs](https://prysmaticlabs.com).
+This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the [Ethereum 2.0](https://ethereum.org/en/eth2/) specification, developed by [Prysmatic Labs](https://prysmaticlabs.com). See the [Changelog](https://github.com/prysmaticlabs/prysm/releases) for details of the latest releases and upcoming breaking changes.
 
 ### Getting Started
 
@@ -13,10 +13,17 @@ A detailed set of installation and usage instructions as well as breakdowns of e
 
 ### Staking on Mainnet
 
-To participate in staking, you can join the [official eth2 launchpad](https://launchpad.ethereum.org). The launchpad is the only recommended way to become a validator on mainnet. You can visualize the nodes in the network on [eth2stats.io](https://eth2stats.io), explore validator rewards/penalties via Bitfly's block explorer: [beaconcha.in](https://beaconcha.in), and follow the latest blocks added to the chain on [beaconscan](https://beaconscan.com).
+To participate in staking, you can join the [official eth2 launchpad](https://launchpad.ethereum.org). The launchpad is the only recommended way to become a validator on mainnet. You can explore validator rewards/penalties via Bitfly's block explorer: [beaconcha.in](https://beaconcha.in), and follow the latest blocks added to the chain on [beaconscan](https://beaconscan.com).
+
 
 ## Contributing
+### Branches
+Prysm maintains two permanent branches:
 
+* [master](https://github.com/prysmaticlabs/prysm/tree/master): This points to the latest stable release. It is ideal for most users.
+* [develop](https://github.com/prysmaticlabs/prysm/tree/develop): This is used for development, it contains the latest PRs. Developers should base their PRs on this branch.
+
+### Guide
 Want to get involved? Check out our [Contribution Guide](https://docs.prylabs.network/docs/contribute/contribution-guidelines/) to learn more!
 
 ## License

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(
@@ -89,10 +89,10 @@ http_archive(
         # nogo check fails for certain third_party dependencies.
         "//third_party:io_bazel_rules_go.patch",
     ],
-    sha256 = "207fad3e6689135c5d8713e5a17ba9d1290238f47b9ba545b63d9303406209c6",
+    sha256 = "dbf5a9ef855684f84cac2e7ae7886c5a001d4f66ae23f6904da0faaaef0d61fc",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.24.7/rules_go-v0.24.7.tar.gz",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.24.7/rules_go-v0.24.7.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.24.11/rules_go-v0.24.11.tar.gz",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.24.11/rules_go-v0.24.11.tar.gz",
     ],
 )
 
@@ -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
 )
 
@@ -156,7 +156,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.15.5",
+    go_version = "1.15.7",
     nogo = "@//:nogo",
 )
 
@@ -210,6 +210,21 @@ http_archive(
     url = "https://github.com/kubernetes/repo-infra/archive/6537f2101fb432b679f3d103ee729dd8ac5d30a0.tar.gz",
 )
 
+http_archive(
+    name = "eip3076_spec_tests",
+    build_file_content = """
+filegroup(
+    name = "test_data",
+    srcs = glob([
+        "**/*.json",
+    ]),
+    visibility = ["//visibility:public"],
+)
+    """,
+    sha256 = "91434d5fd5e1c6eb7b0174fed2afe25e09bddf00e1e4c431db931b2cee4e7773",
+    url = "https://github.com/eth2-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
+)
+
 http_archive(
     name = "eth2_spec_tests_general",
     build_file_content = """
@@ -352,9 +367,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",
     ],
 )
 
@@ -363,10 +378,6 @@ load("//:deps.bzl", "prysm_deps")
 # gazelle:repository_macro deps.bzl%prysm_deps
 prysm_deps()
 
-load("@com_github_prysmaticlabs_go_ssz//:deps.bzl", "go_ssz_dependencies")
-
-go_ssz_dependencies()
-
 load("@prysm//third_party/herumi:herumi.bzl", "bls_dependencies")
 
 bls_dependencies()

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",
@@ -114,7 +116,6 @@ go_test(
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_gogo_protobuf//proto: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",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
@@ -126,6 +127,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 +139,7 @@ go_test(
         # See: https://github.com/etcd-io/bbolt/issues/187.
         "-d=checkptr=0",
     ],
+    gotags = ["develop"],
     race = "on",
     tags = ["race_on"],
     deps = [
@@ -161,7 +164,6 @@ go_test(
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_gogo_protobuf//proto: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",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@org_golang_x_net//context:go_default_library",

beacon-chain/blockchain/blockchain_test.go

@@ -2,18 +2,14 @@ package blockchain
 
 import (
 	"io/ioutil"
-	"os"
 	"testing"
 
 	"github.com/sirupsen/logrus"
 )
 
 func TestMain(m *testing.M) {
-	run := func() int {
-		logrus.SetLevel(logrus.DebugLevel)
-		logrus.SetOutput(ioutil.Discard)
+	logrus.SetLevel(logrus.DebugLevel)
+	logrus.SetOutput(ioutil.Discard)
 
-		return m.Run()
-	}
-	os.Exit(run())
+	m.Run()
 }

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
 	}
 
@@ -234,14 +234,6 @@ func (s *Service) headGenesisValidatorRoot() [32]byte {
 	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
 }
 
-// HasHeadState returns true if head state exists.
-func (s *Service) HasHeadState() bool {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	return s.hasHeadState()
-}
-
 // Returns true if head state exists.
 // This is the lock free version.
 func (s *Service) hasHeadState() bool {

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}
@@ -41,7 +41,8 @@ func TestSaveHead_Different(t *testing.T) {
 	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	headState := testutil.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(1))
 	require.NoError(t, service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}))
 	require.NoError(t, service.beaconDB.SaveState(context.Background(), headState, newRoot))
@@ -51,9 +52,7 @@ func TestSaveHead_Different(t *testing.T) {
 
 	cachedRoot, err := service.HeadRoot(context.Background())
 	require.NoError(t, err)
-	if !bytes.Equal(cachedRoot, newRoot[:]) {
-		t.Error("Head did not change")
-	}
+	assert.DeepEqual(t, cachedRoot, newRoot[:], "Head did not change")
 	assert.DeepEqual(t, newHeadSignedBlock, service.headBlock(), "Head did not change")
 	assert.DeepEqual(t, headState.CloneInnerState(), service.headState(ctx).CloneInnerState(), "Head did not change")
 }
@@ -61,8 +60,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}
@@ -76,7 +75,8 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	headState := testutil.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(1))
 	require.NoError(t, service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}))
 	require.NoError(t, service.beaconDB.SaveState(context.Background(), headState, newRoot))
@@ -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,19 +20,20 @@ func TestService_TreeHandler(t *testing.T) {
 	require.NoError(t, err)
 
 	ctx := context.Background()
-	db, sCache := testDB.SetupDB(t)
-	headState := testutil.NewBeaconState()
+	beaconDB := testDB.SetupDB(t)
+	headState, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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)
+	s, err := New(ctx, cfg)
 	require.NoError(t, err)
 	require.NoError(t, s.forkChoiceStore.ProcessBlock(ctx, 0, [32]byte{'a'}, [32]byte{'g'}, [32]byte{'c'}, 0, 0))
 	require.NoError(t, s.forkChoiceStore.ProcessBlock(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'c'}, 0, 0))

beacon-chain/blockchain/metrics_test.go

@@ -4,23 +4,39 @@ import (
 	"context"
 	"testing"
 
+	eth "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestReportEpochMetrics_BadHeadState(t *testing.T) {
-	s := testutil.NewBeaconState()
-	h := testutil.NewBeaconState()
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
+	h, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, h.SetValidators(nil))
-	err := reportEpochMetrics(context.Background(), s, h)
+	err = reportEpochMetrics(context.Background(), s, h)
 	require.ErrorContains(t, "failed to initialize precompute: nil validators in state", err)
 }
 
 func TestReportEpochMetrics_BadAttestation(t *testing.T) {
-	s := testutil.NewBeaconState()
-	h := testutil.NewBeaconState()
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
+	h, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, h.SetCurrentEpochAttestations([]*pb.PendingAttestation{{InclusionDelay: 0}}))
-	err := reportEpochMetrics(context.Background(), s, h)
+	err = reportEpochMetrics(context.Background(), s, h)
 	require.ErrorContains(t, "attestation with inclusion delay of 0", err)
 }
+
+func TestReportEpochMetrics_SlashedValidatorOutOfBound(t *testing.T) {
+	h, _ := testutil.DeterministicGenesisState(t, 1)
+	v, err := h.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	v.Slashed = true
+	require.NoError(t, h.UpdateValidatorAtIndex(0, v))
+	require.NoError(t, h.SetCurrentEpochAttestations([]*pb.PendingAttestation{{InclusionDelay: 1, Data: testutil.HydrateAttestationData(&eth.AttestationData{})}}))
+	err = reportEpochMetrics(context.Background(), h, h)
+	require.ErrorContains(t, "slot 0 out of bounds", err)
+}

beacon-chain/blockchain/process_attestation.go

@@ -2,25 +2,21 @@ package blockchain
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/timeutils"
 	"go.opencensus.io/trace"
 )
 
-// ErrTargetRootNotInDB returns when the target block root of an attestation cannot be found in the
-// beacon database.
-var ErrTargetRootNotInDB = errors.New("target root does not exist in db")
-
 // onAttestation is called whenever an attestation is received, verifies the attestation is valid and saves
 // it to the DB. As a stateless function, this does not hold nor delay attestation based on the spec descriptions.
-// The delay is handled by the caller in `processAttestation`.
+// The delay is handled by the caller in `processAttestations`.
 //
 // Spec pseudocode definition:
 //   def on_attestation(store: Store, attestation: Attestation) -> None:
@@ -40,73 +36,68 @@ var ErrTargetRootNotInDB = errors.New("target root does not exist in db")
 //
 //    # Update latest messages for attesting indices
 //    update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
-// TODO(#6072): This code path is highly untested. Requires comprehensive tests and simpler refactoring.
-func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) ([]uint64, error) {
+func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 
-	if a == nil {
-		return nil, errors.New("nil attestation")
+	if err := helpers.ValidateNilAttestation(a); err != nil {
+		return err
 	}
-	if a.Data == nil {
-		return nil, errors.New("nil attestation.Data field")
+	if err := helpers.ValidateSlotTargetEpoch(a.Data); err != nil {
+		return err
 	}
-	if a.Data.Target == nil {
-		return nil, errors.New("nil attestation.Data.Target field")
-	}
-
 	tgt := stateTrie.CopyCheckpoint(a.Data.Target)
 
-	if helpers.SlotToEpoch(a.Data.Slot) != a.Data.Target.Epoch {
-		return nil, fmt.Errorf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(a.Data.Slot), a.Data.Target.Epoch)
-	}
-
-	// Verify beacon node has seen the target block before.
-	if !s.hasBlock(ctx, bytesutil.ToBytes32(tgt.Root)) {
-		return nil, ErrTargetRootNotInDB
-	}
+	// Note that target root check is ignored here because it was performed in sync's validation pipeline:
+	// validate_aggregate_proof.go and validate_beacon_attestation.go
+	// If missing target root were to fail in this method, it would have just failed in `getAttPreState`.
 
 	// Retrieve attestation's data beacon block pre state. Advance pre state to latest epoch if necessary and
 	// save it to the cache.
 	baseState, err := s.getAttPreState(ctx, tgt)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	genesisTime := baseState.GenesisTime()
 
 	// Verify attestation target is from current epoch or previous epoch.
 	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(timeutils.Now().Unix()), tgt); err != nil {
-		return nil, err
+		return err
 	}
 
 	// Verify attestation beacon block is known and not from the future.
 	if err := s.verifyBeaconBlock(ctx, a.Data); err != nil {
-		return nil, errors.Wrap(err, "could not verify attestation beacon block")
+		return errors.Wrap(err, "could not verify attestation beacon block")
 	}
 
-	// Verify LMG GHOST and FFG votes are consistent with each other.
-	if err := s.verifyLMDFFGConsistent(ctx, a.Data.Target.Epoch, a.Data.Target.Root, a.Data.BeaconBlockRoot); err != nil {
-		return nil, errors.Wrap(err, "could not verify attestation beacon block")
-	}
+	// Note that LMG GHOST and FFG consistency check is ignored because it was performed in sync's validation pipeline:
+	// validate_aggregate_proof.go and validate_beacon_attestation.go
 
 	// Verify attestations can only affect the fork choice of subsequent slots.
 	if err := helpers.VerifySlotTime(genesisTime, a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
-		return nil, err
+		return err
 	}
 
-	// Use the target state to validate attestation and calculate the committees.
-	indexedAtt, err := s.verifyAttestation(ctx, baseState, a)
+	// Use the target state to verify attesting indices are valid.
+	committee, err := helpers.BeaconCommitteeFromState(baseState, a.Data.Slot, a.Data.CommitteeIndex)
 	if err != nil {
-		return nil, err
+		return err
+	}
+	indexedAtt, err := attestationutil.ConvertToIndexed(ctx, a, committee)
+	if err != nil {
+		return err
+	}
+	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
+		return err
 	}
 
-	if indexedAtt.AttestingIndices == nil {
-		return nil, errors.New("nil attesting indices")
-	}
+	// Note that signature verification is ignored here because it was performed in sync's validation pipeline:
+	// validate_aggregate_proof.go and validate_beacon_attestation.go
+	// We assume trusted attestation in this function has verified signature.
 
 	// Update forkchoice store with the new attestation for updating weight.
 	s.forkChoiceStore.ProcessAttestation(ctx, indexedAtt.AttestingIndices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
 
-	return indexedAtt.AttestingIndices, nil
+	return nil
 }

beacon-chain/blockchain/process_attestation_helpers.go

@@ -1,18 +1,15 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"strconv"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/mputil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -44,7 +41,6 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*sta
 		return nil, err
 	}
 	if epochStartSlot > baseState.Slot() {
-		baseState = baseState.Copy()
 		baseState, err = state.ProcessSlots(ctx, baseState, epochStartSlot)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
@@ -105,33 +101,3 @@ func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.Attestation
 	}
 	return nil
 }
-
-// verifyLMDFFGConsistent verifies LMD GHOST and FFG votes are consistent with each other.
-func (s *Service) verifyLMDFFGConsistent(ctx context.Context, ffgEpoch uint64, ffgRoot, lmdRoot []byte) error {
-	ffgSlot, err := helpers.StartSlot(ffgEpoch)
-	if err != nil {
-		return err
-	}
-	r, err := s.ancestor(ctx, lmdRoot, ffgSlot)
-	if err != nil {
-		return err
-	}
-	if !bytes.Equal(ffgRoot, r) {
-		return errors.New("FFG and LMD votes are not consistent")
-	}
-
-	return nil
-}
-
-// verifyAttestation validates input attestation is valid.
-func (s *Service) verifyAttestation(ctx context.Context, baseState *stateTrie.BeaconState, a *ethpb.Attestation) (*ethpb.IndexedAttestation, error) {
-	committee, err := helpers.BeaconCommitteeFromState(baseState, a.Data.Slot, a.Data.CommitteeIndex)
-	if err != nil {
-		return nil, err
-	}
-	indexedAtt := attestationutil.ConvertToIndexed(ctx, a, committee)
-	if err := blocks.VerifyIndexedAttestation(ctx, baseState, indexedAtt); err != nil {
-		return nil, errors.Wrap(err, "could not verify indexed attestation")
-	}
-	return indexedAtt, nil
-}

beacon-chain/blockchain/process_attestation_test.go

@@ -17,46 +17,49 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 )
 
-func TestStore_OnAttestation(t *testing.T) {
+func TestStore_OnAttestation_ErrorConditions(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)
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
-	_, err = blockTree1(db, []byte{'g'})
+	_, err = blockTree1(t, 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)
 
-	s := testutil.NewBeaconState()
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, service.beaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
 
 	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)
-	s = testutil.NewBeaconState()
+	s, err = testutil.NewBeaconState()
+	require.NoError(t, err)
 	err = s.SetFork(&pb.Fork{
 		Epoch:           0,
 		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
@@ -72,34 +75,29 @@ func TestStore_OnAttestation(t *testing.T) {
 	}{
 		{
 			name:      "attestation's data slot not aligned with target vote",
-			a:         &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}},
-			wantedErr: "data slot is not in the same epoch as target 1 != 0",
-		},
-		{
-			name:      "attestation's target root not in db",
-			a:         &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)}}},
-			wantedErr: "target root does not exist in db",
+			a:         testutil.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
+			wantedErr: "slot 32 does not match target epoch 0",
 		},
 		{
 			name:      "no pre state for attestations's target block",
-			a:         &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}},
+			a:         testutil.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
 			wantedErr: "could not get pre state for epoch 0",
 		},
 		{
 			name: "process attestation doesn't match current epoch",
-			a: &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
-				Root: BlkWithStateBadAttRoot[:]}}},
+			a: testutil.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
+				Root: BlkWithStateBadAttRoot[:]}}}),
 			wantedErr: "target epoch 100 does not match current epoch",
 		},
 		{
 			name:      "process nil attestation",
 			a:         nil,
-			wantedErr: "nil attestation",
+			wantedErr: "attestation can't be nil",
 		},
 		{
 			name:      "process nil field (a.Data) in attestation",
 			a:         &ethpb.Attestation{},
-			wantedErr: "nil attestation.Data field",
+			wantedErr: "attestation's data can't be nil",
 		},
 		{
 			name: "process nil field (a.Target) in attestation",
@@ -112,13 +110,13 @@ func TestStore_OnAttestation(t *testing.T) {
 				AggregationBits: make([]byte, 1),
 				Signature:       make([]byte, 96),
 			},
-			wantedErr: "nil attestation.Data.Target field",
+			wantedErr: "attestation's target can't be nil",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			_, err := service.onAttestation(ctx, tt.a)
+			err := service.onAttestation(ctx, tt.a)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
@@ -128,18 +126,44 @@ func TestStore_OnAttestation(t *testing.T) {
 	}
 }
 
-func TestStore_SaveCheckpointState(t *testing.T) {
+func TestStore_OnAttestation_Ok(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,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, cfg)
+	service, err := New(ctx, cfg)
+	require.NoError(t, err)
+	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
+	require.NoError(t, genesisState.SetGenesisTime(uint64(timeutils.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
+	require.NoError(t, service.saveGenesisData(ctx, genesisState))
+	att, err := testutil.GenerateAttestations(genesisState, pks, 1, 0, false)
+	require.NoError(t, err)
+	tRoot := bytesutil.ToBytes32(att[0].Data.Target.Root)
+	copied := genesisState.Copy()
+	copied, err = state.ProcessSlots(ctx, copied, 1)
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveState(ctx, copied, tRoot))
+	require.NoError(t, service.forkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
+	require.NoError(t, service.onAttestation(ctx, att[0]))
+}
+
+func TestStore_SaveCheckpointState(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
+	}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
-	s := testutil.NewBeaconState()
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	err = s.SetFinalizedCheckpoint(&ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)})
 	require.NoError(t, err)
 	val := &ethpb.Validator{
@@ -201,13 +225,13 @@ 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)
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	epoch := uint64(1)
@@ -242,10 +266,10 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	nowTime := params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
@@ -254,10 +278,10 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	nowTime := params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
@@ -266,10 +290,10 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	nowTime := 2 * params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
@@ -279,26 +303,22 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b := testutil.NewBeaconBlock()
@@ -313,10 +333,10 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b := testutil.NewBeaconBlock()
@@ -329,60 +349,12 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 	assert.NoError(t, service.verifyBeaconBlock(ctx, d), "Did not receive the wanted error")
 }
 
-func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
-	ctx := context.Background()
-	db, _ := testDB.SetupDB(t)
-
-	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx, cfg)
-	require.NoError(t, err)
-
-	b32 := testutil.NewBeaconBlock()
-	b32.Block.Slot = 32
-	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
-	r32, err := b32.Block.HashTreeRoot()
-	require.NoError(t, err)
-	b33 := testutil.NewBeaconBlock()
-	b33.Block.Slot = 33
-	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
-	r33, err := b33.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	wanted := "FFG and LMD votes are not consistent"
-	assert.ErrorContains(t, wanted, service.verifyLMDFFGConsistent(context.Background(), 1, []byte{'a'}, r33[:]))
-}
-
-func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
-	ctx := context.Background()
-	db, _ := testDB.SetupDB(t)
-
-	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx, cfg)
-	require.NoError(t, err)
-
-	b32 := testutil.NewBeaconBlock()
-	b32.Block.Slot = 32
-	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
-	r32, err := b32.Block.HashTreeRoot()
-	require.NoError(t, err)
-	b33 := testutil.NewBeaconBlock()
-	b33.Block.Slot = 33
-	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
-	r33, err := b33.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	err = service.verifyLMDFFGConsistent(context.Background(), 1, r32[:], r33[:])
-	assert.NoError(t, err, "Could not verify LMD and FFG votes to be consistent")
-}
-
 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{})}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()
@@ -406,10 +378,10 @@ 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{})}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()
@@ -433,10 +405,10 @@ 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{})}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b32 := testutil.NewBeaconBlock()

beacon-chain/blockchain/process_block.go

@@ -3,12 +3,14 @@ package blockchain
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"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"
@@ -17,6 +19,9 @@ import (
 	"go.opencensus.io/trace"
 )
 
+// A custom slot deadline for processing state slots in our cache.
+const slotDeadline = 5 * time.Second
+
 // This defines size of the upper bound for initial sync block cache.
 var initialSyncBlockCacheSize = 2 * params.BeaconConfig().SlotsPerEpoch
 
@@ -100,6 +105,20 @@ func (s *Service) onBlock(ctx context.Context, signed *ethpb.SignedBeaconBlock,
 		return err
 	}
 
+	// Updating next slot state cache can happen in the background. It shouldn't block rest of the process.
+	if featureconfig.Get().EnableNextSlotStateCache {
+		go func() {
+			// Use a custom deadline here, since this method runs asynchronously.
+			// We ignore the parent method's context and instead create a new one
+			// with a custom deadline, therefore using the background context instead.
+			slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
+			defer cancel()
+			if err := state.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
+				log.WithError(err).Debug("could not update next slot state cache")
+			}
+		}()
+	}
+
 	// Update justified check point.
 	if postState.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
 		if err := s.updateJustified(ctx, postState); err != nil {
@@ -303,7 +322,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 +354,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 +371,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,25 +381,29 @@ 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
+		}
+		indices, err := attestationutil.AttestingIndices(a.AggregationBits, committee)
 		if err != nil {
 			return err
 		}
-		indices := attestationutil.AttestingIndices(a.AggregationBits, committee)
 		s.forkChoiceStore.ProcessAttestation(ctx, indices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
 	}
 	return nil
@@ -388,7 +426,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 +434,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,29 @@ 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)
+	service, err := New(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()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-	roots, err := blockTree1(db, validGenesisRoot[:])
+	roots, err := blockTree1(t, 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 +124,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)
+	service, err := New(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 +167,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,12 +175,12 @@ 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{})}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 	service.genesisTime = time.Now()
 
@@ -208,12 +209,12 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 	lastJustifiedBlk := testutil.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
@@ -237,13 +238,13 @@ 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)
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	s, err := stateTrie.InitializeFromProto(&pb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
@@ -251,7 +252,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 +271,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)
+	service, err := New(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,23 +308,25 @@ 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())}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}
+	service, err := New(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))
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveState(ctx, st.Copy(), r))
 
 	// Could update
-	s := testutil.NewBeaconState()
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, s.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: r[:]}))
 	require.NoError(t, service.updateJustified(context.Background(), s))
 
@@ -338,23 +341,24 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
 
 	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()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-	roots, err := blockTree1(db, validGenesisRoot[:])
+	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)
 
 	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
@@ -375,23 +379,24 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
 
 	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()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-	roots, err := blockTree1(db, validGenesisRoot[:])
+	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)
 
 	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
@@ -415,10 +420,10 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	// Set finalized epoch to 1.
@@ -426,10 +431,11 @@ 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()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 
@@ -467,7 +473,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(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byte, error) {
 	genesisRoot = bytesutil.PadTo(genesisRoot, 32)
 	b0 := testutil.NewBeaconBlock()
 	b0.Block.Slot = 0
@@ -525,26 +531,27 @@ func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	st := testutil.NewBeaconState()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 
 	for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
 		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
@@ -558,7 +565,7 @@ func TestCurrentSlot_HandlesOverflow(t *testing.T) {
 }
 func TestAncestorByDB_CtxErr(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	service, err := NewService(ctx, &Config{})
+	service, err := New(ctx, &Config{})
 	require.NoError(t, err)
 
 	cancel()
@@ -568,10 +575,10 @@ 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{})}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b1 := testutil.NewBeaconBlock()
@@ -593,7 +600,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.
@@ -614,7 +621,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 func TestAncestor_CanUseForkchoice(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx, cfg)
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b1 := testutil.NewBeaconBlock()
@@ -650,10 +657,10 @@ 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{})}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	b1 := testutil.NewBeaconBlock()
@@ -675,7 +682,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))
@@ -690,7 +697,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 func TestEnsureRootNotZeroHashes(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{}
-	service, err := NewService(ctx, cfg)
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 	service.genesisRoot = [32]byte{'a'}
 
@@ -702,7 +709,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
@@ -741,13 +748,15 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		beaconState := testutil.NewBeaconState()
+		beaconState, err := testutil.NewBeaconState()
+		require.NoError(t, err)
 		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 := New(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)}))
-		genesisState := testutil.NewBeaconState()
+		genesisState, err := testutil.NewBeaconState()
+		require.NoError(t, err)
 		require.NoError(t, service.beaconDB.SaveState(ctx, genesisState, bytesutil.ToBytes32(test.want.Root)))
 
 		if test.args.diffFinalizedCheckPoint {
@@ -777,26 +786,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 +843,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 := New(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,10 +858,10 @@ 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}
-	service, err := NewService(ctx, cfg)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
 	gBlk := testutil.NewBeaconBlock()
@@ -881,11 +889,61 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{}
-	service, err := NewService(ctx, cfg)
+	service, err := New(ctx, cfg)
 	require.NoError(t, err)
 
-	s := testutil.NewBeaconState()
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
 	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 := New(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 := New(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

@@ -35,8 +35,7 @@ func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Att
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveAttestationNoPubsub")
 	defer span.End()
 
-	_, err := s.onAttestation(ctx, att)
-	if err != nil {
+	if err := s.onAttestation(ctx, att); err != nil {
 		return errors.Wrap(err, "could not process attestation")
 	}
 
@@ -62,7 +61,18 @@ func (s *Service) AttestationPreState(ctx context.Context, att *ethpb.Attestatio
 
 // VerifyLmdFfgConsistency verifies that attestation's LMD and FFG votes are consistency to each other.
 func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a *ethpb.Attestation) error {
-	return s.verifyLMDFFGConsistent(ctx, a.Data.Target.Epoch, a.Data.Target.Root, a.Data.BeaconBlockRoot)
+	targetSlot, err := helpers.StartSlot(a.Data.Target.Epoch)
+	if err != nil {
+		return err
+	}
+	r, err := s.ancestor(ctx, a.Data.BeaconBlockRoot, targetSlot)
+	if err != nil {
+		return err
+	}
+	if !bytes.Equal(a.Data.Target.Root, r) {
+		return errors.New("FFG and LMD votes are not consistent")
+	}
+	return nil
 }
 
 // VerifyFinalizedConsistency verifies input root is consistent with finalized store.
@@ -91,8 +101,8 @@ func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) e
 	return nil
 }
 
-// This processes attestations from the attestation pool to account for validator votes and fork choice.
-func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
+// This routine processes fork choice attestations from the pool to account for validator votes and fork choice.
+func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan struct{}) {
 	// Wait for state to be initialized.
 	stateChannel := make(chan *feed.Event, 1)
 	stateSub := s.stateNotifier.StateFeed().Subscribe(stateChannel)
@@ -108,47 +118,51 @@ func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 		log.Warn("Genesis time received, now available to process attestations")
 	}
 
-	st := slotutil.GetSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+	st := slotutil.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
 	for {
 		select {
 		case <-s.ctx.Done():
 			return
 		case <-st.C():
-			ctx := s.ctx
-			atts := s.attPool.ForkchoiceAttestations()
-			for _, a := range atts {
-				// Based on the spec, don't process the attestation until the subsequent slot.
-				// This delays consideration in the fork choice until their slot is in the past.
-				// https://github.com/ethereum/eth2.0-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
-				nextSlot := a.Data.Slot + 1
-				if err := helpers.VerifySlotTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
-					continue
-				}
-
-				hasState := s.stateGen.StateSummaryExists(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
-				hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
-				if !(hasState && hasBlock) {
-					continue
-				}
-
-				if err := s.attPool.DeleteForkchoiceAttestation(a); err != nil {
-					log.WithError(err).Error("Could not delete fork choice attestation in pool")
-				}
-
-				if !helpers.VerifyCheckpointEpoch(a.Data.Target, s.genesisTime) {
-					continue
-				}
-
-				if err := s.ReceiveAttestationNoPubsub(ctx, a); err != nil {
-					log.WithFields(logrus.Fields{
-						"slot":             a.Data.Slot,
-						"committeeIndex":   a.Data.CommitteeIndex,
-						"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.BeaconBlockRoot)),
-						"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.Target.Root)),
-						"aggregationCount": a.AggregationBits.Count(),
-					}).WithError(err).Warn("Could not receive attestation in chain service")
-				}
-			}
+			s.processAttestations(s.ctx)
+		}
+	}
+}
+
+// This processes fork choice attestations from the pool to account for validator votes and fork choice.
+func (s *Service) processAttestations(ctx context.Context) {
+	atts := s.attPool.ForkchoiceAttestations()
+	for _, a := range atts {
+		// Based on the spec, don't process the attestation until the subsequent slot.
+		// This delays consideration in the fork choice until their slot is in the past.
+		// https://github.com/ethereum/eth2.0-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
+		nextSlot := a.Data.Slot + 1
+		if err := helpers.VerifySlotTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+			continue
+		}
+
+		hasState := s.beaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
+		hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
+		if !(hasState && hasBlock) {
+			continue
+		}
+
+		if err := s.attPool.DeleteForkchoiceAttestation(a); err != nil {
+			log.WithError(err).Error("Could not delete fork choice attestation in pool")
+		}
+
+		if !helpers.VerifyCheckpointEpoch(a.Data.Target, s.genesisTime) {
+			continue
+		}
+
+		if err := s.ReceiveAttestationNoPubsub(ctx, a); err != nil {
+			log.WithFields(logrus.Fields{
+				"slot":             a.Data.Slot,
+				"committeeIndex":   a.Data.CommitteeIndex,
+				"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.BeaconBlockRoot)),
+				"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.Target.Root)),
+				"aggregationCount": a.AggregationBits.Count(),
+			}).WithError(err).Warn("Could not process attestation for fork choice")
 		}
 	}
 }

beacon-chain/blockchain/receive_attestation_test.go

@@ -7,19 +7,114 @@ import (
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
+	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 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
 	_, err := chainService.AttestationPreState(context.Background(), &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: e}}})
 	require.ErrorContains(t, "exceeds max allowed value relative to the local clock", err)
 }
+
+func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
+	require.NoError(t, err)
+
+	b32 := testutil.NewBeaconBlock()
+	b32.Block.Slot = 32
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
+	r32, err := b32.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b33 := testutil.NewBeaconBlock()
+	b33.Block.Slot = 33
+	b33.Block.ParentRoot = r32[:]
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
+	r33, err := b33.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	wanted := "FFG and LMD votes are not consistent"
+	a := testutil.NewAttestation()
+	a.Data.Target.Epoch = 1
+	a.Data.Target.Root = []byte{'a'}
+	a.Data.BeaconBlockRoot = r33[:]
+	require.ErrorContains(t, wanted, service.VerifyLmdFfgConsistency(context.Background(), a))
+}
+
+func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := New(ctx, cfg)
+	require.NoError(t, err)
+
+	b32 := testutil.NewBeaconBlock()
+	b32.Block.Slot = 32
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
+	r32, err := b32.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b33 := testutil.NewBeaconBlock()
+	b33.Block.Slot = 33
+	b33.Block.ParentRoot = r32[:]
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
+	r33, err := b33.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	a := testutil.NewAttestation()
+	a.Data.Target.Epoch = 1
+	a.Data.Target.Root = r32[:]
+	a.Data.BeaconBlockRoot = r33[:]
+	err = service.VerifyLmdFfgConsistency(context.Background(), a)
+	require.NoError(t, err, "Could not verify LMD and FFG votes to be consistent")
+}
+
+func TestProcessAttestations_Ok(t *testing.T) {
+	hook := logTest.NewGlobal()
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB:        beaconDB,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
+		AttPool:         attestations.NewPool(),
+	}
+	service, err := New(ctx, cfg)
+	service.genesisTime = timeutils.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
+	require.NoError(t, err)
+	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
+	require.NoError(t, genesisState.SetGenesisTime(uint64(timeutils.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
+	require.NoError(t, service.saveGenesisData(ctx, genesisState))
+	atts, err := testutil.GenerateAttestations(genesisState, pks, 1, 0, false)
+	require.NoError(t, err)
+	tRoot := bytesutil.ToBytes32(atts[0].Data.Target.Root)
+	copied := genesisState.Copy()
+	copied, err = state.ProcessSlots(ctx, copied, 1)
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveState(ctx, copied, tRoot))
+	require.NoError(t, service.forkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
+	require.NoError(t, service.attPool.SaveForkchoiceAttestations(atts))
+	service.processAttestations(ctx)
+	require.Equal(t, 0, len(service.attPool.ForkchoiceAttestations()))
+	require.LogsDoNotContain(t, hook, "Could not process attestation for fork choice")
+}

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,9 +131,9 @@ 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)
+			s, err := New(ctx, cfg)
 			require.NoError(t, err)
 			require.NoError(t, s.saveGenesisData(ctx, genesis))
 			gBlk, err := s.beaconDB.GenesisBlock(ctx)
@@ -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,9 +172,9 @@ 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)
+	s, err := New(ctx, cfg)
 	require.NoError(t, err)
 	require.NoError(t, s.saveGenesisData(ctx, genesis))
 	gBlk, err := s.beaconDB.GenesisBlock(ctx)
@@ -242,20 +242,20 @@ 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)
+			s, err := New(ctx, cfg)
 			require.NoError(t, err)
 			err = s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
@@ -323,20 +323,20 @@ 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)
+			s, err := New(ctx, cfg)
 			require.NoError(t, err)
 			err = s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
@@ -362,7 +362,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 }
 
 func TestService_HasInitSyncBlock(t *testing.T) {
-	s, err := NewService(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
+	s, err := New(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
 	require.NoError(t, err)
 	r := [32]byte{'a'}
 	if s.HasInitSyncBlock(r) {
@@ -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 := New(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 := New(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 := New(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

@@ -99,9 +99,9 @@ type Config struct {
 	WspEpoch          uint64
 }
 
-// NewService instantiates a new block service instance that will
+// New instantiates a new block service instance that will
 // be registered into a running beacon node.
-func NewService(ctx context.Context, cfg *Config) (*Service, error) {
+func New(ctx context.Context, cfg *Config) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	return &Service{
 		ctx:                  ctx,
@@ -175,7 +175,11 @@ func (s *Service) Start() {
 		if err != nil {
 			log.Fatalf("Could not retrieve genesis state: %v", err)
 		}
-		go slotutil.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()))
+		gRoot, err := gState.HashTreeRoot(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not hash tree root genesis state: %v", err)
+		}
+		go slotutil.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()), gRoot)
 
 		justifiedCheckpoint, err := s.beaconDB.JustifiedCheckpoint(s.ctx)
 		if err != nil {
@@ -202,12 +206,14 @@ func (s *Service) Start() {
 			log.Fatalf("Could not get start slot of finalized epoch: %v", err)
 		}
 		h := s.headBlock().Block
-		log.WithFields(logrus.Fields{
-			"startSlot": ss,
-			"endSlot":   h.Slot,
-		}).Info("Loading blocks to fork choice store, this may take a while.")
-		if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, s.finalizedCheckpt, s.justifiedCheckpt); err != nil {
-			log.Fatalf("Could not fill in fork choice store missing blocks: %v", err)
+		if h.Slot > ss {
+			log.WithFields(logrus.Fields{
+				"startSlot": ss,
+				"endSlot":   h.Slot,
+			}).Info("Loading blocks to fork choice store, this may take a while.")
+			if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, s.finalizedCheckpt, s.justifiedCheckpt); err != nil {
+				log.Fatalf("Could not fill in fork choice store missing blocks: %v", err)
+			}
 		}
 
 		if err := s.VerifyWeakSubjectivityRoot(s.ctx); err != nil {
@@ -257,7 +263,7 @@ func (s *Service) Start() {
 		}()
 	}
 
-	go s.processAttestation(attestationProcessorSubscribed)
+	go s.processAttestationsRoutine(attestationProcessorSubscribed)
 }
 
 // processChainStartTime initializes a series of deposits from the ChainStart deposits in the eth1
@@ -269,7 +275,11 @@ func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Ti
 		log.Fatalf("Could not initialize beacon chain: %v", err)
 	}
 	// We start a counter to genesis, if needed.
-	go slotutil.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()))
+	gRoot, err := initializedState.HashTreeRoot(s.ctx)
+	if err != nil {
+		log.Fatalf("Could not hash tree root genesis state: %v", err)
+	}
+	go slotutil.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
 
 	// We send out a state initialized event to the rest of the services
 	// running in the beacon node.

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,9 +10,10 @@ 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/feed"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
@@ -63,7 +64,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
@@ -85,14 +86,14 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummary
 		DepositContainers: []*protodb.DepositContainer{},
 	})
 	require.NoError(t, err)
-	web3Service, err = powchain.NewService(ctx, &powchain.Web3ServiceConfig{
+	web3Service, err = powchain.New(ctx, &powchain.Web3ServiceConfig{
 		BeaconDB:        beaconDB,
-		HTTPEndPoint:    endpoint,
+		HTTPEndpoints:   []string{endpoint},
 		DepositContract: common.Address{},
 	})
 	require.NoError(t, err, "Unable to set up web3 service")
 
-	opsService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
+	opsService, err := attestations.New(ctx, &attestations.Config{Pool: attestations.NewPool()})
 	require.NoError(t, err)
 
 	depositCache, err := depositcache.New()
@@ -106,7 +107,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,
 	}
@@ -114,7 +115,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummary
 	// Safe a state in stategen to purposes of testing a service stop / shutdown.
 	require.NoError(t, cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
 
-	chainService, err := NewService(ctx, cfg)
+	chainService, err := New(ctx, cfg)
 	require.NoError(t, err, "Unable to setup chain service")
 	chainService.genesisTime = time.Unix(1, 0) // non-zero time
 
@@ -124,21 +125,22 @@ 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))
-	s := testutil.NewBeaconState()
+	require.NoError(t, beaconDB.SaveBlock(ctx, genesisBlk))
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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 +155,19 @@ 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))
-	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.SaveBlock(ctx, genesisBlk))
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
+	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 +181,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 +224,21 @@ 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))
-	s := testutil.NewBeaconState()
+	require.NoError(t, beaconDB.SaveBlock(ctx, genesisBlk))
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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,29 +251,30 @@ 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()
 	headBlock.Block.Slot = finalizedSlot
 	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
-	headState := testutil.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
 	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,28 +292,29 @@ 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()
 	headBlock.Block.Slot = finalizedSlot
 	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
-	headState := testutil.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
 	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 +334,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 +356,22 @@ 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()
+	headState, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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 +389,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 +406,42 @@ 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, err := testutil.NewBeaconState()
 	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, err := testutil.NewBeaconState()
+	require.NoError(t, err)
+	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,12 +449,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(beaconDB),
 	}
 	b := testutil.NewBeaconBlock()
 	r, err := b.Block.HashTreeRoot()
@@ -455,11 +465,25 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	require.Equal(t, true, s.beaconDB.HasBlock(ctx, r))
 }
 
+func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+	stateChannel := make(chan *feed.Event, 1)
+	stateSub := service.stateNotifier.StateFeed().Subscribe(stateChannel)
+	defer stateSub.Unsubscribe()
+	service.processChainStartTime(context.Background(), time.Now())
+
+	stateEvent := <-stateChannel
+	require.Equal(t, int(stateEvent.Type), statefeed.Initialized)
+	_, ok := stateEvent.Data.(*statefeed.InitializedData)
+	require.Equal(t, true, ok)
+}
+
 func BenchmarkHasBlockDB(b *testing.B) {
-	db, _ := testDB.SetupDB(b)
+	beaconDB := testDB.SetupDB(b)
 	ctx := context.Background()
 	s := &Service{
-		beaconDB: db,
+		beaconDB: beaconDB,
 	}
 	block := testutil.NewBeaconBlock()
 	require.NoError(b, s.beaconDB.SaveBlock(ctx, block))
@@ -474,19 +498,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,22 +47,23 @@ 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.
-func (ms *ChainService) StateNotifier() statefeed.Notifier {
-	if ms.stateNotifier == nil {
-		ms.stateNotifier = &MockStateNotifier{}
+func (s *ChainService) StateNotifier() statefeed.Notifier {
+	if s.stateNotifier == nil {
+		s.stateNotifier = &MockStateNotifier{}
 	}
-	return ms.stateNotifier
+	return s.stateNotifier
 }
 
 // BlockNotifier mocks the same method in the chain service.
-func (ms *ChainService) BlockNotifier() blockfeed.Notifier {
-	if ms.blockNotifier == nil {
-		ms.blockNotifier = &MockBlockNotifier{}
+func (s *ChainService) BlockNotifier() blockfeed.Notifier {
+	if s.blockNotifier == nil {
+		s.blockNotifier = &MockBlockNotifier{}
 	}
-	return ms.blockNotifier
+	return s.blockNotifier
 }
 
 // MockBlockNotifier mocks the block notifier.
@@ -71,11 +72,11 @@ type MockBlockNotifier struct {
 }
 
 // BlockFeed returns a block feed.
-func (msn *MockBlockNotifier) BlockFeed() *event.Feed {
-	if msn.feed == nil {
-		msn.feed = new(event.Feed)
+func (mbn *MockBlockNotifier) BlockFeed() *event.Feed {
+	if mbn.feed == nil {
+		mbn.feed = new(event.Feed)
 	}
-	return msn.feed
+	return mbn.feed
 }
 
 // MockStateNotifier mocks the state notifier.
@@ -124,11 +125,11 @@ func (msn *MockStateNotifier) StateFeed() *event.Feed {
 }
 
 // OperationNotifier mocks the same method in the chain service.
-func (ms *ChainService) OperationNotifier() opfeed.Notifier {
-	if ms.opNotifier == nil {
-		ms.opNotifier = &MockOperationNotifier{}
+func (s *ChainService) OperationNotifier() opfeed.Notifier {
+	if s.opNotifier == nil {
+		s.opNotifier = &MockOperationNotifier{}
 	}
-	return ms.opNotifier
+	return s.opNotifier
 }
 
 // MockOperationNotifier mocks the operation notifier.
@@ -145,224 +146,227 @@ func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
 }
 
 // ReceiveBlockInitialSync mocks ReceiveBlockInitialSync method in chain service.
-func (ms *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, _ [32]byte) error {
-	if ms.State == nil {
-		ms.State = &stateTrie.BeaconState{}
+func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, _ [32]byte) error {
+	if s.State == nil {
+		s.State = &stateTrie.BeaconState{}
 	}
-	if !bytes.Equal(ms.Root, block.Block.ParentRoot) {
-		return errors.Errorf("wanted %#x but got %#x", ms.Root, block.Block.ParentRoot)
+	if !bytes.Equal(s.Root, block.Block.ParentRoot) {
+		return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block.ParentRoot)
 	}
-	if err := ms.State.SetSlot(block.Block.Slot); err != nil {
+	if err := s.State.SetSlot(block.Block.Slot); err != nil {
 		return err
 	}
-	ms.BlocksReceived = append(ms.BlocksReceived, block)
+	s.BlocksReceived = append(s.BlocksReceived, block)
 	signingRoot, err := block.Block.HashTreeRoot()
 	if err != nil {
 		return err
 	}
-	if ms.DB != nil {
-		if err := ms.DB.SaveBlock(ctx, block); err != nil {
+	if s.DB != nil {
+		if err := s.DB.SaveBlock(ctx, block); err != nil {
 			return err
 		}
 		logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block.Slot)
 	}
-	ms.Root = signingRoot[:]
-	ms.Block = block
+	s.Root = signingRoot[:]
+	s.Block = block
 	return nil
 }
 
 // ReceiveBlockBatch processes blocks in batches from initial-sync.
-func (ms *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock, _ [][32]byte) error {
-	if ms.State == nil {
-		ms.State = &stateTrie.BeaconState{}
+func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock, _ [][32]byte) error {
+	if s.State == nil {
+		s.State = &stateTrie.BeaconState{}
 	}
 	for _, block := range blks {
-		if !bytes.Equal(ms.Root, block.Block.ParentRoot) {
-			return errors.Errorf("wanted %#x but got %#x", ms.Root, block.Block.ParentRoot)
+		if !bytes.Equal(s.Root, block.Block.ParentRoot) {
+			return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block.ParentRoot)
 		}
-		if err := ms.State.SetSlot(block.Block.Slot); err != nil {
+		if err := s.State.SetSlot(block.Block.Slot); err != nil {
 			return err
 		}
-		ms.BlocksReceived = append(ms.BlocksReceived, block)
+		s.BlocksReceived = append(s.BlocksReceived, block)
 		signingRoot, err := block.Block.HashTreeRoot()
 		if err != nil {
 			return err
 		}
-		if ms.DB != nil {
-			if err := ms.DB.SaveBlock(ctx, block); err != nil {
+		if s.DB != nil {
+			if err := s.DB.SaveBlock(ctx, block); err != nil {
 				return err
 			}
 			logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block.Slot)
 		}
-		ms.Root = signingRoot[:]
-		ms.Block = block
+		s.Root = signingRoot[:]
+		s.Block = block
 	}
 	return nil
 }
 
 // ReceiveBlock mocks ReceiveBlock method in chain service.
-func (ms *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, _ [32]byte) error {
-	if ms.State == nil {
-		ms.State = &stateTrie.BeaconState{}
+func (s *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, _ [32]byte) error {
+	if s.State == nil {
+		s.State = &stateTrie.BeaconState{}
 	}
-	if !bytes.Equal(ms.Root, block.Block.ParentRoot) {
-		return errors.Errorf("wanted %#x but got %#x", ms.Root, block.Block.ParentRoot)
+	if !bytes.Equal(s.Root, block.Block.ParentRoot) {
+		return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block.ParentRoot)
 	}
-	if err := ms.State.SetSlot(block.Block.Slot); err != nil {
+	if err := s.State.SetSlot(block.Block.Slot); err != nil {
 		return err
 	}
-	ms.BlocksReceived = append(ms.BlocksReceived, block)
+	s.BlocksReceived = append(s.BlocksReceived, block)
 	signingRoot, err := block.Block.HashTreeRoot()
 	if err != nil {
 		return err
 	}
-	if ms.DB != nil {
-		if err := ms.DB.SaveBlock(ctx, block); err != nil {
+	if s.DB != nil {
+		if err := s.DB.SaveBlock(ctx, block); err != nil {
 			return err
 		}
 		logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block.Slot)
 	}
-	ms.Root = signingRoot[:]
-	ms.Block = block
+	s.Root = signingRoot[:]
+	s.Block = block
 	return nil
 }
 
 // HeadSlot mocks HeadSlot method in chain service.
-func (ms *ChainService) HeadSlot() uint64 {
-	if ms.State == nil {
+func (s *ChainService) HeadSlot() uint64 {
+	if s.State == nil {
 		return 0
 	}
-	return ms.State.Slot()
+	return s.State.Slot()
 }
 
 // HeadRoot mocks HeadRoot method in chain service.
-func (ms *ChainService) HeadRoot(_ context.Context) ([]byte, error) {
-	if len(ms.Root) > 0 {
-		return ms.Root, nil
+func (s *ChainService) HeadRoot(_ context.Context) ([]byte, error) {
+	if len(s.Root) > 0 {
+		return s.Root, nil
 	}
 	return make([]byte, 32), nil
 }
 
 // HeadBlock mocks HeadBlock method in chain service.
-func (ms *ChainService) HeadBlock(context.Context) (*ethpb.SignedBeaconBlock, error) {
-	return ms.Block, nil
+func (s *ChainService) HeadBlock(context.Context) (*ethpb.SignedBeaconBlock, error) {
+	return s.Block, nil
 }
 
 // HeadState mocks HeadState method in chain service.
-func (ms *ChainService) HeadState(context.Context) (*stateTrie.BeaconState, error) {
-	return ms.State, nil
+func (s *ChainService) HeadState(context.Context) (*stateTrie.BeaconState, error) {
+	return s.State, nil
 }
 
 // CurrentFork mocks HeadState method in chain service.
-func (ms *ChainService) CurrentFork() *pb.Fork {
-	return ms.Fork
+func (s *ChainService) CurrentFork() *pb.Fork {
+	return s.Fork
 }
 
 // FinalizedCheckpt mocks FinalizedCheckpt method in chain service.
-func (ms *ChainService) FinalizedCheckpt() *ethpb.Checkpoint {
-	return ms.FinalizedCheckPoint
+func (s *ChainService) FinalizedCheckpt() *ethpb.Checkpoint {
+	return s.FinalizedCheckPoint
 }
 
 // CurrentJustifiedCheckpt mocks CurrentJustifiedCheckpt method in chain service.
-func (ms *ChainService) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
-	return ms.CurrentJustifiedCheckPoint
+func (s *ChainService) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
+	return s.CurrentJustifiedCheckPoint
 }
 
 // PreviousJustifiedCheckpt mocks PreviousJustifiedCheckpt method in chain service.
-func (ms *ChainService) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
-	return ms.PreviousJustifiedCheckPoint
+func (s *ChainService) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
+	return s.PreviousJustifiedCheckPoint
 }
 
 // ReceiveAttestation mocks ReceiveAttestation method in chain service.
-func (ms *ChainService) ReceiveAttestation(_ context.Context, _ *ethpb.Attestation) error {
+func (s *ChainService) ReceiveAttestation(_ context.Context, _ *ethpb.Attestation) error {
 	return nil
 }
 
 // ReceiveAttestationNoPubsub mocks ReceiveAttestationNoPubsub method in chain service.
-func (ms *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attestation) error {
+func (s *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attestation) error {
 	return nil
 }
 
 // AttestationPreState mocks AttestationPreState method in chain service.
-func (ms *ChainService) AttestationPreState(_ context.Context, _ *ethpb.Attestation) (*stateTrie.BeaconState, error) {
-	return ms.State, nil
+func (s *ChainService) AttestationPreState(_ context.Context, _ *ethpb.Attestation) (*stateTrie.BeaconState, error) {
+	return s.State, nil
 }
 
 // HeadValidatorsIndices mocks the same method in the chain service.
-func (ms *ChainService) HeadValidatorsIndices(_ context.Context, epoch uint64) ([]uint64, error) {
-	if ms.State == nil {
+func (s *ChainService) HeadValidatorsIndices(_ context.Context, epoch uint64) ([]uint64, error) {
+	if s.State == nil {
 		return []uint64{}, nil
 	}
-	return helpers.ActiveValidatorIndices(ms.State, epoch)
+	return helpers.ActiveValidatorIndices(s.State, epoch)
 }
 
 // HeadSeed mocks the same method in the chain service.
-func (ms *ChainService) HeadSeed(_ context.Context, epoch uint64) ([32]byte, error) {
-	return helpers.Seed(ms.State, epoch, params.BeaconConfig().DomainBeaconAttester)
+func (s *ChainService) HeadSeed(_ context.Context, epoch uint64) ([32]byte, error) {
+	return helpers.Seed(s.State, epoch, params.BeaconConfig().DomainBeaconAttester)
 }
 
 // HeadETH1Data provides the current ETH1Data of the head state.
-func (ms *ChainService) HeadETH1Data() *ethpb.Eth1Data {
-	return ms.ETH1Data
+func (s *ChainService) HeadETH1Data() *ethpb.Eth1Data {
+	return s.ETH1Data
 }
 
 // ProtoArrayStore mocks the same method in the chain service.
-func (ms *ChainService) ProtoArrayStore() *protoarray.Store {
-	return ms.ForkChoiceStore
+func (s *ChainService) ProtoArrayStore() *protoarray.Store {
+	return s.ForkChoiceStore
 }
 
 // GenesisTime mocks the same method in the chain service.
-func (ms *ChainService) GenesisTime() time.Time {
-	return ms.Genesis
+func (s *ChainService) GenesisTime() time.Time {
+	return s.Genesis
 }
 
 // GenesisValidatorRoot mocks the same method in the chain service.
-func (ms *ChainService) GenesisValidatorRoot() [32]byte {
-	return ms.ValidatorsRoot
+func (s *ChainService) GenesisValidatorRoot() [32]byte {
+	return s.ValidatorsRoot
 }
 
 // CurrentSlot mocks the same method in the chain service.
-func (ms *ChainService) CurrentSlot() uint64 {
-	return uint64(time.Now().Unix()-ms.Genesis.Unix()) / params.BeaconConfig().SecondsPerSlot
+func (s *ChainService) CurrentSlot() uint64 {
+	if s.Slot != nil {
+		return *s.Slot
+	}
+	return uint64(time.Now().Unix()-s.Genesis.Unix()) / params.BeaconConfig().SecondsPerSlot
 }
 
 // Participation mocks the same method in the chain service.
-func (ms *ChainService) Participation(_ uint64) *precompute.Balance {
-	return ms.Balance
+func (s *ChainService) Participation(_ uint64) *precompute.Balance {
+	return s.Balance
 }
 
 // IsValidAttestation always returns true.
-func (ms *ChainService) IsValidAttestation(_ context.Context, _ *ethpb.Attestation) bool {
-	return ms.ValidAttestation
+func (s *ChainService) IsValidAttestation(_ context.Context, _ *ethpb.Attestation) bool {
+	return s.ValidAttestation
 }
 
 // IsCanonical returns and determines whether a block with the provided root is part of
 // the canonical chain.
-func (ms *ChainService) IsCanonical(_ context.Context, r [32]byte) (bool, error) {
-	if ms.CanonicalRoots != nil {
-		_, ok := ms.CanonicalRoots[r]
+func (s *ChainService) IsCanonical(_ context.Context, r [32]byte) (bool, error) {
+	if s.CanonicalRoots != nil {
+		_, ok := s.CanonicalRoots[r]
 		return ok, nil
 	}
 	return true, nil
 }
 
 // HasInitSyncBlock mocks the same method in the chain service.
-func (ms *ChainService) HasInitSyncBlock(_ [32]byte) bool {
+func (s *ChainService) HasInitSyncBlock(_ [32]byte) bool {
 	return false
 }
 
 // HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
-func (ms *ChainService) HeadGenesisValidatorRoot() [32]byte {
+func (s *ChainService) HeadGenesisValidatorRoot() [32]byte {
 	return [32]byte{}
 }
 
 // VerifyBlkDescendant mocks VerifyBlkDescendant and always returns nil.
-func (ms *ChainService) VerifyBlkDescendant(_ context.Context, _ [32]byte) error {
-	return ms.VerifyBlkDescendantErr
+func (s *ChainService) VerifyBlkDescendant(_ context.Context, _ [32]byte) error {
+	return s.VerifyBlkDescendantErr
 }
 
 // VerifyLmdFfgConsistency mocks VerifyLmdFfgConsistency and always returns nil.
-func (ms *ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
+func (s *ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
 	if !bytes.Equal(a.Data.BeaconBlockRoot, a.Data.Target.Root) {
 		return errors.New("LMD and FFG miss matched")
 	}
@@ -370,8 +374,8 @@ func (ms *ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Atte
 }
 
 // VerifyFinalizedConsistency mocks VerifyFinalizedConsistency and always returns nil.
-func (ms *ChainService) VerifyFinalizedConsistency(_ context.Context, r []byte) error {
-	if !bytes.Equal(r, ms.FinalizedCheckPoint.Root) {
+func (s *ChainService) VerifyFinalizedConsistency(_ context.Context, r []byte) error {
+	if !bytes.Equal(r, s.FinalizedCheckPoint.Root) {
 		return errors.New("Root and finalized store are not consistent")
 	}
 	return nil

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/cache_test.go

@@ -1,17 +1,13 @@
 package cache
 
 import (
-	"os"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 )
 
 func TestMain(m *testing.M) {
-	run := func() int {
-		resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{EnableEth1DataVoteCache: true})
-		defer resetCfg()
-		return m.Run()
-	}
-	os.Exit(run())
+	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{EnableEth1DataVoteCache: true})
+	defer resetCfg()
+	m.Run()
 }

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/state_summary.go

@@ -1,65 +0,0 @@
-package cache
-
-import (
-	"sync"
-
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-)
-
-// 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{
-		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) {
-	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
-// of the block.
-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
-// the block.
-func (s *StateSummaryCache) Get(r [32]byte) *pb.StateSummary {
-	s.initSyncStateSummariesLock.RLock()
-	defer s.initSyncStateSummariesLock.RUnlock()
-	b := s.initSyncStateSummaries[r]
-	return b
-}
-
-// 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 {
-	s.initSyncStateSummariesLock.RLock()
-	defer s.initSyncStateSummariesLock.RUnlock()
-
-	summaries := make([]*pb.StateSummary, 0, len(s.initSyncStateSummaries))
-	for _, b := range s.initSyncStateSummaries {
-		summaries = append(summaries, b)
-	}
-	return summaries
-}
-
-// Clear clears out the initial sync state summaries cache.
-func (s *StateSummaryCache) Clear() {
-	s.initSyncStateSummariesLock.Lock()
-	defer s.initSyncStateSummariesLock.Unlock()
-	s.initSyncStateSummaries = make(map[[32]byte]*pb.StateSummary)
-}

beacon-chain/cache/subnet_ids.go

@@ -35,30 +35,30 @@ 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}
 }
 
 // AddAttesterSubnetID adds the subnet index for subscribing subnet for the attester of a given slot.
-func (c *subnetIDs) AddAttesterSubnetID(slot, subnetID uint64) {
-	c.attesterLock.Lock()
-	defer c.attesterLock.Unlock()
+func (s *subnetIDs) AddAttesterSubnetID(slot, subnetID uint64) {
+	s.attesterLock.Lock()
+	defer s.attesterLock.Unlock()
 
 	ids := []uint64{subnetID}
-	val, exists := c.attester.Get(slot)
+	val, exists := s.attester.Get(slot)
 	if exists {
 		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
 	}
-	c.attester.Add(slot, ids)
+	s.attester.Add(slot, ids)
 }
 
 // GetAttesterSubnetIDs gets the subnet IDs for subscribed subnets for attesters of the slot.
-func (c *subnetIDs) GetAttesterSubnetIDs(slot uint64) []uint64 {
-	c.attesterLock.RLock()
-	defer c.attesterLock.RUnlock()
+func (s *subnetIDs) GetAttesterSubnetIDs(slot uint64) []uint64 {
+	s.attesterLock.RLock()
+	defer s.attesterLock.RUnlock()
 
-	val, exists := c.attester.Get(slot)
+	val, exists := s.attester.Get(slot)
 	if !exists {
 		return nil
 	}
@@ -69,24 +69,24 @@ func (c *subnetIDs) GetAttesterSubnetIDs(slot uint64) []uint64 {
 }
 
 // AddAggregatorSubnetID adds the subnet ID for subscribing subnet for the aggregator of a given slot.
-func (c *subnetIDs) AddAggregatorSubnetID(slot, subnetID uint64) {
-	c.aggregatorLock.Lock()
-	defer c.aggregatorLock.Unlock()
+func (s *subnetIDs) AddAggregatorSubnetID(slot, subnetID uint64) {
+	s.aggregatorLock.Lock()
+	defer s.aggregatorLock.Unlock()
 
 	ids := []uint64{subnetID}
-	val, exists := c.aggregator.Get(slot)
+	val, exists := s.aggregator.Get(slot)
 	if exists {
 		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
 	}
-	c.aggregator.Add(slot, ids)
+	s.aggregator.Add(slot, ids)
 }
 
 // GetAggregatorSubnetIDs gets the subnet IDs for subscribing subnet for aggregator of the slot.
-func (c *subnetIDs) GetAggregatorSubnetIDs(slot uint64) []uint64 {
-	c.aggregatorLock.RLock()
-	defer c.aggregatorLock.RUnlock()
+func (s *subnetIDs) GetAggregatorSubnetIDs(slot uint64) []uint64 {
+	s.aggregatorLock.RLock()
+	defer s.aggregatorLock.RUnlock()
 
-	val, exists := c.aggregator.Get(slot)
+	val, exists := s.aggregator.Get(slot)
 	if !exists {
 		return []uint64{}
 	}
@@ -95,11 +95,11 @@ func (c *subnetIDs) GetAggregatorSubnetIDs(slot uint64) []uint64 {
 
 // GetPersistentSubnets retrieves the persistent subnet and expiration time of that validator's
 // subscription.
-func (c *subnetIDs) GetPersistentSubnets(pubkey []byte) ([]uint64, bool, time.Time) {
-	c.subnetsLock.RLock()
-	defer c.subnetsLock.RUnlock()
+func (s *subnetIDs) GetPersistentSubnets(pubkey []byte) ([]uint64, bool, time.Time) {
+	s.subnetsLock.RLock()
+	defer s.subnetsLock.RUnlock()
 
-	id, duration, ok := c.persistentSubnets.GetWithExpiration(string(pubkey))
+	id, duration, ok := s.persistentSubnets.GetWithExpiration(string(pubkey))
 	if !ok {
 		return []uint64{}, ok, time.Time{}
 	}
@@ -108,11 +108,11 @@ func (c *subnetIDs) GetPersistentSubnets(pubkey []byte) ([]uint64, bool, time.Ti
 
 // GetAllSubnets retrieves all the non-expired subscribed subnets of all the validators
 // in the cache.
-func (c *subnetIDs) GetAllSubnets() []uint64 {
-	c.subnetsLock.RLock()
-	defer c.subnetsLock.RUnlock()
+func (s *subnetIDs) GetAllSubnets() []uint64 {
+	s.subnetsLock.RLock()
+	defer s.subnetsLock.RUnlock()
 
-	itemsMap := c.persistentSubnets.Items()
+	itemsMap := s.persistentSubnets.Items()
 	var committees []uint64
 
 	for _, v := range itemsMap {
@@ -126,9 +126,9 @@ func (c *subnetIDs) GetAllSubnets() []uint64 {
 
 // AddPersistentCommittee adds the relevant committee for that particular validator along with its
 // expiration period.
-func (c *subnetIDs) AddPersistentCommittee(pubkey []byte, comIndex []uint64, duration time.Duration) {
-	c.subnetsLock.Lock()
-	defer c.subnetsLock.Unlock()
+func (s *subnetIDs) AddPersistentCommittee(pubkey []byte, comIndex []uint64, duration time.Duration) {
+	s.subnetsLock.Lock()
+	defer s.subnetsLock.Unlock()
 
-	c.persistentSubnets.Set(string(pubkey), comIndex, duration)
+	s.persistentSubnets.Set(string(pubkey), comIndex, duration)
 }

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",
     ],
@@ -69,6 +69,7 @@ go_test(
     shard_count = 2,
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/aggregation: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 {
@@ -130,8 +128,8 @@ func ProcessAttestationNoVerifySignature(
 			currEpoch,
 		)
 	}
-	if helpers.SlotToEpoch(data.Slot) != data.Target.Epoch {
-		return nil, fmt.Errorf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(data.Slot), data.Target.Epoch)
+	if err := helpers.ValidateSlotTargetEpoch(att.Data); err != nil {
+		return nil, err
 	}
 
 	s := att.Data.Slot
@@ -210,7 +208,10 @@ func ProcessAttestationNoVerifySignature(
 	if err != nil {
 		return nil, err
 	}
-	indexedAtt := attestationutil.ConvertToIndexed(ctx, att, committee)
+	indexedAtt, err := attestationutil.ConvertToIndexed(ctx, att, committee)
+	if err != nil {
+		return nil, err
+	}
 	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
 		return nil, err
 	}
@@ -275,14 +276,17 @@ 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 {
 		return err
 	}
-	indexedAtt := attestationutil.ConvertToIndexed(ctx, att, committee)
+	indexedAtt, err := attestationutil.ConvertToIndexed(ctx, att, committee)
+	if err != nil {
+		return err
+	}
 	return VerifyIndexedAttestation(ctx, beaconState, indexedAtt)
 }
 
@@ -345,35 +349,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[:]
@@ -228,7 +226,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, att.Data.Slot, att.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices := attestationutil.AttestingIndices(att.AggregationBits, committee)
+	attestingIndices, err := attestationutil.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
 	sigs := make([]bls.Signature, len(attestingIndices))
 	for i, indice := range attestingIndices {
@@ -251,15 +249,13 @@ 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),
-	}
-	aggBits1 := bitfield.NewBitlist(4)
+	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(3)
 	aggBits1.SetBitAt(0, true)
 	aggBits1.SetBitAt(1, true)
-	aggBits1.SetBitAt(2, true)
 	att1 := &ethpb.Attestation{
 		Data:            data,
 		AggregationBits: aggBits1,
@@ -272,7 +268,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices1 := attestationutil.AttestingIndices(att1.AggregationBits, committee)
+	attestingIndices1, err := attestationutil.AttestingIndices(att1.AggregationBits, committee)
 	require.NoError(t, err)
 	sigs := make([]bls.Signature, len(attestingIndices1))
 	for i, indice := range attestingIndices1 {
@@ -284,10 +280,9 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	}
 	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	aggBits2 := bitfield.NewBitlist(4)
+	aggBits2 := bitfield.NewBitlist(3)
 	aggBits2.SetBitAt(1, true)
 	aggBits2.SetBitAt(2, true)
-	aggBits2.SetBitAt(3, true)
 	att2 := &ethpb.Attestation{
 		Data:            data,
 		AggregationBits: aggBits2,
@@ -295,7 +290,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 
 	committee, err = helpers.BeaconCommitteeFromState(beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices2 := attestationutil.AttestingIndices(att2.AggregationBits, committee)
+	attestingIndices2, err := attestationutil.AttestingIndices(att2.AggregationBits, committee)
 	require.NoError(t, err)
 	sigs = make([]bls.Signature, len(attestingIndices2))
 	for i, indice := range attestingIndices2 {
@@ -316,11 +311,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)
@@ -337,7 +331,7 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices1 := attestationutil.AttestingIndices(att1.AggregationBits, committee)
+	attestingIndices1, err := attestationutil.AttestingIndices(att1.AggregationBits, committee)
 	require.NoError(t, err)
 	sigs := make([]bls.Signature, len(attestingIndices1))
 	for i, indice := range attestingIndices1 {
@@ -360,7 +354,7 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 
 	committee, err = helpers.BeaconCommitteeFromState(beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices2 := attestationutil.AttestingIndices(att2.AggregationBits, committee)
+	attestingIndices2, err := attestationutil.AttestingIndices(att2.AggregationBits, committee)
 	require.NoError(t, err)
 	sigs = make([]bls.Signature, len(attestingIndices2))
 	for i, indice := range attestingIndices2 {
@@ -387,13 +381,13 @@ 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)
+	})
+	wanted := "slot 32 does not match target epoch 0"
 	_, err := blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
 	assert.ErrorContains(t, wanted, err)
 }
@@ -478,24 +472,20 @@ func TestConvertToIndexed_OK(t *testing.T) {
 			wantedAttestingIndices: []uint64{43, 47},
 		},
 		{
-			aggregationBitfield:    bitfield.Bitlist{0x03},
+			aggregationBitfield:    bitfield.Bitlist{0x05},
 			wantedAttestingIndices: []uint64{47},
 		},
 		{
-			aggregationBitfield:    bitfield.Bitlist{0x01},
+			aggregationBitfield:    bitfield.Bitlist{0x04},
 			wantedAttestingIndices: []uint64{},
 		},
 	}
 
 	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{
@@ -506,7 +496,8 @@ func TestConvertToIndexed_OK(t *testing.T) {
 
 		committee, err := helpers.BeaconCommitteeFromState(state, attestation.Data.Slot, attestation.Data.CommitteeIndex)
 		require.NoError(t, err)
-		ia := attestationutil.ConvertToIndexed(context.Background(), attestation, committee)
+		ia, err := attestationutil.ConvertToIndexed(context.Background(), attestation, committee)
+		require.NoError(t, err)
 		assert.DeepEqual(t, wanted, ia, "Convert attestation to indexed attestation didn't result as wanted")
 	}
 }
@@ -539,58 +530,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),
 		}},
@@ -635,10 +607,10 @@ func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
 }
 
 func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
-	beaconState, keys := testutil.DeterministicGenesisState(t, 1000)
+	beaconState, keys := testutil.DeterministicGenesisState(t, 128)
 
 	sig := keys[0].Sign([]byte{'t', 'e', 's', 't'})
-	list := bitfield.Bitlist{0b11111111}
+	list := bitfield.Bitlist{0b11111}
 	var atts []*ethpb.Attestation
 	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
@@ -656,7 +628,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	assert.ErrorContains(t, want, err)
 
 	atts = []*ethpb.Attestation{}
-	list = bitfield.Bitlist{0b00000000}
+	list = bitfield.Bitlist{0b10000}
 	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
 			Data: &ethpb.AttestationData{
@@ -690,23 +662,19 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
 		}
 	}
 
-	st := testutil.NewBeaconState()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(5))
 	require.NoError(t, st.SetValidators(validators))
 
 	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
@@ -760,7 +724,8 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 		}
 	}
 
-	st := testutil.NewBeaconState()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(35))
 	require.NoError(t, st.SetValidators(validators))
 	require.NoError(t, st.SetFork(&pb.Fork{
@@ -771,17 +736,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 +755,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)
@@ -836,23 +792,19 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 		}
 	}
 
-	st := testutil.NewBeaconState()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(5))
 	require.NoError(t, st.SetValidators(validators))
 
 	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 +818,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,19 +246,16 @@ 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,
+		}
+		sr, err := helpers.ComputeSigningRoot(depositMessage, domain)
 		if err != nil {
-			return errors.Wrap(err, "could not get signing root")
+			return err
 		}
-		signingData := &pb.SigningData{
-			ObjectRoot: root[:],
-			Domain:     domain,
-		}
-		ctrRoot, err := signingData.HashTreeRoot()
-		if err != nil {
-			return errors.Wrap(err, "could not get container root")
-		}
-		msgs[i] = ctrRoot
+		msgs[i] = sr
 	}
 	verify, err := bls.VerifyMultipleSignatures(sigs, msgs, pks)
 	if err != nil {

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

@@ -7,16 +7,16 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/sirupsen/logrus"
-
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	p2ptypes "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/sirupsen/logrus"
 )
 
 func init() {
@@ -34,15 +34,13 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 		}
 	}
 
-	state := testutil.NewBeaconState()
+	state, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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 +72,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()
@@ -112,16 +107,13 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 		}
 	}
 
-	state := testutil.NewBeaconState()
+	state, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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)
@@ -129,7 +121,8 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
-	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
+	sszBytes := p2ptypes.SSZBytes("hello")
+	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, &sszBytes, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 	validators[5896].PublicKey = priv.PublicKey().Marshal()
 	block := &ethpb.SignedBeaconBlock{
@@ -159,7 +152,8 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 		}
 	}
 
-	state := testutil.NewBeaconState()
+	state, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
 	bh := state.LatestBlockHeader()
@@ -168,7 +162,8 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	currentEpoch := helpers.CurrentEpoch(state)
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
-	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
+	sszBytes := p2ptypes.SSZBytes("hello")
+	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, &sszBytes, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 	validators[5896].PublicKey = priv.PublicKey().Marshal()
 	pID, err := helpers.BeaconProposerIndex(state)
@@ -196,7 +191,8 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 		}
 	}
 
-	state := testutil.NewBeaconState()
+	state, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
 	bh := state.LatestBlockHeader()
@@ -207,7 +203,8 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 	currentEpoch := helpers.CurrentEpoch(state)
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
-	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
+	sszBytes := p2ptypes.SSZBytes("hello")
+	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, &sszBytes, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 
 	validators[12683].PublicKey = priv.PublicKey().Marshal()
@@ -236,16 +233,13 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 		}
 	}
 
-	state := testutil.NewBeaconState()
+	state, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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)
@@ -297,16 +291,14 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 		}
 	}
 
-	state := testutil.NewBeaconState()
+	state, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	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/blocks/randao_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"bytes"
 	"context"
 	"encoding/binary"
 	"testing"
@@ -64,13 +63,7 @@ func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T)
 	require.NoError(t, err, "Unexpected error processing block randao")
 	currentEpoch := helpers.CurrentEpoch(beaconState)
 	mix := newState.RandaoMixes()[currentEpoch%params.BeaconConfig().EpochsPerHistoricalVector]
-
-	if bytes.Equal(mix, params.BeaconConfig().ZeroHash[:]) {
-		t.Errorf(
-			"Expected empty signature to be overwritten by randao reveal, received %v",
-			params.BeaconConfig().EmptySignature,
-		)
-	}
+	assert.DeepNotEqual(t, params.BeaconConfig().ZeroHash[:], mix, "Expected empty signature to be overwritten by randao reveal")
 }
 
 func TestRandaoSignatureSet_OK(t *testing.T) {

beacon-chain/core/blocks/signature.go

@@ -15,7 +15,7 @@ import (
 )
 
 // retrieves the signature set from the raw data, public key,signature and domain provided.
-func retrieveSignatureSet(signedData, pub, signature, domain []byte) (*bls.SignatureSet, error) {
+func signatureSet(signedData, pub, signature, domain []byte) (*bls.SignatureSet, error) {
 	publicKey, err := bls.PublicKeyFromBytes(pub)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert bytes to public key")
@@ -37,7 +37,7 @@ func retrieveSignatureSet(signedData, pub, signature, domain []byte) (*bls.Signa
 
 // verifies the signature from the raw data, public key and domain provided.
 func verifySignature(signedData, pub, signature, domain []byte) error {
-	set, err := retrieveSignatureSet(signedData, pub, signature, domain)
+	set, err := signatureSet(signedData, pub, signature, domain)
 	if err != nil {
 		return err
 	}
@@ -85,7 +85,7 @@ func BlockSignatureSet(beaconState *stateTrie.BeaconState, block *ethpb.SignedBe
 		return nil, err
 	}
 	proposerPubKey := proposer.PublicKey
-	return helpers.RetrieveBlockSignatureSet(block.Block, proposerPubKey, block.Signature, domain)
+	return helpers.BlockSignatureSet(block.Block, proposerPubKey, block.Signature, domain)
 }
 
 // RandaoSignatureSet retrieves the relevant randao specific signature set object
@@ -97,7 +97,7 @@ func RandaoSignatureSet(beaconState *stateTrie.BeaconState,
 	if err != nil {
 		return nil, err
 	}
-	set, err := retrieveSignatureSet(buf, proposerPub, body.RandaoReveal, domain)
+	set, err := signatureSet(buf, proposerPub, body.RandaoReveal, domain)
 	if err != nil {
 		return nil, err
 	}
@@ -138,7 +138,10 @@ func createAttestationSignatureSet(ctx context.Context, beaconState *stateTrie.B
 		if err != nil {
 			return nil, err
 		}
-		ia := attestationutil.ConvertToIndexed(ctx, a, c)
+		ia, err := attestationutil.ConvertToIndexed(ctx, a, c)
+		if err != nil {
+			return nil, err
+		}
 		if err := attestationutil.IsValidAttestationIndices(ctx, ia); err != nil {
 			return nil, err
 		}

beacon-chain/core/blocks/spectest/BUILD.bazel

@@ -44,7 +44,6 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
     ],
@@ -80,7 +79,6 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
     ],

beacon-chain/core/epoch/epoch_processing.go

@@ -349,7 +349,10 @@ func UnslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingA
 		if err != nil {
 			return nil, err
 		}
-		attestingIndices := attestationutil.AttestingIndices(att.AggregationBits, committee)
+		attestingIndices, err := attestationutil.AttestingIndices(att.AggregationBits, committee)
+		if err != nil {
+			return nil, err
+		}
 		// Create a set for attesting indices
 		for _, index := range attestingIndices {
 			if !seen[index] {

beacon-chain/core/epoch/epoch_processing_test.go

@@ -1,6 +1,7 @@
 package epoch_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -24,7 +25,7 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
 			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 			},
-			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF},
+			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
 		}
 	}
 
@@ -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)
@@ -70,7 +71,7 @@ func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
 		atts[i] = &pb.PendingAttestation{
 			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 				Target: &ethpb.Checkpoint{Epoch: 0}},
-			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF},
+			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
 		}
 	}
 
@@ -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)
@@ -445,7 +446,8 @@ func buildState(t testing.TB, slot, validatorCount uint64) *state.BeaconState {
 	for i := 0; i < len(latestRandaoMixes); i++ {
 		latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
 	}
-	s := testutil.NewBeaconState()
+	s, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	if err := s.SetSlot(slot); err != nil {
 		t.Error(err)
 	}

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

@@ -47,7 +47,10 @@ func ProcessAttestations(
 		if err != nil {
 			return nil, nil, err
 		}
-		indices := attestationutil.AttestingIndices(a.AggregationBits, committee)
+		indices, err := attestationutil.AttestingIndices(a.AggregationBits, committee)
+		if err != nil {
+			return nil, nil, err
+		}
 		vp = UpdateValidator(vp, v, indices, a, a.Data.Slot)
 	}
 

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

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -149,11 +150,11 @@ func TestProcessAttestations(t *testing.T) {
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()
 
-	validators := uint64(64)
+	validators := uint64(128)
 	beaconState, _ := testutil.DeterministicGenesisState(t, validators)
 	require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-
-	bf := []byte{0xff}
+	c := helpers.SlotCommitteeCount(validators)
+	bf := bitfield.NewBitlist(c)
 	att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{
 		Target: &ethpb.Checkpoint{Epoch: 0}},
 		AggregationBits: bf}
@@ -183,7 +184,8 @@ func TestProcessAttestations(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
 	require.NoError(t, err)
-	indices := attestationutil.AttestingIndices(att1.AggregationBits, committee)
+	indices, err := attestationutil.AttestingIndices(att1.AggregationBits, committee)
+	require.NoError(t, err)
 	for _, i := range indices {
 		if !pVals[i].IsPrevEpochAttester {
 			t.Error("Not a prev epoch attester")
@@ -191,7 +193,8 @@ func TestProcessAttestations(t *testing.T) {
 	}
 	committee, err = helpers.BeaconCommitteeFromState(beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
 	require.NoError(t, err)
-	indices = attestationutil.AttestingIndices(att2.AggregationBits, committee)
+	indices, err = attestationutil.AttestingIndices(att2.AggregationBits, committee)
+	require.NoError(t, err)
 	for _, i := range indices {
 		assert.Equal(t, true, pVals[i].IsPrevEpochAttester, "Not a prev epoch attester")
 		assert.Equal(t, true, pVals[i].IsPrevEpochTargetAttester, "Not a prev epoch target attester")

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

@@ -27,30 +27,30 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 				Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
 				Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 			},
-			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
+			AggregationBits: bitfield.Bitlist{0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0x01},
 			InclusionDelay:  1,
 		}
 	}
 	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) {
@@ -70,39 +70,39 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 				},
 				BeaconBlockRoot: emptyRoot[:],
 			},
-			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
+			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x01},
 			InclusionDelay:  1,
 		}
 	}
 	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.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.
@@ -154,22 +154,22 @@ func TestAttestationDeltas_ZeroEpoch(t *testing.T) {
 				},
 				BeaconBlockRoot: emptyRoot[:],
 			},
-			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
+			AggregationBits: bitfield.Bitlist{0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0x01},
 			InclusionDelay:  1,
 		}
 	}
 	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)
 }
 
@@ -217,33 +217,33 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 				Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
 				Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 			},
-			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
+			AggregationBits: bitfield.Bitlist{0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0x01},
 			InclusionDelay:  1,
 		}
 	}
 	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/BUILD.bazel

@@ -37,7 +37,6 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_ghodss_yaml//:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
     ],
@@ -71,7 +70,6 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_ghodss_yaml//:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
     ],

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/BUILD.bazel

@@ -35,7 +35,6 @@ go_test(
         "//shared/testutil:go_default_library",
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
     ],

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/epoch/spectest/spectest_test.go

@@ -1,21 +1,17 @@
 package spectest
 
 import (
-	"os"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 func TestMain(m *testing.M) {
-	run := func() int {
-		prevConfig := params.BeaconConfig().Copy()
-		defer params.OverrideBeaconConfig(prevConfig)
-		c := params.BeaconConfig()
-		c.MinGenesisActiveValidatorCount = 16384
-		params.OverrideBeaconConfig(c)
+	prevConfig := params.BeaconConfig().Copy()
+	defer params.OverrideBeaconConfig(prevConfig)
+	c := params.BeaconConfig()
+	c.MinGenesisActiveValidatorCount = 16384
+	params.OverrideBeaconConfig(c)
 
-		return m.Run()
-	}
-	os.Exit(run())
+	m.Run()
 }

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/BUILD.bazel

@@ -45,7 +45,6 @@ go_library(
         "@com_github_pkg_errors//: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",
     ],
 )
 

beacon-chain/core/helpers/attestation.go

@@ -2,6 +2,7 @@ package helpers
 
 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"time"
 
@@ -12,6 +13,37 @@ 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
+}
+
+// ValidateSlotTargetEpoch checks if attestation data's epoch matches target checkpoint's epoch.
+// It is recommended to run `ValidateNilAttestation` first to ensure `data.Target` can't be nil.
+func ValidateSlotTargetEpoch(data *ethpb.AttestationData) error {
+	if SlotToEpoch(data.Slot) != data.Target.Epoch {
+		return fmt.Errorf("slot %d does not match target epoch %d", data.Slot, data.Target.Epoch)
+	}
+	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,113 @@ 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))
+			}
+		})
+	}
+}
+
+func TestValidateSlotTargetEpoch(t *testing.T) {
+	tests := []struct {
+		name        string
+		attestation *ethpb.Attestation
+		errString   string
+	}{
+		{
+			name: "incorrect slot",
+			attestation: &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					Target: &ethpb.Checkpoint{Epoch: 1},
+					Source: &ethpb.Checkpoint{},
+				},
+				AggregationBits: []byte{},
+			},
+			errString: "slot 0 does not match target epoch 1",
+		},
+		{
+			name: "good attestation",
+			attestation: &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					Slot:   2 * params.BeaconConfig().SlotsPerEpoch,
+					Target: &ethpb.Checkpoint{Epoch: 2},
+					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.ValidateSlotTargetEpoch(tt.attestation.Data))
+			} else {
+				require.NoError(t, helpers.ValidateSlotTargetEpoch(tt.attestation.Data))
+			}
+		})
+	}
+}

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

@@ -4,7 +4,6 @@ import (
 	fssz "github.com/ferranbt/fastssz"
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bls"
@@ -23,8 +22,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 fssz.HashRoot, domain [4]byte, key bls.SecretKey) ([]byte, error) {
+	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
 	if err != nil {
 		return nil, err
 	}
@@ -46,16 +45,8 @@ func ComputeDomainAndSign(state *state.BeaconState, epoch uint64, obj interface{
 //        object_root=hash_tree_root(ssz_object),
 //        domain=domain,
 //    ))
-func ComputeSigningRoot(object interface{}, domain []byte) ([32]byte, error) {
-	if object == nil {
-		return [32]byte{}, errors.New("cannot compute signing root of nil")
-	}
-	return signingData(func() ([32]byte, error) {
-		if v, ok := object.(fssz.HashRoot); ok {
-			return v.HashTreeRoot()
-		}
-		return ssz.HashTreeRoot(object)
-	}, domain)
+func ComputeSigningRoot(object fssz.HashRoot, domain []byte) ([32]byte, error) {
+	return signingData(object.HashTreeRoot, domain)
 }
 
 // Computes the signing data by utilising the provided root function and then
@@ -73,12 +64,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 fssz.HashRoot, 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
 	}
@@ -86,7 +77,7 @@ func ComputeDomainVerifySigningRoot(state *state.BeaconState, index, epoch uint6
 }
 
 // VerifySigningRoot verifies the signing root of an object given it's public key, signature and domain.
-func VerifySigningRoot(obj interface{}, pub, signature, domain []byte) error {
+func VerifySigningRoot(obj fssz.HashRoot, pub, signature, domain []byte) error {
 	publicKey, err := bls.PublicKeyFromBytes(pub)
 	if err != nil {
 		return errors.Wrap(err, "could not convert bytes to public key")
@@ -107,7 +98,7 @@ func VerifySigningRoot(obj interface{}, pub, signature, domain []byte) error {
 
 // VerifyBlockSigningRoot verifies the signing root of a block given it's public key, signature and domain.
 func VerifyBlockSigningRoot(blk *ethpb.BeaconBlock, pub, signature, domain []byte) error {
-	set, err := RetrieveBlockSignatureSet(blk, pub, signature, domain)
+	set, err := BlockSignatureSet(blk, pub, signature, domain)
 	if err != nil {
 		return err
 	}
@@ -126,9 +117,9 @@ func VerifyBlockSigningRoot(blk *ethpb.BeaconBlock, pub, signature, domain []byt
 	return nil
 }
 
-// RetrieveBlockSignatureSet retrieves the relevant signature, message and pubkey data from a block and collating it
+// BlockSignatureSet retrieves the relevant signature, message and pubkey data from a block and collating it
 // into a signature set object.
-func RetrieveBlockSignatureSet(blk *ethpb.BeaconBlock, pub, signature, domain []byte) (*bls.SignatureSet, error) {
+func BlockSignatureSet(blk *ethpb.BeaconBlock, pub, signature, domain []byte) (*bls.SignatureSet, error) {
 	publicKey, err := bls.PublicKeyFromBytes(pub)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert bytes to public key")

beacon-chain/core/helpers/slot_epoch.go

@@ -213,7 +213,7 @@ func WeakSubjectivityCheckptEpoch(valCount uint64) (uint64, error) {
 		if err != nil {
 			return 0, err
 		}
-		v = v / (2 * 100 * m)
+		v /= 2 * 100 * m
 		wsp += v
 	}
 	return wsp, nil

beacon-chain/core/state/BUILD.bazel

@@ -6,8 +6,10 @@ 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",
+        "trailing_slot_state_cache.go",
         "transition.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/state",
@@ -33,12 +35,15 @@ go_library(
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/bls:go_default_library",
         "//shared/bytesutil:go_default_library",
+        "//shared/featureconfig:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/mathutil:go_default_library",
         "//shared/params:go_default_library",
         "//shared/traceutil:go_default_library",
         "//shared/trieutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
@@ -53,6 +58,7 @@ go_test(
         "skip_slot_cache_test.go",
         "state_fuzz_test.go",
         "state_test.go",
+        "trailing_slot_state_cache_test.go",
         "transition_fuzz_test.go",
         "transition_test.go",
     ],
@@ -73,6 +79,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 +88,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",
     ],
 )
@@ -111,6 +117,5 @@ go_test(
         "//shared/params:go_default_library",
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//: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

@@ -1,16 +1,16 @@
 package state_test
 
 import (
-	"bytes"
 	"context"
 	"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/assert"
 	"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")
 	}
 }
@@ -113,9 +113,8 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 
 	tmp1, err := state.ProcessSlots(context.Background(), expected1.Copy(), problemSlot+1)
 	require.NoError(t, err)
-	if gotRoot := tmp1.StateRoots()[problemSlot]; !bytes.Equal(gotRoot, expectedRoot1[:]) {
-		t.Fatalf("state roots for chain 1 are bad, expected root doesn't match: %x <> %x", gotRoot, expectedRoot1[:])
-	}
+	gotRoot := tmp1.StateRoots()[problemSlot]
+	require.DeepEqual(t, expectedRoot1[:], gotRoot, "State roots for chain 1 are bad, expected root doesn't match")
 
 	expected2, err := state.ProcessSlots(context.Background(), state2.Copy(), problemSlot)
 	require.NoError(t, err)
@@ -125,9 +124,8 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 
 	tmp2, err := state.ProcessSlots(context.Background(), expected2.Copy(), problemSlot+1)
 	require.NoError(t, err)
-	if gotRoot := tmp2.StateRoots()[problemSlot]; !bytes.Equal(gotRoot, expectedRoot2[:]) {
-		t.Fatalf("state roots for chain 2 are bad, expected root doesn't match %x <> %x", gotRoot, expectedRoot2[:])
-	}
+	gotRoot = tmp2.StateRoots()[problemSlot]
+	require.DeepEqual(t, expectedRoot2[:], gotRoot, "State roots for chain 2 are bad, expected root doesn't match")
 
 	var wg sync.WaitGroup
 	wg.Add(len(setups))
@@ -139,13 +137,9 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 		roots := outState.StateRoots()
 		gotRoot := roots[problemSlot]
 		if i%2 == 0 {
-			if !bytes.Equal(gotRoot, expectedRoot1[:]) {
-				t.Errorf("unexpected root on chain 1, item %3d: %x", i, gotRoot)
-			}
+			assert.DeepEqual(t, expectedRoot1[:], gotRoot, "Unexpected root on chain 1")
 		} else {
-			if !bytes.Equal(gotRoot, expectedRoot2[:]) {
-				t.Errorf("unexpected root on chain 2, item %3d: %x", i, gotRoot)
-			}
+			assert.DeepEqual(t, expectedRoot2[:], gotRoot, "Unexpected root on chain 2")
 		}
 		wg.Done()
 	}

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

@@ -34,7 +34,6 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
@@ -69,7 +68,6 @@ go_test(
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",

beacon-chain/core/state/trailing_slot_state_cache.go

@@ -0,0 +1,64 @@
+package state
+
+import (
+	"bytes"
+	"context"
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+)
+
+type nextSlotCache struct {
+	sync.RWMutex
+	root  []byte
+	state *state.BeaconState
+}
+
+var (
+	nsc nextSlotCache
+	// Metrics for the validator cache.
+	nextSlotCacheHit = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "next_slot_cache_hit",
+		Help: "The total number of cache hits on the next slot state cache.",
+	})
+	nextSlotCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "next_slot_cache_miss",
+		Help: "The total number of cache misses on the next slot state cache.",
+	})
+)
+
+// NextSlotState returns the saved state if the input root matches the root in `nextSlotCache`. Returns nil otherwise.
+// This is useful to check before processing slots. With a cache hit, it will return last processed state with slot plus
+// one advancement.
+func NextSlotState(ctx context.Context, root []byte) (*state.BeaconState, error) {
+	nsc.RLock()
+	defer nsc.RUnlock()
+	if !bytes.Equal(root, nsc.root) {
+		nextSlotCacheMiss.Inc()
+		return nil, nil
+	}
+	nextSlotCacheHit.Inc()
+	// Returning copied state.
+	return nsc.state.Copy(), nil
+}
+
+// UpdateNextSlotCache updates the `nextSlotCache`. It saves the input state after advancing the state slot by 1
+// by calling `ProcessSlots`, it also saves the input root for later look up.
+// This is useful to call after successfully processing a block.
+func UpdateNextSlotCache(ctx context.Context, root []byte, state *state.BeaconState) error {
+	// Advancing one slot by using a copied state.
+	copied := state.Copy()
+	copied, err := ProcessSlots(ctx, copied, copied.Slot()+1)
+	if err != nil {
+		return err
+	}
+
+	nsc.Lock()
+	defer nsc.Unlock()
+
+	nsc.root = root
+	nsc.state = copied
+	return nil
+}

beacon-chain/core/state/trailing_slot_state_cache_test.go

@@ -0,0 +1,30 @@
+package state_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	st "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestTrailingSlotState_RoundTrip(t *testing.T) {
+	ctx := context.Background()
+	r := []byte{'a'}
+	s, err := state.NextSlotState(ctx, r)
+	require.NoError(t, err)
+	require.Equal(t, (*st.BeaconState)(nil), s)
+
+	s, _ = testutil.DeterministicGenesisState(t, 1)
+	require.NoError(t, state.UpdateNextSlotCache(ctx, r, s))
+	s, err = state.NextSlotState(ctx, r)
+	require.NoError(t, err)
+	require.Equal(t, uint64(1), s.Slot())
+
+	require.NoError(t, state.UpdateNextSlotCache(ctx, r, s))
+	s, err = state.NextSlotState(ctx, r)
+	require.NoError(t, err)
+	require.Equal(t, uint64(2), s.Slot())
+}

beacon-chain/core/state/transition.go

@@ -18,10 +18,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state/interop"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bls"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"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"
 )
 
@@ -71,7 +71,7 @@ func ExecuteStateTransition(
 		return nil, errors.New("nil block")
 	}
 
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.ExecuteStateTransition")
+	ctx, span := trace.StartSpan(ctx, "core.state.ExecuteStateTransition")
 	defer span.End()
 	var err error
 	// Execute per slots transition.
@@ -127,14 +127,20 @@ func ExecuteStateTransitionNoVerifyAnySig(
 		return nil, nil, errors.New("nil block")
 	}
 
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.ExecuteStateTransitionNoVerifyAttSigs")
+	ctx, span := trace.StartSpan(ctx, "core.state.ExecuteStateTransitionNoVerifyAttSigs")
 	defer span.End()
 	var err error
 
-	// Execute per slots transition.
-	state, err = ProcessSlots(ctx, state, signed.Block.Slot)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not process slot")
+	if featureconfig.Get().EnableNextSlotStateCache {
+		state, err = ProcessSlotsUsingNextSlotCache(ctx, state, signed.Block.ParentRoot, signed.Block.Slot)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "could not process slots")
+		}
+	} else {
+		state, err = ProcessSlots(ctx, state, signed.Block.Slot)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "could not process slot")
+		}
 	}
 
 	// Execute per block transition.
@@ -167,7 +173,7 @@ func CalculateStateRoot(
 	state *stateTrie.BeaconState,
 	signed *ethpb.SignedBeaconBlock,
 ) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.CalculateStateRoot")
+	ctx, span := trace.StartSpan(ctx, "core.state.CalculateStateRoot")
 	defer span.End()
 	if ctx.Err() != nil {
 		traceutil.AnnotateError(span, ctx.Err())
@@ -184,9 +190,17 @@ func CalculateStateRoot(
 	state = state.Copy()
 
 	// Execute per slots transition.
-	state, err := ProcessSlots(ctx, state, signed.Block.Slot)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not process slot")
+	var err error
+	if featureconfig.Get().EnableNextSlotStateCache {
+		state, err = ProcessSlotsUsingNextSlotCache(ctx, state, signed.Block.ParentRoot, signed.Block.Slot)
+		if err != nil {
+			return [32]byte{}, errors.Wrap(err, "could not process slots")
+		}
+	} else {
+		state, err = ProcessSlots(ctx, state, signed.Block.Slot)
+		if err != nil {
+			return [32]byte{}, errors.Wrap(err, "could not process slot")
+		}
 	}
 
 	// Execute per block transition.
@@ -215,7 +229,7 @@ func CalculateStateRoot(
 //    previous_block_root = hash_tree_root(state.latest_block_header)
 //    state.block_roots[state.slot % SLOTS_PER_HISTORICAL_ROOT] = previous_block_root
 func ProcessSlot(ctx context.Context, state *stateTrie.BeaconState) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.state.ProcessSlot")
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlot")
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("slot", int64(state.Slot())))
 
@@ -254,6 +268,37 @@ func ProcessSlot(ctx context.Context, state *stateTrie.BeaconState) (*stateTrie.
 	return state, nil
 }
 
+// ProcessSlotsUsingNextSlotCache processes slots by using next slot cache for higher efficiency.
+func ProcessSlotsUsingNextSlotCache(
+	ctx context.Context,
+	parentState *stateTrie.BeaconState,
+	parentRoot []byte,
+	slot uint64) (*stateTrie.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlotsUsingNextSlotCache")
+	defer span.End()
+
+	// Check whether the parent state has been advanced by 1 slot in next slot cache.
+	nextSlotState, err := NextSlotState(ctx, parentRoot)
+	if err != nil {
+		return nil, err
+	}
+	// If the next slot state is not nil (i.e. cache hit).
+	// We replace next slot state with parent state.
+	if nextSlotState != nil {
+		parentState = nextSlotState
+	}
+
+	// Since next slot cache only advances state by 1 slot,
+	// we check if there's more slots that need to process.
+	if slot > parentState.Slot() {
+		parentState, err = ProcessSlots(ctx, parentState, slot)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not process slots")
+		}
+	}
+	return parentState, nil
+}
+
 // ProcessSlots process through skip slots and apply epoch transition when it's needed
 //
 // Spec pseudocode definition:
@@ -267,7 +312,7 @@ func ProcessSlot(ctx context.Context, state *stateTrie.BeaconState) (*stateTrie.
 //        state.slot += 1
 //    ]
 func ProcessSlots(ctx context.Context, state *stateTrie.BeaconState, slot uint64) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.ProcessSlots")
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlots")
 	defer span.End()
 	if state == nil {
 		return nil, errors.New("nil state")
@@ -312,7 +357,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 +367,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 +392,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)
 		}
 	}
@@ -371,7 +416,7 @@ func ProcessBlock(
 	state *stateTrie.BeaconState,
 	signed *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.state.ProcessBlock")
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlock")
 	defer span.End()
 
 	var err error
@@ -402,7 +447,7 @@ func ProcessBlockNoVerifyAnySig(
 	state *stateTrie.BeaconState,
 	signed *ethpb.SignedBeaconBlock,
 ) (*bls.SignatureSet, *stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.state.ProcessBlockNoVerifyAnySig")
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockNoVerifyAnySig")
 	defer span.End()
 
 	state, err := b.ProcessBlockHeaderNoVerify(state, signed.Block)
@@ -478,7 +523,7 @@ func ProcessOperationsNoVerifyAttsSigs(
 	ctx context.Context,
 	state *stateTrie.BeaconState,
 	signedBeaconBlock *ethpb.SignedBeaconBlock) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.state.ProcessOperationsNoVerifyAttsSigs")
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessOperationsNoVerifyAttsSigs")
 	defer span.End()
 
 	if _, err := VerifyOperationLengths(ctx, state, signedBeaconBlock); err != nil {
@@ -576,7 +621,7 @@ func CanProcessEpoch(state *stateTrie.BeaconState) bool {
 // ProcessEpochPrecompute describes the per epoch operations that are performed on the beacon state.
 // It's optimized by pre computing validator attested info and epoch total/attested balances upfront.
 func ProcessEpochPrecompute(ctx context.Context, state *stateTrie.BeaconState) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.state.ProcessEpochPrecompute")
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessEpochPrecompute")
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("epoch", int64(helpers.CurrentEpoch(state))))
 
@@ -626,7 +671,7 @@ func ProcessBlockForStateRoot(
 	state *stateTrie.BeaconState,
 	signed *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.ChainService.state.ProcessBlockForStateRoot")
+	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockForStateRoot")
 	defer span.End()
 
 	state, err := b.ProcessBlockHeaderNoVerify(state, signed.Block)

beacon-chain/core/state/transition_test.go

@@ -1,7 +1,6 @@
 package state_test
 
 import (
-	"bytes"
 	"context"
 	"encoding/binary"
 	"fmt"
@@ -101,9 +100,7 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 
 	mix, err := beaconState.RandaoMixAtIndex(1)
 	require.NoError(t, err)
-	if bytes.Equal(mix, oldMix) {
-		t.Errorf("Did not expect new and old randao mix to equal, %#x == %#x", mix, oldMix)
-	}
+	assert.DeepNotEqual(t, oldMix, mix, "Did not expect new and old randao mix to equal")
 }
 
 func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
@@ -164,24 +161,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 +192,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 +220,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 +255,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 +269,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 +325,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 +356,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 +372,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,22 +402,18 @@ 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)
-	attestingIndices := attestationutil.AttestingIndices(blockAtt.AggregationBits, committee)
+	attestingIndices, err := attestationutil.AttestingIndices(blockAtt.AggregationBits, committee)
+	require.NoError(t, err)
 	assert.NoError(t, err)
 	hashTreeRoot, err = helpers.ComputeSigningRoot(blockAtt.Data, domain)
 	assert.NoError(t, err)
@@ -491,25 +446,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 +588,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,20 +703,15 @@ 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)
-		attestingIndices := attestationutil.AttestingIndices(att.AggregationBits, committee)
+		attestingIndices, err := attestationutil.AttestingIndices(att.AggregationBits, committee)
+		require.NoError(t, err)
 		domain, err := helpers.Domain(s.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, s.GenesisValidatorRoot())
 		require.NoError(t, err)
 		sigs := make([]bls.Signature, len(attestingIndices))
@@ -955,3 +890,12 @@ func TestProcessSlots_LowerSlotAsParentState(t *testing.T) {
 	_, err = state.ProcessSlots(context.Background(), parentState, slot-1)
 	assert.ErrorContains(t, "expected state.slot 2 < slot 1", err)
 }
+
+func TestProcessSlotsUsingNextSlotCache(t *testing.T) {
+	ctx := context.Background()
+	s, _ := testutil.DeterministicGenesisState(t, 1)
+	r := []byte{'a'}
+	s, err := state.ProcessSlotsUsingNextSlotCache(ctx, s, r, 5)
+	require.NoError(t, err)
+	require.Equal(t, uint64(5), s.Slot())
+}

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,7 +11,9 @@ go_library(
     name = "go_default_library",
     srcs = [
         "alias.go",
-        "http_backup_handler.go",
+        "cmd.go",
+        "log.go",
+        "restore.go",
     ] + select({
         ":kafka_disabled": [
             "db.go",
@@ -30,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/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//proto/beacon/db:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/backuputil:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
     ],

beacon-chain/db/iface/interface.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/proto/beacon/db"
 	ethereum_beacon_p2p_v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/backuputil"
 )
 
 // ReadOnlyDatabase defines a struct which only has read access to database methods.
@@ -21,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
@@ -100,11 +103,9 @@ type HeadAccessDatabase interface {
 // Database interface with full access.
 type Database interface {
 	io.Closer
+	backuputil.BackupExporter
 	HeadAccessDatabase
 
 	DatabasePath() string
 	ClearDB() error
-
-	// Backup and restore methods
-	Backup(ctx context.Context, outputDir string) error
 }

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",
@@ -22,10 +23,10 @@ go_library(
         "@com_github_golang_protobuf//jsonpb:go_default_library_gen",
         "@com_github_golang_protobuf//proto: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",
         "@in_gopkg_confluentinc_confluent_kafka_go_v1//kafka:go_default_library",
         "@in_gopkg_confluentinc_confluent_kafka_go_v1//kafka/librdkafka:go_default_library",
+        "@in_gopkg_errgo_v2//fmt/errors:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
 )

beacon-chain/db/kafka/export_wrapper.go

@@ -10,18 +10,16 @@ import (
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/proto"
 	eth "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"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.
+	"gopkg.in/errgo.v2/fmt/errors"
 )
 
 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.
@@ -61,7 +59,7 @@ func (e Exporter) publish(ctx context.Context, topic string, msg proto.Message)
 	if v, ok := msg.(fssz.HashRoot); ok {
 		key, err = v.HashTreeRoot()
 	} else {
-		key, err = ssz.HashTreeRoot(msg)
+		err = errors.New("object does not follow hash tree root interface")
 	}
 	if err != nil {
 		traceutil.AnnotateError(span, err)

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/archived_point_test.go

@@ -17,7 +17,8 @@ func TestArchivedPointIndexRoot_CanSaveRetrieve(t *testing.T) {
 
 	received := db.ArchivedPointRoot(ctx, i1)
 	require.NotEqual(t, r1, received, "Should not have been saved")
-	st := testutil.NewBeaconState()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(i1))
 	require.NoError(t, db.SaveState(ctx, st, r1))
 	received = db.ArchivedPointRoot(ctx, i1)
@@ -31,7 +32,8 @@ func TestLastArchivedPoint_CanRetrieve(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, uint64(0), i, "Did not get correct index")
 
-	st := testutil.NewBeaconState()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	assert.NoError(t, db.SaveState(ctx, st, [32]byte{'A'}))
 	assert.Equal(t, [32]byte{'A'}, db.LastArchivedRoot(ctx), "Did not get wanted root")
 

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,
@@ -51,17 +50,17 @@ func (s *Store) Backup(ctx context.Context, outputDir string) error {
 		&bolt.Options{Timeout: params.BeaconIoConfig().BoltTimeout},
 	)
 	if err != nil {
-		panic(err)
+		return err
 	}
 	defer func() {
 		if err := copyDB.Close(); err != nil {
-			logrus.WithError(err).Error("Failed to close destination 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

@@ -3,7 +3,8 @@ package kv
 import (
 	"context"
 	"io/ioutil"
-	"path"
+	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/shared/testutil"
@@ -11,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()
@@ -20,13 +22,29 @@ func TestStore_Backup(t *testing.T) {
 	require.NoError(t, db.SaveBlock(ctx, head))
 	root, err := head.Block.HashTreeRoot()
 	require.NoError(t, err)
-	st := testutil.NewBeaconState()
+	st, err := testutil.NewBeaconState()
+	require.NoError(t, err)
 	require.NoError(t, db.SaveState(ctx, st, root))
 	require.NoError(t, db.SaveHeadBlockRoot(ctx, root))
 
 	require.NoError(t, db.Backup(ctx, ""))
 
-	files, err := ioutil.ReadDir(path.Join(db.databasePath, backupsDirectoryName))
+	backupsPath := filepath.Join(db.databasePath, backupsDirectoryName)
+	files, err := ioutil.ReadDir(backupsPath)
 	require.NoError(t, err)
 	require.NotEqual(t, 0, len(files), "No backups created")
+	require.NoError(t, db.Close(), "Failed to close database")
+
+	oldFilePath := filepath.Join(backupsPath, files[0].Name())
+	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(ctx, backupsPath)
+	require.NoError(t, err, "Failed to instantiate DB")
+	t.Cleanup(func() {
+		require.NoError(t, backedDB.Close(), "Failed to close database")
+	})
+	require.Equal(t, true, backedDB.HasState(ctx, root))
 }

beacon-chain/db/kv/blocks.go

@@ -71,7 +71,7 @@ func (s *Store) Blocks(ctx context.Context, f *filters.QueryFilter) ([]*ethpb.Si
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
 
-		keys, err := getBlockRootsByFilter(ctx, tx, f)
+		keys, err := blockRootsByFilter(ctx, tx, f)
 		if err != nil {
 			return err
 		}
@@ -100,7 +100,7 @@ func (s *Store) BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]b
 	defer span.End()
 	blockRoots := make([][32]byte, 0)
 	err := s.db.View(func(tx *bolt.Tx) error {
-		keys, err := getBlockRootsByFilter(ctx, tx, f)
+		keys, err := blockRootsByFilter(ctx, tx, f)
 		if err != nil {
 			return err
 		}
@@ -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 := blockRootsBySlot(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 := blockRootsBySlot(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")
 		}
 
@@ -326,9 +374,9 @@ func (s *Store) HighestSlotBlocksBelow(ctx context.Context, slot uint64) ([]*eth
 	return []*ethpb.SignedBeaconBlock{blk}, nil
 }
 
-// getBlockRootsByFilter retrieves the block roots given the filter criteria.
-func getBlockRootsByFilter(ctx context.Context, tx *bolt.Tx, f *filters.QueryFilter) ([][]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.getBlockRootsByFilter")
+// blockRootsByFilter retrieves the block roots given the filter criteria.
+func blockRootsByFilter(ctx context.Context, tx *bolt.Tx, f *filters.QueryFilter) ([][]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsByFilter")
 	defer span.End()
 
 	// If no filter criteria are specified, return an error.
@@ -346,7 +394,7 @@ func getBlockRootsByFilter(ctx context.Context, tx *bolt.Tx, f *filters.QueryFil
 
 	// We retrieve block roots that match a filter criteria of slot ranges, if specified.
 	filtersMap := f.Filters()
-	rootsBySlotRange, err := fetchBlockRootsBySlotRange(
+	rootsBySlotRange, err := blockRootsBySlotRange(
 		ctx,
 		tx.Bucket(blockSlotIndicesBucket),
 		filtersMap[filters.StartSlot],
@@ -383,17 +431,22 @@ func getBlockRootsByFilter(ctx context.Context, tx *bolt.Tx, f *filters.QueryFil
 	return keys, nil
 }
 
-// fetchBlockRootsBySlotRange looks into a boltDB bucket and performs a binary search
+// blockRootsBySlotRange looks into a boltDB bucket and performs a binary search
 // range scan using sorted left-padded byte keys using a start slot and an end slot.
 // However, if step is one, the implemented logic won’t skip half of the slots in the range.
-func fetchBlockRootsBySlotRange(
+func blockRootsBySlotRange(
 	ctx context.Context,
 	bkt *bolt.Bucket,
 	startSlotEncoded, endSlotEncoded, startEpochEncoded, endEpochEncoded, slotStepEncoded interface{},
 ) ([][]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.fetchBlockRootsBySlotRange")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlotRange")
 	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
 }
 
+// blockRootsBySlot retrieves the block roots by slot
+func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot uint64) ([][]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
+	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).