exit better (#7697)

* cherry-pick commits

* re-arrange calls

.bazelrc

@@ -5,6 +5,9 @@ test --test_verbose_timeout_warnings
 test --build_tests_only
 test --test_output=errors
 
+# E2E run with debug gotag
+test:e2e --define gotags=debug
+
 # Clearly indicate that coverage is enabled to disable certain nogo checks.
 coverage --define=coverage_enabled=1
 
@@ -33,9 +36,17 @@ build --define kafka_enabled=false
 test --define kafka_enabled=false
 run --define kafka_enabled=false
 
+# Enable blst by default, we use a config so that our fuzzer stops complaining.
+build --config=blst_enabled
+test --config=blst_enabled
+run --config=blst_enabled
+
 build:kafka_enabled --define kafka_enabled=true
 build:kafka_enabled --define gotags=kafka_enabled
 
+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
@@ -69,18 +80,13 @@ build:fuzz --copt=-fno-omit-frame-pointer
 build:fuzz --define=FUZZING_ENGINE=libfuzzer
 build:fuzz --copt=-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 build:fuzz --linkopt -Wl,--no-as-needed
-build:fuzz --define=gc_goopts=-d=libfuzzer
+build:fuzz --define=gc_goopts=-d=libfuzzer,checkptr
 build:fuzz --run_under=//tools:fuzz_wrapper
 build:fuzz --compilation_mode=opt
+build:fuzz --define=blst_enabled=false
 
 test:fuzz --local_test_jobs="HOST_CPUS*.5"
 
-test:fuzzit --config=fuzz
-test:fuzzit --test_env=FUZZIT_API_KEY
-test:fuzzit --test_env=PRYSM_BUILD_IMAGE=gcr.io/prysmaticlabs/prysm-fuzzit:v0.11.0
-test:fuzzit --test_timeout=1200
-test:fuzzit --run_under=//tools:fuzzit_wrapper
-
 # Build binary with cgo symbolizer for debugging / profiling.
 build:cgo_symbolizer --config=llvm
 build:cgo_symbolizer --copt=-g

.buildkite-bazelrc

@@ -3,10 +3,10 @@
 # 
 # This config is loaded from https://github.com/bazelbuild/bazel-toolchains/blob/master/bazelrc/latest.bazelrc
 build:remote-cache --remote_timeout=3600
-build:remote-cache --spawn_strategy=standalone
-build:remote-cache --strategy=Javac=standalone
-build:remote-cache --strategy=Closure=standalone
-build:remote-cache --strategy=Genrule=standalone
+#build:remote-cache --spawn_strategy=standalone
+#build:remote-cache --strategy=Javac=standalone
+#build:remote-cache --strategy=Closure=standalone
+#build:remote-cache --strategy=Genrule=standalone
 
 # Prysm specific remote-cache properties.
 #build:remote-cache --disk_cache=
@@ -34,16 +34,5 @@ build --flaky_test_attempts=5
 # Disabled race detection due to unstable test results under constrained environment build kite
 # build --features=race
 
-# Enable kafka for CI tests only.
-test --config=kafka_enabled
-
-build --bes_backend=grpcs://builds.prylabs.net:1985
-build --bes_results_url=https://builds.prylabs.net/invocation/
-
 # Disable flaky test detection for fuzzing.
 test:fuzz --flaky_test_attempts=1
-
-# Expose test environment variables in CI
-test:fuzzit --test_env=GITHUB_REF
-test:fuzzit --test_env=GITHUB_SHA
-test:fuzzit --test_env=DOCKER_HOST

.deepsource.toml

@@ -0,0 +1,12 @@
+version = 1
+
+[[analyzers]]
+name = "go"
+enabled = true
+
+  [analyzers.meta]
+  import_paths = ["github.com/prysmaticlabs/prysm"]
+
+[[analyzers]]
+name = "test-coverage"
+enabled = true

.github/workflows/go.yml

@@ -43,7 +43,8 @@ jobs:
           go get -v -t -d ./...
 
       - name: Build
-        run: go build -v ./...
+        # Use blst tag to allow go and bazel builds for blst.
+        run: go build -v --tags=blst_enabled ./...
 
 # Tests run via Bazel for now...
 #      - name: Test

.gitignore

@@ -29,3 +29,7 @@ password.txt
 
 # Dist files
 dist
+
+# libfuzzer
+oom-*
+crash-*

.policy.yml

@@ -0,0 +1,91 @@
+policy:
+  approval:
+    - or:
+        - only test files are changed
+        - only proto files are changed
+        - touches consensus critical code
+        - touches sync/blockchain/p2p code
+        - large line count
+        - is critical priority
+approval_rules:
+  - name: only test files are changed
+    if:
+      only_changed_files:
+        paths:
+          - "*_test.go"
+          - "*.bazel"
+    options:
+      ignore_commits_by:
+        users: ["bulldozer[bot]"]
+    requires:
+      count: 1
+      teams:
+        - "prysmaticlabs/core-team"
+  - name: only proto files are changed
+    if:
+      only_changed_files:
+        paths:
+          - "*pb.go"
+          - "*pb.gw.go"
+          - "*.bazel"
+    options:
+      ignore_commits_by:
+        users: ["bulldozer[bot]"]
+    requires:
+      count: 1
+      teams:
+        - "prysmaticlabs/core-team"
+  - name: touches consensus critical code
+    if:
+      only_changed_files:
+        paths:
+          - "beacon-chain/core/*"
+          - "beacon-chain/state/*"
+    options:
+      ignore_commits_by:
+        users: ["bulldozer[bot]"]
+    requires:
+      count: 2
+      teams:
+        - "prysmaticlabs/core-team"
+  - name: touches sync/blockchain/p2p code
+    if:
+      only_changed_files:
+        paths:
+          - "beacon-chain/blockchain/*"
+          - "beacon-chain/sync/*"
+          - "beacon-chain/p2p/*"
+    options:
+      ignore_commits_by:
+        users: ["bulldozer[bot]"]
+    requires:
+      count: 2
+      teams:
+        - "prysmaticlabs/core-team"
+  - name: large line count
+    if:
+      modified_lines:
+        total: "> 1000"
+      changed_files:
+        ignore:
+          - "*pb.go"
+          - "*pb.gw.go"
+          - "*.bazel"
+    options:
+      ignore_commits_by:
+        users: ["bulldozer[bot]"]
+    requires:
+      count: 2
+      teams:
+        - "prysmaticlabs/core-team"
+  - name: is critical priority
+    if:
+      has_labels:
+        - "Priority: Critical"
+    options:
+      ignore_commits_by:
+        users: ["bulldozer[bot]"]
+    requires:
+      count: 3
+      teams:
+        - "prysmaticlabs/core-team"

BUILD.bazel

@@ -104,10 +104,14 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/inspect:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/asmdecl:go_tool_library",
         "//tools/analyzers/maligned:go_tool_library",
-        "//tools/analyzers/roughtime:go_tool_library",
         "//tools/analyzers/cryptorand:go_tool_library",
         "//tools/analyzers/errcheck:go_tool_library",
         "//tools/analyzers/featureconfig:go_tool_library",
+        "//tools/analyzers/comparesame:go_tool_library",
+        "//tools/analyzers/shadowpredecl:go_tool_library",
+        "//tools/analyzers/nop:go_tool_library",
+        "//tools/analyzers/slicedirect:go_tool_library",
+        "//tools/analyzers/ineffassign:go_tool_library",
     ] + select({
         # nogo checks that fail with coverage enabled.
         ":coverage_enabled": [],

README.md

@@ -1,7 +1,7 @@
 # Prysm: An Ethereum 2.0 Client Written in Go
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
-[![ETH2.0_Spec_Version 0.12.2](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v0.12.2-blue.svg)](https://github.com/ethereum/eth2.0-specs/tree/v0.12.2)
+[![ETH2.0_Spec_Version 0.12.3](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v0.12.3-blue.svg)](https://github.com/ethereum/eth2.0-specs/tree/v0.12.3)
 [![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/KSA7rPr)
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/prysmaticlabs/geth-sharding?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 

TERMS_OF_SERVICE.md

@@ -0,0 +1,45 @@
+## Terms of Use
+
+Effective as of Oct 14, 2020
+
+By downloading, accessing or using the Prysm implementation (“Prysm”), you (referenced herein as “you” or the “user”) certify that you have read and agreed to the terms and conditions below (the “Terms”) which form a binding contract between you and Prysmatic Labs (referenced herein as “we” or “us”). If you do not agree to the Terms, do not download or use Prysm.
+
+### About Prysm
+Prysm is a client implementation for Ethereum 2.0 Phase 0 protocol for a proof-of-stake blockchain. To participate in the network, a user must send ETH from the Eth1.0 chain into a validator deposit contract, which will queue in the user as a validator in the system. Validators participate in proposing and voting on blocks in the protocol, and the network applies rewards/penalties based on their behavior. A detailed set of installation and usage instructions as well as breakdowns of each individual component are available in the official documentation portal, however, we do not warrant the accuracy, completeness or usefulness of this documentation. Any reliance you place on such information is strictly at your own risk.
+
+### Licensing Terms
+Prysm is a fully open-source software program licensed pursuant to the GNU General Public License v3.0.
+
+The Prysmatic Labs name, the term “Prysm” and all related names, logos, product and service names, designs and slogans are trademarks of Prysmatic Labs or its affiliates and/or licensors. You must not use such marks without our prior written permission.
+
+### Risks of Operating Prysm
+The use of Prysm and acting as a validator on the Ethereum 2.0 network can lead to loss of money. Ethereum is still an experimental system and ETH remains a risky investment. You alone are responsible for your actions on Prysm including the security of your ETH and meeting any applicable minimum system requirements.
+
+Use of Prysm and the ability to receive rewards or penalties may be affected at any time by mistakes made by the user or other users, software problems such as bugs, errors, incorrectly constructed transactions, unsafe cryptographic libraries or malware affecting the network, technical failures in the hardware of a user, security problems experienced by a user and/or actions or inactions of third parties and/or events experienced by third parties, among other risks. We cannot and do not guarantee that any user of Prysm will make money, that the Prysm network will operate in accordance with the documentation or that transactions will be effective or secure.
+
+We make no claims that Prysm is appropriate or permitted for use in any specific jurisdiction. Access to Prysm may not be legal by certain persons or in certain jurisdictions or countries. If you access Prysm, you do so on your own initiative and are responsible for compliance with local laws.
+
+Some Internet plans will charge an additional amount for any excess upload bandwidth used that isn’t included in the plan and may terminate your connection without warning because of overuse. We advise that you check whether your Internet connection is subjected to such limitations and monitor your bandwidth use so that you can stop Prysm before you reach your upload limit.
+
+### Warranty Disclaimer
+PRYSM IS PROVIDED ON AN “AS-IS” BASIS AND MAY INCLUDE ERRORS, OMISSIONS, OR OTHER INACCURACIES. PRYSMATIC LABS AND ITS CONTRIBUTORS MAKE NO REPRESENTATIONS OR WARRANTIES ABOUT PRYSM FOR ANY PURPOSE, AND HEREBY EXPRESSLY DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT OR ANY OTHER IMPLIED WARRANTY UNDER THE UNIFORM COMPUTER INFORMATION TRANSACTIONS ACT AS ENACTED BY ANY STATE. WE ALSO MAKE NO REPRESENTATIONS OR WARRANTIES THAT PRYSM WILL OPERATE ERROR-FREE, UNINTERRUPTED, OR IN A MANNER THAT WILL MEET YOUR REQUIREMENTS AND/OR NEEDS. THEREFORE, YOU ASSUME THE ENTIRE RISK REGARDING THE QUALITY AND/OR PERFORMANCE OF PRYSM AND ANY TRANSACTIONS ENTERED INTO THEREON.
+
+### Limitation of Liability
+In no event will Prysmatic Labs or any of its contributors be liable, whether in contract, warranty, tort (including negligence, whether active, passive or imputed), product liability, strict liability or other theory, breach of statutory duty or otherwise arising out of, or in connection with, your use of Prysm, for any direct, indirect, incidental, special or consequential damages (including any loss of profits or data, business interruption or other pecuniary loss, or damage, loss or other compromise of data, in each case whether direct, indirect, incidental, special or consequential) arising out of use Prysm, even if we or other users have been advised of the possibility of such damages. The foregoing limitations and disclaimers shall apply to the maximum extent permitted by applicable law, even if any remedy fails of its essential purpose. You acknowledge and agree that the limitations of liability afforded us hereunder constitute a material and actual inducement and condition to entering into these Terms, and are reasonable, fair and equitable in scope to protect our legitimate interests in light of the fact that we are not receiving consideration from you for providing Prysm.
+
+### Indemnification
+To the maximum extent permitted by law, you will defend, indemnify and hold Prysmatic Labs and its contributors harmless from and against any and all claims, actions, suits, investigations, or proceedings by any third party (including any party or purported party to or beneficiary or purported beneficiary of any transaction on Prysm), as well as any and all losses, liabilities,
+damages, costs, and expenses (including reasonable attorneys’ fees) arising out of, accruing from, or in any way related to (i) your breach of the terms of this Agreement, (ii) any transaction, or the failure to occur of any transaction on Prysm, and (iii) your negligence, fraud, or willful misconduct.
+
+### Compliance with Laws and Tax Obligations
+Your use of Prysm is subject to all applicable laws of any governmental authority, including, without limitation, federal, state and foreign securities laws, tax laws, tariff and trade laws, ordinances, judgments, decrees, injunctions, writs and orders or like actions of any governmental authority and rules, regulations, orders, interpretations, licenses, and permits of any federal,
+regional, state, county, municipal or other governmental authority and you agree to comply with all such laws in your use of Prysm. The users of Prysm are solely responsible to determinate what, if any, taxes apply to their ETH transactions. The owners of, or contributors to, Prysm are not responsible for determining the taxes that apply to ETH transactions.
+
+### Miscellaneous
+These Terms will be construed and enforced in accordance with the laws of the state of Illinois as applied to agreements entered into and completely performed in Illinois. You agree to the personal jurisdiction by and venue in Illinois and waive any objection to such jurisdiction or venue.
+
+We reserve the right to revise these Terms, and your rights and obligations are at all times subject to the then-current Terms provided on Prysm. Your continued use of Prysm constitutes acceptance of such revised Terms.
+
+These Terms constitute the entire agreement between you and Prysmatic Labs regarding use of Prysm and will supersede all prior agreements whether, written or oral. No usage of trade or other regular practice or method of dealing between the parties will be used to modify, interpret, supplement, or alter the terms of these Terms.
+
+If any portion of these Terms is held invalid or unenforceable, such invalidity or enforceability will not affect the other provisions of these Terms, which will remain in full force and effect, and the invalid or unenforceable portion will be given effect to the greatest extent possible. The failure of a party to require performance of any provision will not affect that party’s right to require performance at any time thereafter, nor will a waiver of any breach or default of these Terms or any provision of these Terms constitute a waiver of any subsequent breach or default or a waiver of the provision itself.

WORKSPACE

@@ -5,11 +5,11 @@ load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
 
 http_archive(
     name = "bazel_toolchains",
-    sha256 = "144290c4166bd67e76a54f96cd504ed86416ca3ca82030282760f0823c10be48",
-    strip_prefix = "bazel-toolchains-3.1.1",
+    sha256 = "db48eed61552e25d36fe051a65d2a329cc0fb08442627e8f13960c5ab087a44e",
+    strip_prefix = "bazel-toolchains-3.2.0",
     urls = [
-        "https://github.com/bazelbuild/bazel-toolchains/releases/download/3.1.1/bazel-toolchains-3.1.1.tar.gz",
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/3.1.1.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/releases/download/3.2.0/bazel-toolchains-3.2.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-toolchains/releases/download/3.2.0/bazel-toolchains-3.2.0.tar.gz",
     ],
 )
 
@@ -161,6 +161,10 @@ load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
 
 gazelle_dependencies()
 
+load("@io_bazel_rules_go//extras:embed_data_deps.bzl", "go_embed_data_dependencies")
+
+go_embed_data_dependencies()
+
 load("@com_github_atlassian_bazel_tools//gometalinter:deps.bzl", "gometalinter_dependencies")
 
 gometalinter_dependencies()
@@ -215,8 +219,8 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "9e09ada15c5f494388ecdb3ab49f4554d9ed53ce904cd21c42c350e6d7b2f323",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.2/general.tar.gz",
+    sha256 = "6b3498001de98c477aa2c256beffc20a85ce1b12b8e0f8e88502a5c3a18c01de",
+    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v1.0.0-rc.0/general.tar.gz",
 )
 
 http_archive(
@@ -231,8 +235,8 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "5fc930e200af7682a176d6025db56cec79807112bb860dca2e1e91fb160312de",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.2/minimal.tar.gz",
+    sha256 = "72c2f561db879ddcdf729fef93d10e0f9162b4cf3a697c513ef8935b93f6165a",
+    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.3/minimal.tar.gz",
 )
 
 http_archive(
@@ -247,8 +251,8 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "fbab14605a0178ef4c8f7efea0de275a22b815a8d3245099f0f5525f7a33faf8",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.2/mainnet.tar.gz",
+    sha256 = "63eca02503692a0b6a2d7b70118e0dd62dff094153a3a542af6dbea721841b0d",
+    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.3/mainnet.tar.gz",
 )
 
 http_archive(
@@ -336,6 +340,21 @@ go_binary(
     urls = ["https://github.com/ferranbt/fastssz/archive/06015a5d84f9e4eefe2c21377ca678fa8f1a1b09.tar.gz"],
 )
 
+http_archive(
+    name = "prysm_web_ui",
+    build_file_content = """
+filegroup(
+    name = "site",
+    srcs = glob(["**/*"]),
+    visibility = ["//visibility:public"],
+)
+""",
+    sha256 = "6bb16ff0dc9348090cc31a9ea453643d32b617e66ac6e7bb38985d530070631b",
+    urls = [
+        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/0.0.2-alpha/prysm-web-ui.tar.gz",
+    ],
+)
+
 load("//:deps.bzl", "prysm_deps")
 
 # gazelle:repository_macro deps.bzl%prysm_deps

beacon-chain/BUILD.bazel

@@ -19,15 +19,16 @@ go_library(
         "//shared/cmd:go_default_library",
         "//shared/debug:go_default_library",
         "//shared/featureconfig:go_default_library",
+        "//shared/journald:go_default_library",
         "//shared/logutil:go_default_library",
         "//shared/maxprocs:go_default_library",
+        "//shared/tos:go_default_library",
         "//shared/version:go_default_library",
         "@com_github_ethereum_go_ethereum//log:go_default_library",
         "@com_github_ipfs_go_log_v2//:go_default_library",
         "@com_github_joonix_log//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
-        "@com_github_urfave_cli_v2//altsrc:go_default_library",
         "@com_github_x_cray_logrus_prefixed_formatter//:go_default_library",
     ],
 )
@@ -53,19 +54,20 @@ go_image(
     deps = [
         "//beacon-chain/flags:go_default_library",
         "//beacon-chain/node:go_default_library",
+        "//shared/tos:go_default_library",
         "//shared/cmd:go_default_library",
         "//shared/debug:go_default_library",
         "//shared/featureconfig:go_default_library",
+        "//shared/journald:go_default_library",
         "//shared/logutil:go_default_library",
+        "//shared/maxprocs:go_default_library",
         "//shared/version:go_default_library",
         "@com_github_ethereum_go_ethereum//log:go_default_library",
         "@com_github_ipfs_go_log_v2//:go_default_library",
         "@com_github_joonix_log//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
-        "@com_github_urfave_cli_v2//altsrc:go_default_library",
         "@com_github_x_cray_logrus_prefixed_formatter//:go_default_library",
-        "//shared/maxprocs:go_default_library",
     ],
 )
 

beacon-chain/blockchain/BUILD.bazel

@@ -17,9 +17,13 @@ go_library(
         "receive_attestation.go",
         "receive_block.go",
         "service.go",
+        "weak_subjectivity_checks.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain",
-    visibility = ["//beacon-chain:__subpackages__"],
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//fuzz:__pkg__",
+    ],
     deps = [
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
@@ -30,6 +34,7 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/state:go_default_library",
         "//beacon-chain/db:go_default_library",
+        "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/flags:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
@@ -40,15 +45,14 @@ go_library(
         "//beacon-chain/powchain:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
-        "//beacon-chain/state/stateutil:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/attestationutil:go_default_library",
         "//shared/bls:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/featureconfig:go_default_library",
         "//shared/params:go_default_library",
-        "//shared/roughtime:go_default_library",
         "//shared/slotutil:go_default_library",
+        "//shared/timeutils:go_default_library",
         "//shared/traceutil:go_default_library",
         "@com_github_emicklei_dot//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -75,11 +79,13 @@ go_test(
         "chain_info_test.go",
         "head_test.go",
         "info_test.go",
+        "metrics_test.go",
         "process_attestation_test.go",
         "process_block_test.go",
         "receive_attestation_test.go",
         "receive_block_test.go",
         "service_test.go",
+        "weak_subjectivity_checks_test.go",
     ],
     embed = [":go_default_library"],
     deps = [

beacon-chain/blockchain/chain_info.go

@@ -5,14 +5,14 @@ import (
 	"time"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"go.opencensus.io/trace"
+
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
@@ -97,6 +97,9 @@ func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 
 // HeadSlot returns the slot of the head of the chain.
 func (s *Service) HeadSlot() uint64 {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return 0
 	}
@@ -106,6 +109,9 @@ func (s *Service) HeadSlot() uint64 {
 
 // HeadRoot returns the root of the head of the chain.
 func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if s.headRoot() != params.BeaconConfig().ZeroHash {
 		r := s.headRoot()
 		return r[:], nil
@@ -119,7 +125,7 @@ func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
 		return params.BeaconConfig().ZeroHash[:], nil
 	}
 
-	r, err := stateutil.BlockRoot(b.Block)
+	r, err := b.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
@@ -131,6 +137,9 @@ func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
 // If the head is nil from service struct,
 // it will attempt to get the head block from DB.
 func (s *Service) HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if s.hasHeadState() {
 		return s.headBlock(), nil
 	}
@@ -144,6 +153,8 @@ func (s *Service) HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, erro
 func (s *Service) HeadState(ctx context.Context) (*state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.HeadState")
 	defer span.End()
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
 
 	ok := s.hasHeadState()
 	span.AddAttributes(trace.BoolAttribute("cache_hit", ok))
@@ -152,11 +163,14 @@ func (s *Service) HeadState(ctx context.Context) (*state.BeaconState, error) {
 		return s.headState(ctx), nil
 	}
 
-	return s.beaconDB.HeadState(ctx)
+	return s.stateGen.StateByRoot(ctx, s.headRoot())
 }
 
 // HeadValidatorsIndices returns a list of active validator indices from the head view of a given epoch.
 func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]uint64, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return []uint64{}, nil
 	}
@@ -165,6 +179,9 @@ func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]ui
 
 // HeadSeed returns the seed from the head view of a given epoch.
 func (s *Service) HeadSeed(ctx context.Context, epoch uint64) ([32]byte, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return [32]byte{}, nil
 	}
@@ -174,6 +191,9 @@ func (s *Service) HeadSeed(ctx context.Context, epoch uint64) ([32]byte, error)
 
 // HeadGenesisValidatorRoot returns genesis validator root of the head state.
 func (s *Service) HeadGenesisValidatorRoot() [32]byte {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return [32]byte{}
 	}
@@ -183,6 +203,9 @@ func (s *Service) HeadGenesisValidatorRoot() [32]byte {
 
 // HeadETH1Data returns the eth1data of the current head state.
 func (s *Service) HeadETH1Data() *ethpb.Eth1Data {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return &ethpb.Eth1Data{}
 	}
@@ -202,6 +225,9 @@ func (s *Service) GenesisTime() time.Time {
 // GenesisValidatorRoot returns the genesis validator
 // root of the chain.
 func (s *Service) GenesisValidatorRoot() [32]byte {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return [32]byte{}
 	}
@@ -210,6 +236,9 @@ func (s *Service) GenesisValidatorRoot() [32]byte {
 
 // CurrentFork retrieves the latest fork information of the beacon chain.
 func (s *Service) CurrentFork() *pb.Fork {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return &pb.Fork{
 			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
@@ -226,9 +255,6 @@ func (s *Service) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, er
 		return true, nil
 	}
 
-	// If the block has not been finalized, the block must be recent. Check recent canonical roots
-	// mapping which uses proto array fork choice.
-	s.recentCanonicalBlocksLock.RLock()
-	defer s.recentCanonicalBlocksLock.RUnlock()
-	return s.recentCanonicalBlocks[blockRoot], nil
+	// If the block has not been finalized, check fork choice store to see if the block is canonical
+	return s.forkChoiceStore.IsCanonical(blockRoot), nil
 }

beacon-chain/blockchain/chain_info_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"testing"
 	"time"
@@ -11,22 +10,22 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"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"
 )
 
 // Ensure Service implements chain info interface.
-var _ = ChainInfoFetcher(&Service{})
-var _ = TimeFetcher(&Service{})
-var _ = ForkFetcher(&Service{})
+var _ ChainInfoFetcher = (*Service)(nil)
+var _ TimeFetcher = (*Service)(nil)
+var _ ForkFetcher = (*Service)(nil)
 
 func TestFinalizedCheckpt_Nil(t *testing.T) {
 	db, sc := testDB.SetupDB(t)
 	c := setupBeaconChain(t, db, sc)
-	if !bytes.Equal(c.FinalizedCheckpt().Root, params.BeaconConfig().ZeroHash[:]) {
-		t.Error("Incorrect pre chain start value")
-	}
+	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], c.FinalizedCheckpt().Root, "Incorrect pre chain start value")
 }
 
 func TestHeadRoot_Nil(t *testing.T) {
@@ -34,15 +33,13 @@ func TestHeadRoot_Nil(t *testing.T) {
 	c := setupBeaconChain(t, db, sc)
 	headRoot, err := c.HeadRoot(context.Background())
 	require.NoError(t, err)
-	if !bytes.Equal(headRoot, params.BeaconConfig().ZeroHash[:]) {
-		t.Error("Incorrect pre chain start value")
-	}
+	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
 }
 
 func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
 	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 5, Root: []byte("foo")}
+	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
 	c := setupBeaconChain(t, db, sc)
 	c.finalizedCheckpt = cp
 
@@ -57,16 +54,13 @@ func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
 	c := setupBeaconChain(t, db, sc)
 	c.finalizedCheckpt = cp
 	c.genesisRoot = genesisRoot
-
-	if !bytes.Equal(c.FinalizedCheckpt().Root, c.genesisRoot[:]) {
-		t.Errorf("Got: %v, wanted: %v", c.FinalizedCheckpt().Root, c.genesisRoot[:])
-	}
+	assert.DeepEqual(t, c.genesisRoot[:], c.FinalizedCheckpt().Root)
 }
 
 func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
 	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 6, Root: []byte("foo")}
+	cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
 	c := setupBeaconChain(t, db, sc)
 	c.justifiedCheckpt = cp
 
@@ -81,19 +75,15 @@ func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 	c := setupBeaconChain(t, db, sc)
 	c.justifiedCheckpt = cp
 	c.genesisRoot = genesisRoot
-
-	if !bytes.Equal(c.CurrentJustifiedCheckpt().Root, c.genesisRoot[:]) {
-		t.Errorf("Got: %v, wanted: %v", c.CurrentJustifiedCheckpt().Root, c.genesisRoot[:])
-	}
+	assert.DeepEqual(t, c.genesisRoot[:], c.CurrentJustifiedCheckpt().Root)
 }
 
 func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
 	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 7, Root: []byte("foo")}
+	cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
 	c := setupBeaconChain(t, db, sc)
 	c.prevJustifiedCheckpt = cp
-
 	assert.Equal(t, cp.Epoch, c.PreviousJustifiedCheckpt().Epoch, "Unexpected previous justified epoch")
 }
 
@@ -105,30 +95,28 @@ func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 	c := setupBeaconChain(t, db, sc)
 	c.prevJustifiedCheckpt = cp
 	c.genesisRoot = genesisRoot
-
-	if !bytes.Equal(c.PreviousJustifiedCheckpt().Root, c.genesisRoot[:]) {
-		t.Errorf("Got: %v, wanted: %v", c.PreviousJustifiedCheckpt().Root, c.genesisRoot[:])
-	}
+	assert.DeepEqual(t, c.genesisRoot[:], c.PreviousJustifiedCheckpt().Root)
 }
 
 func TestHeadSlot_CanRetrieve(t *testing.T) {
 	c := &Service{}
 	s, err := state.InitializeFromProto(&pb.BeaconState{})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	c.head = &head{slot: 100, state: s}
-	assert.Equal(t, uint64(100), c.headSlot())
+	assert.Equal(t, uint64(100), c.HeadSlot())
 }
 
 func TestHeadRoot_CanRetrieve(t *testing.T) {
 	c := &Service{}
 	c.head = &head{root: [32]byte{'A'}}
-	assert.Equal(t, [32]byte{'A'}, c.headRoot())
+	r, err := c.HeadRoot(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, [32]byte{'A'}, bytesutil.ToBytes32(r))
 }
 
 func TestHeadBlock_CanRetrieve(t *testing.T) {
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 1
 	s, err := state.InitializeFromProto(&pb.BeaconState{})
 	require.NoError(t, err)
 	c := &Service{}
@@ -146,9 +134,7 @@ func TestHeadState_CanRetrieve(t *testing.T) {
 	c.head = &head{state: s}
 	headState, err := c.HeadState(context.Background())
 	require.NoError(t, err)
-	if !proto.Equal(s.InnerStateUnsafe(), headState.InnerStateUnsafe()) {
-		t.Error("incorrect head state received")
-	}
+	assert.DeepEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Incorrect head state received")
 }
 
 func TestGenesisTime_CanRetrieve(t *testing.T) {
@@ -195,3 +181,23 @@ func TestHeadETH1Data_CanRetrieve(t *testing.T) {
 		t.Error("Received incorrect eth1 data")
 	}
 }
+
+func TestIsCanonical_Ok(t *testing.T) {
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+	c := setupBeaconChain(t, db, sc)
+
+	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))
+	can, err := c.IsCanonical(ctx, root)
+	require.NoError(t, err)
+	assert.Equal(t, true, can)
+
+	can, err = c.IsCanonical(ctx, [32]byte{'a'})
+	require.NoError(t, err)
+	assert.Equal(t, false, can)
+}

beacon-chain/blockchain/head.go

@@ -11,7 +11,6 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -24,7 +23,7 @@ type head struct {
 	slot  uint64                   // current head slot.
 	root  [32]byte                 // current head root.
 	block *ethpb.SignedBeaconBlock // current head block.
-	state *state.BeaconState       // current head state.
+	state *stateTrie.BeaconState   // current head state.
 }
 
 // Determined the head from the fork choice service and saves its new data
@@ -52,12 +51,24 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 	if headStartRoot == params.BeaconConfig().ZeroHash {
 		headStartRoot = s.genesisRoot
 	}
-	headRoot, err := s.forkChoiceStore.Head(ctx, j.Epoch, headStartRoot, balances, f.Epoch)
-	if err != nil {
-		return err
+
+	// In order to process head, fork choice store requires justified info.
+	// If the fork choice store is missing justified block info, a node should
+	// re-initiate fork choice store using the latest justified info.
+	// This recovers a fatal condition and should not happen in run time.
+	if !s.forkChoiceStore.HasNode(headStartRoot) {
+		jb, err := s.beaconDB.Block(ctx, headStartRoot)
+		if err != nil {
+			return err
+		}
+		s.forkChoiceStore = protoarray.New(j.Epoch, f.Epoch, bytesutil.ToBytes32(f.Root))
+		if err := s.insertBlockToForkChoiceStore(ctx, jb.Block, headStartRoot, f, j); err != nil {
+			return err
+		}
 	}
 
-	if err := s.updateRecentCanonicalBlocks(ctx, headRoot); err != nil {
+	headRoot, err := s.forkChoiceStore.Head(ctx, j.Epoch, headStartRoot, balances, f.Epoch)
+	if err != nil {
 		return err
 	}
 
@@ -72,7 +83,11 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 	defer span.End()
 
 	// Do nothing if head hasn't changed.
-	if headRoot == s.headRoot() {
+	r, err := s.HeadRoot(ctx)
+	if err != nil {
+		return err
+	}
+	if headRoot == bytesutil.ToBytes32(r) {
 		return nil
 	}
 
@@ -101,16 +116,17 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 	}
 
 	// A chain re-org occurred, so we fire an event notifying the rest of the services.
-	if bytesutil.ToBytes32(newHeadBlock.Block.ParentRoot) != s.headRoot() {
+	headSlot := s.HeadSlot()
+	if bytesutil.ToBytes32(newHeadBlock.Block.ParentRoot) != bytesutil.ToBytes32(r) {
 		log.WithFields(logrus.Fields{
 			"newSlot": fmt.Sprintf("%d", newHeadBlock.Block.Slot),
-			"oldSlot": fmt.Sprintf("%d", s.headSlot()),
+			"oldSlot": fmt.Sprintf("%d", headSlot),
 		}).Debug("Chain reorg occurred")
 		s.stateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Reorg,
 			Data: &statefeed.ReorgData{
 				NewSlot: newHeadBlock.Block.Slot,
-				OldSlot: s.headSlot(),
+				OldSlot: headSlot,
 			},
 		})
 
@@ -131,7 +147,7 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 // This gets called to update canonical root mapping. It does not save head block
 // root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
 // check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
-func (s *Service) saveHeadNoDB(ctx context.Context, b *ethpb.SignedBeaconBlock, r [32]byte, hs *state.BeaconState) error {
+func (s *Service) saveHeadNoDB(ctx context.Context, b *ethpb.SignedBeaconBlock, r [32]byte, hs *stateTrie.BeaconState) error {
 	cachedHeadRoot, err := s.HeadRoot(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get head root from cache")
@@ -149,7 +165,7 @@ func (s *Service) saveHeadNoDB(ctx context.Context, b *ethpb.SignedBeaconBlock,
 }
 
 // This sets head view object which is used to track the head slot, root, block and state.
-func (s *Service) setHead(root [32]byte, block *ethpb.SignedBeaconBlock, state *state.BeaconState) {
+func (s *Service) setHead(root [32]byte, block *ethpb.SignedBeaconBlock, state *stateTrie.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
@@ -165,7 +181,7 @@ func (s *Service) setHead(root [32]byte, block *ethpb.SignedBeaconBlock, state *
 // This sets head view object which is used to track the head slot, root, block and state. The method
 // assumes that state being passed into the method will not be modified by any other alternate
 // caller which holds the state's reference.
-func (s *Service) setHeadInitialSync(root [32]byte, block *ethpb.SignedBeaconBlock, state *state.BeaconState) {
+func (s *Service) setHeadInitialSync(root [32]byte, block *ethpb.SignedBeaconBlock, state *stateTrie.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
@@ -179,89 +195,57 @@ func (s *Service) setHeadInitialSync(root [32]byte, block *ethpb.SignedBeaconBlo
 }
 
 // This returns the head slot.
+// This is a lock free version.
 func (s *Service) headSlot() uint64 {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
 	return s.head.slot
 }
 
 // This returns the head root.
 // It does a full copy on head root for immutability.
+// This is a lock free version.
 func (s *Service) headRoot() [32]byte {
 	if s.head == nil {
 		return params.BeaconConfig().ZeroHash
 	}
 
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
 	return s.head.root
 }
 
 // This returns the head block.
 // It does a full copy on head block for immutability.
+// This is a lock free version.
 func (s *Service) headBlock() *ethpb.SignedBeaconBlock {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
 	return stateTrie.CopySignedBeaconBlock(s.head.block)
 }
 
 // This returns the head state.
 // It does a full copy on head state for immutability.
+// This is a lock free version.
 func (s *Service) headState(ctx context.Context) *stateTrie.BeaconState {
 	ctx, span := trace.StartSpan(ctx, "blockChain.headState")
 	defer span.End()
 
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
 	return s.head.state.Copy()
 }
 
 // This returns the genesis validator root of the head state.
+// This is a lock free version.
 func (s *Service) headGenesisValidatorRoot() [32]byte {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
 	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
 }
 
-// Returns true if head state exists.
-func (s *Service) hasHeadState() bool {
+// HasHeadState returns true if head state exists.
+func (s *Service) HasHeadState() bool {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
-	return s.head != nil && s.head.state != nil
+	return s.hasHeadState()
 }
 
-// This updates recent canonical block mapping. It uses input head root and retrieves
-// all the canonical block roots that are ancestor of the input head block root.
-func (s *Service) updateRecentCanonicalBlocks(ctx context.Context, headRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.updateRecentCanonicalBlocks")
-	defer span.End()
-
-	s.recentCanonicalBlocksLock.Lock()
-	defer s.recentCanonicalBlocksLock.Unlock()
-
-	s.recentCanonicalBlocks = make(map[[32]byte]bool)
-	s.recentCanonicalBlocks[headRoot] = true
-	nodes := s.forkChoiceStore.Nodes()
-	node := s.forkChoiceStore.Node(headRoot)
-	if node == nil {
-		return nil
-	}
-
-	for node.Parent() != protoarray.NonExistentNode {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		node = nodes[node.Parent()]
-		s.recentCanonicalBlocks[node.Root()] = true
-	}
-
-	return nil
+// Returns true if head state exists.
+// This is the lock free version.
+func (s *Service) hasHeadState() bool {
+	return s.head != nil && s.head.state != nil
 }
 
 // This caches justified state balances to be used for fork choice.

beacon-chain/blockchain/head_test.go

@@ -7,7 +7,6 @@ import (
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -35,11 +34,12 @@ func TestSaveHead_Different(t *testing.T) {
 	oldRoot := [32]byte{'A'}
 	service.head = &head{slot: 0, root: oldRoot}
 
-	newHeadBlock := &ethpb.BeaconBlock{Slot: 1}
-	newHeadSignedBlock := &ethpb.SignedBeaconBlock{Block: newHeadBlock}
+	newHeadSignedBlock := testutil.NewBeaconBlock()
+	newHeadSignedBlock.Block.Slot = 1
+	newHeadBlock := newHeadSignedBlock.Block
 
 	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
-	newRoot, err := stateutil.BlockRoot(newHeadBlock)
+	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
 	headState := testutil.NewBeaconState()
 	require.NoError(t, headState.SetSlot(1))
@@ -68,14 +68,13 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	service.head = &head{slot: 0, root: oldRoot}
 
 	reorgChainParent := [32]byte{'B'}
-	newHeadBlock := &ethpb.BeaconBlock{
-		Slot:       1,
-		ParentRoot: reorgChainParent[:],
-	}
-	newHeadSignedBlock := &ethpb.SignedBeaconBlock{Block: newHeadBlock}
+	newHeadSignedBlock := testutil.NewBeaconBlock()
+	newHeadSignedBlock.Block.Slot = 1
+	newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
+	newHeadBlock := newHeadSignedBlock.Block
 
 	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
-	newRoot, err := stateutil.BlockRoot(newHeadBlock)
+	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
 	headState := testutil.NewBeaconState()
 	require.NoError(t, headState.SetSlot(1))
@@ -95,39 +94,6 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.LogsContain(t, hook, "Chain reorg occurred")
 }
 
-func TestUpdateRecentCanonicalBlocks_CanUpdateWithoutParent(t *testing.T) {
-	db, sc := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db, sc)
-
-	r := [32]byte{'a'}
-	require.NoError(t, service.updateRecentCanonicalBlocks(context.Background(), r))
-	canonical, err := service.IsCanonical(context.Background(), r)
-	require.NoError(t, err)
-	assert.Equal(t, true, canonical, "Block should be canonical")
-}
-
-func TestUpdateRecentCanonicalBlocks_CanUpdateWithParent(t *testing.T) {
-	db, sc := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db, sc)
-	oldHead := [32]byte{'a'}
-	require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), 1, oldHead, [32]byte{'g'}, [32]byte{}, 0, 0))
-	currentHead := [32]byte{'b'}
-	require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), 3, currentHead, oldHead, [32]byte{}, 0, 0))
-	forkedRoot := [32]byte{'c'}
-	require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), 2, forkedRoot, oldHead, [32]byte{}, 0, 0))
-
-	require.NoError(t, service.updateRecentCanonicalBlocks(context.Background(), currentHead))
-	canonical, err := service.IsCanonical(context.Background(), currentHead)
-	require.NoError(t, err)
-	assert.Equal(t, true, canonical, "Block should be canonical")
-	canonical, err = service.IsCanonical(context.Background(), oldHead)
-	require.NoError(t, err)
-	assert.Equal(t, true, canonical, "Block should be canonical")
-	canonical, err = service.IsCanonical(context.Background(), forkedRoot)
-	require.NoError(t, err)
-	assert.Equal(t, false, canonical, "Block should not be canonical")
-}
-
 func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
 	db, sc := testDB.SetupDB(t)
 	service := setupBeaconChain(t, db, sc)
@@ -139,3 +105,19 @@ func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
 	require.NoError(t, service.cacheJustifiedStateBalances(context.Background(), r))
 	require.DeepEqual(t, service.getJustifiedBalances(), state.Balances(), "Incorrect justified balances")
 }
+
+func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
+
+	b := testutil.NewBeaconBlock()
+	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), b))
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.finalizedCheckpt = &ethpb.Checkpoint{}
+	service.bestJustifiedCheckpt = &ethpb.Checkpoint{}
+
+	require.NoError(t, service.updateHead(context.Background(), []uint64{}))
+}

beacon-chain/blockchain/info.go

@@ -34,7 +34,12 @@ const template = `<html>
 
 // TreeHandler is a handler to serve /tree page in metrics.
 func (s *Service) TreeHandler(w http.ResponseWriter, r *http.Request) {
-	if s.headState(r.Context()) == nil {
+	headState, err := s.HeadState(r.Context())
+	if err != nil {
+		log.WithError(err).Error("Could not get head state")
+		return
+	}
+	if headState == nil {
 		if _, err := w.Write([]byte("Unavailable during initial syncing")); err != nil {
 			log.WithError(err).Error("Failed to render p2p info page")
 		}
@@ -47,7 +52,7 @@ func (s *Service) TreeHandler(w http.ResponseWriter, r *http.Request) {
 	graph.Attr("labeljust", "l")
 
 	dotNodes := make([]*dot.Node, len(nodes))
-	avgBalance := uint64(averageBalance(s.headState(r.Context()).Balances()))
+	avgBalance := uint64(averageBalance(headState.Balances()))
 
 	for i := len(nodes) - 1; i >= 0; i-- {
 		// Construct label for each node.
@@ -63,7 +68,7 @@ func (s *Service) TreeHandler(w http.ResponseWriter, r *http.Request) {
 			dotN = graph.Node(index).Box().Attr("label", label)
 		}
 
-		if nodes[i].Slot() == s.headSlot() &&
+		if nodes[i].Slot() == s.HeadSlot() &&
 			nodes[i].BestDescendant() == ^uint64(0) &&
 			nodes[i].Parent() != ^uint64(0) {
 			dotN = dotN.Attr("color", "green")

beacon-chain/blockchain/info_test.go

@@ -33,6 +33,7 @@ func TestService_TreeHandler(t *testing.T) {
 		StateGen: stategen.New(db, sCache),
 	}
 	s, err := NewService(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))
 	s.setHead([32]byte{'a'}, testutil.NewBeaconBlock(), headState)

beacon-chain/blockchain/log.go

@@ -6,6 +6,7 @@ import (
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/sirupsen/logrus"
 )
 
@@ -25,9 +26,10 @@ func logStateTransitionData(b *ethpb.BeaconBlock) {
 func logBlockSyncStatus(block *ethpb.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint) {
 	log.WithFields(logrus.Fields{
 		"slot":           block.Slot,
+		"slotInEpoch":    block.Slot % params.BeaconConfig().SlotsPerEpoch,
 		"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
 		"epoch":          helpers.SlotToEpoch(block.Slot),
 		"finalizedEpoch": finalized.Epoch,
-		"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root[:])[:8]),
+		"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
 	}).Info("Synced new block")
 }

beacon-chain/blockchain/metrics.go

@@ -1,17 +1,15 @@
 package blockchain
 
 import (
-	"time"
+	"context"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/roughtime"
 )
 
 var (
@@ -76,25 +74,30 @@ var (
 		Name: "current_eth1_data_deposit_count",
 		Help: "The current eth1 deposit count in the last processed state eth1data field.",
 	})
-	totalEligibleBalances = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "total_eligible_balances",
-		Help: "The total amount of ether, in gwei, that is eligible for voting of previous epoch",
+	stateTrieReferences = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "field_references",
+		Help: "The number of states a particular field is shared with.",
+	}, []string{"state"})
+	prevEpochActiveBalances = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_prev_epoch_active_gwei",
+		Help: "The total amount of ether, in gwei, that was active for voting of previous epoch",
 	})
-	totalVotedTargetBalances = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "total_voted_target_balances",
+	prevEpochSourceBalances = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_prev_epoch_source_gwei",
+		Help: "The total amount of ether, in gwei, that has been used in voting attestation source of previous epoch",
+	})
+	prevEpochTargetBalances = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_prev_epoch_target_gwei",
 		Help: "The total amount of ether, in gwei, that has been used in voting attestation target of previous epoch",
 	})
+	prevEpochHeadBalances = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_prev_epoch_head_gwei",
+		Help: "The total amount of ether, in gwei, that has been used in voting attestation head of previous epoch",
+	})
 	reorgCount = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "beacon_reorg_total",
 		Help: "Count the number of times beacon chain has a reorg",
 	})
-	sentBlockPropagationHistogram = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "block_sent_latency_milliseconds",
-			Help:    "Captures blocks broadcast time. Blocks sent in milliseconds distribution",
-			Buckets: []float64{1000, 2000, 3000, 4000, 5000, 6000},
-		},
-	)
 	attestationInclusionDelay = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "attestation_inclusion_delay_slots",
@@ -105,7 +108,7 @@ var (
 )
 
 // reportSlotMetrics reports slot related metrics.
-func reportSlotMetrics(stateSlot uint64, headSlot uint64, clockSlot uint64, finalizedCheckpoint *ethpb.Checkpoint) {
+func reportSlotMetrics(stateSlot, headSlot, clockSlot uint64, finalizedCheckpoint *ethpb.Checkpoint) {
 	clockTimeSlot.Set(float64(clockSlot))
 	beaconSlot.Set(float64(stateSlot))
 	beaconHeadSlot.Set(float64(headSlot))
@@ -116,8 +119,8 @@ func reportSlotMetrics(stateSlot uint64, headSlot uint64, clockSlot uint64, fina
 }
 
 // reportEpochMetrics reports epoch related metrics.
-func reportEpochMetrics(state *stateTrie.BeaconState) {
-	currentEpoch := state.Slot() / params.BeaconConfig().SlotsPerEpoch
+func reportEpochMetrics(ctx context.Context, postState, headState *stateTrie.BeaconState) error {
+	currentEpoch := postState.Slot() / params.BeaconConfig().SlotsPerEpoch
 
 	// Validator instances
 	pendingInstances := 0
@@ -135,8 +138,8 @@ func reportEpochMetrics(state *stateTrie.BeaconState) {
 	slashingBalance := uint64(0)
 	slashingEffectiveBalance := uint64(0)
 
-	for i, validator := range state.Validators() {
-		bal, err := state.BalanceAtIndex(uint64(i))
+	for i, validator := range postState.Validators() {
+		bal, err := postState.BalanceAtIndex(uint64(i))
 		if err != nil {
 			log.Errorf("Could not load validator balance: %v", err)
 			continue
@@ -185,33 +188,36 @@ func reportEpochMetrics(state *stateTrie.BeaconState) {
 	validatorsEffectiveBalance.WithLabelValues("Slashing").Set(float64(slashingEffectiveBalance))
 
 	// Last justified slot
-	beaconCurrentJustifiedEpoch.Set(float64(state.CurrentJustifiedCheckpoint().Epoch))
-	beaconCurrentJustifiedRoot.Set(float64(bytesutil.ToLowInt64(state.CurrentJustifiedCheckpoint().Root)))
+	beaconCurrentJustifiedEpoch.Set(float64(postState.CurrentJustifiedCheckpoint().Epoch))
+	beaconCurrentJustifiedRoot.Set(float64(bytesutil.ToLowInt64(postState.CurrentJustifiedCheckpoint().Root)))
 
 	// Last previous justified slot
-	beaconPrevJustifiedEpoch.Set(float64(state.PreviousJustifiedCheckpoint().Epoch))
-	beaconPrevJustifiedRoot.Set(float64(bytesutil.ToLowInt64(state.PreviousJustifiedCheckpoint().Root)))
+	beaconPrevJustifiedEpoch.Set(float64(postState.PreviousJustifiedCheckpoint().Epoch))
+	beaconPrevJustifiedRoot.Set(float64(bytesutil.ToLowInt64(postState.PreviousJustifiedCheckpoint().Root)))
 
 	// Last finalized slot
-	beaconFinalizedEpoch.Set(float64(state.FinalizedCheckpointEpoch()))
-	beaconFinalizedRoot.Set(float64(bytesutil.ToLowInt64(state.FinalizedCheckpoint().Root)))
+	beaconFinalizedEpoch.Set(float64(postState.FinalizedCheckpointEpoch()))
+	beaconFinalizedRoot.Set(float64(bytesutil.ToLowInt64(postState.FinalizedCheckpoint().Root)))
+	currentEth1DataDepositCount.Set(float64(postState.Eth1Data().DepositCount))
 
-	currentEth1DataDepositCount.Set(float64(state.Eth1Data().DepositCount))
-
-	if precompute.Balances != nil {
-		totalEligibleBalances.Set(float64(precompute.Balances.ActivePrevEpoch))
-		totalVotedTargetBalances.Set(float64(precompute.Balances.PrevEpochTargetAttested))
-	}
-}
-
-// This captures metrics for block sent time by subtracts slot start time.
-func captureSentTimeMetric(genesisTime uint64, currentSlot uint64) error {
-	startTime, err := helpers.SlotToTime(genesisTime, currentSlot)
+	// Validator participation should be viewed on the canonical chain.
+	v, b, err := precompute.New(ctx, headState)
 	if err != nil {
 		return err
 	}
-	diffMs := roughtime.Now().Sub(startTime) / time.Millisecond
-	sentBlockPropagationHistogram.Observe(float64(diffMs))
+	_, b, err = precompute.ProcessAttestations(ctx, headState, v, b)
+	if err != nil {
+		return err
+	}
+	prevEpochActiveBalances.Set(float64(b.ActivePrevEpoch))
+	prevEpochSourceBalances.Set(float64(b.PrevEpochAttested))
+	prevEpochTargetBalances.Set(float64(b.PrevEpochTargetAttested))
+	prevEpochHeadBalances.Set(float64(b.PrevEpochHeadAttested))
+
+	refMap := postState.FieldReferencesCount()
+	for name, val := range refMap {
+		stateTrieReferences.WithLabelValues(name).Set(float64(val))
+	}
 
 	return nil
 }

beacon-chain/blockchain/metrics_test.go

@@ -0,0 +1,26 @@
+package blockchain
+
+import (
+	"context"
+	"testing"
+
+	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()
+	require.NoError(t, h.SetValidators(nil))
+	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()
+	require.NoError(t, h.SetCurrentEpochAttestations([]*pb.PendingAttestation{{InclusionDelay: 0}}))
+	err := reportEpochMetrics(context.Background(), s, h)
+	require.ErrorContains(t, "attestation with inclusion delay of 0", err)
+}

beacon-chain/blockchain/process_attestation.go

@@ -10,7 +10,7 @@ import (
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/roughtime"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 	"go.opencensus.io/trace"
 )
 
@@ -73,10 +73,10 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) ([]ui
 		return nil, err
 	}
 
-	genesisTime := helpers.GenesisTime(baseState)
+	genesisTime := baseState.GenesisTime()
 
 	// Verify attestation target is from current epoch or previous epoch.
-	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(roughtime.Now().Unix()), tgt); err != nil {
+	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(timeutils.Now().Unix()), tgt); err != nil {
 		return nil, err
 	}
 

beacon-chain/blockchain/process_attestation_helpers.go

@@ -7,6 +7,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/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
@@ -18,10 +19,7 @@ import (
 
 // getAttPreState retrieves the att pre state by either from the cache or the DB.
 func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*stateTrie.BeaconState, error) {
-	s.checkpointStateLock.Lock()
-	defer s.checkpointStateLock.Unlock()
-
-	cachedState, err := s.checkpointState.StateByCheckpoint(c)
+	cachedState, err := s.checkpointStateCache.StateByCheckpoint(ctx, c)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get cached checkpoint state")
 	}
@@ -29,38 +27,59 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*sta
 		return cachedState, nil
 	}
 
+	if err := s.checkpointStateCache.MarkInProgress(c); err != nil {
+		if errors.Is(err, cache.ErrAlreadyInProgress) {
+			cachedState, err = s.checkpointStateCache.StateByCheckpoint(ctx, c)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get cached checkpoint state")
+			}
+			if cachedState != nil {
+				return cachedState, nil
+			}
+		} else {
+			return nil, err
+		}
+	}
+	defer func() {
+		if err := s.checkpointStateCache.MarkNotInProgress(c); err != nil {
+			log.WithError(err).Error("Failed to mark cache not in progress")
+		}
+	}()
 	baseState, err := s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(c.Root))
 	if err != nil {
-		return nil, errors.Wrapf(err, "could not get pre state for slot %d", helpers.StartSlot(c.Epoch))
+		return nil, errors.Wrapf(err, "could not get pre state for epoch %d", c.Epoch)
 	}
-
-	if helpers.StartSlot(c.Epoch) > baseState.Slot() {
-		baseState = baseState.Copy()
-		baseState, err = state.ProcessSlots(ctx, baseState, helpers.StartSlot(c.Epoch))
+	epochStartSlot, err := helpers.StartSlot(c.Epoch)
+	if err != nil {
+		return nil, err
+	}
+	if epochStartSlot > baseState.Slot() {
+		baseState, err = state.ProcessSlots(ctx, baseState, epochStartSlot)
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not process slots up to %d", helpers.StartSlot(c.Epoch))
+			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
 		}
-		if err := s.checkpointState.AddCheckpointState(c, baseState); err != nil {
+		if err := s.checkpointStateCache.AddCheckpointState(c, baseState); err != nil {
 			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
 		}
 		return baseState, nil
 	}
 
-	has, err := s.stateGen.HasState(ctx, bytesutil.ToBytes32(c.Root))
+	// To avoid sharing the same state across checkpoint state cache and hot state cache,
+	// we don't add the state to check point cache.
+	has, err := s.stateGen.HasStateInCache(ctx, bytesutil.ToBytes32(c.Root))
 	if err != nil {
 		return nil, err
 	}
 	if !has {
-		if err := s.checkpointState.AddCheckpointState(c, baseState); err != nil {
+		if err := s.checkpointStateCache.AddCheckpointState(c, baseState); err != nil {
 			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
 		}
 	}
 	return baseState, nil
-
 }
 
 // verifyAttTargetEpoch validates attestation is from the current or previous epoch.
-func (s *Service) verifyAttTargetEpoch(ctx context.Context, genesisTime uint64, nowTime uint64, c *ethpb.Checkpoint) error {
+func (s *Service) verifyAttTargetEpoch(_ context.Context, genesisTime, nowTime uint64, c *ethpb.Checkpoint) error {
 	currentSlot := (nowTime - genesisTime) / params.BeaconConfig().SecondsPerSlot
 	currentEpoch := helpers.SlotToEpoch(currentSlot)
 	var prevEpoch uint64
@@ -96,8 +115,11 @@ func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.Attestation
 }
 
 // verifyLMDFFGConsistent verifies LMD GHOST and FFG votes are consistent with each other.
-func (s *Service) verifyLMDFFGConsistent(ctx context.Context, ffgEpoch uint64, ffgRoot []byte, lmdRoot []byte) error {
-	ffgSlot := helpers.StartSlot(ffgEpoch)
+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

beacon-chain/blockchain/process_attestation_test.go

@@ -2,8 +2,9 @@ package blockchain
 
 import (
 	"context"
-	"strings"
+	"sync"
 	"testing"
+	"time"
 
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
@@ -11,9 +12,7 @@ import (
 	"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"
-	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -37,103 +36,95 @@ func TestStore_OnAttestation(t *testing.T) {
 	_, err = blockTree1(db, []byte{'g'})
 	require.NoError(t, err)
 
-	BlkWithOutState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 0}}
+	BlkWithOutState := testutil.NewBeaconBlock()
+	BlkWithOutState.Block.Slot = 0
 	require.NoError(t, db.SaveBlock(ctx, BlkWithOutState))
-	BlkWithOutStateRoot, err := stateutil.BlockRoot(BlkWithOutState.Block)
+	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	BlkWithStateBadAtt := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
+	BlkWithStateBadAtt := testutil.NewBeaconBlock()
+	BlkWithStateBadAtt.Block.Slot = 1
 	require.NoError(t, db.SaveBlock(ctx, BlkWithStateBadAtt))
-	BlkWithStateBadAttRoot, err := stateutil.BlockRoot(BlkWithStateBadAtt.Block)
+	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	s := testutil.NewBeaconState()
 	require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, service.beaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
 
-	BlkWithValidState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
+	BlkWithValidState := testutil.NewBeaconBlock()
+	BlkWithValidState.Block.Slot = 2
 	require.NoError(t, db.SaveBlock(ctx, BlkWithValidState))
 
-	BlkWithValidStateRoot, err := stateutil.BlockRoot(BlkWithValidState.Block)
+	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
 	s = testutil.NewBeaconState()
-	if err := s.SetFork(&pb.Fork{
+	err = s.SetFork(&pb.Fork{
 		Epoch:           0,
 		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-	}); err != nil {
-		t.Fatal(err)
-	}
+	})
+	require.NoError(t, err)
 	require.NoError(t, service.beaconDB.SaveState(ctx, s, BlkWithValidStateRoot))
 
 	tests := []struct {
-		name          string
-		a             *ethpb.Attestation
-		s             *pb.BeaconState
-		wantErr       bool
-		wantErrString string
+		name      string
+		a         *ethpb.Attestation
+		wantedErr string
 	}{
 		{
-			name:          "attestation's data slot not aligned with target vote",
-			a:             &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{}}},
-			s:             &pb.BeaconState{},
-			wantErr:       true,
-			wantErrString: "data slot is not in the same epoch as target 1 != 0",
+			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: []byte{'A'}}}},
-			s:             &pb.BeaconState{},
-			wantErr:       true,
-			wantErrString: "target root does not exist in db",
+			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",
 		},
 		{
-			name:          "no pre state for attestations's target block",
-			a:             &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}},
-			s:             &pb.BeaconState{},
-			wantErr:       true,
-			wantErrString: "could not get pre state for slot 0",
+			name:      "no pre state for attestations's target block",
+			a:         &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[:]}}},
-			s:             &pb.BeaconState{Slot: 100 * params.BeaconConfig().SlotsPerEpoch},
-			wantErr:       true,
-			wantErrString: "target epoch 100 does not match current epoch",
+			wantedErr: "target epoch 100 does not match current epoch",
 		},
 		{
-			name:          "process nil field (a.Target) in attestation",
-			a:             nil,
-			s:             &pb.BeaconState{},
-			wantErr:       true,
-			wantErrString: "nil attestation",
+			name:      "process nil attestation",
+			a:         nil,
+			wantedErr: "nil attestation",
 		},
 		{
-			name:          "process nil field (a.Data) in attestation",
-			a:             &ethpb.Attestation{},
-			s:             &pb.BeaconState{},
-			wantErr:       true,
-			wantErrString: "nil attestation.Data field",
+			name:      "process nil field (a.Data) in attestation",
+			a:         &ethpb.Attestation{},
+			wantedErr: "nil attestation.Data field",
 		},
 		{
-			name:          "process nil field (a.Target) in attestation",
-			a:             &ethpb.Attestation{Data: &ethpb.AttestationData{}},
-			s:             &pb.BeaconState{},
-			wantErr:       true,
-			wantErrString: "nil attestation.Data.Target field",
+			name: "process nil field (a.Target) in attestation",
+			a: &ethpb.Attestation{
+				Data: &ethpb.AttestationData{
+					BeaconBlockRoot: make([]byte, 32),
+					Target:          nil,
+					Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+				},
+				AggregationBits: make([]byte, 1),
+				Signature:       make([]byte, 96),
+			},
+			wantedErr: "nil attestation.Data.Target field",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			_, err := service.onAttestation(ctx, tt.a)
-			if tt.wantErr {
-				if err == nil || !strings.Contains(err.Error(), tt.wantErrString) {
-					t.Errorf("Store.onAttestation() error = %v, wantErr = %v", err, tt.wantErrString)
-				}
+			if tt.wantedErr != "" {
+				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
-				t.Error(err)
+				assert.NoError(t, err)
 			}
 		})
 	}
@@ -150,22 +141,16 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	s, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Fork: &pb.Fork{
-			Epoch:           0,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-		},
-		RandaoMixes:         make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		StateRoots:          make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot),
-		BlockRoots:          make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot),
-		LatestBlockHeader:   &ethpb.BeaconBlockHeader{},
-		JustificationBits:   []byte{0},
-		Slashings:           make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
-		FinalizedCheckpoint: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)},
-		Validators:          []*ethpb.Validator{{PublicKey: bytesutil.PadTo([]byte("foo"), 48)}},
-		Balances:            []uint64{0},
-	})
+	s := testutil.NewBeaconState()
+	err = s.SetFinalizedCheckpoint(&ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)})
+	require.NoError(t, err)
+	val := &ethpb.Validator{
+		PublicKey:             bytesutil.PadTo([]byte("foo"), 48),
+		WithdrawalCredentials: bytesutil.PadTo([]byte("bar"), 32),
+	}
+	err = s.SetValidators([]*ethpb.Validator{val})
+	require.NoError(t, err)
+	err = s.SetBalances([]uint64{0})
 	require.NoError(t, err)
 	r := [32]byte{'g'}
 	require.NoError(t, service.beaconDB.SaveState(ctx, s, r))
@@ -195,11 +180,11 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
 
-	s1, err = service.checkpointState.StateByCheckpoint(cp1)
+	s1, err = service.checkpointStateCache.StateByCheckpoint(ctx, cp1)
 	require.NoError(t, err)
 	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
 
-	s2, err = service.checkpointState.StateByCheckpoint(cp2)
+	s2, err = service.checkpointStateCache.StateByCheckpoint(ctx, cp2)
 	require.NoError(t, err)
 	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
 
@@ -229,33 +214,74 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 
 	epoch := uint64(1)
 	baseState, _ := testutil.DeterministicGenesisState(t, 1)
-	require.NoError(t, baseState.SetSlot(epoch*params.BeaconConfig().SlotsPerEpoch))
-	checkpoint := &ethpb.Checkpoint{Epoch: epoch}
+	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("hi"), 32)}
 	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
 	returned, err := service.getAttPreState(ctx, checkpoint)
 	require.NoError(t, err)
-	assert.Equal(t, returned.Slot(), baseState.Slot(), "Incorrectly returned base state")
+	assert.Equal(t, returned.Slot(), checkpoint.Epoch*params.BeaconConfig().SlotsPerEpoch, "Incorrectly returned base state")
 
-	cached, err := service.checkpointState.StateByCheckpoint(checkpoint)
+	cached, err := service.checkpointStateCache.StateByCheckpoint(ctx, checkpoint)
 	require.NoError(t, err)
-	assert.NotNil(t, cached, "State should have been cached")
+	assert.Equal(t, returned.Slot(), cached.Slot(), "State should have been cached")
 
 	epoch = uint64(2)
-	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch}
+	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("bye"), 32)}
 	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)
 	require.NoError(t, err)
-	baseState, err = state.ProcessSlots(ctx, baseState, helpers.StartSlot(newCheckpoint.Epoch))
+	s, err := helpers.StartSlot(newCheckpoint.Epoch)
+	require.NoError(t, err)
+	baseState, err = state.ProcessSlots(ctx, baseState, s)
 	require.NoError(t, err)
 	assert.Equal(t, returned.Slot(), baseState.Slot(), "Incorrectly returned base state")
 
-	cached, err = service.checkpointState.StateByCheckpoint(newCheckpoint)
+	cached, err = service.checkpointStateCache.StateByCheckpoint(ctx, newCheckpoint)
 	require.NoError(t, err)
 	if !proto.Equal(returned.InnerStateUnsafe(), cached.InnerStateUnsafe()) {
 		t.Error("Incorrectly cached base state")
 	}
 }
 
+func TestStore_CheckpointState_InProgress(t *testing.T) {
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB: db,
+		StateGen: stategen.New(db, sc),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	epoch := uint64(1)
+	baseState, _ := testutil.DeterministicGenesisState(t, 1)
+	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("hi"), 32)}
+	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
+	require.NoError(t, service.checkpointStateCache.MarkInProgress(checkpoint))
+
+	var wg sync.WaitGroup
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		response, err := service.getAttPreState(ctx, checkpoint)
+		require.NoError(t, err)
+		if !proto.Equal(baseState.InnerStateUnsafe(), response.InnerStateUnsafe()) {
+			t.Error("Expected  equal responses from cache")
+		}
+	}()
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		assert.NoError(t, service.checkpointStateCache.AddCheckpointState(checkpoint, baseState))
+		assert.NoError(t, service.checkpointStateCache.MarkNotInProgress(checkpoint))
+	}()
+
+	testutil.WaitTimeout(&wg, time.Second*2)
+}
+
 func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	ctx := context.Background()
 	db, _ := testDB.SetupDB(t)
@@ -264,13 +290,8 @@ func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	if err := service.verifyAttTargetEpoch(
-		ctx,
-		0,
-		params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
-		&ethpb.Checkpoint{}); err != nil {
-		t.Error(err)
-	}
+	nowTime := params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
+	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)}))
 }
 
 func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
@@ -281,13 +302,8 @@ func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	if err := service.verifyAttTargetEpoch(
-		ctx,
-		0,
-		params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
-		&ethpb.Checkpoint{Epoch: 1}); err != nil {
-		t.Error(err)
-	}
+	nowTime := params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
+	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
 }
 
 func TestAttEpoch_NotMatch(t *testing.T) {
@@ -298,14 +314,9 @@ func TestAttEpoch_NotMatch(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	if err := service.verifyAttTargetEpoch(
-		ctx,
-		0,
-		2*params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
-		&ethpb.Checkpoint{}); !strings.Contains(err.Error(),
-		"target epoch 0 does not match current epoch 2 or prev epoch 1") {
-		t.Error("Did not receive wanted error")
-	}
+	nowTime := 2 * params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot
+	err = service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)})
+	assert.ErrorContains(t, "target epoch 0 does not match current epoch 2 or prev epoch 1", err)
 }
 
 func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
@@ -316,8 +327,12 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	d := &ethpb.AttestationData{}
-	assert.ErrorContains(t, "beacon block  does not exist", service.verifyBeaconBlock(ctx, d))
+	d := &ethpb.AttestationData{
+		BeaconBlockRoot: make([]byte, 32),
+		Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+	}
+	assert.ErrorContains(t, "beacon block 0x000000000000 does not exist", service.verifyBeaconBlock(ctx, d))
 }
 
 func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
@@ -328,9 +343,10 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 2
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
-	r, err := stateutil.BlockRoot(b.Block)
+	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
 
@@ -345,9 +361,10 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 2
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
-	r, err := stateutil.BlockRoot(b.Block)
+	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
 
@@ -362,13 +379,16 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
+	b32 := testutil.NewBeaconBlock()
+	b32.Block.Slot = 32
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
-	r32, err := stateutil.BlockRoot(b32.Block)
+	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
+	b33 := testutil.NewBeaconBlock()
+	b33.Block.Slot = 33
+	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
-	r33, err := stateutil.BlockRoot(b33.Block)
+	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	wanted := "FFG and LMD votes are not consistent"
@@ -383,15 +403,102 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
+	b32 := testutil.NewBeaconBlock()
+	b32.Block.Slot = 32
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
-	r32, err := stateutil.BlockRoot(b32.Block)
+	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
+	b33 := testutil.NewBeaconBlock()
+	b33.Block.Slot = 33
+	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
-	r33, err := stateutil.BlockRoot(b33.Block)
+	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)
+
+	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)
+
+	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
+
+	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.VerifyFinalizedConsistency(context.Background(), r33[:])
+	require.ErrorContains(t, "Root and finalized store are not consistent", err)
+}
+
+func TestVerifyFinalizedConsistency_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)
+
+	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
+
+	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.VerifyFinalizedConsistency(context.Background(), r33[:])
+	require.NoError(t, err)
+}
+
+func TestVerifyFinalizedConsistency_IsCanonical(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
+	r32, err := b32.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
+
+	b33 := testutil.NewBeaconBlock()
+	b33.Block.Slot = 33
+	b33.Block.ParentRoot = r32[:]
+	r33, err := b33.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.NoError(t, service.forkChoiceStore.ProcessBlock(ctx, b32.Block.Slot, r32, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, service.forkChoiceStore.ProcessBlock(ctx, b33.Block.Slot, r33, r32, [32]byte{}, 0, 0))
+
+	_, err = service.forkChoiceStore.Head(ctx, 0, r32, []uint64{}, 0)
+	require.NoError(t, err)
+	err = service.VerifyFinalizedConsistency(context.Background(), r33[:])
+	require.NoError(t, err)
+}

beacon-chain/blockchain/process_block.go

@@ -121,12 +121,26 @@ func (s *Service) onBlock(ctx context.Context, signed *ethpb.SignedBeaconBlock,
 		}
 
 		// Update deposit cache.
-		s.depositCache.InsertFinalizedDeposits(ctx, int64(postState.Eth1DepositIndex()))
+		finalizedState, err := s.stateGen.StateByRoot(ctx, fRoot)
+		if err != nil {
+			return errors.Wrap(err, "could not fetch finalized state")
+		}
+		// We update the cache up to the last deposit index in the finalized block's state.
+		// We can be confident that these deposits will be included in some block
+		// because the Eth1 follow distance makes such long-range reorgs extremely unlikely.
+		eth1DepositIndex := int64(finalizedState.Eth1Data().DepositCount - 1)
+		s.depositCache.InsertFinalizedDeposits(ctx, eth1DepositIndex)
+		if featureconfig.Get().EnablePruningDepositProofs {
+			// Deposit proofs are only used during state transition and can be safely removed to save space.
+			if err = s.depositCache.PruneProofs(ctx, eth1DepositIndex); err != nil {
+				return errors.Wrap(err, "could not prune deposit proofs")
+			}
+		}
 	}
 
 	defer reportAttestationInclusion(b)
 
-	return s.handleEpochBoundary(postState)
+	return s.handleEpochBoundary(ctx, postState)
 }
 
 // onBlockInitialSyncStateTransition is called when an initial sync block is received.
@@ -161,12 +175,7 @@ func (s *Service) onBlockInitialSyncStateTransition(ctx context.Context, signed
 		return nil
 	}
 
-	var postState *stateTrie.BeaconState
-	if featureconfig.Get().InitSyncNoVerify {
-		postState, err = state.ExecuteStateTransitionNoVerifyAttSigs(ctx, preState, signed)
-	} else {
-		postState, err = state.ExecuteStateTransition(ctx, preState, signed)
-	}
+	postState, err := state.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
 		return errors.Wrap(err, "could not execute state transition")
 	}
@@ -200,7 +209,7 @@ func (s *Service) onBlockInitialSyncStateTransition(ctx context.Context, signed
 		}
 	}
 
-	return s.handleEpochBoundary(postState)
+	return s.handleEpochBoundary(ctx, postState)
 }
 
 func (s *Service) onBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock,
@@ -231,11 +240,11 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBl
 	jCheckpoints := make([]*ethpb.Checkpoint, len(blks))
 	fCheckpoints := make([]*ethpb.Checkpoint, len(blks))
 	sigSet := &bls.SignatureSet{
-		Signatures: []bls.Signature{},
+		Signatures: [][]byte{},
 		PublicKeys: []bls.PublicKey{},
 		Messages:   [][32]byte{},
 	}
-	set := new(bls.SignatureSet)
+	var set *bls.SignatureSet
 	boundaries := make(map[[32]byte]*stateTrie.BeaconState)
 	for i, b := range blks {
 		set, preState, err = state.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
@@ -245,15 +254,15 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBl
 		// Save potential boundary states.
 		if helpers.IsEpochStart(preState.Slot()) {
 			boundaries[blockRoots[i]] = preState.Copy()
-			if err := s.handleEpochBoundary(preState); err != nil {
-				return nil, nil, fmt.Errorf("could not handle epoch boundary state")
+			if err := s.handleEpochBoundary(ctx, preState); err != nil {
+				return nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
 			}
 		}
 		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
 		fCheckpoints[i] = preState.FinalizedCheckpoint()
 		sigSet.Join(set)
 	}
-	verify, err := bls.VerifyMultipleSignatures(sigSet.Signatures, sigSet.Messages, sigSet.PublicKeys)
+	verify, err := sigSet.Verify()
 	if err != nil {
 		return nil, nil, err
 	}
@@ -280,7 +289,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBl
 // handles a block after the block's batch has been verified, where we can save blocks
 // their state summaries and split them off to relative hot/cold storage.
 func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed *ethpb.SignedBeaconBlock,
-	blockRoot [32]byte, fCheckpoint *ethpb.Checkpoint, jCheckpoint *ethpb.Checkpoint) error {
+	blockRoot [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	b := signed.Block
 
 	s.saveInitSyncBlock(blockRoot, signed)
@@ -313,11 +322,16 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed *ethpb
 }
 
 // Epoch boundary bookkeeping such as logging epoch summaries.
-func (s *Service) handleEpochBoundary(postState *stateTrie.BeaconState) error {
+func (s *Service) handleEpochBoundary(ctx context.Context, postState *stateTrie.BeaconState) error {
 	if postState.Slot() >= s.nextEpochBoundarySlot {
-		reportEpochMetrics(postState)
-		s.nextEpochBoundarySlot = helpers.StartSlot(helpers.NextEpoch(postState))
-
+		if err := reportEpochMetrics(ctx, postState, s.head.state); err != nil {
+			return err
+		}
+		var err error
+		s.nextEpochBoundarySlot, err = helpers.StartSlot(helpers.NextEpoch(postState))
+		if err != nil {
+			return err
+		}
 		// Update committees cache at epoch boundary slot.
 		if err := helpers.UpdateCommitteeCache(postState, helpers.CurrentEpoch(postState)); err != nil {
 			return err
@@ -351,7 +365,7 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 }
 
 func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk *ethpb.BeaconBlock,
-	root [32]byte, fCheckpoint *ethpb.Checkpoint, jCheckpoint *ethpb.Checkpoint) error {
+	root [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}

beacon-chain/blockchain/process_block_helpers.go

@@ -9,30 +9,23 @@ import (
 	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/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/roughtime"
 	"github.com/prysmaticlabs/prysm/shared/traceutil"
 	"go.opencensus.io/trace"
 )
 
 // CurrentSlot returns the current slot based on time.
 func (s *Service) CurrentSlot() uint64 {
-	now := roughtime.Now().Unix()
-	genesis := s.genesisTime.Unix()
-	if now < genesis {
-		return 0
-	}
-	return uint64(now-genesis) / params.BeaconConfig().SecondsPerSlot
+	return helpers.CurrentSlot(uint64(s.genesisTime.Unix()))
 }
 
 // getBlockPreState returns the pre state of an incoming block. It uses the parent root of the block
 // to retrieve the state in DB. It verifies the pre state's validity and the incoming block
 // is in the correct time window.
 func (s *Service) getBlockPreState(ctx context.Context, b *ethpb.BeaconBlock) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "forkChoice.getBlockPreState")
+	ctx, span := trace.StartSpan(ctx, "blockChain.getBlockPreState")
 	defer span.End()
 
 	// Verify incoming block has a valid pre state.
@@ -49,12 +42,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b *ethpb.BeaconBlock) (*
 	}
 
 	// Verify block slot time is not from the future.
-	if err := helpers.VerifySlotTime(helpers.GenesisTime(preState), b.Slot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
-		return nil, err
-	}
-
-	// Verify block is a descendent of a finalized block.
-	if err := s.VerifyBlkDescendant(ctx, bytesutil.ToBytes32(b.ParentRoot)); err != nil {
+	if err := helpers.VerifySlotTime(preState.GenesisTime(), b.Slot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return nil, err
 	}
 
@@ -68,7 +56,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b *ethpb.BeaconBlock) (*
 
 // verifyBlkPreState validates input block has a valid pre-state.
 func (s *Service) verifyBlkPreState(ctx context.Context, b *ethpb.BeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "chainService.verifyBlkPreState")
+	ctx, span := trace.StartSpan(ctx, "blockChain.verifyBlkPreState")
 	defer span.End()
 
 	parentRoot := bytesutil.ToBytes32(b.ParentRoot)
@@ -78,6 +66,11 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b *ethpb.BeaconBlock) e
 	if !s.stateGen.StateSummaryExists(ctx, parentRoot) && !s.beaconDB.HasBlock(ctx, parentRoot) {
 		return errors.New("could not reconstruct parent state")
 	}
+
+	if err := s.VerifyBlkDescendant(ctx, bytesutil.ToBytes32(b.ParentRoot)); err != nil {
+		return err
+	}
+
 	has, err := s.stateGen.HasState(ctx, parentRoot)
 	if err != nil {
 		return err
@@ -94,7 +87,7 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b *ethpb.BeaconBlock) e
 // VerifyBlkDescendant validates input block root is a descendant of the
 // current finalized block root.
 func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "forkChoice.VerifyBlkDescendant")
+	ctx, span := trace.StartSpan(ctx, "blockChain.VerifyBlkDescendant")
 	defer span.End()
 	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.finalizedCheckpt.Root))
 	finalizedBlkSigned, err := s.beaconDB.Block(ctx, fRoot)
@@ -126,7 +119,10 @@ func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error
 // verifyBlkFinalizedSlot validates input block is not less than or equal
 // to current finalized slot.
 func (s *Service) verifyBlkFinalizedSlot(b *ethpb.BeaconBlock) error {
-	finalizedSlot := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+	finalizedSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+	if err != nil {
+		return err
+	}
 	if finalizedSlot >= b.Slot {
 		return fmt.Errorf("block is equal or earlier than finalized block, slot %d < slot %d", b.Slot, finalizedSlot)
 	}
@@ -157,7 +153,11 @@ func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustified
 	}
 
 	newJustifiedBlock := newJustifiedBlockSigned.Block
-	if newJustifiedBlock.Slot <= helpers.StartSlot(s.justifiedCheckpt.Epoch) {
+	jSlot, err := helpers.StartSlot(s.justifiedCheckpt.Epoch)
+	if err != nil {
+		return false, err
+	}
+	if newJustifiedBlock.Slot <= jSlot {
 		return false, nil
 	}
 	var justifiedBlockSigned *ethpb.SignedBeaconBlock
@@ -227,6 +227,10 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 	}
 	s.clearInitSyncBlocks()
 
+	if err := s.beaconDB.SaveFinalizedCheckpoint(ctx, cp); err != nil {
+		return err
+	}
+
 	s.prevFinalizedCheckpt = s.finalizedCheckpt
 	s.finalizedCheckpt = cp
 
@@ -235,9 +239,7 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 		return errors.Wrap(err, "could not migrate to cold")
 	}
 
-	s.attPool.ClearSeenAtts()
-
-	return s.beaconDB.SaveFinalizedCheckpoint(ctx, cp)
+	return nil
 }
 
 // ancestor returns the block root of an ancestry block from the input block root.
@@ -253,7 +255,39 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 //        # root is older than queried slot, thus a skip slot. Return most recent root prior to slot
 //        return root
 func (s *Service) ancestor(ctx context.Context, root []byte, slot uint64) ([]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "forkChoice.ancestor")
+	ctx, span := trace.StartSpan(ctx, "blockChain.ancestor")
+	defer span.End()
+
+	r := bytesutil.ToBytes32(root)
+	// Get ancestor root from fork choice store instead of recursively looking up blocks in DB.
+	// This is most optimal outcome.
+	ar, err := s.ancestorByForkChoiceStore(ctx, r, slot)
+	if err != nil {
+		// Try getting ancestor root from DB when failed to retrieve from fork choice store.
+		// This is the second line of defense for retrieving ancestor root.
+		ar, err = s.ancestorByDB(ctx, r, slot)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return ar, nil
+}
+
+// This retrieves an ancestor root using fork choice store. The look up is looping through the a flat array structure.
+func (s *Service) ancestorByForkChoiceStore(ctx context.Context, r [32]byte, slot uint64) ([]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.ancestorByForkChoiceStore")
+	defer span.End()
+
+	if !s.forkChoiceStore.HasParent(r) {
+		return nil, errors.New("could not find root in fork choice store")
+	}
+	return s.forkChoiceStore.AncestorRoot(ctx, r, slot)
+}
+
+// This retrieves an ancestor root using DB. The look up is recursively looking up DB. Slower than `ancestorByForkChoiceStore`.
+func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot uint64) ([]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.ancestorByDB")
 	defer span.End()
 
 	// Stop recursive ancestry lookup if context is cancelled.
@@ -261,13 +295,6 @@ func (s *Service) ancestor(ctx context.Context, root []byte, slot uint64) ([]byt
 		return nil, ctx.Err()
 	}
 
-	r := bytesutil.ToBytes32(root)
-	// Get ancestor root from fork choice store instead of recursively looking up blocks in DB.
-	// This is most optimal outcome.
-	if s.forkChoiceStore.HasParent(r) {
-		return s.forkChoiceStore.AncestorRoot(ctx, r, slot)
-	}
-
 	signed, err := s.beaconDB.Block(ctx, r)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get ancestor block")
@@ -282,10 +309,10 @@ func (s *Service) ancestor(ctx context.Context, root []byte, slot uint64) ([]byt
 	}
 	b := signed.Block
 	if b.Slot == slot || b.Slot < slot {
-		return root, nil
+		return r[:], nil
 	}
 
-	return s.ancestor(ctx, b.ParentRoot, slot)
+	return s.ancestorByDB(ctx, bytesutil.ToBytes32(b.ParentRoot), slot)
 }
 
 // This updates justified check point in store, if the new justified is later than stored justified or
@@ -308,14 +335,14 @@ func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state *state
 	if !attestationutil.CheckPointIsEqual(s.justifiedCheckpt, state.CurrentJustifiedCheckpoint()) {
 		if state.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
 			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
-			if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
-				return err
-			}
-			return nil
+			return s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
 		}
 
 		// Update justified if store justified is not in chain with finalized check point.
-		finalizedSlot := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+		finalizedSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+		if err != nil {
+			return err
+		}
 		justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))
 		anc, err := s.ancestor(ctx, justifiedRoot[:], finalizedSlot)
 		if err != nil {
@@ -334,13 +361,17 @@ func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state *state
 // This retrieves missing blocks from DB (ie. the blocks that couldn't be received over sync) and inserts them to fork choice store.
 // This is useful for block tree visualizer and additional vote accounting.
 func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk *ethpb.BeaconBlock,
-	fCheckpoint *ethpb.Checkpoint, jCheckpoint *ethpb.Checkpoint) error {
+	fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	pendingNodes := make([]*ethpb.BeaconBlock, 0)
 
 	parentRoot := bytesutil.ToBytes32(blk.ParentRoot)
 	slot := blk.Slot
 	// Fork choice only matters from last finalized slot.
-	higherThanFinalized := slot > helpers.StartSlot(s.finalizedCheckpt.Epoch)
+	fSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+	if err != nil {
+		return err
+	}
+	higherThanFinalized := slot > fSlot
 	// As long as parent node is not in fork choice store, and parent node is in DB.
 	for !s.forkChoiceStore.HasNode(parentRoot) && s.beaconDB.HasBlock(ctx, parentRoot) && higherThanFinalized {
 		b, err := s.beaconDB.Block(ctx, parentRoot)
@@ -351,14 +382,14 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk *ethpb.
 		pendingNodes = append(pendingNodes, b.Block)
 		parentRoot = bytesutil.ToBytes32(b.Block.ParentRoot)
 		slot = b.Block.Slot
-		higherThanFinalized = slot > helpers.StartSlot(s.finalizedCheckpt.Epoch)
+		higherThanFinalized = slot > fSlot
 	}
 
 	// Insert parent nodes to fork choice store in reverse order.
 	// Lower slots should be at the end of the list.
 	for i := len(pendingNodes) - 1; i >= 0; i-- {
 		b := pendingNodes[i]
-		r, err := stateutil.BlockRoot(b)
+		r, err := b.HashTreeRoot()
 		if err != nil {
 			return err
 		}

beacon-chain/blockchain/process_block_test.go

@@ -2,12 +2,11 @@ package blockchain
 
 import (
 	"context"
-	"strings"
 	"testing"
 	"time"
 
+	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
@@ -16,16 +15,14 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/roughtime"
 	"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_OnBlock(t *testing.T) {
@@ -42,50 +39,66 @@ func TestStore_OnBlock(t *testing.T) {
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
 	assert.NoError(t, db.SaveBlock(ctx, genesis))
-	validGenesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st := testutil.NewBeaconState()
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 	roots, err := blockTree1(db, validGenesisRoot[:])
 	require.NoError(t, err)
-	random := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1, ParentRoot: validGenesisRoot[:]}}
+	random := testutil.NewBeaconBlock()
+	random.Block.Slot = 1
+	random.Block.ParentRoot = validGenesisRoot[:]
 	assert.NoError(t, db.SaveBlock(ctx, random))
-	randomParentRoot, err := stateutil.BlockRoot(random.Block)
+	randomParentRoot, err := random.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), randomParentRoot))
 	randomParentRoot2 := roots[1]
-	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot2[:]}))
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot2}))
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), bytesutil.ToBytes32(randomParentRoot2)))
 
 	tests := []struct {
 		name          string
-		blk           *ethpb.BeaconBlock
+		blk           *ethpb.SignedBeaconBlock
 		s             *stateTrie.BeaconState
 		time          uint64
 		wantErrString string
 	}{
 		{
 			name:          "parent block root does not have a state",
-			blk:           &ethpb.BeaconBlock{},
+			blk:           testutil.NewBeaconBlock(),
 			s:             st.Copy(),
 			wantErrString: "could not reconstruct parent state",
 		},
 		{
-			name:          "block is from the future",
-			blk:           &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:], Slot: params.BeaconConfig().FarFutureEpoch},
+			name: "block is from the future",
+			blk: func() *ethpb.SignedBeaconBlock {
+				b := testutil.NewBeaconBlock()
+				b.Block.ParentRoot = randomParentRoot2
+				b.Block.Slot = params.BeaconConfig().FarFutureEpoch
+				return b
+			}(),
 			s:             st.Copy(),
-			wantErrString: "far distant future",
+			wantErrString: "is in the far distant future",
 		},
 		{
-			name:          "could not get finalized block",
-			blk:           &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:]},
+			name: "could not get finalized block",
+			blk: func() *ethpb.SignedBeaconBlock {
+				b := testutil.NewBeaconBlock()
+				b.Block.ParentRoot = randomParentRoot[:]
+				return b
+			}(),
 			s:             st.Copy(),
 			wantErrString: "is not a descendent of the current finalized block",
 		},
 		{
-			name:          "same slot as finalized block",
-			blk:           &ethpb.BeaconBlock{Slot: 0, ParentRoot: randomParentRoot2},
+			name: "same slot as finalized block",
+			blk: func() *ethpb.SignedBeaconBlock {
+				b := testutil.NewBeaconBlock()
+				b.Block.Slot = 0
+				b.Block.ParentRoot = randomParentRoot2
+				return b
+			}(),
 			s:             st.Copy(),
 			wantErrString: "block is equal or earlier than finalized block, slot 0 < slot 0",
 		},
@@ -99,9 +112,9 @@ func TestStore_OnBlock(t *testing.T) {
 			service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
 			service.finalizedCheckpt.Root = roots[0]
 
-			root, err := stateutil.BlockRoot(tt.blk)
+			root, err := tt.blk.Block.HashTreeRoot()
 			assert.NoError(t, err)
-			err = service.onBlock(ctx, &ethpb.SignedBeaconBlock{Block: tt.blk}, root)
+			err = service.onBlock(ctx, tt.blk, root)
 			assert.ErrorContains(t, tt.wantErrString, err)
 		})
 	}
@@ -121,13 +134,20 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
 	assert.NoError(t, db.SaveBlock(ctx, genesis))
+	gRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	service.finalizedCheckpt = &ethpb.Checkpoint{
+		Root: gRoot[:],
+	}
+	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{})
+	service.saveInitSyncBlock(gRoot, genesis)
 
 	st, keys := testutil.DeterministicGenesisState(t, 64)
 
 	bState := st.Copy()
 
-	blks := []*ethpb.SignedBeaconBlock{}
-	blkRoots := [][32]byte{}
+	var blks []*ethpb.SignedBeaconBlock
+	var blkRoots [][32]byte
 	var firstState *stateTrie.BeaconState
 	for i := 1; i < 10; i++ {
 		b, err := testutil.GenerateFullBlock(bState, keys, testutil.DefaultBlockGenConfig(), uint64(i))
@@ -137,11 +157,14 @@ func TestStore_OnBlockBatch(t *testing.T) {
 		if i == 1 {
 			firstState = bState.Copy()
 		}
-		root, err := stateutil.BlockRoot(b.Block)
+		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
+		service.saveInitSyncBlock(root, b)
 		blks = append(blks, b)
 		blkRoots = append(blkRoots, root)
 	}
+
+	blks[0].Block.ParentRoot = gRoot[:]
 	require.NoError(t, db.SaveBlock(context.Background(), blks[0]))
 	require.NoError(t, service.stateGen.SaveState(ctx, blkRoots[0], firstState))
 	_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
@@ -159,17 +182,17 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	require.NoError(t, err)
 	service.genesisTime = time.Now()
 
-	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{})
+	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: make([]byte, 32)})
 	require.NoError(t, err)
 	assert.Equal(t, true, update, "Should be able to update justified")
 	lastJustifiedBlk := testutil.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
-	lastJustifiedRoot, err := stateutil.BlockRoot(lastJustifiedBlk.Block)
+	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	newJustifiedBlk := testutil.NewBeaconBlock()
 	newJustifiedBlk.Block.Slot = 1
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
-	newJustifiedRoot, err := stateutil.BlockRoot(newJustifiedBlk.Block)
+	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, newJustifiedBlk))
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, lastJustifiedBlk))
@@ -193,11 +216,11 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	require.NoError(t, err)
 	lastJustifiedBlk := testutil.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
-	lastJustifiedRoot, err := stateutil.BlockRoot(lastJustifiedBlk.Block)
+	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	newJustifiedBlk := testutil.NewBeaconBlock()
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
-	newJustifiedRoot, err := stateutil.BlockRoot(newJustifiedBlk.Block)
+	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, newJustifiedBlk))
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, lastJustifiedBlk))
@@ -212,9 +235,6 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 }
 
 func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
-	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{NewStateMgmt: true})
-	defer resetCfg()
-
 	ctx := context.Background()
 	db, sc := testDB.SetupDB(t)
 
@@ -227,17 +247,27 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 
 	s, err := stateTrie.InitializeFromProto(&pb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
 	require.NoError(t, err)
-	r := [32]byte{'A'}
-	b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
-	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: r[:]}))
-	require.NoError(t, service.stateGen.SaveState(ctx, r, s))
-	require.NoError(t, service.verifyBlkPreState(ctx, b))
+
+	genesisStateRoot := [32]byte{}
+	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
+	assert.NoError(t, db.SaveBlock(ctx, genesis))
+	gRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	service.finalizedCheckpt = &ethpb.Checkpoint{
+		Root: gRoot[:],
+	}
+	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{})
+	service.saveInitSyncBlock(gRoot, genesis)
+
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 1
+	b.Block.ParentRoot = gRoot[:]
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: gRoot[:]}))
+	require.NoError(t, service.stateGen.SaveState(ctx, gRoot, s))
+	require.NoError(t, service.verifyBlkPreState(ctx, b.Block))
 }
 
 func TestCachedPreState_CanGetFromDB(t *testing.T) {
-	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{NewStateMgmt: true})
-	defer resetCfg()
-
 	ctx := context.Background()
 	db, sc := testDB.SetupDB(t)
 
@@ -248,19 +278,30 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	r := [32]byte{'A'}
-	b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
+	genesisStateRoot := [32]byte{}
+	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
+	assert.NoError(t, db.SaveBlock(ctx, genesis))
+	gRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	service.finalizedCheckpt = &ethpb.Checkpoint{
+		Root: gRoot[:],
+	}
+	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{})
+	service.saveInitSyncBlock(gRoot, genesis)
 
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	err = service.verifyBlkPreState(ctx, b)
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 1
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	err = service.verifyBlkPreState(ctx, b.Block)
 	wanted := "could not reconstruct parent state"
 	assert.ErrorContains(t, wanted, err)
 
+	b.Block.ParentRoot = gRoot[:]
 	s, err := stateTrie.InitializeFromProto(&pb.BeaconState{Slot: 1})
 	require.NoError(t, err)
-	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: r[:]}))
-	require.NoError(t, service.stateGen.SaveState(ctx, r, s))
-	require.NoError(t, service.verifyBlkPreState(ctx, b))
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: gRoot[:]}))
+	require.NoError(t, service.stateGen.SaveState(ctx, gRoot, s))
+	require.NoError(t, service.verifyBlkPreState(ctx, b.Block))
 }
 
 func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
@@ -271,14 +312,13 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	signedBlock := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
+	signedBlock := testutil.NewBeaconBlock()
 	require.NoError(t, db.SaveBlock(ctx, signedBlock))
-	r, err := stateutil.BlockRoot(signedBlock.Block)
+	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()
-	service.initSyncState[r] = st.Copy()
 	require.NoError(t, db.SaveState(ctx, st.Copy(), r))
 
 	// Could update
@@ -303,12 +343,12 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
-	service.finalizedCheckpt = &ethpb.Checkpoint{}
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
 	require.NoError(t, db.SaveBlock(ctx, genesis))
-	validGenesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st := testutil.NewBeaconState()
 
@@ -317,10 +357,12 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
-	block := &ethpb.BeaconBlock{Slot: 9, ParentRoot: roots[8], Body: &ethpb.BeaconBlockBody{Graffiti: []byte{}}}
+	block := testutil.NewBeaconBlock()
+	block.Block.Slot = 9
+	block.Block.ParentRoot = roots[8]
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), block, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), block.Block, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -344,22 +386,27 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
 	assert.NoError(t, db.SaveBlock(ctx, genesis))
-	validGenesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	st := testutil.NewBeaconState()
 
 	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 
 	// Define a tree branch, slot 63 <- 64 <- 65
-	b63 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 63, Body: &ethpb.BeaconBlockBody{}}}
+	b63 := testutil.NewBeaconBlock()
+	b63.Block.Slot = 63
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b63))
-	r63, err := stateutil.BlockRoot(b63.Block)
+	r63, err := b63.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b64 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 64, ParentRoot: r63[:], Body: &ethpb.BeaconBlockBody{}}}
+	b64 := testutil.NewBeaconBlock()
+	b64.Block.Slot = 64
+	b64.Block.ParentRoot = r63[:]
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b64))
-	r64, err := stateutil.BlockRoot(b64.Block)
+	r64, err := b64.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b65 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 65, ParentRoot: r64[:], Body: &ethpb.BeaconBlockBody{}}}
+	b65 := testutil.NewBeaconBlock()
+	b65.Block.Slot = 65
+	b65.Block.ParentRoot = r64[:]
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, b65))
 
 	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
@@ -380,58 +427,74 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 //    \- B3 - B4 - B6 - B8
 // (B1, and B3 are all from the same slots)
 func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
-	b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
-	r0, err := ssz.HashTreeRoot(b0)
+	genesisRoot = bytesutil.PadTo(genesisRoot, 32)
+	b0 := testutil.NewBeaconBlock()
+	b0.Block.Slot = 0
+	b0.Block.ParentRoot = genesisRoot
+	r0, err := b0.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
-	r1, err := ssz.HashTreeRoot(b1)
+	b1 := testutil.NewBeaconBlock()
+	b1.Block.Slot = 1
+	b1.Block.ParentRoot = r0[:]
+	r1, err := b1.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: r0[:]}
-	r3, err := ssz.HashTreeRoot(b3)
+	b3 := testutil.NewBeaconBlock()
+	b3.Block.Slot = 3
+	b3.Block.ParentRoot = r0[:]
+	r3, err := b3.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b4 := &ethpb.BeaconBlock{Slot: 4, ParentRoot: r3[:]}
-	r4, err := ssz.HashTreeRoot(b4)
+	b4 := testutil.NewBeaconBlock()
+	b4.Block.Slot = 4
+	b4.Block.ParentRoot = r3[:]
+	r4, err := b4.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b5 := &ethpb.BeaconBlock{Slot: 5, ParentRoot: r4[:]}
-	r5, err := ssz.HashTreeRoot(b5)
+	b5 := testutil.NewBeaconBlock()
+	b5.Block.Slot = 5
+	b5.Block.ParentRoot = r4[:]
+	r5, err := b5.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b6 := &ethpb.BeaconBlock{Slot: 6, ParentRoot: r4[:]}
-	r6, err := ssz.HashTreeRoot(b6)
+	b6 := testutil.NewBeaconBlock()
+	b6.Block.Slot = 6
+	b6.Block.ParentRoot = r4[:]
+	r6, err := b6.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b7 := &ethpb.BeaconBlock{Slot: 7, ParentRoot: r5[:]}
-	r7, err := ssz.HashTreeRoot(b7)
+	b7 := testutil.NewBeaconBlock()
+	b7.Block.Slot = 7
+	b7.Block.ParentRoot = r5[:]
+	r7, err := b7.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b8 := &ethpb.BeaconBlock{Slot: 8, ParentRoot: r6[:]}
-	r8, err := ssz.HashTreeRoot(b8)
+	b8 := testutil.NewBeaconBlock()
+	b8.Block.Slot = 8
+	b8.Block.ParentRoot = r6[:]
+	r8, err := b8.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
 	st := testutil.NewBeaconState()
 
-	for _, b := range []*ethpb.BeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
+	for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
 		beaconBlock := testutil.NewBeaconBlock()
-		beaconBlock.Block.Slot = b.Slot
-		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
-		beaconBlock.Block.Body = &ethpb.BeaconBlockBody{}
+		beaconBlock.Block.Slot = b.Block.Slot
+		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
 			return nil, err
 		}
 		if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "could not save state")
 		}
 	}
 	if err := db.SaveState(context.Background(), st.Copy(), r1); err != nil {
@@ -447,11 +510,20 @@ func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
 }
 
 func TestCurrentSlot_HandlesOverflow(t *testing.T) {
-	svc := Service{genesisTime: roughtime.Now().Add(1 * time.Hour)}
+	svc := Service{genesisTime: timeutils.Now().Add(1 * time.Hour)}
 
 	slot := svc.CurrentSlot()
 	require.Equal(t, uint64(0), slot, "Unexpected slot")
 }
+func TestAncestorByDB_CtxErr(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	service, err := NewService(ctx, &Config{})
+	require.NoError(t, err)
+
+	cancel()
+	_, err = service.ancestorByDB(ctx, [32]byte{}, 0)
+	require.ErrorContains(t, "context canceled", err)
+}
 
 func TestAncestor_HandleSkipSlot(t *testing.T) {
 	ctx := context.Background()
@@ -461,20 +533,25 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: []byte{'a'}}
-	r1, err := ssz.HashTreeRoot(b1)
+	b1 := testutil.NewBeaconBlock()
+	b1.Block.Slot = 1
+	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
+	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b100 := &ethpb.BeaconBlock{Slot: 100, ParentRoot: r1[:]}
-	r100, err := ssz.HashTreeRoot(b100)
+	b100 := testutil.NewBeaconBlock()
+	b100.Block.Slot = 100
+	b100.Block.ParentRoot = r1[:]
+	r100, err := b100.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b200 := &ethpb.BeaconBlock{Slot: 200, ParentRoot: r100[:]}
-	r200, err := ssz.HashTreeRoot(b200)
+	b200 := testutil.NewBeaconBlock()
+	b200.Block.Slot = 200
+	b200.Block.ParentRoot = r100[:]
+	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
-	for _, b := range []*ethpb.BeaconBlock{b1, b100, b200} {
+	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
 		beaconBlock := testutil.NewBeaconBlock()
-		beaconBlock.Block.Slot = b.Slot
-		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
-		beaconBlock.Block.Body = &ethpb.BeaconBlockBody{}
+		beaconBlock.Block.Slot = b.Block.Slot
+		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		require.NoError(t, db.SaveBlock(context.Background(), beaconBlock))
 	}
 
@@ -493,6 +570,82 @@ 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)
+	require.NoError(t, err)
+
+	b1 := testutil.NewBeaconBlock()
+	b1.Block.Slot = 1
+	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
+	r1, err := b1.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b100 := testutil.NewBeaconBlock()
+	b100.Block.Slot = 100
+	b100.Block.ParentRoot = r1[:]
+	r100, err := b100.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b200 := testutil.NewBeaconBlock()
+	b200.Block.Slot = 200
+	b200.Block.ParentRoot = r100[:]
+	r200, err := b200.Block.HashTreeRoot()
+	require.NoError(t, err)
+	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
+		beaconBlock := testutil.NewBeaconBlock()
+		beaconBlock.Block.Slot = b.Block.Slot
+		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
+		r, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), [32]byte{}, 0, 0)) // Saves blocks to fork choice store.
+	}
+
+	r, err := service.ancestor(context.Background(), r200[:], 150)
+	require.NoError(t, err)
+	if bytesutil.ToBytes32(r) != r100 {
+		t.Error("Did not get correct root")
+	}
+}
+
+func TestAncestor_CanUseDB(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)
+
+	b1 := testutil.NewBeaconBlock()
+	b1.Block.Slot = 1
+	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
+	r1, err := b1.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b100 := testutil.NewBeaconBlock()
+	b100.Block.Slot = 100
+	b100.Block.ParentRoot = r1[:]
+	r100, err := b100.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b200 := testutil.NewBeaconBlock()
+	b200.Block.Slot = 200
+	b200.Block.ParentRoot = r100[:]
+	r200, err := b200.Block.HashTreeRoot()
+	require.NoError(t, err)
+	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
+		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, service.forkChoiceStore.ProcessBlock(context.Background(), 200, r200, r200, [32]byte{}, 0, 0))
+
+	r, err := service.ancestor(context.Background(), r200[:], 150)
+	require.NoError(t, err)
+	if bytesutil.ToBytes32(r) != r100 {
+		t.Error("Did not get correct root")
+	}
+}
+
 func TestEnsureRootNotZeroHashes(t *testing.T) {
 	ctx := context.Background()
 	cfg := &Config{}
@@ -557,16 +710,20 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		require.NoError(t, service.beaconDB.SaveState(ctx, genesisState, bytesutil.ToBytes32(test.want.Root)))
 
 		if test.args.diffFinalizedCheckPoint {
-			b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: []byte{'a'}}
-			r1, err := ssz.HashTreeRoot(b1)
+			b1 := testutil.NewBeaconBlock()
+			b1.Block.Slot = 1
+			b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
+			r1, err := b1.Block.HashTreeRoot()
 			require.NoError(t, err)
-			b100 := &ethpb.BeaconBlock{Slot: 100, ParentRoot: r1[:]}
-			r100, err := ssz.HashTreeRoot(b100)
+			b100 := testutil.NewBeaconBlock()
+			b100.Block.Slot = 100
+			b100.Block.ParentRoot = r1[:]
+			r100, err := b100.Block.HashTreeRoot()
 			require.NoError(t, err)
-			for _, b := range []*ethpb.BeaconBlock{b1, b100} {
+			for _, b := range []*ethpb.SignedBeaconBlock{b1, b100} {
 				beaconBlock := testutil.NewBeaconBlock()
-				beaconBlock.Block.Slot = b.Slot
-				beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
+				beaconBlock.Block.Slot = b.Block.Slot
+				beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 				require.NoError(t, service.beaconDB.SaveBlock(context.Background(), beaconBlock))
 			}
 			service.finalizedCheckpt = &ethpb.Checkpoint{Root: []byte{'c'}, Epoch: 1}
@@ -584,14 +741,14 @@ func TestVerifyBlkDescendant(t *testing.T) {
 
 	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 1
-	r, err := stateutil.BlockRoot(b.Block)
+	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, b))
 
 	b1 := testutil.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32)
-	r1, err := stateutil.BlockRoot(b1.Block)
+	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, b1))
 
@@ -601,18 +758,16 @@ func TestVerifyBlkDescendant(t *testing.T) {
 		finalizedSlot uint64
 	}
 	tests := []struct {
-		name        string
-		args        args
-		shouldError bool
-		err         string
+		name      string
+		args      args
+		wantedErr string
 	}{
 		{
 			name: "could not get finalized block in block service cache",
 			args: args{
 				finalizedRoot: [32]byte{'a'},
 			},
-			shouldError: true,
-			err:         "nil finalized block",
+			wantedErr: "nil finalized block",
 		},
 		{
 			name: "could not get finalized block root in DB",
@@ -620,8 +775,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 				finalizedRoot: r,
 				parentRoot:    [32]byte{'a'},
 			},
-			shouldError: true,
-			err:         "could not get finalized block root",
+			wantedErr: "could not get finalized block root",
 		},
 		{
 			name: "is not descendant",
@@ -629,8 +783,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 				finalizedRoot: r1,
 				parentRoot:    r,
 			},
-			shouldError: true,
-			err:         "is not a descendent of the current finalized block slot",
+			wantedErr: "is not a descendent of the current finalized block slot",
 		},
 		{
 			name: "is descendant",
@@ -638,22 +791,19 @@ func TestVerifyBlkDescendant(t *testing.T) {
 				finalizedRoot: r,
 				parentRoot:    r,
 			},
-			shouldError: false,
 		},
 	}
-	for _, test := range tests {
+	for _, tt := range tests {
 		service, err := NewService(ctx, &Config{BeaconDB: db, StateGen: stategen.New(db, sc), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
 		require.NoError(t, err)
 		service.finalizedCheckpt = &ethpb.Checkpoint{
-			Root: test.args.finalizedRoot[:],
+			Root: tt.args.finalizedRoot[:],
 		}
-		err = service.VerifyBlkDescendant(ctx, test.args.parentRoot)
-		if test.shouldError {
-			if err == nil || !strings.Contains(err.Error(), test.err) {
-				t.Error("Did not get wanted error")
-			}
+		err = service.VerifyBlkDescendant(ctx, tt.args.parentRoot)
+		if tt.wantedErr != "" {
+			assert.ErrorContains(t, tt.wantedErr, err)
 		} else if err != nil {
-			t.Error(err)
+			assert.NoError(t, err)
 		}
 	}
 }
@@ -665,8 +815,8 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
-	gRoot, err := stateutil.BlockRoot(gBlk.Block)
+	gBlk := testutil.NewBeaconBlock()
+	gRoot, err := gBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, service.beaconDB.SaveBlock(ctx, gBlk))
 	require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
@@ -683,8 +833,18 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	assert.DeepEqual(t, currentCp, service.prevJustifiedCheckpt, "Incorrect previous justified checkpoint")
 	assert.DeepEqual(t, newCp, service.CurrentJustifiedCheckpt(), "Incorrect current justified checkpoint in cache")
 	cp, err := service.beaconDB.JustifiedCheckpoint(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	assert.DeepEqual(t, newCp, cp, "Incorrect current justified checkpoint in db")
 }
+
+func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
+	ctx := context.Background()
+	cfg := &Config{}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	s := testutil.NewBeaconState()
+	require.NoError(t, s.SetSlot(1))
+	service.head = &head{}
+	require.ErrorContains(t, "failed to initialize precompute: nil inner state", service.handleEpochBoundary(ctx, s))
+}

beacon-chain/blockchain/receive_attestation.go

@@ -1,19 +1,17 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 
 	"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/feed"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/roughtime"
 	"github.com/prysmaticlabs/prysm/shared/slotutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -22,8 +20,9 @@ import (
 // AttestationReceiver interface defines the methods of chain service receive and processing new attestations.
 type AttestationReceiver interface {
 	ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation) error
-	IsValidAttestation(ctx context.Context, att *ethpb.Attestation) bool
 	AttestationPreState(ctx context.Context, att *ethpb.Attestation) (*state.BeaconState, error)
+	VerifyLmdFfgConsistency(ctx context.Context, att *ethpb.Attestation) error
+	VerifyFinalizedConsistency(ctx context.Context, root []byte) error
 }
 
 // ReceiveAttestationNoPubsub is a function that defines the operations that are performed on
@@ -40,40 +39,57 @@ func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Att
 		return errors.Wrap(err, "could not process attestation")
 	}
 
-	if !featureconfig.Get().DisableUpdateHeadPerAttestation {
-		// This updates fork choice head, if a new head could not be updated due to
-		// long range or intermediate forking. It simply logs a warning and returns nil
-		// as that's more appropriate than returning errors.
-		if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
-			log.Warnf("Resolving fork due to new attestation: %v", err)
-			return nil
-		}
+	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
+		log.Warnf("Resolving fork due to new attestation: %v", err)
+		return nil
 	}
 
 	return nil
 }
 
-// IsValidAttestation returns true if the attestation can be verified against its pre-state.
-func (s *Service) IsValidAttestation(ctx context.Context, att *ethpb.Attestation) bool {
-	baseState, err := s.AttestationPreState(ctx, att)
-	if err != nil {
-		log.WithError(err).Error("Failed to get attestation pre state")
-		return false
-	}
-
-	if err := blocks.VerifyAttestation(ctx, baseState, att); err != nil {
-		log.WithError(err).Error("Failed to validate attestation")
-		return false
-	}
-
-	return true
-}
-
 // AttestationPreState returns the pre state of attestation.
 func (s *Service) AttestationPreState(ctx context.Context, att *ethpb.Attestation) (*state.BeaconState, error) {
+	ss, err := helpers.StartSlot(att.Data.Target.Epoch)
+	if err != nil {
+		return nil, err
+	}
+	if err := helpers.ValidateSlotClock(ss, uint64(s.genesisTime.Unix())); err != nil {
+		return nil, err
+	}
 	return s.getAttPreState(ctx, att.Data.Target)
 }
 
+// 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)
+}
+
+// VerifyFinalizedConsistency verifies input root is consistent with finalized store.
+// When the input root is not be consistent with finalized store then we know it is not
+// on the finalized check point that leads to current canonical chain and should be rejected accordingly.
+func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) error {
+	// A canonical root implies the root to has an ancestor that aligns with finalized check point.
+	// In this case, we could exit early to save on additional computation.
+	if s.forkChoiceStore.IsCanonical(bytesutil.ToBytes32(root)) {
+		return nil
+	}
+
+	f := s.FinalizedCheckpt()
+	ss, err := helpers.StartSlot(f.Epoch)
+	if err != nil {
+		return err
+	}
+	r, err := s.ancestor(ctx, root, ss)
+	if err != nil {
+		return err
+	}
+	if !bytes.Equal(f.Root, r) {
+		return errors.New("Root and finalized store are not consistent")
+	}
+
+	return nil
+}
+
 // This processes attestations from the attestation pool to account for validator votes and fork choice.
 func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 	// Wait for state to be initialized.
@@ -89,7 +105,7 @@ func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 		case <-s.ctx.Done():
 			return
 		case <-st.C():
-			ctx := context.Background()
+			ctx := s.ctx
 			atts := s.attPool.ForkchoiceAttestations()
 			for _, a := range atts {
 				// Based on the spec, don't process the attestation until the subsequent slot.
@@ -110,7 +126,7 @@ func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 					log.WithError(err).Error("Could not delete fork choice attestation in pool")
 				}
 
-				if !s.verifyCheckpointEpoch(a.Data.Target) {
+				if !helpers.VerifyCheckpointEpoch(a.Data.Target, s.genesisTime) {
 					continue
 				}
 
@@ -127,23 +143,3 @@ func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 		}
 	}
 }
-
-// This verifies the epoch of input checkpoint is within current epoch and previous epoch
-// with respect to current time. Returns true if it's within, false if it's not.
-func (s *Service) verifyCheckpointEpoch(c *ethpb.Checkpoint) bool {
-	now := uint64(roughtime.Now().Unix())
-	genesisTime := uint64(s.genesisTime.Unix())
-	currentSlot := (now - genesisTime) / params.BeaconConfig().SecondsPerSlot
-	currentEpoch := helpers.SlotToEpoch(currentSlot)
-
-	var prevEpoch uint64
-	if currentEpoch > 1 {
-		prevEpoch = currentEpoch - 1
-	}
-
-	if c.Epoch != prevEpoch && c.Epoch != currentEpoch {
-		return false
-	}
-
-	return true
-}

beacon-chain/blockchain/receive_attestation_test.go

@@ -1,22 +1,25 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 	"time"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
-func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
+func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 	helpers.ClearCache()
 	db, sc := testDB.SetupDB(t)
 
 	chainService := setupBeaconChain(t, db, sc)
 	chainService.genesisTime = time.Now()
 
-	assert.Equal(t, true, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{}))
-	assert.Equal(t, false, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 1}))
+	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)
 }

beacon-chain/blockchain/receive_block.go

@@ -7,12 +7,16 @@ import (
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"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"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/traceutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
+// This defines how many epochs since finality the run time will begin to save hot state on to the DB.
+var epochsSinceFinalitySaveHotStateDB = 100
+
 // BlockReceiver interface defines the methods of chain service receive and processing new blocks.
 type BlockReceiver interface {
 	ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error
@@ -58,8 +62,13 @@ func (s *Service) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlo
 		return err
 	}
 
+	// Have we been finalizing? Should we start saving hot states to db?
+	if err := s.checkSaveHotStateDB(ctx); err != nil {
+		return err
+	}
+
 	// Reports on block and fork choice metrics.
-	reportSlotMetrics(blockCopy.Block.Slot, s.headSlot(), s.CurrentSlot(), s.finalizedCheckpt)
+	reportSlotMetrics(blockCopy.Block.Slot, s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 
 	// Log block sync status.
 	logBlockSyncStatus(blockCopy.Block, blockRoot, s.finalizedCheckpt)
@@ -95,7 +104,7 @@ func (s *Service) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.Sign
 	})
 
 	// Reports on blockCopy and fork choice metrics.
-	reportSlotMetrics(blockCopy.Block.Slot, s.headSlot(), s.CurrentSlot(), s.finalizedCheckpt)
+	reportSlotMetrics(blockCopy.Block.Slot, s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 
 	// Log state transition data.
 	log.WithFields(logrus.Fields{
@@ -139,7 +148,14 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []*ethpb.SignedB
 		})
 
 		// Reports on blockCopy and fork choice metrics.
-		reportSlotMetrics(blockCopy.Block.Slot, s.headSlot(), s.CurrentSlot(), s.finalizedCheckpt)
+		reportSlotMetrics(blockCopy.Block.Slot, s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
+	}
+
+	if err := s.VerifyWeakSubjectivityRoot(s.ctx); err != nil {
+		// log.Fatalf will prevent defer from being called
+		span.End()
+		// Exit run time if the node failed to verify weak subjectivity checkpoint.
+		log.Fatalf("Could not verify weak subjectivity checkpoint: %v", err)
 	}
 
 	return nil
@@ -172,3 +188,21 @@ func (s *Service) handlePostBlockOperations(b *ethpb.BeaconBlock) error {
 	}
 	return nil
 }
+
+// This checks whether it's time to start saving hot state to DB.
+// It's time when there's `epochsSinceFinalitySaveHotStateDB` epochs of non-finality.
+func (s *Service) checkSaveHotStateDB(ctx context.Context) error {
+	currentEpoch := helpers.SlotToEpoch(s.CurrentSlot())
+	// Prevent `sinceFinality` going underflow.
+	var sinceFinality uint64
+	if currentEpoch > s.finalizedCheckpt.Epoch {
+		sinceFinality = currentEpoch - s.finalizedCheckpt.Epoch
+	}
+
+	if sinceFinality >= uint64(epochsSinceFinalitySaveHotStateDB) {
+		s.stateGen.EnableSaveHotStateToDB(ctx)
+		return nil
+	}
+
+	return s.stateGen.DisableSaveHotStateToDB(ctx)
+}

beacon-chain/blockchain/receive_block_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"sync"
 	"testing"
+	"time"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	blockchainTesting "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
@@ -12,12 +13,12 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	"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"
+	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 func TestService_ReceiveBlock(t *testing.T) {
@@ -37,10 +38,10 @@ func TestService_ReceiveBlock(t *testing.T) {
 		block *ethpb.SignedBeaconBlock
 	}
 	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-		check   func(*testing.T, *Service)
+		name      string
+		args      args
+		wantedErr string
+		check     func(*testing.T, *Service)
 	}{
 		{
 			name: "applies block with state transition",
@@ -139,13 +140,16 @@ func TestService_ReceiveBlock(t *testing.T) {
 			require.NoError(t, s.saveGenesisData(ctx, genesis))
 			gBlk, err := s.beaconDB.GenesisBlock(ctx)
 			require.NoError(t, err)
-			gRoot, err := stateutil.BlockRoot(gBlk.Block)
-			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
-			root, err := stateutil.BlockRoot(tt.args.block.Block)
+			gRoot, err := gBlk.Block.HashTreeRoot()
 			require.NoError(t, err)
-			if err := s.ReceiveBlock(ctx, tt.args.block, root); (err != nil) != tt.wantErr {
-				t.Errorf("ReceiveBlock() error = %v, wantErr %v", err, tt.wantErr)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			root, err := tt.args.block.Block.HashTreeRoot()
+			require.NoError(t, err)
+			err = s.ReceiveBlock(ctx, tt.args.block, root)
+			if tt.wantedErr != "" {
+				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
+				assert.NoError(t, err)
 				tt.check(t, s)
 			}
 		})
@@ -177,9 +181,10 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	require.NoError(t, s.saveGenesisData(ctx, genesis))
 	gBlk, err := s.beaconDB.GenesisBlock(ctx)
 	require.NoError(t, err)
-	gRoot, err := stateutil.BlockRoot(gBlk.Block)
+	gRoot, err := gBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
 	s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
-	root, err := stateutil.BlockRoot(b.Block)
+	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wg := sync.WaitGroup{}
 	wg.Add(1)
@@ -201,9 +206,7 @@ func TestService_ReceiveBlockInitialSync(t *testing.T) {
 	genesis, keys := testutil.DeterministicGenesisState(t, 64)
 	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot uint64) *ethpb.SignedBeaconBlock {
 		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
-		if err != nil {
-			t.Error(err)
-		}
+		assert.NoError(t, err)
 		return blk
 	}
 
@@ -211,10 +214,10 @@ func TestService_ReceiveBlockInitialSync(t *testing.T) {
 		block *ethpb.SignedBeaconBlock
 	}
 	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-		check   func(*testing.T, *Service)
+		name      string
+		args      args
+		wantedErr string
+		check     func(*testing.T, *Service)
 	}{
 		{
 			name: "applies block with state transition",
@@ -261,14 +264,17 @@ func TestService_ReceiveBlockInitialSync(t *testing.T) {
 			gBlk, err := s.beaconDB.GenesisBlock(ctx)
 			require.NoError(t, err)
 
-			gRoot, err := stateutil.BlockRoot(gBlk.Block)
+			gRoot, err := gBlk.Block.HashTreeRoot()
+			require.NoError(t, err)
 			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
-			root, err := stateutil.BlockRoot(tt.args.block.Block)
+			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
 
-			if err := s.ReceiveBlockInitialSync(ctx, tt.args.block, root); (err != nil) != tt.wantErr {
-				t.Errorf("ReceiveBlockInitialSync() error = %v, wantErr %v", err, tt.wantErr)
+			err = s.ReceiveBlockInitialSync(ctx, tt.args.block, root)
+			if tt.wantedErr != "" {
+				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
+				assert.NoError(t, err)
 				tt.check(t, s)
 			}
 		})
@@ -281,9 +287,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 	genesis, keys := testutil.DeterministicGenesisState(t, 64)
 	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot uint64) *ethpb.SignedBeaconBlock {
 		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
-		if err != nil {
-			t.Error(err)
-		}
+		assert.NoError(t, err)
 		return blk
 	}
 
@@ -291,10 +295,10 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 		block *ethpb.SignedBeaconBlock
 	}
 	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-		check   func(*testing.T, *Service)
+		name      string
+		args      args
+		wantedErr string
+		check     func(*testing.T, *Service)
 	}{
 		{
 			name: "applies block with state transition",
@@ -322,8 +326,8 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			db, stateSummaryCache := testDB.SetupDB(t)
-			genesisBlockRoot := bytesutil.ToBytes32(nil)
-
+			genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
+			require.NoError(t, err)
 			cfg := &Config{
 				BeaconDB: db,
 				ForkChoiceStore: protoarray.New(
@@ -341,15 +345,18 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			gBlk, err := s.beaconDB.GenesisBlock(ctx)
 			require.NoError(t, err)
 
-			gRoot, err := stateutil.BlockRoot(gBlk.Block)
+			gRoot, err := gBlk.Block.HashTreeRoot()
+			require.NoError(t, err)
 			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
-			root, err := stateutil.BlockRoot(tt.args.block.Block)
+			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
 			blks := []*ethpb.SignedBeaconBlock{tt.args.block}
 			roots := [][32]byte{root}
-			if err := s.ReceiveBlockBatch(ctx, blks, roots); (err != nil) != tt.wantErr {
-				t.Errorf("ReceiveBlockBatch() error = %v, wantErr %v", err, tt.wantErr)
+			err = s.ReceiveBlockBatch(ctx, blks, roots)
+			if tt.wantedErr != "" {
+				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
+				assert.NoError(t, err)
 				tt.check(t, s)
 			}
 		})
@@ -357,7 +364,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 }
 
 func TestService_HasInitSyncBlock(t *testing.T) {
-	s, err := NewService(context.Background(), &Config{})
+	s, err := NewService(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
 	require.NoError(t, err)
 	r := [32]byte{'a'}
 	if s.HasInitSyncBlock(r) {
@@ -368,3 +375,41 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 		t.Error("Should have block")
 	}
 }
+
+func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
+	db, stateSummaryCache := testDB.SetupDB(t)
+	hook := logTest.NewGlobal()
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db, stateSummaryCache)})
+	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)
+	s.finalizedCheckpt = &ethpb.Checkpoint{}
+
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
+	assert.LogsContain(t, hook, "Entering mode to save hot states in DB")
+}
+
+func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
+	db, stateSummaryCache := testDB.SetupDB(t)
+	hook := logTest.NewGlobal()
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db, stateSummaryCache)})
+	require.NoError(t, err)
+	s.finalizedCheckpt = &ethpb.Checkpoint{}
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
+	s.genesisTime = time.Now()
+
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
+	assert.LogsContain(t, hook, "Exiting mode to save hot states in DB")
+}
+
+func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
+	db, stateSummaryCache := testDB.SetupDB(t)
+	hook := logTest.NewGlobal()
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(db, stateSummaryCache)})
+	require.NoError(t, err)
+	s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
+	s.genesisTime = time.Now()
+
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
+	assert.LogsDoNotContain(t, hook, "Entering mode to save hot states in DB")
+}

beacon-chain/blockchain/service.go

@@ -30,51 +30,50 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/slotutil"
+	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	ctx                       context.Context
-	cancel                    context.CancelFunc
-	beaconDB                  db.HeadAccessDatabase
-	depositCache              *depositcache.DepositCache
-	chainStartFetcher         powchain.ChainStartFetcher
-	attPool                   attestations.Pool
-	slashingPool              *slashings.Pool
-	exitPool                  *voluntaryexits.Pool
-	genesisTime               time.Time
-	p2p                       p2p.Broadcaster
-	maxRoutines               int
-	head                      *head
-	headLock                  sync.RWMutex
-	stateNotifier             statefeed.Notifier
-	genesisRoot               [32]byte
-	forkChoiceStore           f.ForkChoicer
-	justifiedCheckpt          *ethpb.Checkpoint
-	prevJustifiedCheckpt      *ethpb.Checkpoint
-	bestJustifiedCheckpt      *ethpb.Checkpoint
-	finalizedCheckpt          *ethpb.Checkpoint
-	prevFinalizedCheckpt      *ethpb.Checkpoint
-	nextEpochBoundarySlot     uint64
-	initSyncState             map[[32]byte]*stateTrie.BeaconState
-	boundaryRoots             [][32]byte
-	checkpointState           *cache.CheckpointStateCache
-	checkpointStateLock       sync.Mutex
-	stateGen                  *stategen.State
-	opsService                *attestations.Service
-	initSyncBlocks            map[[32]byte]*ethpb.SignedBeaconBlock
-	initSyncBlocksLock        sync.RWMutex
-	recentCanonicalBlocks     map[[32]byte]bool
-	recentCanonicalBlocksLock sync.RWMutex
-	justifiedBalances         []uint64
-	justifiedBalancesLock     sync.RWMutex
+	ctx                   context.Context
+	cancel                context.CancelFunc
+	beaconDB              db.HeadAccessDatabase
+	depositCache          *depositcache.DepositCache
+	chainStartFetcher     powchain.ChainStartFetcher
+	attPool               attestations.Pool
+	slashingPool          *slashings.Pool
+	exitPool              *voluntaryexits.Pool
+	genesisTime           time.Time
+	p2p                   p2p.Broadcaster
+	maxRoutines           int
+	head                  *head
+	headLock              sync.RWMutex
+	stateNotifier         statefeed.Notifier
+	genesisRoot           [32]byte
+	forkChoiceStore       f.ForkChoicer
+	justifiedCheckpt      *ethpb.Checkpoint
+	prevJustifiedCheckpt  *ethpb.Checkpoint
+	bestJustifiedCheckpt  *ethpb.Checkpoint
+	finalizedCheckpt      *ethpb.Checkpoint
+	prevFinalizedCheckpt  *ethpb.Checkpoint
+	nextEpochBoundarySlot uint64
+	boundaryRoots         [][32]byte
+	checkpointStateCache  *cache.CheckpointStateCache
+	stateGen              *stategen.State
+	opsService            *attestations.Service
+	initSyncBlocks        map[[32]byte]*ethpb.SignedBeaconBlock
+	initSyncBlocksLock    sync.RWMutex
+	justifiedBalances     []uint64
+	justifiedBalancesLock sync.RWMutex
+	wsEpoch               uint64
+	wsRoot                []byte
+	wsVerified            bool
 }
 
 // Config options for the service.
@@ -92,6 +91,8 @@ type Config struct {
 	ForkChoiceStore   f.ForkChoicer
 	OpsService        *attestations.Service
 	StateGen          *stategen.State
+	WspBlockRoot      []byte
+	WspEpoch          uint64
 }
 
 // NewService instantiates a new block service instance that will
@@ -99,36 +100,31 @@ type Config struct {
 func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	return &Service{
-		ctx:                   ctx,
-		cancel:                cancel,
-		beaconDB:              cfg.BeaconDB,
-		depositCache:          cfg.DepositCache,
-		chainStartFetcher:     cfg.ChainStartFetcher,
-		attPool:               cfg.AttPool,
-		exitPool:              cfg.ExitPool,
-		slashingPool:          cfg.SlashingPool,
-		p2p:                   cfg.P2p,
-		maxRoutines:           cfg.MaxRoutines,
-		stateNotifier:         cfg.StateNotifier,
-		forkChoiceStore:       cfg.ForkChoiceStore,
-		initSyncState:         make(map[[32]byte]*stateTrie.BeaconState),
-		boundaryRoots:         [][32]byte{},
-		checkpointState:       cache.NewCheckpointStateCache(),
-		opsService:            cfg.OpsService,
-		stateGen:              cfg.StateGen,
-		initSyncBlocks:        make(map[[32]byte]*ethpb.SignedBeaconBlock),
-		recentCanonicalBlocks: make(map[[32]byte]bool),
-		justifiedBalances:     make([]uint64, 0),
+		ctx:                  ctx,
+		cancel:               cancel,
+		beaconDB:             cfg.BeaconDB,
+		depositCache:         cfg.DepositCache,
+		chainStartFetcher:    cfg.ChainStartFetcher,
+		attPool:              cfg.AttPool,
+		exitPool:             cfg.ExitPool,
+		slashingPool:         cfg.SlashingPool,
+		p2p:                  cfg.P2p,
+		maxRoutines:          cfg.MaxRoutines,
+		stateNotifier:        cfg.StateNotifier,
+		forkChoiceStore:      cfg.ForkChoiceStore,
+		boundaryRoots:        [][32]byte{},
+		checkpointStateCache: cache.NewCheckpointStateCache(),
+		opsService:           cfg.OpsService,
+		stateGen:             cfg.StateGen,
+		initSyncBlocks:       make(map[[32]byte]*ethpb.SignedBeaconBlock),
+		justifiedBalances:    make([]uint64, 0),
+		wsEpoch:              cfg.WspEpoch,
+		wsRoot:               cfg.WspBlockRoot,
 	}, nil
 }
 
 // Start a blockchain service's main event loop.
 func (s *Service) Start() {
-	beaconState, err := s.beaconDB.HeadState(s.ctx)
-	if err != nil {
-		log.Fatalf("Could not fetch beacon state: %v", err)
-	}
-
 	// For running initial sync with state cache, in an event of restart, we use
 	// last finalized check point as start point to sync instead of head
 	// state. This is because we no longer save state every slot during sync.
@@ -137,11 +133,25 @@ func (s *Service) Start() {
 		log.Fatalf("Could not fetch finalized cp: %v", err)
 	}
 
-	if beaconState == nil {
-		beaconState, err = s.stateGen.StateByRoot(s.ctx, bytesutil.ToBytes32(cp.Root))
+	r := bytesutil.ToBytes32(cp.Root)
+	// Before the first finalized epoch, in the current epoch,
+	// the finalized root is defined as zero hashes instead of genesis root hash.
+	// We want to use genesis root to retrieve for state.
+	if r == params.BeaconConfig().ZeroHash {
+		genesisBlock, err := s.beaconDB.GenesisBlock(s.ctx)
 		if err != nil {
-			log.Fatalf("Could not fetch beacon state by root: %v", err)
+			log.Fatalf("Could not fetch finalized cp: %v", err)
 		}
+		if genesisBlock != nil {
+			r, err = genesisBlock.Block.HashTreeRoot()
+			if err != nil {
+				log.Fatalf("Could not tree hash genesis block: %v", err)
+			}
+		}
+	}
+	beaconState, err := s.stateGen.StateByRoot(s.ctx, r)
+	if err != nil {
+		log.Fatalf("Could not fetch beacon state by root: %v", err)
 	}
 
 	// Make sure that attestation processor is subscribed and ready for state initializing event.
@@ -150,8 +160,8 @@ func (s *Service) Start() {
 	// If the chain has already been initialized, simply start the block processing routine.
 	if beaconState != nil {
 		log.Info("Blockchain data already exists in DB, initializing...")
-		s.genesisTime = time.Unix(int64(helpers.GenesisTime(beaconState)), 0)
-		s.opsService.SetGenesisTime(helpers.GenesisTime(beaconState))
+		s.genesisTime = time.Unix(int64(beaconState.GenesisTime()), 0)
+		s.opsService.SetGenesisTime(beaconState.GenesisTime())
 		if err := s.initializeChainInfo(s.ctx); err != nil {
 			log.Fatalf("Could not set up chain info: %v", err)
 		}
@@ -183,6 +193,24 @@ func (s *Service) Start() {
 		s.prevFinalizedCheckpt = stateTrie.CopyCheckpoint(finalizedCheckpoint)
 		s.resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint)
 
+		ss, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+		if err != nil {
+			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 err := s.VerifyWeakSubjectivityRoot(s.ctx); err != nil {
+			// Exit run time if the node failed to verify weak subjectivity checkpoint.
+			log.Fatalf("Could not verify weak subjectivity checkpoint: %v", err)
+		}
+
 		s.stateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Initialized,
 			Data: &statefeed.InitializedData{
@@ -258,7 +286,7 @@ func (s *Service) initializeBeaconChain(
 	genesisTime time.Time,
 	preGenesisState *stateTrie.BeaconState,
 	eth1data *ethpb.Eth1Data) (*stateTrie.BeaconState, error) {
-	_, span := trace.StartSpan(context.Background(), "beacon-chain.Service.initializeBeaconChain")
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.Service.initializeBeaconChain")
 	defer span.End()
 	s.genesisTime = genesisTime
 	unixTime := uint64(genesisTime.Unix())
@@ -285,7 +313,7 @@ func (s *Service) initializeBeaconChain(
 		return nil, err
 	}
 
-	s.opsService.SetGenesisTime(helpers.GenesisTime(genesisState))
+	s.opsService.SetGenesisTime(genesisState.GenesisTime())
 
 	return genesisState, nil
 }
@@ -295,9 +323,13 @@ func (s *Service) Stop() error {
 	defer s.cancel()
 
 	if s.stateGen != nil && s.head != nil && s.head.state != nil {
-		return s.stateGen.ForceCheckpoint(s.ctx, s.head.state.FinalizedCheckpoint().Root)
+		if err := s.stateGen.ForceCheckpoint(s.ctx, s.head.state.FinalizedCheckpoint().Root); err != nil {
+			return err
+		}
 	}
-	return nil
+
+	// Save initial sync cached blocks to the DB before stop.
+	return s.beaconDB.SaveBlocks(s.ctx, s.getInitSyncBlocks())
 }
 
 // Status always returns nil unless there is an error condition that causes
@@ -309,12 +341,6 @@ func (s *Service) Status() error {
 	return nil
 }
 
-// ClearCachedStates removes all stored caches states. This is done after the node
-// is synced.
-func (s *Service) ClearCachedStates() {
-	s.initSyncState = map[[32]byte]*stateTrie.BeaconState{}
-}
-
 // This gets called when beacon chain is first initialized to save genesis data (state, block, and more) in db.
 func (s *Service) saveGenesisData(ctx context.Context, genesisState *stateTrie.BeaconState) error {
 	stateRoot, err := genesisState.HashTreeRoot(ctx)
@@ -322,7 +348,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState *stateTrie.B
 		return err
 	}
 	genesisBlk := blocks.NewGenesisBlock(stateRoot[:])
-	genesisBlkRoot, err := stateutil.BlockRoot(genesisBlk.Block)
+	genesisBlkRoot, err := genesisBlk.Block.HashTreeRoot()
 	if err != nil {
 		return errors.Wrap(err, "could not get genesis block root")
 	}
@@ -386,22 +412,28 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 	if genesisBlock == nil {
 		return errors.New("no genesis block in db")
 	}
-	genesisBlkRoot, err := stateutil.BlockRoot(genesisBlock.Block)
+	genesisBlkRoot, err := genesisBlock.Block.HashTreeRoot()
 	if err != nil {
 		return errors.Wrap(err, "could not get signing root of genesis block")
 	}
 	s.genesisRoot = genesisBlkRoot
 
-	if flags.Get().UnsafeSync {
+	if flags.Get().HeadSync {
 		headBlock, err := s.beaconDB.HeadBlock(ctx)
 		if err != nil {
 			return errors.Wrap(err, "could not retrieve head block")
 		}
-		headRoot, err := stateutil.BlockRoot(headBlock.Block)
+		headRoot, err := headBlock.Block.HashTreeRoot()
 		if err != nil {
 			return errors.Wrap(err, "could not hash head block")
 		}
-		headState, err := s.beaconDB.HeadState(ctx)
+		finalizedState, err := s.stateGen.Resume(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not get finalized state from db")
+		}
+		log.Infof("Regenerating state from the last checkpoint at slot %d to current head slot of %d."+
+			"This process may take a while, please wait.", finalizedState.Slot(), headBlock.Block.Slot)
+		headState, err := s.stateGen.StateByRoot(ctx, headRoot)
 		if err != nil {
 			return errors.Wrap(err, "could not retrieve head state")
 		}
@@ -418,17 +450,13 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 		// would be the genesis state and block.
 		return errors.New("no finalized epoch in the database")
 	}
-	finalizedRoot := bytesutil.ToBytes32(finalized.Root)
+	finalizedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
 	var finalizedState *stateTrie.BeaconState
 
 	finalizedState, err = s.stateGen.Resume(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized state from db")
 	}
-	finalizedRoot = s.beaconDB.LastArchivedRoot(ctx)
-	if finalizedRoot == params.BeaconConfig().ZeroHash {
-		finalizedRoot = bytesutil.ToBytes32(finalized.Root)
-	}
 
 	finalizedBlock, err := s.beaconDB.Block(ctx, finalizedRoot)
 	if err != nil {
@@ -445,7 +473,7 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 
 // This is called when a client starts from non-genesis slot. This passes last justified and finalized
 // information to fork choice service to initializes fork choice store.
-func (s *Service) resumeForkChoice(justifiedCheckpoint *ethpb.Checkpoint, finalizedCheckpoint *ethpb.Checkpoint) {
+func (s *Service) resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint *ethpb.Checkpoint) {
 	store := protoarray.New(justifiedCheckpoint.Epoch, finalizedCheckpoint.Epoch, bytesutil.ToBytes32(finalizedCheckpoint.Root))
 	s.forkChoiceStore = store
 }

beacon-chain/blockchain/service_test.go

@@ -11,7 +11,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
@@ -25,7 +24,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	protodb "github.com/prysmaticlabs/prysm/proto/beacon/db"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -69,7 +67,7 @@ func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ *
 	return nil
 }
 
-var _ = p2p.Broadcaster(&mockBroadcaster{})
+var _ p2p.Broadcaster = (*mockBroadcaster)(nil)
 
 func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummaryCache) *Service {
 	endpoint := "http://127.0.0.1"
@@ -103,7 +101,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummary
 	opsService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
 	require.NoError(t, err)
 
-	depositCache, err := depositcache.NewDepositCache()
+	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
 	cfg := &Config{
@@ -120,9 +118,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.
-	if err := cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
 
 	chainService, err := NewService(ctx, cfg)
 	require.NoError(t, err, "Unable to setup chain service")
@@ -139,7 +135,7 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	chainService := setupBeaconChain(t, db, sc)
 
 	genesisBlk := testutil.NewBeaconBlock()
-	blkRoot, err := stateutil.BlockRoot(genesisBlk.Block)
+	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, genesisBlk))
 	s := testutil.NewBeaconState()
@@ -148,6 +144,33 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	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[:]}))
+
+	// Test the start function.
+	chainService.Start()
+
+	require.NoError(t, chainService.Stop(), "Unable to stop chain service")
+
+	// The context should have been canceled.
+	assert.Equal(t, context.Canceled, chainService.ctx.Err(), "Context was not canceled")
+	require.LogsContain(t, hook, "data already exists")
+}
+
+func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
+	hook := logTest.NewGlobal()
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	chainService := setupBeaconChain(t, db, sc)
+
+	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[:]}))
 
 	// Test the start function.
 	chainService.Start()
@@ -179,11 +202,13 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 	err = genState.SetEth1Data(&ethpb.Eth1Data{
 		DepositRoot:  hashTreeRoot[:],
 		DepositCount: uint64(len(deposits)),
+		BlockHash:    make([]byte, 32),
 	})
+	require.NoError(t, err)
 	genState, err = b.ProcessPreGenesisDeposits(ctx, genState, deposits)
 	require.NoError(t, err)
 
-	_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:]})
+	_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:], BlockHash: make([]byte, 32)})
 	require.NoError(t, err)
 
 	_, err = bc.HeadState(ctx)
@@ -193,7 +218,9 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 	if headBlk == nil {
 		t.Error("Head state can't be nil after initialize beacon chain")
 	}
-	if bc.headRoot() == params.BeaconConfig().ZeroHash {
+	r, err := bc.HeadRoot(ctx)
+	require.NoError(t, err)
+	if bytesutil.ToBytes32(r) == params.BeaconConfig().ZeroHash {
 		t.Error("Canonical root for slot 0 can't be zeros after initialize beacon chain")
 	}
 }
@@ -205,7 +232,7 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	chainService := setupBeaconChain(t, db, sc)
 
 	genesisBlk := testutil.NewBeaconBlock()
-	blkRoot, err := stateutil.BlockRoot(genesisBlk.Block)
+	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, genesisBlk))
 	s := testutil.NewBeaconState()
@@ -213,10 +240,12 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	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[:]}))
+
 	// Test the start function.
 	chainService.Start()
 
-	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], chainService.finalizedCheckpt.Root, "Finalize Checkpoint root is incorrect")
+	require.DeepEqual(t, blkRoot[:], chainService.finalizedCheckpt.Root, "Finalize Checkpoint root is incorrect")
 	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], chainService.justifiedCheckpt.Root, "Justified Checkpoint root is incorrect")
 
 	require.NoError(t, chainService.Stop(), "Unable to stop chain service")
@@ -228,7 +257,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	ctx := context.Background()
 
 	genesis := testutil.NewBeaconBlock()
-	genesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisRoot))
 	require.NoError(t, db.SaveBlock(ctx, genesis))
@@ -240,17 +269,12 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	headState := testutil.NewBeaconState()
 	require.NoError(t, headState.SetSlot(finalizedSlot))
 	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
-	headRoot, err := stateutil.BlockRoot(headBlock.Block)
+	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))
-	if err := db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
-		Epoch: helpers.SlotToEpoch(finalizedSlot),
-		Root:  headRoot[:],
-	}); err != nil {
-		t.Fatal(err)
-	}
+	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, c.initializeChainInfo(ctx))
 	headBlk, err := c.HeadBlock(ctx)
@@ -268,6 +292,37 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 }
 
+func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
+	db, sc := 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))
+
+	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
+	headBlock := testutil.NewBeaconBlock()
+	headBlock.Block.Slot = finalizedSlot
+	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
+	headState := testutil.NewBeaconState()
+	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, c.initializeChainInfo(ctx))
+	s, err := c.HeadState(ctx)
+	require.NoError(t, err)
+	assert.DeepEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
+	assert.DeepEqual(t, genesis, c.head.block)
+}
+
 func TestChainService_SaveHeadNoDB(t *testing.T) {
 	db, sc := testDB.SetupDB(t)
 	ctx := context.Background()
@@ -275,8 +330,9 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 		beaconDB: db,
 		stateGen: stategen.New(db, sc),
 	}
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
-	r, err := ssz.HashTreeRoot(b)
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 1
+	r, err := b.HashTreeRoot()
 	require.NoError(t, err)
 	newState := testutil.NewBeaconState()
 	require.NoError(t, s.stateGen.SaveState(ctx, r, newState))
@@ -294,30 +350,45 @@ func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
 	db, _ := testDB.SetupDB(t)
 	s := &Service{
 		forkChoiceStore:  protoarray.New(0, 0, [32]byte{}),
-		finalizedCheckpt: &ethpb.Checkpoint{},
+		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
 		beaconDB:         db,
 	}
-	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
-	r, err := stateutil.BlockRoot(block.Block)
-	require.NoError(t, err)
-	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
-	state, err := beaconstate.InitializeFromProto(bs)
+	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))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
 }
 
+func TestServiceStop_SaveCachedBlocks(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	db, _ := testDB.SetupDB(t)
+	s := &Service{
+		ctx:            ctx,
+		cancel:         cancel,
+		beaconDB:       db,
+		initSyncBlocks: make(map[[32]byte]*ethpb.SignedBeaconBlock),
+	}
+	b := testutil.NewBeaconBlock()
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	s.saveInitSyncBlock(r, b)
+	require.NoError(t, s.Stop())
+	require.Equal(t, true, s.beaconDB.HasBlock(ctx, r))
+}
+
 func BenchmarkHasBlockDB(b *testing.B) {
 	db, _ := testDB.SetupDB(b)
 	ctx := context.Background()
 	s := &Service{
 		beaconDB: db,
 	}
-	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
+	block := testutil.NewBeaconBlock()
 	require.NoError(b, s.beaconDB.SaveBlock(ctx, block))
-	r, err := stateutil.BlockRoot(block.Block)
+	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
 
 	b.ResetTimer()
@@ -331,13 +402,13 @@ func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
 	db, _ := testDB.SetupDB(b)
 	s := &Service{
 		forkChoiceStore:  protoarray.New(0, 0, [32]byte{}),
-		finalizedCheckpt: &ethpb.Checkpoint{},
+		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
 		beaconDB:         db,
 	}
 	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
-	r, err := stateutil.BlockRoot(block.Block)
+	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
-	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
+	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	state, err := beaconstate.InitializeFromProto(bs)
 	require.NoError(b, err)
 	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))

beacon-chain/blockchain/testing/BUILD.bazel

@@ -19,8 +19,8 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/stateutil:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/bytesutil:go_default_library",
         "//shared/event:go_default_library",
         "//shared/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -19,8 +19,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/event"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/sirupsen/logrus"
@@ -38,6 +38,7 @@ type ChainService struct {
 	Balance                     *precompute.Balance
 	Genesis                     time.Time
 	ValidatorsRoot              [32]byte
+	CanonicalRoots              map[[32]byte]bool
 	Fork                        *pb.Fork
 	ETH1Data                    *ethpb.Eth1Data
 	DB                          db.Database
@@ -80,7 +81,8 @@ func (msn *MockBlockNotifier) BlockFeed() *event.Feed {
 
 // MockStateNotifier mocks the state notifier.
 type MockStateNotifier struct {
-	feed *event.Feed
+	feed     *event.Feed
+	feedLock sync.Mutex
 
 	recv     []*feed.Event
 	recvLock sync.Mutex
@@ -98,6 +100,9 @@ func (msn *MockStateNotifier) ReceivedEvents() []*feed.Event {
 
 // StateFeed returns a state feed.
 func (msn *MockStateNotifier) StateFeed() *event.Feed {
+	msn.feedLock.Lock()
+	defer msn.feedLock.Unlock()
+
 	if msn.feed == nil && msn.recvCh == nil {
 		msn.feed = new(event.Feed)
 		if msn.RecordEvents {
@@ -141,7 +146,7 @@ func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
 }
 
 // ReceiveBlockInitialSync mocks ReceiveBlockInitialSync method in chain service.
-func (ms *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
+func (ms *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, _ [32]byte) error {
 	if ms.State == nil {
 		ms.State = &stateTrie.BeaconState{}
 	}
@@ -152,7 +157,7 @@ func (ms *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethp
 		return err
 	}
 	ms.BlocksReceived = append(ms.BlocksReceived, block)
-	signingRoot, err := stateutil.BlockRoot(block.Block)
+	signingRoot, err := block.Block.HashTreeRoot()
 	if err != nil {
 		return err
 	}
@@ -168,7 +173,7 @@ func (ms *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethp
 }
 
 // ReceiveBlockBatch processes blocks in batches from initial-sync.
-func (ms *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock, roots [][32]byte) error {
+func (ms *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock, _ [][32]byte) error {
 	if ms.State == nil {
 		ms.State = &stateTrie.BeaconState{}
 	}
@@ -180,7 +185,7 @@ func (ms *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.Sig
 			return err
 		}
 		ms.BlocksReceived = append(ms.BlocksReceived, block)
-		signingRoot, err := stateutil.BlockRoot(block.Block)
+		signingRoot, err := block.Block.HashTreeRoot()
 		if err != nil {
 			return err
 		}
@@ -197,7 +202,7 @@ func (ms *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.Sig
 }
 
 // ReceiveBlock mocks ReceiveBlock method in chain service.
-func (ms *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
+func (ms *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, _ [32]byte) error {
 	if ms.State == nil {
 		ms.State = &stateTrie.BeaconState{}
 	}
@@ -208,7 +213,7 @@ func (ms *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBea
 		return err
 	}
 	ms.BlocksReceived = append(ms.BlocksReceived, block)
-	signingRoot, err := stateutil.BlockRoot(block.Block)
+	signingRoot, err := block.Block.HashTreeRoot()
 	if err != nil {
 		return err
 	}
@@ -232,9 +237,11 @@ func (ms *ChainService) HeadSlot() uint64 {
 }
 
 // HeadRoot mocks HeadRoot method in chain service.
-func (ms *ChainService) HeadRoot(ctx context.Context) ([]byte, error) {
-	return ms.Root, nil
-
+func (ms *ChainService) HeadRoot(_ context.Context) ([]byte, error) {
+	if len(ms.Root) > 0 {
+		return ms.Root, nil
+	}
+	return make([]byte, 32), nil
 }
 
 // HeadBlock mocks HeadBlock method in chain service.
@@ -268,7 +275,7 @@ func (ms *ChainService) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 }
 
 // ReceiveAttestation mocks ReceiveAttestation method in chain service.
-func (ms *ChainService) ReceiveAttestation(context.Context, *ethpb.Attestation) error {
+func (ms *ChainService) ReceiveAttestation(_ context.Context, _ *ethpb.Attestation) error {
 	return nil
 }
 
@@ -278,12 +285,12 @@ func (ms *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attes
 }
 
 // AttestationPreState mocks AttestationPreState method in chain service.
-func (ms *ChainService) AttestationPreState(ctx context.Context, att *ethpb.Attestation) (*stateTrie.BeaconState, error) {
+func (ms *ChainService) AttestationPreState(_ context.Context, _ *ethpb.Attestation) (*stateTrie.BeaconState, error) {
 	return ms.State, nil
 }
 
 // HeadValidatorsIndices mocks the same method in the chain service.
-func (ms *ChainService) HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]uint64, error) {
+func (ms *ChainService) HeadValidatorsIndices(_ context.Context, epoch uint64) ([]uint64, error) {
 	if ms.State == nil {
 		return []uint64{}, nil
 	}
@@ -291,7 +298,7 @@ func (ms *ChainService) HeadValidatorsIndices(ctx context.Context, epoch uint64)
 }
 
 // HeadSeed mocks the same method in the chain service.
-func (ms *ChainService) HeadSeed(ctx context.Context, epoch uint64) ([32]byte, error) {
+func (ms *ChainService) HeadSeed(_ context.Context, epoch uint64) ([32]byte, error) {
 	return helpers.Seed(ms.State, epoch, params.BeaconConfig().DomainBeaconAttester)
 }
 
@@ -321,26 +328,27 @@ func (ms *ChainService) CurrentSlot() uint64 {
 }
 
 // Participation mocks the same method in the chain service.
-func (ms *ChainService) Participation(epoch uint64) *precompute.Balance {
+func (ms *ChainService) Participation(_ uint64) *precompute.Balance {
 	return ms.Balance
 }
 
 // IsValidAttestation always returns true.
-func (ms *ChainService) IsValidAttestation(ctx context.Context, att *ethpb.Attestation) bool {
+func (ms *ChainService) IsValidAttestation(_ context.Context, _ *ethpb.Attestation) bool {
 	return ms.ValidAttestation
 }
 
 // IsCanonical returns and determines whether a block with the provided root is part of
 // the canonical chain.
-func (ms *ChainService) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error) {
+func (ms *ChainService) IsCanonical(_ context.Context, r [32]byte) (bool, error) {
+	if ms.CanonicalRoots != nil {
+		_, ok := ms.CanonicalRoots[r]
+		return ok, nil
+	}
 	return true, nil
 }
 
-// ClearCachedStates does nothing.
-func (ms *ChainService) ClearCachedStates() {}
-
 // HasInitSyncBlock mocks the same method in the chain service.
-func (ms *ChainService) HasInitSyncBlock(root [32]byte) bool {
+func (ms *ChainService) HasInitSyncBlock(_ [32]byte) bool {
 	return false
 }
 
@@ -350,6 +358,52 @@ func (ms *ChainService) HeadGenesisValidatorRoot() [32]byte {
 }
 
 // VerifyBlkDescendant mocks VerifyBlkDescendant and always returns nil.
-func (ms *ChainService) VerifyBlkDescendant(ctx context.Context, root [32]byte) error {
+func (ms *ChainService) VerifyBlkDescendant(_ context.Context, _ [32]byte) error {
 	return ms.VerifyBlkDescendantErr
 }
+
+// VerifyLmdFfgConsistency mocks VerifyLmdFfgConsistency and always returns nil.
+func (ms *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")
+	}
+	return nil
+}
+
+// VerifyFinalizedConsistency mocks VerifyFinalizedConsistency and always returns nil.
+func (ms *ChainService) VerifyFinalizedConsistency(_ context.Context, r []byte) error {
+	if !bytes.Equal(r, ms.FinalizedCheckPoint.Root) {
+		return errors.New("Root and finalized store are not consistent")
+	}
+	return nil
+}
+
+// AttestationCheckPtInfo mocks AttestationCheckPtInfo and always returns nil.
+func (ms *ChainService) AttestationCheckPtInfo(_ context.Context, att *ethpb.Attestation) (*pb.CheckPtInfo, error) {
+	f := ms.State.Fork()
+	g := bytesutil.ToBytes32(ms.State.GenesisValidatorRoot())
+	seed, err := helpers.Seed(ms.State, helpers.SlotToEpoch(att.Data.Slot), params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return nil, err
+	}
+	indices, err := helpers.ActiveValidatorIndices(ms.State, helpers.SlotToEpoch(att.Data.Slot))
+	if err != nil {
+		return nil, err
+	}
+	validators := ms.State.ValidatorsReadOnly()
+	pks := make([][]byte, len(validators))
+	for i := 0; i < len(pks); i++ {
+		pk := validators[i].PublicKey()
+		pks[i] = pk[:]
+	}
+
+	info := &pb.CheckPtInfo{
+		Fork:          f,
+		GenesisRoot:   g[:],
+		Seed:          seed[:],
+		ActiveIndices: indices,
+		PubKeys:       pks,
+	}
+
+	return info, nil
+}

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -0,0 +1,60 @@
+package blockchain
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// VerifyWeakSubjectivityRoot verifies the weak subjectivity root in the service struct.
+// Reference design: https://github.com/ethereum/eth2.0-specs/blob/master/specs/phase0/weak-subjectivity.md#weak-subjectivity-sync-procedure
+func (s *Service) VerifyWeakSubjectivityRoot(ctx context.Context) error {
+	// TODO(7342): Remove the following to fully use weak subjectivity in production.
+	if len(s.wsRoot) == 0 || s.wsEpoch == 0 {
+		return nil
+	}
+
+	// Do nothing if the weak subjectivity has previously been verified,
+	// or weak subjectivity epoch is higher than last finalized epoch.
+	if s.wsVerified {
+		return nil
+	}
+	if s.wsEpoch > s.finalizedCheckpt.Epoch {
+		return nil
+	}
+
+	r := bytesutil.ToBytes32(s.wsRoot)
+	log.Infof("Performing weak subjectivity check for root %#x in epoch %d", r, s.wsEpoch)
+	// Save initial sync cached blocks to DB.
+	if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+		return err
+	}
+	// A node should have the weak subjectivity block in the DB.
+	if !s.beaconDB.HasBlock(ctx, r) {
+		return fmt.Errorf("node does not have root in DB: %#x", r)
+	}
+
+	startSlot, err := helpers.StartSlot(s.wsEpoch)
+	if err != nil {
+		return err
+	}
+	// A node should have the weak subjectivity block corresponds to the correct epoch in the DB.
+	filter := filters.NewFilter().SetStartSlot(startSlot).SetEndSlot(startSlot + params.BeaconConfig().SlotsPerEpoch)
+	roots, err := s.beaconDB.BlockRoots(ctx, filter)
+	if err != nil {
+		return err
+	}
+	for _, root := range roots {
+		if r == root {
+			log.Info("Weak subjectivity check has passed")
+			s.wsVerified = true
+			return nil
+		}
+	}
+
+	return fmt.Errorf("node does not have root in db corresponding to epoch: %#x %d", r, s.wsEpoch)
+}

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -0,0 +1,85 @@
+package blockchain
+
+import (
+	"context"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
+	db, _ := testDB.SetupDB(t)
+
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 32
+	require.NoError(t, db.SaveBlock(context.Background(), b))
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	tests := []struct {
+		wsVerified     bool
+		wantErr        bool
+		wsRoot         [32]byte
+		wsEpoch        uint64
+		finalizedEpoch uint64
+		errString      string
+		name           string
+	}{
+		{
+			name:    "nil root and epoch",
+			wantErr: false,
+		},
+		{
+			name:           "already verified",
+			wsEpoch:        2,
+			finalizedEpoch: 2,
+			wsVerified:     true,
+			wantErr:        false,
+		},
+		{
+			name:           "not yet to verify, ws epoch higher than finalized epoch",
+			wsEpoch:        2,
+			finalizedEpoch: 1,
+			wantErr:        false,
+		},
+		{
+			name:           "can't find the block in DB",
+			wsEpoch:        1,
+			wsRoot:         [32]byte{'a'},
+			finalizedEpoch: 3,
+			wantErr:        true,
+			errString:      "node does not have root in DB",
+		},
+		{
+			name:           "can't find the block corresponds to ws epoch in DB",
+			wsEpoch:        2,
+			wsRoot:         r, // Root belongs in epoch 1.
+			finalizedEpoch: 3,
+			wantErr:        true,
+			errString:      "node does not have root in db corresponding to epoch",
+		},
+		{
+			name:           "can verify and pass",
+			wsEpoch:        1,
+			wsRoot:         r,
+			finalizedEpoch: 3,
+			wantErr:        false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &Service{
+				beaconDB:         db,
+				wsRoot:           tt.wsRoot[:],
+				wsEpoch:          tt.wsEpoch,
+				wsVerified:       tt.wsVerified,
+				finalizedCheckpt: &ethpb.Checkpoint{Epoch: tt.finalizedEpoch},
+			}
+			if err := s.VerifyWeakSubjectivityRoot(context.Background()); (err != nil) != tt.wantErr {
+				require.ErrorContains(t, tt.errString, err)
+			}
+		})
+	}
+}

beacon-chain/cache/BUILD.bazel

@@ -1,19 +1,31 @@
 load("@prysm//tools/go:def.bzl", "go_library")
 load("@io_bazel_rules_go//go:def.bzl", "go_test")
 
+# gazelle:ignore committee_disabled.go
+# gazelle:ignore proposer_indices_disabled.go
 go_library(
     name = "go_default_library",
     srcs = [
         "attestation_data.go",
         "checkpoint_state.go",
-        "committee.go",
+        "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({
+        "//fuzz:fuzzing_enabled": [
+            "committee_disabled.go",
+            "proposer_indices_disabled.go"
+        ],
+        "//conditions:default": [
+            "committee.go",
+            "proposer_indices.go",
+        ],
+    }),
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache",
     visibility = [
         "//beacon-chain:__subpackages__",
@@ -49,6 +61,7 @@ go_test(
         "hot_state_cache_test.go",
         "skip_slot_cache_test.go",
         "subnet_ids_test.go",
+        "proposer_indices_test.go"
     ],
     embed = [":go_default_library"],
     deps = [

beacon-chain/cache/attestation_data.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"k8s.io/client-go/tools/cache"
 )
 
@@ -99,10 +98,7 @@ func (c *AttestationCache) Get(ctx context.Context, req *ethpb.AttestationDataRe
 
 	if exists && item != nil && item.(*attestationReqResWrapper).res != nil {
 		attestationCacheHit.Inc()
-		if featureconfig.Get().ReduceAttesterStateCopy {
-			return state.CopyAttestationData(item.(*attestationReqResWrapper).res), nil
-		}
-		return item.(*attestationReqResWrapper).res, nil
+		return state.CopyAttestationData(item.(*attestationReqResWrapper).res), nil
 	}
 	attestationCacheMiss.Inc()
 	return nil, nil
@@ -138,7 +134,7 @@ func (c *AttestationCache) MarkNotInProgress(req *ethpb.AttestationDataRequest)
 }
 
 // Put the response in the cache.
-func (c *AttestationCache) Put(ctx context.Context, req *ethpb.AttestationDataRequest, res *ethpb.AttestationData) error {
+func (c *AttestationCache) Put(_ context.Context, req *ethpb.AttestationDataRequest, res *ethpb.AttestationData) error {
 	data := &attestationReqResWrapper{
 		req,
 		res,
@@ -167,10 +163,7 @@ func wrapperToKey(i interface{}) (string, error) {
 }
 
 func reqToKey(req *ethpb.AttestationDataRequest) (string, error) {
-	if featureconfig.Get().ReduceAttesterStateCopy {
-		return fmt.Sprintf("%d", req.Slot), nil
-	}
-	return fmt.Sprintf("%d-%d", req.CommitteeIndex, req.Slot), nil
+	return fmt.Sprintf("%d", req.Slot), nil
 }
 
 type attestationReqResWrapper struct {

beacon-chain/cache/attestation_data_test.go

@@ -26,7 +26,7 @@ func TestAttestationCache_RoundTrip(t *testing.T) {
 	assert.NoError(t, c.MarkInProgress(req))
 
 	res := &ethpb.AttestationData{
-		Target: &ethpb.Checkpoint{Epoch: 5},
+		Target: &ethpb.Checkpoint{Epoch: 5, Root: make([]byte, 32)},
 	}
 
 	assert.NoError(t, c.Put(ctx, req, res))

beacon-chain/cache/checkpoint_state.go

@@ -1,8 +1,10 @@
 package cache
 
 import (
-	"errors"
+	"context"
+	"math"
 	"sync"
+	"time"
 
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
@@ -13,10 +15,6 @@ import (
 )
 
 var (
-	// ErrNotCheckpointState will be returned when a cache object is not a pointer to
-	// a CheckpointState struct.
-	ErrNotCheckpointState = errors.New("object is not a state by check point struct")
-
 	// maxCheckpointStateSize defines the max number of entries check point to state cache can contain.
 	// Choosing 10 to account for multiple forks, this allows 5 forks per epoch boundary with 2 epochs
 	// window to accept attestation based on latest spec.
@@ -35,8 +33,9 @@ var (
 
 // CheckpointStateCache is a struct with 1 queue for looking up state by checkpoint.
 type CheckpointStateCache struct {
-	cache *lru.Cache
-	lock  sync.RWMutex
+	cache      *lru.Cache
+	lock       sync.RWMutex
+	inProgress map[string]bool
 }
 
 // NewCheckpointStateCache creates a new checkpoint state cache for storing/accessing processed state.
@@ -46,22 +45,45 @@ func NewCheckpointStateCache() *CheckpointStateCache {
 		panic(err)
 	}
 	return &CheckpointStateCache{
-		cache: cache,
+		cache:      cache,
+		inProgress: map[string]bool{},
 	}
 }
 
 // StateByCheckpoint fetches state by checkpoint. Returns true with a
 // reference to the CheckpointState info, if exists. Otherwise returns false, nil.
-func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (*stateTrie.BeaconState, error) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	h, err := hashutil.HashProto(cp)
+func (c *CheckpointStateCache) StateByCheckpoint(ctx context.Context, cp *ethpb.Checkpoint) (*stateTrie.BeaconState, error) {
+	k, err := checkpointKey(cp)
 	if err != nil {
 		return nil, err
 	}
 
-	item, exists := c.cache.Get(h)
+	delay := minDelay
 
+	// Another identical request may be in progress already. Let's wait until
+	// any in progress request resolves or our timeout is exceeded.
+	for {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
+
+		c.lock.RLock()
+		if !c.inProgress[k] {
+			c.lock.RUnlock()
+			break
+		}
+		c.lock.RUnlock()
+
+		// This increasing backoff is to decrease the CPU cycles while waiting
+		// for the in progress boolean to flip to false.
+		time.Sleep(time.Duration(delay) * time.Nanosecond)
+		delay *= delayFactor
+		delay = math.Min(delay, maxDelay)
+	}
+
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	item, exists := c.cache.Get(k)
 	if exists && item != nil {
 		checkpointStateHit.Inc()
 		// Copy here is unnecessary since the return will only be used to verify attestation signature.
@@ -77,10 +99,47 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (*stateTr
 func (c *CheckpointStateCache) AddCheckpointState(cp *ethpb.Checkpoint, s *stateTrie.BeaconState) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
-	h, err := hashutil.HashProto(cp)
+	k, err := checkpointKey(cp)
 	if err != nil {
 		return err
 	}
-	c.cache.Add(h, s)
+	c.cache.ContainsOrAdd(k, s)
 	return nil
 }
+
+// MarkInProgress a request so that any other similar requests will block on
+// Get until MarkNotInProgress is called.
+func (c *CheckpointStateCache) MarkInProgress(cp *ethpb.Checkpoint) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	k, err := checkpointKey(cp)
+	if err != nil {
+		return err
+	}
+	if c.inProgress[k] {
+		return ErrAlreadyInProgress
+	}
+	c.inProgress[k] = true
+	return nil
+}
+
+// MarkNotInProgress will release the lock on a given request. This should be
+// called after put.
+func (c *CheckpointStateCache) MarkNotInProgress(cp *ethpb.Checkpoint) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	k, err := checkpointKey(cp)
+	if err != nil {
+		return err
+	}
+	delete(c.inProgress, k)
+	return nil
+}
+
+func checkpointKey(cp *ethpb.Checkpoint) (string, error) {
+	h, err := hashutil.HashProto(cp)
+	if err != nil {
+		return "", err
+	}
+	return string(h[:]), nil
+}

beacon-chain/cache/checkpoint_state_test.go

@@ -1,6 +1,7 @@
 package cache
 
 import (
+	"context"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -23,13 +24,13 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	state, err := cache.StateByCheckpoint(cp1)
+	state, err := cache.StateByCheckpoint(context.Background(), cp1)
 	require.NoError(t, err)
 	assert.Equal(t, (*stateTrie.BeaconState)(nil), state, "Expected state not to exist in empty cache")
 
 	require.NoError(t, cache.AddCheckpointState(cp1, st))
 
-	state, err = cache.StateByCheckpoint(cp1)
+	state, err = cache.StateByCheckpoint(context.Background(), cp1)
 	require.NoError(t, err)
 
 	if !proto.Equal(state.InnerStateUnsafe(), st.InnerStateUnsafe()) {
@@ -43,11 +44,11 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, cache.AddCheckpointState(cp2, st2))
 
-	state, err = cache.StateByCheckpoint(cp2)
+	state, err = cache.StateByCheckpoint(context.Background(), cp2)
 	require.NoError(t, err)
 	assert.DeepEqual(t, st2.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")
 
-	state, err = cache.StateByCheckpoint(cp1)
+	state, err = cache.StateByCheckpoint(context.Background(), cp1)
 	require.NoError(t, err)
 	assert.DeepEqual(t, st.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")
 }
@@ -61,7 +62,7 @@ func TestCheckpointStateCache_MaxSize(t *testing.T) {
 
 	for i := uint64(0); i < uint64(maxCheckpointStateSize+100); i++ {
 		require.NoError(t, st.SetSlot(i))
-		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: i}, st))
+		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: i, Root: make([]byte, 32)}, st))
 	}
 
 	assert.Equal(t, maxCheckpointStateSize, len(c.cache.Keys()))

beacon-chain/cache/committee.go

@@ -1,3 +1,5 @@
+// +build !libfuzzer
+
 package cache
 
 import (
@@ -12,10 +14,6 @@ import (
 )
 
 var (
-	// ErrNotCommittee will be returned when a cache object is not a pointer to
-	// a Committee struct.
-	ErrNotCommittee = errors.New("object is not a committee struct")
-
 	// maxCommitteesCacheSize defines the max number of shuffled committees on per randao basis can cache.
 	// Due to reorgs and long finality, it's good to keep the old cache around for quickly switch over.
 	maxCommitteesCacheSize = uint64(32)
@@ -32,15 +30,6 @@ var (
 	})
 )
 
-// Committees defines the shuffled committees seed.
-type Committees struct {
-	CommitteeCount  uint64
-	Seed            [32]byte
-	ShuffledIndices []uint64
-	SortedIndices   []uint64
-	ProposerIndices []uint64
-}
-
 // CommitteeCache is a struct with 1 queue for looking up shuffled indices list by seed.
 type CommitteeCache struct {
 	CommitteeCache *cache.FIFO
@@ -115,35 +104,6 @@ func (c *CommitteeCache) AddCommitteeShuffledList(committees *Committees) error
 	return nil
 }
 
-// AddProposerIndicesList updates the committee shuffled list with proposer indices.
-func (c *CommitteeCache) AddProposerIndicesList(seed [32]byte, indices []uint64) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	obj, exists, err := c.CommitteeCache.GetByKey(key(seed))
-	if err != nil {
-		return err
-	}
-	if !exists {
-		committees := &Committees{ProposerIndices: indices}
-		if err := c.CommitteeCache.Add(committees); err != nil {
-			return err
-		}
-	} else {
-		committees, ok := obj.(*Committees)
-		if !ok {
-			return ErrNotCommittee
-		}
-		committees.ProposerIndices = indices
-		if err := c.CommitteeCache.Add(committees); err != nil {
-			return err
-		}
-	}
-
-	trim(c.CommitteeCache, maxCommitteesCacheSize)
-	return nil
-}
-
 // ActiveIndices returns the active indices of a given seed stored in cache.
 func (c *CommitteeCache) ActiveIndices(seed [32]byte) ([]uint64, error) {
 	c.lock.RLock()
@@ -192,28 +152,10 @@ func (c *CommitteeCache) ActiveIndicesCount(seed [32]byte) (int, error) {
 	return len(item.SortedIndices), nil
 }
 
-// ProposerIndices returns the proposer indices of a given seed.
-func (c *CommitteeCache) ProposerIndices(seed [32]byte) ([]uint64, error) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	obj, exists, err := c.CommitteeCache.GetByKey(key(seed))
-	if err != nil {
-		return nil, err
-	}
-
-	if exists {
-		CommitteeCacheHit.Inc()
-	} else {
-		CommitteeCacheMiss.Inc()
-		return nil, nil
-	}
-
-	item, ok := obj.(*Committees)
-	if !ok {
-		return nil, ErrNotCommittee
-	}
-
-	return item.ProposerIndices, nil
+// HasEntry returns true if the committee cache has a value.
+func (c *CommitteeCache) HasEntry(seed string) bool {
+	_, ok, err := c.CommitteeCache.GetByKey(seed)
+	return err == nil && ok
 }
 
 func startEndIndices(c *Committees, index uint64) (uint64, uint64) {

beacon-chain/cache/committee_disabled.go

@@ -0,0 +1,50 @@
+// +build libfuzzer
+
+// This file is used in fuzzer builds to bypass global committee caches.
+package cache
+
+// FakeCommitteeCache is a struct with 1 queue for looking up shuffled indices list by seed.
+type FakeCommitteeCache struct {
+}
+
+// NewCommitteesCache creates a new committee cache for storing/accessing shuffled indices of a committee.
+func NewCommitteesCache() *FakeCommitteeCache {
+	return &FakeCommitteeCache{}
+}
+
+// Committee fetches the shuffled indices by slot and committee index. Every list of indices
+// represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.
+func (c *FakeCommitteeCache) Committee(slot uint64, seed [32]byte, index uint64) ([]uint64, error) {
+	return nil, nil
+}
+
+// AddCommitteeShuffledList adds Committee shuffled list object to the cache. T
+// his method also trims the least recently list if the cache size has ready the max cache size limit.
+func (c *FakeCommitteeCache) AddCommitteeShuffledList(committees *Committees) error {
+	return nil
+}
+
+// AddProposerIndicesList updates the committee shuffled list with proposer indices.
+func (c *FakeCommitteeCache) AddProposerIndicesList(seed [32]byte, indices []uint64) error {
+	return nil
+}
+
+// ActiveIndices returns the active indices of a given seed stored in cache.
+func (c *FakeCommitteeCache) ActiveIndices(seed [32]byte) ([]uint64, error) {
+	return nil, nil
+}
+
+// ActiveIndicesCount returns the active indices count of a given seed stored in cache.
+func (c *FakeCommitteeCache) ActiveIndicesCount(seed [32]byte) (int, error) {
+	return 0, nil
+}
+
+// ProposerIndices returns the proposer indices of a given seed.
+func (c *FakeCommitteeCache) ProposerIndices(seed [32]byte) ([]uint64, error) {
+	return nil, nil
+}
+
+// HasEntry returns true if the committee cache has a value.
+func (c *FakeCommitteeCache) HasEntry(string) bool {
+	return false
+}

beacon-chain/cache/committee_test.go

@@ -87,37 +87,6 @@ func TestCommitteeCache_ActiveCount(t *testing.T) {
 	assert.Equal(t, len(item.SortedIndices), count)
 }
 
-func TestCommitteeCache_AddProposerIndicesList(t *testing.T) {
-	cache := NewCommitteesCache()
-
-	seed := [32]byte{'A'}
-	indices := []uint64{1, 2, 3, 4, 5}
-	indices, err := cache.ProposerIndices(seed)
-	require.NoError(t, err)
-	if indices != nil {
-		t.Error("Expected committee count not to exist in empty cache")
-	}
-	require.NoError(t, cache.AddProposerIndicesList(seed, indices))
-
-	received, err := cache.ProposerIndices(seed)
-	require.NoError(t, err)
-	assert.DeepEqual(t, received, indices)
-
-	item := &Committees{Seed: [32]byte{'B'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
-	require.NoError(t, cache.AddCommitteeShuffledList(item))
-
-	indices, err = cache.ProposerIndices(item.Seed)
-	require.NoError(t, err)
-	if indices != nil {
-		t.Error("Expected committee count not to exist in empty cache")
-	}
-	require.NoError(t, cache.AddProposerIndicesList(item.Seed, indices))
-
-	received, err = cache.ProposerIndices(item.Seed)
-	require.NoError(t, err)
-	assert.DeepEqual(t, received, indices)
-}
-
 func TestCommitteeCache_CanRotate(t *testing.T) {
 	cache := NewCommitteesCache()
 
@@ -152,7 +121,6 @@ func TestCommitteeCacheOutOfRange(t *testing.T) {
 		Seed:            seed,
 		ShuffledIndices: []uint64{0},
 		SortedIndices:   []uint64{},
-		ProposerIndices: []uint64{},
 	})
 	require.NoError(t, err)
 

beacon-chain/cache/committees.go

@@ -0,0 +1,15 @@
+package cache
+
+import "errors"
+
+// ErrNotCommittee will be returned when a cache object is not a pointer to
+// a Committee struct.
+var ErrNotCommittee = errors.New("object is not a committee struct")
+
+// Committees defines the shuffled committees seed.
+type Committees struct {
+	CommitteeCount  uint64
+	Seed            [32]byte
+	ShuffledIndices []uint64
+	SortedIndices   []uint64
+}

beacon-chain/cache/common.go

@@ -24,6 +24,6 @@ func trim(queue *cache.FIFO, maxSize uint64) {
 }
 
 // popProcessNoopFunc is a no-op function that never returns an error.
-func popProcessNoopFunc(obj interface{}) error {
+func popProcessNoopFunc(_ interface{}) error {
 	return nil
 }

beacon-chain/cache/depositcache/BUILD.bazel

@@ -18,7 +18,6 @@ go_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_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -40,7 +39,6 @@ go_test(
         "//shared/trieutil: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//hooks/test:go_default_library",
     ],
 )

beacon-chain/cache/depositcache/deposits_cache.go

@@ -15,7 +15,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -51,17 +50,17 @@ type FinalizedDeposits struct {
 // stores all the deposit related data that is required by the beacon-node.
 type DepositCache struct {
 	// Beacon chain deposits in memory.
-	pendingDeposits    []*dbpb.DepositContainer
-	deposits           []*dbpb.DepositContainer
-	finalizedDeposits  *FinalizedDeposits
-	depositsLock       sync.RWMutex
-	chainStartDeposits []*ethpb.Deposit
-	chainStartPubkeys  map[string]bool
+	pendingDeposits       []*dbpb.DepositContainer
+	deposits              []*dbpb.DepositContainer
+	finalizedDeposits     *FinalizedDeposits
+	depositsLock          sync.RWMutex
+	chainStartPubkeys     map[string]bool
+	chainStartPubkeysLock sync.RWMutex
 }
 
-// NewDepositCache instantiates a new deposit cache
-func NewDepositCache() (*DepositCache, error) {
-	finalizedDepositsTrie, err := trieutil.NewTrie(int(params.BeaconConfig().DepositContractTreeDepth))
+// New instantiates a new deposit cache
+func New() (*DepositCache, error) {
+	finalizedDepositsTrie, err := trieutil.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
 	if err != nil {
 		return nil, err
 	}
@@ -69,11 +68,10 @@ func NewDepositCache() (*DepositCache, error) {
 	// finalizedDeposits.MerkleTrieIndex is initialized to -1 because it represents the index of the last trie item.
 	// Inserting the first item into the trie will set the value of the index to 0.
 	return &DepositCache{
-		pendingDeposits:    []*dbpb.DepositContainer{},
-		deposits:           []*dbpb.DepositContainer{},
-		finalizedDeposits:  &FinalizedDeposits{Deposits: finalizedDepositsTrie, MerkleTrieIndex: -1},
-		chainStartPubkeys:  make(map[string]bool),
-		chainStartDeposits: make([]*ethpb.Deposit, 0),
+		pendingDeposits:   []*dbpb.DepositContainer{},
+		deposits:          []*dbpb.DepositContainer{},
+		finalizedDeposits: &FinalizedDeposits{Deposits: finalizedDepositsTrie, MerkleTrieIndex: -1},
+		chainStartPubkeys: make(map[string]bool),
 	}, nil
 }
 
@@ -120,7 +118,7 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
 	defer dc.depositsLock.Unlock()
 
 	depositTrie := dc.finalizedDeposits.Deposits
-	insertIndex := dc.finalizedDeposits.MerkleTrieIndex + 1
+	insertIndex := int(dc.finalizedDeposits.MerkleTrieIndex + 1)
 	for _, d := range dc.deposits {
 		if d.Index <= dc.finalizedDeposits.MerkleTrieIndex {
 			continue
@@ -128,12 +126,12 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
 		if d.Index > eth1DepositIndex {
 			break
 		}
-		depHash, err := ssz.HashTreeRoot(d.Deposit.Data)
+		depHash, err := d.Deposit.Data.HashTreeRoot()
 		if err != nil {
 			log.WithError(err).Error("Could not hash deposit data. Finalized deposit cache not updated.")
 			return
 		}
-		depositTrie.Insert(depHash[:], int(insertIndex))
+		depositTrie.Insert(depHash[:], insertIndex)
 		insertIndex++
 	}
 
@@ -157,6 +155,8 @@ func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*dbpb.Deposi
 func (dc *DepositCache) MarkPubkeyForChainstart(ctx context.Context, pubkey string) {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.MarkPubkeyForChainstart")
 	defer span.End()
+	dc.chainStartPubkeysLock.Lock()
+	defer dc.chainStartPubkeysLock.Unlock()
 	dc.chainStartPubkeys[pubkey] = true
 }
 
@@ -164,6 +164,8 @@ func (dc *DepositCache) MarkPubkeyForChainstart(ctx context.Context, pubkey stri
 func (dc *DepositCache) PubkeyInChainstart(ctx context.Context, pubkey string) bool {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.PubkeyInChainstart")
 	defer span.End()
+	dc.chainStartPubkeysLock.RLock()
+	defer dc.chainStartPubkeysLock.RUnlock()
 	if dc.chainStartPubkeys != nil {
 		return dc.chainStartPubkeys[pubkey]
 	}
@@ -259,3 +261,28 @@ func (dc *DepositCache) NonFinalizedDeposits(ctx context.Context, untilBlk *big.
 
 	return deposits
 }
+
+// PruneProofs removes proofs from all deposits whose index is equal or less than untilDepositIndex.
+func (dc *DepositCache) PruneProofs(ctx context.Context, untilDepositIndex int64) error {
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.PruneProofs")
+	defer span.End()
+	dc.depositsLock.Lock()
+	defer dc.depositsLock.Unlock()
+
+	if untilDepositIndex > int64(len(dc.deposits)) {
+		untilDepositIndex = int64(len(dc.deposits) - 1)
+	}
+
+	for i := untilDepositIndex; i >= 0; i-- {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		// Finding a nil proof means that all proofs up to this deposit have been already pruned.
+		if dc.deposits[i].Deposit.Proof == nil {
+			break
+		}
+		dc.deposits[i].Deposit.Proof = nil
+	}
+
+	return nil
+}

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -20,11 +19,11 @@ import (
 
 const nilDepositErr = "Ignoring nil deposit insertion"
 
-var _ = DepositFetcher(&DepositCache{})
+var _ DepositFetcher = (*DepositCache)(nil)
 
 func TestInsertDeposit_LogsOnNilDepositInsertion(t *testing.T) {
 	hook := logTest.NewGlobal()
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	dc.InsertDeposit(context.Background(), nil, 1, 0, [32]byte{})
@@ -34,7 +33,7 @@ func TestInsertDeposit_LogsOnNilDepositInsertion(t *testing.T) {
 }
 
 func TestInsertDeposit_MaintainsSortedOrderByIndex(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	insertions := []struct {
@@ -76,7 +75,7 @@ func TestInsertDeposit_MaintainsSortedOrderByIndex(t *testing.T) {
 }
 
 func TestAllDeposits_ReturnsAllDeposits(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	deposits := []*dbpb.DepositContainer{
@@ -116,7 +115,7 @@ func TestAllDeposits_ReturnsAllDeposits(t *testing.T) {
 }
 
 func TestAllDeposits_FiltersDepositUpToAndIncludingBlockNumber(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	deposits := []*dbpb.DepositContainer{
@@ -156,38 +155,80 @@ func TestAllDeposits_FiltersDepositUpToAndIncludingBlockNumber(t *testing.T) {
 }
 
 func TestDepositsNumberAndRootAtHeight_ReturnsAppropriateCountAndRoot(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	dc.deposits = []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
 		},
 		{
 			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
 		},
 		{
 			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
 		},
 		{
 			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
 		},
 		{
 			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-			DepositRoot:     []byte("root"),
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			DepositRoot: bytesutil.PadTo([]byte("root"), 32),
 		},
 		{
 			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
 		},
 		{
 			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
 		},
 	}
 
@@ -197,19 +238,31 @@ func TestDepositsNumberAndRootAtHeight_ReturnsAppropriateCountAndRoot(t *testing
 }
 
 func TestDepositsNumberAndRootAtHeight_ReturnsEmptyTrieIfBlockHeightLessThanOldestDeposit(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	dc.deposits = []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-			DepositRoot:     []byte("root"),
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			DepositRoot: bytesutil.PadTo([]byte("root"), 32),
 		},
 		{
 			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-			DepositRoot:     []byte("root"),
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			DepositRoot: bytesutil.PadTo([]byte("root"), 32),
 		},
 	}
 
@@ -219,7 +272,7 @@ func TestDepositsNumberAndRootAtHeight_ReturnsEmptyTrieIfBlockHeightLessThanOlde
 }
 
 func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	dc.deposits = []*dbpb.DepositContainer{
@@ -227,7 +280,9 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 			Eth1BlockHeight: 9,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk0"),
+					PublicKey:             bytesutil.PadTo([]byte("pk0"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 		},
@@ -235,7 +290,9 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk1"),
+					PublicKey:             bytesutil.PadTo([]byte("pk1"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 		},
@@ -243,7 +300,9 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 			Eth1BlockHeight: 11,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk1"),
+					PublicKey:             bytesutil.PadTo([]byte("pk1"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 		},
@@ -251,15 +310,18 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 			Eth1BlockHeight: 12,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk2"),
+					PublicKey:             bytesutil.PadTo([]byte("pk2"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 		},
 	}
 
-	dep, blkNum := dc.DepositByPubkey(context.Background(), []byte("pk1"))
+	pk1 := bytesutil.PadTo([]byte("pk1"), 48)
+	dep, blkNum := dc.DepositByPubkey(context.Background(), pk1)
 
-	if !bytes.Equal(dep.Data.PublicKey, []byte("pk1")) {
+	if dep == nil || !bytes.Equal(dep.Data.PublicKey, pk1) {
 		t.Error("Returned wrong deposit")
 	}
 	assert.Equal(t, 0, blkNum.Cmp(big.NewInt(10)),
@@ -267,14 +329,16 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 }
 
 func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	finalizedDeposits := []*dbpb.DepositContainer{
 		{
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{0},
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 0,
@@ -282,7 +346,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 		{
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{1},
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 1,
@@ -290,7 +356,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 		{
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{2},
+					PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 2,
@@ -299,7 +367,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 	dc.deposits = append(finalizedDeposits, &dbpb.DepositContainer{
 		Deposit: &ethpb.Deposit{
 			Data: &ethpb.Deposit_Data{
-				PublicKey: []byte{3},
+				PublicKey:             bytesutil.PadTo([]byte{3}, 48),
+				WithdrawalCredentials: make([]byte, 32),
+				Signature:             make([]byte, 96),
 			},
 		},
 		Index: 3,
@@ -313,24 +383,26 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 
 	var deps [][]byte
 	for _, d := range finalizedDeposits {
-		hash, err := ssz.HashTreeRoot(d.Deposit.Data)
+		hash, err := d.Deposit.Data.HashTreeRoot()
 		require.NoError(t, err, "Could not hash deposit data")
 		deps = append(deps, hash[:])
 	}
-	trie, err := trieutil.GenerateTrieFromItems(deps, int(params.BeaconConfig().DepositContractTreeDepth))
+	trie, err := trieutil.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate deposit trie")
 	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
 }
 
 func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	oldFinalizedDeposits := []*dbpb.DepositContainer{
 		{
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{0},
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 0,
@@ -338,7 +410,9 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 		{
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{1},
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 1,
@@ -347,7 +421,9 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 	newFinalizedDeposit := dbpb.DepositContainer{
 		Deposit: &ethpb.Deposit{
 			Data: &ethpb.Deposit_Data{
-				PublicKey: []byte{2},
+				PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+				WithdrawalCredentials: make([]byte, 32),
+				Signature:             make([]byte, 96),
 			},
 		},
 		Index: 2,
@@ -365,17 +441,17 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 
 	var deps [][]byte
 	for _, d := range append(oldFinalizedDeposits, &newFinalizedDeposit) {
-		hash, err := ssz.HashTreeRoot(d.Deposit.Data)
+		hash, err := d.Deposit.Data.HashTreeRoot()
 		require.NoError(t, err, "Could not hash deposit data")
 		deps = append(deps, hash[:])
 	}
-	trie, err := trieutil.GenerateTrieFromItems(deps, int(params.BeaconConfig().DepositContractTreeDepth))
+	trie, err := trieutil.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate deposit trie")
 	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
 }
 
 func TestFinalizedDeposits_InitializedCorrectly(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	finalizedDeposits := dc.finalizedDeposits
@@ -385,7 +461,7 @@ func TestFinalizedDeposits_InitializedCorrectly(t *testing.T) {
 }
 
 func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	finalizedDeposits := []*dbpb.DepositContainer{
@@ -393,7 +469,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{0},
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 0,
@@ -402,7 +480,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{1},
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 1,
@@ -413,7 +493,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{2},
+					PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 2,
@@ -422,7 +504,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 			Eth1BlockHeight: 11,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{3},
+					PublicKey:             bytesutil.PadTo([]byte{3}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 3,
@@ -434,7 +518,7 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 }
 
 func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *testing.T) {
-	dc, err := NewDepositCache()
+	dc, err := New()
 	require.NoError(t, err)
 
 	finalizedDeposits := []*dbpb.DepositContainer{
@@ -442,7 +526,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{0},
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 0,
@@ -451,7 +537,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{1},
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 1,
@@ -462,7 +550,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{2},
+					PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 2,
@@ -471,7 +561,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 			Eth1BlockHeight: 11,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte{3},
+					PublicKey:             bytesutil.PadTo([]byte{3}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
 				},
 			},
 			Index: 3,
@@ -481,3 +573,137 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 	deps := dc.NonFinalizedDeposits(context.Background(), big.NewInt(10))
 	assert.Equal(t, 1, len(deps))
 }
+
+func TestPruneProofs_Ok(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	deposits := []struct {
+		blkNum  uint64
+		deposit *ethpb.Deposit
+		index   int64
+	}{
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   0,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   1,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   2,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   3,
+		},
+	}
+
+	for _, ins := range deposits {
+		dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{})
+	}
+
+	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.NotNil(t, dc.deposits[2].Deposit.Proof)
+	assert.NotNil(t, dc.deposits[3].Deposit.Proof)
+}
+
+func TestPruneProofs_SomeAlreadyPruned(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	deposits := []struct {
+		blkNum  uint64
+		deposit *ethpb.Deposit
+		index   int64
+	}{
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: nil},
+			index:   0,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: nil},
+			index:   1,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   2,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   3,
+		},
+	}
+
+	for _, ins := range deposits {
+		dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{})
+	}
+
+	require.NoError(t, dc.PruneProofs(context.Background(), 2))
+
+	assert.DeepEqual(t, ([][]byte)(nil), dc.deposits[2].Deposit.Proof)
+}
+
+func TestPruneProofs_PruneAllWhenDepositIndexTooBig(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	deposits := []struct {
+		blkNum  uint64
+		deposit *ethpb.Deposit
+		index   int64
+	}{
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   0,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   1,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   2,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   3,
+		},
+	}
+
+	for _, ins := range deposits {
+		dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{})
+	}
+
+	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)
+}
+
+func makeDepositProof() [][]byte {
+	proof := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
+	for i := range proof {
+		proof[i] = make([]byte, 32)
+	}
+	return proof
+}

beacon-chain/cache/depositcache/pending_deposits_test.go

@@ -9,11 +9,10 @@ import (
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 )
 
-var _ = PendingDepositsFetcher(&DepositCache{})
+var _ PendingDepositsFetcher = (*DepositCache)(nil)
 
 func TestInsertPendingDeposit_OK(t *testing.T) {
 	dc := DepositCache{}
@@ -31,12 +30,18 @@ func TestInsertPendingDeposit_ignoresNilDeposit(t *testing.T) {
 
 func TestRemovePendingDeposit_OK(t *testing.T) {
 	db := DepositCache{}
-	proof1 := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
+	proof1 := makeDepositProof()
 	proof1[0] = bytesutil.PadTo([]byte{'A'}, 32)
-	proof2 := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
+	proof2 := makeDepositProof()
 	proof2[0] = bytesutil.PadTo([]byte{'A'}, 32)
-	depToRemove := &ethpb.Deposit{Proof: proof1}
-	otherDep := &ethpb.Deposit{Proof: proof2}
+	data := &ethpb.Deposit_Data{
+		PublicKey:             make([]byte, 48),
+		WithdrawalCredentials: make([]byte, 32),
+		Amount:                0,
+		Signature:             make([]byte, 96),
+	}
+	depToRemove := &ethpb.Deposit{Proof: proof1, Data: data}
+	otherDep := &ethpb.Deposit{Proof: proof2, Data: data}
 	db.pendingDeposits = []*dbpb.DepositContainer{
 		{Deposit: depToRemove, Index: 1},
 		{Deposit: otherDep, Index: 5},
@@ -57,9 +62,15 @@ func TestRemovePendingDeposit_IgnoresNilDeposit(t *testing.T) {
 
 func TestPendingDeposit_RoundTrip(t *testing.T) {
 	dc := DepositCache{}
-	proof := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
+	proof := makeDepositProof()
 	proof[0] = bytesutil.PadTo([]byte{'A'}, 32)
-	dep := &ethpb.Deposit{Proof: proof}
+	data := &ethpb.Deposit_Data{
+		PublicKey:             make([]byte, 48),
+		WithdrawalCredentials: make([]byte, 32),
+		Amount:                0,
+		Signature:             make([]byte, 96),
+	}
+	dep := &ethpb.Deposit{Proof: proof, Data: data}
 	dc.InsertPendingDeposit(context.Background(), dep, 111, 100, [32]byte{})
 	dc.RemovePendingDeposit(context.Background(), dep)
 	assert.Equal(t, 0, len(dc.pendingDeposits), "Failed to insert & delete a pending deposit")

beacon-chain/cache/feature_flag_test.go

@@ -10,5 +10,8 @@ import (
 func TestMain(m *testing.M) {
 	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{EnableEth1DataVoteCache: true})
 	defer resetCfg()
-	os.Exit(m.Run())
+	code := m.Run()
+	// os.Exit will prevent defer from being called
+	resetCfg()
+	os.Exit(code)
 }

beacon-chain/cache/proposer_indices.go

@@ -0,0 +1,88 @@
+// +build !libfuzzer
+
+package cache
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"k8s.io/client-go/tools/cache"
+)
+
+var (
+	// maxProposerIndicesCacheSize defines the max number of proposer indices on per block root basis can cache.
+	// Due to reorgs and long finality, it's good to keep the old cache around for quickly switch over.
+	maxProposerIndicesCacheSize = uint64(8)
+
+	// ProposerIndicesCacheMiss tracks the number of proposerIndices requests that aren't present in the cache.
+	ProposerIndicesCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "proposer_indices_cache_miss",
+		Help: "The number of proposer indices requests that aren't present in the cache.",
+	})
+	// ProposerIndicesCacheHit tracks the number of proposerIndices requests that are in the cache.
+	ProposerIndicesCacheHit = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "proposer_indices_cache_hit",
+		Help: "The number of proposer indices requests that are present in the cache.",
+	})
+)
+
+// ProposerIndicesCache is a struct with 1 queue for looking up proposer indices by root.
+type ProposerIndicesCache struct {
+	ProposerIndicesCache *cache.FIFO
+	lock                 sync.RWMutex
+}
+
+// proposerIndicesKeyFn takes the block root as the key to retrieve proposer indices in a given epoch.
+func proposerIndicesKeyFn(obj interface{}) (string, error) {
+	info, ok := obj.(*ProposerIndices)
+	if !ok {
+		return "", ErrNotProposerIndices
+	}
+
+	return key(info.BlockRoot), nil
+}
+
+// NewProposerIndicesCache creates a new proposer indices cache for storing/accessing proposer index assignments of an epoch.
+func NewProposerIndicesCache() *ProposerIndicesCache {
+	return &ProposerIndicesCache{
+		ProposerIndicesCache: cache.NewFIFO(proposerIndicesKeyFn),
+	}
+}
+
+// AddProposerIndices adds ProposerIndices object to the cache.
+// This method also trims the least recently list if the cache size has ready the max cache size limit.
+func (c *ProposerIndicesCache) AddProposerIndices(p *ProposerIndices) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if err := c.ProposerIndicesCache.AddIfNotPresent(p); err != nil {
+		return err
+	}
+	trim(c.ProposerIndicesCache, maxProposerIndicesCacheSize)
+	return nil
+}
+
+// ProposerIndices returns the proposer indices of a block root seed.
+func (c *ProposerIndicesCache) ProposerIndices(r [32]byte) ([]uint64, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	obj, exists, err := c.ProposerIndicesCache.GetByKey(key(r))
+	if err != nil {
+		return nil, err
+	}
+
+	if exists {
+		ProposerIndicesCacheHit.Inc()
+	} else {
+		ProposerIndicesCacheMiss.Inc()
+		return nil, nil
+	}
+
+	item, ok := obj.(*ProposerIndices)
+	if !ok {
+		return nil, ErrNotProposerIndices
+	}
+
+	return item.ProposerIndices, nil
+}

beacon-chain/cache/proposer_indices_disabled.go

@@ -0,0 +1,24 @@
+// +build libfuzzer
+
+// This file is used in fuzzer builds to bypass proposer indices caches.
+package cache
+
+// FakeProposerIndicesCache is a struct with 1 queue for looking up proposer indices by root.
+type FakeProposerIndicesCache struct {
+}
+
+// NewProposerIndicesCache creates a new proposer indices cache for storing/accessing proposer index assignments of an epoch.
+func NewProposerIndicesCache() *FakeProposerIndicesCache {
+	return &FakeProposerIndicesCache{}
+}
+
+// AddProposerIndices adds ProposerIndices object to the cache.
+// This method also trims the least recently list if the cache size has ready the max cache size limit.
+func (c *FakeProposerIndicesCache) AddProposerIndices(p *ProposerIndices) error {
+	return nil
+}
+
+// ProposerIndices returns the proposer indices of a block root seed.
+func (c *FakeProposerIndicesCache) ProposerIndices(r [32]byte) ([]uint64, error) {
+	return nil, nil
+}

beacon-chain/cache/proposer_indices_test.go

@@ -0,0 +1,63 @@
+package cache
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestProposerKeyFn_OK(t *testing.T) {
+	item := &ProposerIndices{
+		BlockRoot:       [32]byte{'A'},
+		ProposerIndices: []uint64{1, 2, 3, 4, 5},
+	}
+
+	k, err := proposerIndicesKeyFn(item)
+	require.NoError(t, err)
+	assert.Equal(t, key(item.BlockRoot), k)
+}
+
+func TestProposerKeyFn_InvalidObj(t *testing.T) {
+	_, err := proposerIndicesKeyFn("bad")
+	assert.Equal(t, ErrNotProposerIndices, err)
+}
+
+func TestProposerCache_AddProposerIndicesList(t *testing.T) {
+	cache := NewProposerIndicesCache()
+	bRoot := [32]byte{'A'}
+	indices, err := cache.ProposerIndices(bRoot)
+	require.NoError(t, err)
+	if indices != nil {
+		t.Error("Expected committee count not to exist in empty cache")
+	}
+	require.NoError(t, cache.AddProposerIndices(&ProposerIndices{
+		ProposerIndices: indices,
+		BlockRoot:       bRoot,
+	}))
+
+	received, err := cache.ProposerIndices(bRoot)
+	require.NoError(t, err)
+	assert.DeepEqual(t, received, indices)
+
+	item := &ProposerIndices{BlockRoot: [32]byte{'B'}, ProposerIndices: []uint64{1, 2, 3, 4, 5, 6}}
+	require.NoError(t, cache.AddProposerIndices(item))
+
+	received, err = cache.ProposerIndices(item.BlockRoot)
+	require.NoError(t, err)
+	assert.DeepEqual(t, item.ProposerIndices, received)
+}
+
+func TestProposerCache_CanRotate(t *testing.T) {
+	cache := NewProposerIndicesCache()
+	for i := 0; i < int(maxProposerIndicesCacheSize)+1; i++ {
+		s := []byte(strconv.Itoa(i))
+		item := &ProposerIndices{BlockRoot: bytesutil.ToBytes32(s)}
+		require.NoError(t, cache.AddProposerIndices(item))
+	}
+
+	k := cache.ProposerIndicesCache.ListKeys()
+	assert.Equal(t, maxProposerIndicesCacheSize, uint64(len(k)))
+}

beacon-chain/cache/proposer_indices_type.go

@@ -0,0 +1,13 @@
+package cache
+
+import "errors"
+
+// ErrNotProposerIndices will be returned when a cache object is not a pointer to
+// a ProposerIndices struct.
+var ErrNotProposerIndices = errors.New("object is not a proposer indices struct")
+
+// ProposerIndices defines the cached struct for proposer indices.
+type ProposerIndices struct {
+	BlockRoot       [32]byte
+	ProposerIndices []uint64
+}

beacon-chain/cache/skip_slot_cache.go

@@ -30,7 +30,7 @@ type SkipSlotCache struct {
 	cache      *lru.Cache
 	lock       sync.RWMutex
 	disabled   bool // Allow for programmatic toggling of the cache, useful during initial sync.
-	inProgress map[uint64]bool
+	inProgress map[[32]byte]bool
 }
 
 // NewSkipSlotCache initializes the map and underlying cache.
@@ -41,7 +41,7 @@ func NewSkipSlotCache() *SkipSlotCache {
 	}
 	return &SkipSlotCache{
 		cache:      cache,
-		inProgress: make(map[uint64]bool),
+		inProgress: make(map[[32]byte]bool),
 	}
 }
 
@@ -57,7 +57,7 @@ func (c *SkipSlotCache) Disable() {
 
 // Get waits for any in progress calculation to complete before returning a
 // cached response, if any.
-func (c *SkipSlotCache) Get(ctx context.Context, slot uint64) (*stateTrie.BeaconState, error) {
+func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (*stateTrie.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "skipSlotCache.Get")
 	defer span.End()
 	if c.disabled {
@@ -77,7 +77,7 @@ func (c *SkipSlotCache) Get(ctx context.Context, slot uint64) (*stateTrie.Beacon
 		}
 
 		c.lock.RLock()
-		if !c.inProgress[slot] {
+		if !c.inProgress[r] {
 			c.lock.RUnlock()
 			break
 		}
@@ -92,7 +92,7 @@ func (c *SkipSlotCache) Get(ctx context.Context, slot uint64) (*stateTrie.Beacon
 	}
 	span.AddAttributes(trace.BoolAttribute("inProgress", inProgress))
 
-	item, exists := c.cache.Get(slot)
+	item, exists := c.cache.Get(r)
 
 	if exists && item != nil {
 		skipSlotCacheHit.Inc()
@@ -106,7 +106,7 @@ func (c *SkipSlotCache) Get(ctx context.Context, slot uint64) (*stateTrie.Beacon
 
 // MarkInProgress a request so that any other similar requests will block on
 // Get until MarkNotInProgress is called.
-func (c *SkipSlotCache) MarkInProgress(slot uint64) error {
+func (c *SkipSlotCache) MarkInProgress(r [32]byte) error {
 	if c.disabled {
 		return nil
 	}
@@ -114,16 +114,16 @@ func (c *SkipSlotCache) MarkInProgress(slot uint64) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
-	if c.inProgress[slot] {
+	if c.inProgress[r] {
 		return ErrAlreadyInProgress
 	}
-	c.inProgress[slot] = true
+	c.inProgress[r] = true
 	return nil
 }
 
 // MarkNotInProgress will release the lock on a given request. This should be
 // called after put.
-func (c *SkipSlotCache) MarkNotInProgress(slot uint64) error {
+func (c *SkipSlotCache) MarkNotInProgress(r [32]byte) error {
 	if c.disabled {
 		return nil
 	}
@@ -131,18 +131,18 @@ func (c *SkipSlotCache) MarkNotInProgress(slot uint64) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
-	delete(c.inProgress, slot)
+	delete(c.inProgress, r)
 	return nil
 }
 
 // Put the response in the cache.
-func (c *SkipSlotCache) Put(ctx context.Context, slot uint64, state *stateTrie.BeaconState) error {
+func (c *SkipSlotCache) Put(_ context.Context, r [32]byte, state *stateTrie.BeaconState) error {
 	if c.disabled {
 		return nil
 	}
 
 	// Copy state so cached value is not mutated.
-	c.cache.Add(slot, state.Copy())
+	c.cache.Add(r, state.Copy())
 
 	return nil
 }

beacon-chain/cache/skip_slot_cache_test.go

@@ -15,21 +15,22 @@ func TestSkipSlotCache_RoundTrip(t *testing.T) {
 	ctx := context.Background()
 	c := cache.NewSkipSlotCache()
 
-	state, err := c.Get(ctx, 5)
+	r := [32]byte{'a'}
+	state, err := c.Get(ctx, r)
 	require.NoError(t, err)
 	assert.Equal(t, (*stateTrie.BeaconState)(nil), state, "Empty cache returned an object")
 
-	require.NoError(t, c.MarkInProgress(5))
+	require.NoError(t, c.MarkInProgress(r))
 
 	state, err = stateTrie.InitializeFromProto(&pb.BeaconState{
 		Slot: 10,
 	})
 	require.NoError(t, err)
 
-	require.NoError(t, c.Put(ctx, 5, state))
-	require.NoError(t, c.MarkNotInProgress(5))
+	require.NoError(t, c.Put(ctx, r, state))
+	require.NoError(t, c.MarkNotInProgress(r))
 
-	res, err := c.Get(ctx, 5)
+	res, err := c.Get(ctx, r)
 	require.NoError(t, err)
 	assert.DeepEqual(t, res.CloneInnerState(), state.CloneInnerState(), "Expected equal protos to return from cache")
 }

beacon-chain/cache/state_summary.go

@@ -50,11 +50,11 @@ func (s *StateSummaryCache) GetAll() []*pb.StateSummary {
 	s.initSyncStateSummariesLock.RLock()
 	defer s.initSyncStateSummariesLock.RUnlock()
 
-	blks := make([]*pb.StateSummary, 0, len(s.initSyncStateSummaries))
+	summaries := make([]*pb.StateSummary, 0, len(s.initSyncStateSummaries))
 	for _, b := range s.initSyncStateSummaries {
-		blks = append(blks, b)
+		summaries = append(summaries, b)
 	}
-	return blks
+	return summaries
 }
 
 // Clear clears out the initial sync state summaries cache.

beacon-chain/cache/subnet_ids.go

@@ -25,12 +25,12 @@ var SubnetIDs = newSubnetIDs()
 func newSubnetIDs() *subnetIDs {
 	// Given a node can calculate committee assignments of current epoch and next epoch.
 	// Max size is set to 2 epoch length.
-	cacheSize := params.BeaconConfig().MaxCommitteesPerSlot * params.BeaconConfig().SlotsPerEpoch * 2
-	attesterCache, err := lru.New(int(cacheSize))
+	cacheSize := int(params.BeaconConfig().MaxCommitteesPerSlot * params.BeaconConfig().SlotsPerEpoch * 2)
+	attesterCache, err := lru.New(cacheSize)
 	if err != nil {
 		panic(err)
 	}
-	aggregatorCache, err := lru.New(int(cacheSize))
+	aggregatorCache, err := lru.New(cacheSize)
 	if err != nil {
 		panic(err)
 	}
@@ -41,7 +41,7 @@ func newSubnetIDs() *subnetIDs {
 }
 
 // AddAttesterSubnetID adds the subnet index for subscribing subnet for the attester of a given slot.
-func (c *subnetIDs) AddAttesterSubnetID(slot uint64, subnetID uint64) {
+func (c *subnetIDs) AddAttesterSubnetID(slot, subnetID uint64) {
 	c.attesterLock.Lock()
 	defer c.attesterLock.Unlock()
 
@@ -69,7 +69,7 @@ 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 uint64, subnetID uint64) {
+func (c *subnetIDs) AddAggregatorSubnetID(slot, subnetID uint64) {
 	c.aggregatorLock.Lock()
 	defer c.aggregatorLock.Unlock()
 
@@ -113,7 +113,7 @@ func (c *subnetIDs) GetAllSubnets() []uint64 {
 	defer c.subnetsLock.RUnlock()
 
 	itemsMap := c.persistentSubnets.Items()
-	committees := []uint64{}
+	var committees []uint64
 
 	for _, v := range itemsMap {
 		if v.Expired() {

beacon-chain/cache/subnet_ids_test.go

@@ -42,12 +42,10 @@ func TestSubnetIDsCache_RoundTrip(t *testing.T) {
 }
 
 func TestSubnetIDsCache_PersistentCommitteeRoundtrip(t *testing.T) {
-	pubkeySet := [][48]byte{}
 	c := newSubnetIDs()
 
 	for i := 0; i < 20; i++ {
 		pubkey := [48]byte{byte(i)}
-		pubkeySet = append(pubkeySet, pubkey)
 		c.AddPersistentCommittee(pubkey[:], []uint64{uint64(i)}, 0)
 	}
 

beacon-chain/core/blocks/BUILD.bazel

@@ -21,12 +21,12 @@ go_library(
         "//beacon-chain:__subpackages__",
         "//fuzz:__pkg__",
         "//shared/testutil:__pkg__",
+        "//validator/accounts:__pkg__",
     ],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/stateutil:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/attestationutil:go_default_library",
         "//shared/bls:go_default_library",
@@ -50,6 +50,7 @@ go_test(
     name = "go_default_test",
     size = "medium",
     srcs = [
+        "attestation_regression_test.go",
         "attestation_test.go",
         "attester_slashing_test.go",
         "block_operations_fuzz_test.go",
@@ -62,11 +63,12 @@ go_test(
         "proposer_slashing_test.go",
         "randao_test.go",
     ],
+    data = glob(["testdata/**"]),
     embed = [":go_default_library"],
+    shard_count = 2,
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/stateutil:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/aggregation:go_default_library",
         "//shared/aggregation/attestations:go_default_library",
@@ -82,7 +84,6 @@ go_test(
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/core/blocks/attestation.go

@@ -12,6 +12,7 @@ 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"
 )
@@ -21,10 +22,14 @@ import (
 func ProcessAttestations(
 	ctx context.Context,
 	beaconState *stateTrie.BeaconState,
-	body *ethpb.BeaconBlockBody,
+	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
+	if b.Block == nil || b.Block.Body == nil {
+		return nil, errors.New("block and block body can't be nil")
+	}
+
 	var err error
-	for idx, attestation := range body.Attestations {
+	for idx, attestation := range b.Block.Body.Attestations {
 		beaconState, err = ProcessAttestation(ctx, beaconState, attestation)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not verify attestation at index %d in block", idx)
@@ -67,23 +72,27 @@ func ProcessAttestation(
 	beaconState *stateTrie.BeaconState,
 	att *ethpb.Attestation,
 ) (*stateTrie.BeaconState, error) {
-	beaconState, err := ProcessAttestationNoVerify(ctx, beaconState, att)
+	beaconState, err := ProcessAttestationNoVerifySignature(ctx, beaconState, att)
 	if err != nil {
 		return nil, err
 	}
-	return beaconState, VerifyAttestation(ctx, beaconState, att)
+	return beaconState, VerifyAttestationSignature(ctx, beaconState, att)
 }
 
-// ProcessAttestationsNoVerify applies processing operations to a block's inner attestation
+// ProcessAttestationsNoVerifySignature applies processing operations to a block's inner attestation
 // records. The only difference would be that the attestation signature would not be verified.
-func ProcessAttestationsNoVerify(
+func ProcessAttestationsNoVerifySignature(
 	ctx context.Context,
 	beaconState *stateTrie.BeaconState,
-	body *ethpb.BeaconBlockBody,
+	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
+	if b.Block == nil || b.Block.Body == nil {
+		return nil, errors.New("block and block body can't be nil")
+	}
+	body := b.Block.Body
 	var err error
 	for idx, attestation := range body.Attestations {
-		beaconState, err = ProcessAttestationNoVerify(ctx, beaconState, attestation)
+		beaconState, err = ProcessAttestationNoVerifySignature(ctx, beaconState, attestation)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not verify attestation at index %d in block", idx)
 		}
@@ -91,14 +100,14 @@ func ProcessAttestationsNoVerify(
 	return beaconState, nil
 }
 
-// ProcessAttestationNoVerify processes the attestation without verifying the attestation signature. This
+// ProcessAttestationNoVerifySignature processes the attestation without verifying the attestation signature. This
 // method is used to validate attestations whose signatures have already been verified.
-func ProcessAttestationNoVerify(
+func ProcessAttestationNoVerifySignature(
 	ctx context.Context,
 	beaconState *stateTrie.BeaconState,
 	att *ethpb.Attestation,
 ) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "core.ProcessAttestationNoVerify")
+	ctx, span := trace.StartSpan(ctx, "core.ProcessAttestationNoVerifySignature")
 	defer span.End()
 
 	if att == nil || att.Data == nil || att.Data.Target == nil {
@@ -149,7 +158,7 @@ func ProcessAttestationNoVerify(
 		return nil, err
 	}
 	c := helpers.SlotCommitteeCount(activeValidatorCount)
-	if att.Data.CommitteeIndex > c {
+	if att.Data.CommitteeIndex >= c {
 		return nil, fmt.Errorf("committee index %d >= committee count %d", att.Data.CommitteeIndex, c)
 	}
 
@@ -196,17 +205,28 @@ func ProcessAttestationNoVerify(
 		return nil, fmt.Errorf("expected target epoch %d, received %d", ffgTargetEpoch, data.Target.Epoch)
 	}
 
+	// Verify attesting indices are correct.
+	committee, err := helpers.BeaconCommitteeFromState(beaconState, att.Data.Slot, att.Data.CommitteeIndex)
+	if err != nil {
+		return nil, err
+	}
+	indexedAtt := attestationutil.ConvertToIndexed(ctx, att, committee)
+	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
+		return nil, err
+	}
+
 	return beaconState, nil
 }
 
-// VerifyAttestations will verify the signatures of the provided attestations. This method performs
+// VerifyAttestationsSignatures will verify the signatures of the provided attestations. This method performs
 // a single BLS verification call to verify the signatures of all of the provided attestations. All
 // of the provided attestations must have valid signatures or this method will return an error.
 // This method does not determine which attestation signature is invalid, only that one or more
 // attestation signatures were not valid.
-func VerifyAttestations(ctx context.Context, beaconState *stateTrie.BeaconState, atts []*ethpb.Attestation) error {
-	ctx, span := trace.StartSpan(ctx, "core.VerifyAttestations")
+func VerifyAttestationsSignatures(ctx context.Context, beaconState *stateTrie.BeaconState, b *ethpb.SignedBeaconBlock) error {
+	ctx, span := trace.StartSpan(ctx, "core.VerifyAttestationsSignatures")
 	defer span.End()
+	atts := b.Block.Body.Attestations
 	span.AddAttributes(trace.Int64Attribute("attestations", int64(len(atts))))
 
 	if len(atts) == 0 {
@@ -234,7 +254,7 @@ func VerifyAttestations(ctx context.Context, beaconState *stateTrie.BeaconState,
 		if err != nil {
 			return err
 		}
-		if err := verifyAttestationsWithDomain(ctx, beaconState, preForkAtts, prevDomain); err != nil {
+		if err := verifyAttestationsSigWithDomain(ctx, beaconState, preForkAtts, prevDomain); err != nil {
 			return err
 		}
 	} else if len(preForkAtts) > 0 {
@@ -249,12 +269,12 @@ func VerifyAttestations(ctx context.Context, beaconState *stateTrie.BeaconState,
 		return err
 	}
 
-	return verifyAttestationsWithDomain(ctx, beaconState, postForkAtts, currDomain)
+	return verifyAttestationsSigWithDomain(ctx, beaconState, postForkAtts, currDomain)
 }
 
-// VerifyAttestation converts and attestation into an indexed attestation and verifies
+// VerifyAttestationSignature converts and attestation into an indexed attestation and verifies
 // the signature in that attestation.
-func VerifyAttestation(ctx context.Context, beaconState *stateTrie.BeaconState, att *ethpb.Attestation) error {
+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)
 	}
@@ -294,7 +314,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState *stateTrie.Beacon
 		return err
 	}
 	indices := indexedAtt.AttestingIndices
-	pubkeys := []bls.PublicKey{}
+	var pubkeys []bls.PublicKey
 	for i := 0; i < len(indices); i++ {
 		pubkeyAtIdx := beaconState.PubkeyAtIndex(indices[i])
 		pk, err := bls.PublicKeyFromBytes(pubkeyAtIdx[:])
@@ -308,7 +328,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState *stateTrie.Beacon
 
 // Inner method to verify attestations. This abstraction allows for the domain to be provided as an
 // argument.
-func verifyAttestationsWithDomain(ctx context.Context, beaconState *stateTrie.BeaconState, atts []*ethpb.Attestation, domain []byte) error {
+func verifyAttestationsSigWithDomain(ctx context.Context, beaconState *stateTrie.BeaconState, atts []*ethpb.Attestation, domain []byte) error {
 	if len(atts) == 0 {
 		return nil
 	}
@@ -316,7 +336,7 @@ func verifyAttestationsWithDomain(ctx context.Context, beaconState *stateTrie.Be
 	if err != nil {
 		return err
 	}
-	verify, err := bls.VerifyMultipleSignatures(set.Signatures, set.Messages, set.PublicKeys)
+	verify, err := set.Verify()
 	if err != nil {
 		return errors.Errorf("got error in multiple verification: %v", err)
 	}
@@ -325,3 +345,35 @@ func verifyAttestationsWithDomain(ctx context.Context, beaconState *stateTrie.Be
 	}
 	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_regression_test.go

@@ -0,0 +1,44 @@
+package blocks_test
+
+import (
+	"context"
+	"io/ioutil"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+// Beaconfuzz discovered an off by one issue where an attestation could be produced which would pass
+// validation when att.Data.CommitteeIndex is 1 and the committee count per slot is also 1. The only
+// valid att.Data.Committee index would be 0, so this is an off by one error.
+// See: https://github.com/sigp/beacon-fuzz/issues/78
+func TestProcessAttestationNoVerifySignature_BeaconFuzzIssue78(t *testing.T) {
+	attData, err := ioutil.ReadFile("testdata/beaconfuzz_78_attestation.ssz")
+	if err != nil {
+		t.Fatal(err)
+	}
+	att := &ethpb.Attestation{}
+	if err := att.UnmarshalSSZ(attData); err != nil {
+		t.Fatal(err)
+	}
+	stateData, err := ioutil.ReadFile("testdata/beaconfuzz_78_beacon.ssz")
+	if err != nil {
+		t.Fatal(err)
+	}
+	spb := &pb.BeaconState{}
+	if err := spb.UnmarshalSSZ(stateData); err != nil {
+		t.Fatal(err)
+	}
+	st, err := state.InitializeFromProtoUnsafe(spb)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx := context.Background()
+	_, err = blocks.ProcessAttestationNoVerifySignature(ctx, st, att)
+	require.ErrorContains(t, "committee index 1 >= committee count 1", err)
+}

beacon-chain/core/blocks/attestation_test.go

@@ -15,6 +15,7 @@ import (
 	attaggregation "github.com/prysmaticlabs/prysm/shared/aggregation/attestations"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"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"
@@ -25,12 +26,13 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 	attestations := []*ethpb.Attestation{
 		{
 			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{Epoch: 0},
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 				Slot:   5,
 			},
 		},
 	}
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Attestations: attestations,
 		},
@@ -43,7 +45,7 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 		params.BeaconConfig().MinAttestationInclusionDelay,
 		beaconState.Slot(),
 	)
-	_, err := blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err := blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -53,7 +55,8 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
 			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
 			Target: &ethpb.Checkpoint{Epoch: 0}}}
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Attestations: []*ethpb.Attestation{att},
 		},
@@ -72,7 +75,7 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
 		helpers.PrevEpoch(beaconState),
 		helpers.CurrentEpoch(beaconState),
 	)
-	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -81,13 +84,14 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 	attestations := []*ethpb.Attestation{
 		{
 			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{Epoch: 0},
-				Source: &ethpb.Checkpoint{Epoch: 1},
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+				Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
 			},
 			AggregationBits: aggBits,
 		},
 	}
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Attestations: attestations,
 		},
@@ -104,18 +108,18 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 		helpers.CurrentEpoch(beaconState),
 		attestations[0].Data.Source.Epoch,
 	)
-	_, err := blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err := blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 
-	block.Body.Attestations[0].Data.Source.Epoch = helpers.CurrentEpoch(beaconState)
-	block.Body.Attestations[0].Data.Source.Root = []byte{}
+	b.Block.Body.Attestations[0].Data.Source.Epoch = helpers.CurrentEpoch(beaconState)
+	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
 
 	want = fmt.Sprintf(
 		"expected source root %#x, received %#x",
 		beaconState.CurrentJustifiedCheckpoint().Root,
 		attestations[0].Data.Source.Root,
 	)
-	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -127,14 +131,15 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 	attestations := []*ethpb.Attestation{
 		{
 			Data: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{Epoch: 1},
-				Target: &ethpb.Checkpoint{Epoch: 1},
+				Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+				Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
 				Slot:   params.BeaconConfig().SlotsPerEpoch,
 			},
 			AggregationBits: aggBits,
 		},
 	}
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Attestations: attestations,
 		},
@@ -152,19 +157,19 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 		helpers.PrevEpoch(beaconState),
 		attestations[0].Data.Source.Epoch,
 	)
-	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 
-	block.Body.Attestations[0].Data.Source.Epoch = helpers.PrevEpoch(beaconState)
-	block.Body.Attestations[0].Data.Target.Epoch = helpers.CurrentEpoch(beaconState)
-	block.Body.Attestations[0].Data.Source.Root = []byte{}
+	b.Block.Body.Attestations[0].Data.Source.Epoch = helpers.PrevEpoch(beaconState)
+	b.Block.Body.Attestations[0].Data.Target.Epoch = helpers.CurrentEpoch(beaconState)
+	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
 
 	want = fmt.Sprintf(
 		"expected source root %#x, received %#x",
 		beaconState.CurrentJustifiedCheckpoint().Root,
 		attestations[0].Data.Source.Root,
 	)
-	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -179,7 +184,8 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 		AggregationBits: aggBits,
 	}
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Attestations: []*ethpb.Attestation{att},
 		},
@@ -194,7 +200,7 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
 
 	expected := "failed to verify aggregation bitfield: wanted participants bitfield length 3, got: 4"
-	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
 	assert.ErrorContains(t, expected, err)
 }
 
@@ -207,10 +213,12 @@ func TestProcessAttestations_OK(t *testing.T) {
 	copy(mockRoot[:], "hello-world")
 	att := &ethpb.Attestation{
 		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
-			Target: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+			Source:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+			Target:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+			BeaconBlockRoot: make([]byte, 32),
 		},
 		AggregationBits: aggBits,
+		Signature:       make([]byte, 96),
 	}
 
 	cfc := beaconState.CurrentJustifiedCheckpoint()
@@ -230,25 +238,23 @@ func TestProcessAttestations_OK(t *testing.T) {
 		require.NoError(t, err)
 		sigs[i] = sig
 	}
-	att.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
+	att.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	block := &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			Attestations: []*ethpb.Attestation{att},
-		},
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.Body.Attestations = []*ethpb.Attestation{att}
 
 	err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
 	require.NoError(t, err)
-	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block)
 	assert.NoError(t, err)
 }
 
 func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
 	data := &ethpb.AttestationData{
-		Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
-		Target: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
+		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)
 	aggBits1.SetBitAt(0, true)
@@ -260,7 +266,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	}
 
 	cfc := beaconState.CurrentJustifiedCheckpoint()
-	cfc.Root = []byte("hello-world")
+	cfc.Root = bytesutil.PadTo([]byte("hello-world"), 32)
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
 	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
 
@@ -276,7 +282,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 		require.NoError(t, err)
 		sigs[i] = sig
 	}
-	att1.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
+	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
 
 	aggBits2 := bitfield.NewBitlist(4)
 	aggBits2.SetBitAt(1, true)
@@ -299,7 +305,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 		require.NoError(t, err)
 		sigs[i] = sig
 	}
-	att2.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
+	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
 	_, err = attaggregation.AggregatePair(att1, att2)
 	assert.ErrorContains(t, aggregation.ErrBitsOverlap.Error(), err)
@@ -311,8 +317,9 @@ 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[:]},
+		Source:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+		Target:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+		BeaconBlockRoot: make([]byte, 32),
 	}
 	aggBits1 := bitfield.NewBitlist(9)
 	aggBits1.SetBitAt(0, true)
@@ -320,6 +327,7 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 	att1 := &ethpb.Attestation{
 		Data:            data,
 		AggregationBits: aggBits1,
+		Signature:       make([]byte, 32),
 	}
 
 	cfc := beaconState.CurrentJustifiedCheckpoint()
@@ -339,7 +347,7 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 		require.NoError(t, err)
 		sigs[i] = sig
 	}
-	att1.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
+	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
 
 	aggBits2 := bitfield.NewBitlist(9)
 	aggBits2.SetBitAt(2, true)
@@ -347,6 +355,7 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 	att2 := &ethpb.Attestation{
 		Data:            data,
 		AggregationBits: aggBits2,
+		Signature:       make([]byte, 32),
 	}
 
 	committee, err = helpers.BeaconCommitteeFromState(beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
@@ -361,20 +370,17 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 		require.NoError(t, err)
 		sigs[i] = sig
 	}
-	att2.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
+	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
 	aggregatedAtt, err := attaggregation.AggregatePair(att1, att2)
 	require.NoError(t, err)
-	block := &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			Attestations: []*ethpb.Attestation{aggregatedAtt},
-		},
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.Body.Attestations = []*ethpb.Attestation{aggregatedAtt}
 
 	err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
 	require.NoError(t, err)
 
-	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block)
 	assert.NoError(t, err)
 }
 
@@ -384,11 +390,11 @@ func TestProcessAttestationsNoVerify_IncorrectSlotTargetEpoch(t *testing.T) {
 	att := &ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Slot:   params.BeaconConfig().SlotsPerEpoch,
-			Target: &ethpb.Checkpoint{},
+			Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
 		},
 	}
 	wanted := fmt.Sprintf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(att.Data.Slot), att.Data.Target.Epoch)
-	_, err := blocks.ProcessAttestationNoVerify(context.TODO(), beaconState, att)
+	_, err := blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
 	assert.ErrorContains(t, wanted, err)
 }
 
@@ -404,7 +410,7 @@ func TestProcessAttestationsNoVerify_OK(t *testing.T) {
 	att := &ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
-			Target: &ethpb.Checkpoint{Epoch: 0},
+			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 		},
 		AggregationBits: aggBits,
 	}
@@ -419,7 +425,7 @@ func TestProcessAttestationsNoVerify_OK(t *testing.T) {
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
 	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
 
-	_, err = blocks.ProcessAttestationNoVerify(context.TODO(), beaconState, att)
+	_, err = blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
 	assert.NoError(t, err)
 }
 
@@ -433,7 +439,7 @@ func TestProcessAttestationsNoVerify_BadAttIdx(t *testing.T) {
 		Data: &ethpb.AttestationData{
 			CommitteeIndex: 100,
 			Source:         &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
-			Target:         &ethpb.Checkpoint{Epoch: 0},
+			Target:         &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 		},
 		AggregationBits: aggBits,
 	}
@@ -444,7 +450,7 @@ func TestProcessAttestationsNoVerify_BadAttIdx(t *testing.T) {
 	copy(ckp.Root, "hello-world")
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
 	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
-	_, err := blocks.ProcessAttestationNoVerify(context.TODO(), beaconState, att)
+	_, err := blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
 	require.ErrorContains(t, "committee index 100 >= committee count 1", err)
 }
 
@@ -486,8 +492,8 @@ func TestConvertToIndexed_OK(t *testing.T) {
 	attestation := &ethpb.Attestation{
 		Signature: sig[:],
 		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 0},
-			Target: &ethpb.Checkpoint{Epoch: 0},
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 		},
 	}
 	for _, tt := range tests {
@@ -512,8 +518,9 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 	require.NoError(t, err)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			PublicKey: keys[i].PublicKey().Marshal(),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
 		}
 	}
 
@@ -535,33 +542,57 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 2,
+					Root:  make([]byte, 32),
 				},
+				Source: &ethpb.Checkpoint{
+					Root: make([]byte, 32),
+				},
+				BeaconBlockRoot: make([]byte, 32),
 			},
 			AttestingIndices: []uint64{1},
+			Signature:        make([]byte, 96),
 		}},
 		{attestation: &ethpb.IndexedAttestation{
 			Data: &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{
 				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{
 				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),
 		}},
 	}
 
@@ -608,7 +639,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 
 	sig := keys[0].Sign([]byte{'t', 'e', 's', 't'})
 	list := bitfield.Bitlist{0b11111111}
-	atts := []*ethpb.Attestation{}
+	var atts []*ethpb.Attestation
 	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
 			Data: &ethpb.AttestationData{
@@ -653,32 +684,28 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
 	require.NoError(t, err)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			PublicKey: keys[i].PublicKey().Marshal(),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
 		}
 	}
 
-	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Slot:       5,
-		Validators: validators,
-		Fork: &pb.Fork{
-			Epoch:           0,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
+	st := testutil.NewBeaconState()
+	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{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
-			Slot:           1,
-			CommitteeIndex: 0,
-			Target:         new(ethpb.Checkpoint),
+			Slot:            1,
+			CommitteeIndex:  0,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
 		},
-		Signature: nil,
+		Signature: make([]byte, 96),
 	}
 	domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
 	require.NoError(t, err)
@@ -696,11 +723,13 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
 	att2 := &ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
-			Slot:           1,
-			CommitteeIndex: 1,
-			Target:         new(ethpb.Checkpoint),
+			Slot:            1,
+			CommitteeIndex:  1,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
 		},
-		Signature: nil,
+		Signature: make([]byte, 96),
 	}
 	root, err = helpers.ComputeSigningRoot(att2.Data, domain)
 	require.NoError(t, err)
@@ -711,7 +740,9 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	require.NoError(t, blocks.VerifyAttestations(ctx, st, []*ethpb.Attestation{att1, att2}))
+	b := testutil.NewBeaconBlock()
+	b.Block.Body.Attestations = []*ethpb.Attestation{att1, att2}
+	require.NoError(t, blocks.VerifyAttestationsSignatures(ctx, st, b))
 }
 
 func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
@@ -723,32 +754,33 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 	require.NoError(t, err)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			PublicKey: keys[i].PublicKey().Marshal(),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
 		}
 	}
 
-	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Slot:       35,
-		Validators: validators,
-		Fork: &pb.Fork{
-			Epoch:           1,
-			CurrentVersion:  []byte{0, 1, 2, 3},
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
+	st := testutil.NewBeaconState()
+	require.NoError(t, st.SetSlot(35))
+	require.NoError(t, st.SetValidators(validators))
+	require.NoError(t, st.SetFork(&pb.Fork{
+		Epoch:           1,
+		CurrentVersion:  []byte{0, 1, 2, 3},
+		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+	}))
 
 	comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
 	att1 := &ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
-			Slot:           1,
-			CommitteeIndex: 0,
-			Target:         new(ethpb.Checkpoint),
+			Slot:            1,
+			CommitteeIndex:  0,
+			BeaconBlockRoot: make([]byte, 32),
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
 		},
-		Signature: nil,
+		Signature: make([]byte, 96),
 	}
 	prevDomain, err := helpers.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
 	require.NoError(t, err)
@@ -766,13 +798,16 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 	att2 := &ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
-			Slot:           1*params.BeaconConfig().SlotsPerEpoch + 1,
-			CommitteeIndex: 1,
-			Target:         new(ethpb.Checkpoint),
+			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)},
 		},
-		Signature: nil,
+		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)
 	require.NoError(t, err)
 	sigs = nil
@@ -782,7 +817,9 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	require.NoError(t, blocks.VerifyAttestations(ctx, st, []*ethpb.Attestation{att1, att2}))
+	b := testutil.NewBeaconBlock()
+	b.Block.Body.Attestations = []*ethpb.Attestation{att1, att2}
+	require.NoError(t, blocks.VerifyAttestationsSignatures(ctx, st, b))
 }
 
 func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) {
@@ -793,32 +830,28 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	require.NoError(t, err)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			PublicKey: keys[i].PublicKey().Marshal(),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
 		}
 	}
 
-	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Slot:       5,
-		Validators: validators,
-		Fork: &pb.Fork{
-			Epoch:           0,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
+	st := testutil.NewBeaconState()
+	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{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
-			Slot:           1,
-			CommitteeIndex: 0,
-			Target:         new(ethpb.Checkpoint),
+			Slot:            1,
+			CommitteeIndex:  0,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
 		},
-		Signature: nil,
+		Signature: make([]byte, 96),
 	}
 	domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
 	require.NoError(t, err)
@@ -836,11 +869,13 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	att2 := &ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
-			Slot:           1,
-			CommitteeIndex: 1,
-			Target:         new(ethpb.Checkpoint),
+			Slot:            1,
+			CommitteeIndex:  1,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
 		},
-		Signature: nil,
+		Signature: make([]byte, 96),
 	}
 	root, err = helpers.ComputeSigningRoot(att2.Data, domain)
 	require.NoError(t, err)

beacon-chain/core/blocks/attester_slashing.go

@@ -35,8 +35,13 @@ import (
 func ProcessAttesterSlashings(
 	ctx context.Context,
 	beaconState *stateTrie.BeaconState,
-	body *ethpb.BeaconBlockBody,
+	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
+	if b.Block == nil || b.Block.Body == nil {
+		return nil, errors.New("block and block body can't be nil")
+	}
+
+	body := b.Block.Body
 	for idx, slashing := range body.AttesterSlashings {
 		if err := VerifyAttesterSlashing(ctx, beaconState, slashing); err != nil {
 			return nil, errors.Wrapf(err, "could not verify attester slashing %d", idx)
@@ -110,7 +115,7 @@ func VerifyAttesterSlashing(ctx context.Context, beaconState *stateTrie.BeaconSt
 //        # Surround vote
 //        (data_1.source.epoch < data_2.source.epoch and data_2.target.epoch < data_1.target.epoch)
 //    )
-func IsSlashableAttestationData(data1 *ethpb.AttestationData, data2 *ethpb.AttestationData) bool {
+func IsSlashableAttestationData(data1, data2 *ethpb.AttestationData) bool {
 	if data1 == nil || data2 == nil || data1.Target == nil || data2.Target == nil || data1.Source == nil || data2.Source == nil {
 		return false
 	}

beacon-chain/core/blocks/attester_slashing_test.go

@@ -2,7 +2,6 @@ package blocks_test
 
 import (
 	"context"
-	"fmt"
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
@@ -11,6 +10,7 @@ import (
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"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"
@@ -19,12 +19,14 @@ import (
 
 func TestSlashableAttestationData_CanSlash(t *testing.T) {
 	att1 := &ethpb.AttestationData{
-		Target: &ethpb.Checkpoint{Epoch: 1},
-		Source: &ethpb.Checkpoint{Root: []byte{'A'}},
+		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},
-		Source: &ethpb.Checkpoint{Root: []byte{'B'}},
+		Target:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+		Source:          &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'B'}, 32)},
+		BeaconBlockRoot: make([]byte, 32),
 	}
 	assert.Equal(t, true, blocks.IsSlashableAttestationData(att1, att2), "Atts should have been slashable")
 	att1.Target.Epoch = 4
@@ -38,19 +40,23 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 		{
 			Attestation_1: &ethpb.IndexedAttestation{
 				Data: &ethpb.AttestationData{
-					Source: &ethpb.Checkpoint{Epoch: 0},
-					Target: &ethpb.Checkpoint{Epoch: 0},
+					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},
-					Target: &ethpb.Checkpoint{Epoch: 1},
+					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),
 			},
 		},
 	}
-	registry := []*ethpb.Validator{}
+	var registry []*ethpb.Validator
 	currentSlot := uint64(0)
 
 	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
@@ -58,18 +64,18 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 		Slot:       currentSlot,
 	})
 	require.NoError(t, err)
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			AttesterSlashings: slashings,
 		},
 	}
-	want := fmt.Sprint("attestations are not slashable")
-	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, block.Body)
-	assert.ErrorContains(t, want, err)
+	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, b)
+	assert.ErrorContains(t, "attestations are not slashable", err)
 }
 
 func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T) {
-	registry := []*ethpb.Validator{}
+	var registry []*ethpb.Validator
 	currentSlot := uint64(0)
 
 	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
@@ -82,30 +88,34 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 		{
 			Attestation_1: &ethpb.IndexedAttestation{
 				Data: &ethpb.AttestationData{
-					Source: &ethpb.Checkpoint{Epoch: 1},
-					Target: &ethpb.Checkpoint{Epoch: 0},
+					Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					BeaconBlockRoot: make([]byte, 32),
 				},
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
+				Signature:        make([]byte, 96),
 			},
 			Attestation_2: &ethpb.IndexedAttestation{
 				Data: &ethpb.AttestationData{
-					Source: &ethpb.Checkpoint{Epoch: 0},
-					Target: &ethpb.Checkpoint{Epoch: 0},
+					Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					BeaconBlockRoot: make([]byte, 32),
 				},
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
+				Signature:        make([]byte, 96),
 			},
 		},
 	}
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			AttesterSlashings: slashings,
 		},
 	}
 
-	want := fmt.Sprint("validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE")
-	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, block.Body)
-	assert.ErrorContains(t, want, err)
+	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, b)
+	assert.ErrorContains(t, "validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE", err)
 }
 
 func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
@@ -116,8 +126,9 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 
 	att1 := &ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 1},
-			Target: &ethpb.Checkpoint{Epoch: 0},
+			Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			BeaconBlockRoot: make([]byte, 32),
 		},
 		AttestingIndices: []uint64{0, 1},
 	}
@@ -128,12 +139,13 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 	sig0 := privKeys[0].Sign(signingRoot[:])
 	sig1 := privKeys[1].Sign(signingRoot[:])
 	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	att1.Signature = aggregateSig.Marshal()[:]
+	att1.Signature = aggregateSig.Marshal()
 
 	att2 := &ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 0},
-			Target: &ethpb.Checkpoint{Epoch: 0},
+			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			BeaconBlockRoot: make([]byte, 32),
 		},
 		AttestingIndices: []uint64{0, 1},
 	}
@@ -142,7 +154,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 	sig0 = privKeys[0].Sign(signingRoot[:])
 	sig1 = privKeys[1].Sign(signingRoot[:])
 	aggregateSig = bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	att2.Signature = aggregateSig.Marshal()[:]
+	att2.Signature = aggregateSig.Marshal()
 
 	slashings := []*ethpb.AttesterSlashing{
 		{
@@ -154,13 +166,14 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 	currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch
 	require.NoError(t, beaconState.SetSlot(currentSlot))
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			AttesterSlashings: slashings,
 		},
 	}
 
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, block.Body)
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -9,51 +9,50 @@ import (
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/params"
-
-	//"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	ethereum_beacon_p2p_v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestFuzzProcessAttestationNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	ctx := context.Background()
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	att := &eth.Attestation{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(att)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		_, err = ProcessAttestationNoVerify(ctx, s, att)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		_, err = ProcessAttestationNoVerifySignature(ctx, s, att)
 		_ = err
 	}
 }
 
 func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	block := &eth.SignedBeaconBlock{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(block)
 
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		_, err = ProcessBlockHeader(s, block)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		_, err = ProcessBlockHeader(context.Background(), s, block)
 		_ = err
 	}
 }
 
 func TestFuzzverifyDepositDataSigningRoot_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	ba := []byte{}
+	var ba []byte
 	pubkey := [48]byte{}
 	sig := [96]byte{}
 	domain := [4]byte{}
-	p := []byte{}
-	s := []byte{}
-	d := []byte{}
+	var p []byte
+	var s []byte
+	var d []byte
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(&ba)
 		fuzzer.Fuzz(&pubkey)
@@ -63,6 +62,7 @@ func TestFuzzverifyDepositDataSigningRoot_10000(t *testing.T) {
 		fuzzer.Fuzz(&s)
 		fuzzer.Fuzz(&d)
 		err := verifySignature(ba, pubkey[:], sig[:], domain[:])
+		_ = err
 		err = verifySignature(ba, p, s, d)
 		_ = err
 	}
@@ -70,14 +70,14 @@ func TestFuzzverifyDepositDataSigningRoot_10000(t *testing.T) {
 
 func TestFuzzProcessEth1DataInBlock_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	block := &eth.BeaconBlock{}
+	b := &eth.SignedBeaconBlock{}
 	state := &stateTrie.BeaconState{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(block)
-		s, err := ProcessEth1DataInBlock(state, block)
+		fuzzer.Fuzz(b)
+		s, err := ProcessEth1DataInBlock(context.Background(), state, b)
 		if err != nil && s != nil {
-			t.Fatalf("state should be nil on err. found: %v on error: %v for state: %v and block: %v", s, err, state, block)
+			t.Fatalf("state should be nil on err. found: %v on error: %v for state: %v and block: %v", s, err, state, b)
 		}
 	}
 }
@@ -98,13 +98,14 @@ func TestFuzzareEth1DataEqual_10000(t *testing.T) {
 func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	eth1data := &eth.Eth1Data{}
-	stateVotes := []*eth.Eth1Data{}
+	var stateVotes []*eth.Eth1Data
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(eth1data)
 		fuzzer.Fuzz(&stateVotes)
-		s, err := beaconstate.InitializeFromProto(&ethereum_beacon_p2p_v1.BeaconState{
+		s, err := stateTrie.InitializeFromProto(&pb.BeaconState{
 			Eth1DataVotes: stateVotes,
 		})
+		require.NoError(t, err)
 		_, err = Eth1DataHasEnoughSupport(s, eth1data)
 		_ = err
 	}
@@ -113,13 +114,14 @@ func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
 
 func TestFuzzProcessBlockHeaderNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	block := &eth.BeaconBlock{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(block)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		_, err = ProcessBlockHeaderNoVerify(s, block)
 		_ = err
 	}
@@ -127,29 +129,31 @@ func TestFuzzProcessBlockHeaderNoVerify_10000(t *testing.T) {
 
 func TestFuzzProcessRandao_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessRandao(s, blockBody)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessRandao(context.Background(), s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
 
 func TestFuzzProcessRandaoNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	blockBody := &eth.BeaconBlockBody{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		r, err := ProcessRandaoNoVerify(s, blockBody)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
@@ -159,28 +163,30 @@ func TestFuzzProcessRandaoNoVerify_10000(t *testing.T) {
 
 func TestFuzzProcessProposerSlashings_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessProposerSlashings(ctx, s, blockBody)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessProposerSlashings(ctx, s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
 
 func TestFuzzVerifyProposerSlashing_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	proposerSlashing := &eth.ProposerSlashing{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(proposerSlashing)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		err = VerifyProposerSlashing(s, proposerSlashing)
 		_ = err
 	}
@@ -188,29 +194,31 @@ func TestFuzzVerifyProposerSlashing_10000(t *testing.T) {
 
 func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessAttesterSlashings(ctx, s, blockBody)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessAttesterSlashings(ctx, s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
 
 func TestFuzzVerifyAttesterSlashing_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	attesterSlashing := &eth.AttesterSlashing{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(attesterSlashing)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		err = VerifyAttesterSlashing(ctx, s, attesterSlashing)
 		_ = err
 	}
@@ -240,45 +248,48 @@ func TestFuzzslashableAttesterIndices_10000(t *testing.T) {
 
 func TestFuzzProcessAttestations_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessAttestations(ctx, s, blockBody)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessAttestations(ctx, s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
 
 func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessAttestationsNoVerify(ctx, s, blockBody)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessAttestationsNoVerifySignature(ctx, s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
 
 func TestFuzzProcessAttestation_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	attestation := &eth.Attestation{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(attestation)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		r, err := ProcessAttestation(ctx, s, attestation)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, attestation)
@@ -288,13 +299,14 @@ func TestFuzzProcessAttestation_10000(t *testing.T) {
 
 func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	idxAttestation := &eth.IndexedAttestation{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(idxAttestation)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		err = VerifyIndexedAttestation(ctx, s, idxAttestation)
 		_ = err
 	}
@@ -302,44 +314,47 @@ func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
 
 func TestFuzzVerifyAttestation_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	attestation := &eth.Attestation{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(attestation)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		err = VerifyAttestation(ctx, s, attestation)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		err = VerifyAttestationSignature(ctx, s, attestation)
 		_ = err
 	}
 }
 
 func TestFuzzProcessDeposits_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessDeposits(ctx, s, blockBody.Deposits)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessDeposits(ctx, s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
 
 func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	deposit := &eth.Deposit{}
 	ctx := context.Background()
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		r, err := ProcessPreGenesisDeposits(ctx, s, []*eth.Deposit{deposit})
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
@@ -349,13 +364,14 @@ func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
 
 func TestFuzzProcessDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	deposit := &eth.Deposit{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		r, err := ProcessDeposit(s, deposit, true)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
@@ -365,12 +381,13 @@ func TestFuzzProcessDeposit_10000(t *testing.T) {
 
 func TestFuzzverifyDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
+	state := &pb.BeaconState{}
 	deposit := &eth.Deposit{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
 		err = verifyDeposit(s, deposit)
 		_ = err
 	}
@@ -378,31 +395,33 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 
 func TestFuzzProcessVoluntaryExits_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessVoluntaryExits(ctx, s, blockBody)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessVoluntaryExits(ctx, s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
 
 func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethereum_beacon_p2p_v1.BeaconState{}
-	blockBody := &eth.BeaconBlockBody{}
+	state := &pb.BeaconState{}
+	b := &eth.SignedBeaconBlock{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(blockBody)
-		s, err := beaconstate.InitializeFromProtoUnsafe(state)
-		r, err := ProcessVoluntaryExitsNoVerify(s, blockBody)
+		fuzzer.Fuzz(b)
+		s, err := stateTrie.InitializeFromProtoUnsafe(state)
+		require.NoError(t, err)
+		r, err := ProcessVoluntaryExits(context.Background(), s, b)
 		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
 	}
 }
@@ -410,7 +429,7 @@ func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
 func TestFuzzVerifyExit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	ve := &eth.SignedVoluntaryExit{}
-	val := &beaconstate.ReadOnlyValidator{}
+	val := &stateTrie.ReadOnlyValidator{}
 	fork := &pb.Fork{}
 	var slot uint64
 
@@ -419,7 +438,7 @@ func TestFuzzVerifyExit_10000(t *testing.T) {
 		fuzzer.Fuzz(val)
 		fuzzer.Fuzz(fork)
 		fuzzer.Fuzz(&slot)
-		err := VerifyExit(val, slot, fork, ve, params.BeaconConfig().ZeroHash[:])
+		err := VerifyExitAndSignature(val, slot, fork, ve, params.BeaconConfig().ZeroHash[:])
 		_ = err
 	}
 }

beacon-chain/core/blocks/block_regression_test.go

@@ -39,30 +39,34 @@ 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},
-			Target: &ethpb.Checkpoint{Epoch: 0, Root: root1[:]},
+			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Epoch: 0, Root: root1[:]},
+			BeaconBlockRoot: make([]byte, 32),
 		},
 		AttestingIndices: setA,
+		Signature:        make([]byte, 96),
 	}
 	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
 	require.NoError(t, err)
 	signingRoot, err := helpers.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err, "Could not get signing root of beacon block header")
-	aggSigs := []bls.Signature{}
+	var aggSigs []bls.Signature
 	for _, index := range setA {
 		sig := privKeys[index].Sign(signingRoot[:])
 		aggSigs = append(aggSigs, sig)
 	}
 	aggregateSig := bls.AggregateSignatures(aggSigs)
-	att1.Signature = aggregateSig.Marshal()[:]
+	att1.Signature = aggregateSig.Marshal()
 
 	root2 := [32]byte{'d', 'o', 'u', 'b', 'l', 'e', '2'}
 	att2 := &ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 0},
-			Target: &ethpb.Checkpoint{Epoch: 0, Root: root2[:]},
+			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Epoch: 0, Root: root2[:]},
+			BeaconBlockRoot: make([]byte, 32),
 		},
 		AttestingIndices: setB,
+		Signature:        make([]byte, 96),
 	}
 	signingRoot, err = helpers.ComputeSigningRoot(att2.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")
@@ -72,7 +76,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 		aggSigs = append(aggSigs, sig)
 	}
 	aggregateSig = bls.AggregateSignatures(aggSigs)
-	att2.Signature = aggregateSig.Marshal()[:]
+	att2.Signature = aggregateSig.Marshal()
 
 	slashings := []*ethpb.AttesterSlashing{
 		{
@@ -84,13 +88,14 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 	currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch
 	require.NoError(t, beaconState.SetSlot(currentSlot))
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			AttesterSlashings: slashings,
 		},
 	}
 
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, block.Body)
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 	if !newRegistry[expectedSlashedVal].Slashed {

beacon-chain/core/blocks/deposit.go

@@ -25,7 +25,8 @@ func ProcessPreGenesisDeposits(
 	deposits []*ethpb.Deposit,
 ) (*stateTrie.BeaconState, error) {
 	var err error
-	beaconState, err = ProcessDeposits(ctx, beaconState, deposits)
+	beaconState, err = ProcessDeposits(ctx, beaconState, &ethpb.SignedBeaconBlock{
+		Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Deposits: deposits}}})
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit")
 	}
@@ -66,10 +67,14 @@ func ProcessPreGenesisDeposits(
 func ProcessDeposits(
 	ctx context.Context,
 	beaconState *stateTrie.BeaconState,
-	deposits []*ethpb.Deposit,
+	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
-	var err error
+	if b.Block == nil || b.Block.Body == nil {
+		return nil, errors.New("block and block body can't be nil")
+	}
 
+	deposits := b.Block.Body.Deposits
+	var err error
 	domain, err := helpers.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
 	if err != nil {
 		return nil, err
@@ -153,8 +158,7 @@ func ProcessDeposit(beaconState *stateTrie.BeaconState, deposit *ethpb.Deposit,
 			if err != nil {
 				return nil, err
 			}
-			depositSig := deposit.Data.Signature
-			if err := verifyDepositDataSigningRoot(deposit.Data, pubKey, depositSig, domain); err != nil {
+			if err := verifyDepositDataSigningRoot(deposit.Data, domain); err != nil {
 				// Ignore this error as in the spec pseudo code.
 				log.Debugf("Skipping deposit: could not verify deposit data signature: %v", err)
 				return beaconState, nil
@@ -197,7 +201,7 @@ func verifyDeposit(beaconState *stateTrie.BeaconState, deposit *ethpb.Deposit) e
 	}
 
 	receiptRoot := eth1Data.DepositRoot
-	leaf, err := ssz.HashTreeRoot(deposit.Data)
+	leaf, err := deposit.Data.HashTreeRoot()
 	if err != nil {
 		return errors.Wrap(err, "could not tree hash deposit data")
 	}
@@ -206,17 +210,19 @@ func verifyDeposit(beaconState *stateTrie.BeaconState, deposit *ethpb.Deposit) e
 		leaf[:],
 		int(beaconState.Eth1DepositIndex()),
 		deposit.Proof,
+		params.BeaconConfig().DepositContractTreeDepth,
 	); !ok {
 		return fmt.Errorf(
 			"deposit merkle branch of deposit root did not verify for root: %#x",
 			receiptRoot,
 		)
 	}
+
 	return nil
 }
 
 // Deprecated: This method uses deprecated ssz.SigningRoot.
-func verifyDepositDataSigningRoot(obj *ethpb.Deposit_Data, pub []byte, signature []byte, domain []byte) error {
+func verifyDepositDataSigningRoot(obj *ethpb.Deposit_Data, domain []byte) error {
 	return depositutil.VerifyDepositSignature(obj, domain)
 }
 
@@ -225,7 +231,7 @@ func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, dom
 		return nil
 	}
 	pks := make([]bls.PublicKey, len(deps))
-	sigs := make([]bls.Signature, len(deps))
+	sigs := make([][]byte, len(deps))
 	msgs := make([][32]byte, len(deps))
 	for i, dep := range deps {
 		if ctx.Err() != nil {
@@ -234,17 +240,12 @@ func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, dom
 		if dep == nil || dep.Data == nil {
 			return errors.New("nil deposit")
 		}
-
 		dpk, err := bls.PublicKeyFromBytes(dep.Data.PublicKey)
 		if err != nil {
 			return err
 		}
 		pks[i] = dpk
-		dsig, err := bls.SignatureFromBytes(dep.Data.Signature)
-		if err != nil {
-			return err
-		}
-		sigs[i] = dsig
+		sigs[i] = dep.Data.Signature
 		root, err := ssz.SigningRoot(dep.Data)
 		if err != nil {
 			return errors.Wrap(err, "could not get signing root")
@@ -253,7 +254,7 @@ func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, dom
 			ObjectRoot: root[:],
 			Domain:     domain,
 		}
-		ctrRoot, err := ssz.HashTreeRoot(signingData)
+		ctrRoot, err := signingData.HashTreeRoot()
 		if err != nil {
 			return errors.Wrap(err, "could not get container root")
 		}

beacon-chain/core/blocks/deposit_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -26,7 +25,8 @@ func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
 	require.NoError(t, err)
 	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
 	require.NoError(t, err)
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			// 3 deposits from the same validator
 			Deposits: []*ethpb.Deposit{dep[0], dep[1], dep[2]},
@@ -49,7 +49,7 @@ func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, block.Body.Deposits)
+	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, b)
 	require.NoError(t, err, "Expected block deposits to process correctly")
 
 	assert.Equal(t, 2, len(newState.Validators()), "Incorrect validator count")
@@ -58,21 +58,23 @@ func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
 func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
-			PublicKey: []byte{1, 2, 3},
-			Signature: make([]byte, 96),
+			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, 96),
 		},
 	}
-	leaf, err := ssz.HashTreeRoot(deposit.Data)
+	leaf, err := deposit.Data.HashTreeRoot()
 	require.NoError(t, err)
 
 	// We then create a merkle branch for the test.
-	depositTrie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, int(params.BeaconConfig().DepositContractTreeDepth))
+	depositTrie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate trie")
 	proof, err := depositTrie.MerkleProof(0)
 	require.NoError(t, err, "Could not generate proof")
 
 	deposit.Proof = proof
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Deposits: []*ethpb.Deposit{deposit},
 		},
@@ -85,7 +87,7 @@ func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 	})
 	require.NoError(t, err)
 	want := "deposit root did not verify"
-	_, err = blocks.ProcessDeposits(context.Background(), beaconState, block.Body.Deposits)
+	_, err = blocks.ProcessDeposits(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -95,7 +97,8 @@ func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
 	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
 	require.NoError(t, err)
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Deposits: []*ethpb.Deposit{dep[0]},
 		},
@@ -117,7 +120,7 @@ func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, block.Body.Deposits)
+	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, b)
 	require.NoError(t, err, "Expected block deposits to process correctly")
 	if newState.Balances()[1] != dep[0].Data.Amount {
 		t.Errorf(
@@ -129,28 +132,32 @@ func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
 }
 
 func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
-	sk := bls.RandKey()
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
-			PublicKey: sk.PublicKey().Marshal(),
-			Amount:    1000,
+			PublicKey:             sk.PublicKey().Marshal(),
+			Amount:                1000,
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, 96),
 		},
 	}
-	sr, err := helpers.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 8))
+	sr, err := helpers.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
 	require.NoError(t, err)
 	sig := sk.Sign(sr[:])
 	deposit.Data.Signature = sig.Marshal()
-	leaf, err := ssz.HashTreeRoot(deposit.Data)
+	leaf, err := deposit.Data.HashTreeRoot()
 	require.NoError(t, err)
 
 	// We then create a merkle branch for the test.
-	depositTrie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, int(params.BeaconConfig().DepositContractTreeDepth))
+	depositTrie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate trie")
 	proof, err := depositTrie.MerkleProof(0)
 	require.NoError(t, err, "Could not generate proof")
 
 	deposit.Proof = proof
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Deposits: []*ethpb.Deposit{deposit},
 		},
@@ -175,7 +182,7 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 		},
 	})
 	require.NoError(t, err)
-	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, block.Body.Deposits)
+	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, b)
 	require.NoError(t, err, "Process deposit failed")
 	assert.Equal(t, uint64(1000+50), newState.Balances()[1], "Expected balance at index 1 to be 1050")
 }

beacon-chain/core/blocks/eth1_data.go

@@ -2,6 +2,7 @@ package blocks
 
 import (
 	"bytes"
+	"context"
 	"errors"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
@@ -18,7 +19,8 @@ import (
 //    state.eth1_data_votes.append(body.eth1_data)
 //    if state.eth1_data_votes.count(body.eth1_data) * 2 > EPOCHS_PER_ETH1_VOTING_PERIOD * SLOTS_PER_EPOCH:
 //        state.latest_eth1_data = body.eth1_data
-func ProcessEth1DataInBlock(beaconState *stateTrie.BeaconState, block *ethpb.BeaconBlock) (*stateTrie.BeaconState, error) {
+func ProcessEth1DataInBlock(_ context.Context, beaconState *stateTrie.BeaconState, b *ethpb.SignedBeaconBlock) (*stateTrie.BeaconState, error) {
+	block := b.Block
 	if beaconState == nil {
 		return nil, errors.New("nil state")
 	}

beacon-chain/core/blocks/eth1_data_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
@@ -9,7 +10,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"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"
 )
@@ -19,7 +22,7 @@ func FakeDeposits(n uint64) []*ethpb.Eth1Data {
 	for i := uint64(0); i < n; i++ {
 		deposits[i] = &ethpb.Eth1Data{
 			DepositCount: 1,
-			DepositRoot:  []byte("root"),
+			DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 		}
 	}
 	return deposits
@@ -36,7 +39,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
-				DepositRoot:  []byte("root"),
+				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 			},
 			hasSupport:         true,
 			votingPeriodLength: 7,
@@ -44,7 +47,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
-				DepositRoot:  []byte("root"),
+				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 			},
 			hasSupport:         false,
 			votingPeriodLength: 8,
@@ -52,7 +55,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
-				DepositRoot:  []byte("root"),
+				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 			},
 			hasSupport:         false,
 			votingPeriodLength: 10,
@@ -161,7 +164,8 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			Eth1Data: &ethpb.Eth1Data{
 				DepositRoot: []byte{2},
@@ -172,7 +176,7 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 
 	period := params.BeaconConfig().EpochsPerEth1VotingPeriod * params.BeaconConfig().SlotsPerEpoch
 	for i := uint64(0); i < period; i++ {
-		beaconState, err = blocks.ProcessEth1DataInBlock(beaconState, block)
+		beaconState, err = blocks.ProcessEth1DataInBlock(context.Background(), beaconState, b)
 		require.NoError(t, err)
 	}
 
@@ -180,10 +184,10 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 	if len(newETH1DataVotes) <= 1 {
 		t.Error("Expected new ETH1 data votes to have length > 1")
 	}
-	if !proto.Equal(beaconState.Eth1Data(), beaconstate.CopyETH1Data(block.Body.Eth1Data)) {
+	if !proto.Equal(beaconState.Eth1Data(), beaconstate.CopyETH1Data(b.Block.Body.Eth1Data)) {
 		t.Errorf(
 			"Expected latest eth1 data to have been set to %v, received %v",
-			block.Body.Eth1Data,
+			b.Block.Body.Eth1Data,
 			beaconState.Eth1Data(),
 		)
 	}

beacon-chain/core/blocks/exit.go

@@ -13,6 +13,13 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
+// ValidatorAlreadyExitedMsg defines a message saying that a validator has already exited.
+var ValidatorAlreadyExitedMsg = "validator has already submitted an exit, which will take place at epoch"
+
+// ValidatorCannotExitYetMsg defines a message saying that a validator cannot exit
+// because it has not been active long enough.
+var ValidatorCannotExitYetMsg = "validator has not been active long enough to exit"
+
 // ProcessVoluntaryExits is one of the operations performed
 // on each processed beacon block to determine which validators
 // should exit the state's validator registry.
@@ -37,10 +44,15 @@ import (
 //    # Initiate exit
 //    initiate_validator_exit(state, exit.validator_index)
 func ProcessVoluntaryExits(
-	ctx context.Context,
+	_ context.Context,
 	beaconState *stateTrie.BeaconState,
-	body *ethpb.BeaconBlockBody,
+	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
+	if b.Block == nil || b.Block.Body == nil {
+		return nil, errors.New("block and block body can't be nil")
+	}
+
+	body := b.Block.Body
 	exits := body.VoluntaryExits
 	for idx, exit := range exits {
 		if exit == nil || exit.Exit == nil {
@@ -50,7 +62,7 @@ func ProcessVoluntaryExits(
 		if err != nil {
 			return nil, err
 		}
-		if err := VerifyExit(val, beaconState.Slot(), beaconState.Fork(), exit, beaconState.GenesisValidatorRoot()); err != nil {
+		if err := VerifyExitAndSignature(val, beaconState.Slot(), beaconState.Fork(), exit, beaconState.GenesisValidatorRoot()); err != nil {
 			return nil, errors.Wrapf(err, "could not verify exit %d", idx)
 		}
 		beaconState, err = v.InitiateValidatorExit(beaconState, exit.Exit.ValidatorIndex)
@@ -61,9 +73,10 @@ func ProcessVoluntaryExits(
 	return beaconState, nil
 }
 
-// ProcessVoluntaryExitsNoVerify processes all the voluntary exits in
+// ProcessVoluntaryExitsNoVerifySignature processes all the voluntary exits in
 // a block body, without verifying their BLS signatures.
-func ProcessVoluntaryExitsNoVerify(
+// This function is here to satisfy fuzz tests.
+func ProcessVoluntaryExitsNoVerifySignature(
 	beaconState *stateTrie.BeaconState,
 	body *ethpb.BeaconBlockBody,
 ) (*stateTrie.BeaconState, error) {
@@ -93,7 +106,7 @@ func ProcessVoluntaryExitsNoVerify(
 	return beaconState, nil
 }
 
-// VerifyExit implements the spec defined validation for voluntary exits.
+// VerifyExitAndSignature implements the spec defined validation for voluntary exits.
 //
 // Spec pseudocode definition:
 //   def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
@@ -112,7 +125,7 @@ func ProcessVoluntaryExitsNoVerify(
 //    # Verify signature
 //    domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, exit.epoch)
 //    assert bls_verify(validator.pubkey, signing_root(exit), exit.signature, domain)
-func VerifyExit(validator *stateTrie.ReadOnlyValidator, currentSlot uint64, fork *pb.Fork, signed *ethpb.SignedVoluntaryExit, genesisRoot []byte) error {
+func VerifyExitAndSignature(validator *stateTrie.ReadOnlyValidator, currentSlot uint64, fork *pb.Fork, signed *ethpb.SignedVoluntaryExit, genesisRoot []byte) error {
 	if signed == nil || signed.Exit == nil {
 		return errors.New("nil exit")
 	}
@@ -154,9 +167,9 @@ func verifyExitConditions(validator *stateTrie.ReadOnlyValidator, currentSlot ui
 	if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {
 		return errors.New("non-active validator cannot exit")
 	}
-	// Verify the validator has not yet exited.
+	// Verify the validator has not yet submitted an exit.
 	if validator.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
-		return fmt.Errorf("validator has already exited at epoch: %v", validator.ExitEpoch())
+		return fmt.Errorf("%s: %v", ValidatorAlreadyExitedMsg, validator.ExitEpoch())
 	}
 	// Exits must specify an epoch when they become valid; they are not valid before then.
 	if currentEpoch < exit.Epoch {
@@ -165,7 +178,8 @@ func verifyExitConditions(validator *stateTrie.ReadOnlyValidator, currentSlot ui
 	// Verify the validator has been active long enough.
 	if currentEpoch < validator.ActivationEpoch()+params.BeaconConfig().ShardCommitteePeriod {
 		return fmt.Errorf(
-			"validator has not been active long enough to exit, wanted epoch %d >= %d",
+			"%s: %d epochs vs required %d epochs",
+			ValidatorCannotExitYetMsg,
 			currentEpoch,
 			validator.ActivationEpoch()+params.BeaconConfig().ShardCommitteePeriod,
 		)

beacon-chain/core/blocks/exit_test.go

@@ -11,6 +11,7 @@ import (
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"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"
 )
@@ -32,18 +33,19 @@ func TestProcessVoluntaryExits_ValidatorNotActive(t *testing.T) {
 		Validators: registry,
 	})
 	require.NoError(t, err)
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			VoluntaryExits: exits,
 		},
 	}
 
 	want := "non-active validator cannot exit"
-	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, block.Body)
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
 	assert.ErrorContains(t, want, err)
 
 	// Check conformance of no verify method.
-	_, err = blocks.ProcessVoluntaryExitsNoVerify(state, block.Body)
+	_, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -65,20 +67,20 @@ func TestProcessVoluntaryExits_InvalidExitEpoch(t *testing.T) {
 		Slot:       0,
 	})
 	require.NoError(t, err)
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			VoluntaryExits: exits,
 		},
 	}
 
 	want := "expected current epoch >= exit epoch"
-	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, block.Body)
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
 	assert.ErrorContains(t, want, err)
 
 	// Check conformance of no verify method.
-	_, err = blocks.ProcessVoluntaryExitsNoVerify(state, block.Body)
+	_, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body)
 	assert.ErrorContains(t, want, err)
-
 }
 
 func TestProcessVoluntaryExits_NotActiveLongEnoughToExit(t *testing.T) {
@@ -100,14 +102,45 @@ func TestProcessVoluntaryExits_NotActiveLongEnoughToExit(t *testing.T) {
 		Slot:       10,
 	})
 	require.NoError(t, err)
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			VoluntaryExits: exits,
 		},
 	}
 
 	want := "validator has not been active long enough to exit"
-	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, block.Body)
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessVoluntaryExits_ExitAlreadySubmitted(t *testing.T) {
+	exits := []*ethpb.SignedVoluntaryExit{
+		{
+			Exit: &ethpb.VoluntaryExit{
+				Epoch: 10,
+			},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			ExitEpoch: 10,
+		},
+	}
+	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Slot:       0,
+	})
+	require.NoError(t, err)
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			VoluntaryExits: exits,
+		},
+	}
+
+	want := "validator has already submitted an exit, which will take place at epoch: 10"
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -138,22 +171,25 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 	err = state.SetSlot(state.Slot() + (params.BeaconConfig().ShardCommitteePeriod * params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, err)
 
-	priv := bls.RandKey()
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
+
 	val, err := state.ValidatorAtIndex(0)
 	require.NoError(t, err)
-	val.PublicKey = priv.PublicKey().Marshal()[:]
+	val.PublicKey = priv.PublicKey().Marshal()
 	require.NoError(t, state.UpdateValidatorAtIndex(0, val))
 	exits[0].Signature, err = helpers.ComputeDomainAndSign(state, helpers.CurrentEpoch(state), exits[0].Exit, params.BeaconConfig().DomainVoluntaryExit, priv)
 	require.NoError(t, err)
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			VoluntaryExits: exits,
 		},
 	}
 
 	stateCopy := state.Copy()
-	newState, err := blocks.ProcessVoluntaryExits(context.Background(), state, block.Body)
+	newState, err := blocks.ProcessVoluntaryExits(context.Background(), state, b)
 	require.NoError(t, err, "Could not process exits")
 	newRegistry := newState.Validators()
 	if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch) {
@@ -162,12 +198,11 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 	}
 
 	// Check conformance with NoVerify Exit Method.
-	newState, err = blocks.ProcessVoluntaryExitsNoVerify(stateCopy, block.Body)
+	newState, err = blocks.ProcessVoluntaryExitsNoVerifySignature(stateCopy, b.Block.Body)
 	require.NoError(t, err, "Could not process exits")
 	newRegistry = newState.Validators()
 	if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(stateCopy.Slot()/params.BeaconConfig().SlotsPerEpoch) {
 		t.Errorf("Expected validator exit epoch to be %d, got %d",
 			helpers.ActivationExitEpoch(stateCopy.Slot()/params.BeaconConfig().SlotsPerEpoch), newRegistry[0].ExitEpoch)
 	}
-
 }

beacon-chain/core/blocks/genesis.go

@@ -4,19 +4,27 @@ package blocks
 
 import (
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 // NewGenesisBlock returns the canonical, genesis block for the beacon chain protocol.
 func NewGenesisBlock(stateRoot []byte) *ethpb.SignedBeaconBlock {
 	zeroHash := params.BeaconConfig().ZeroHash[:]
-	genBlock := &ethpb.BeaconBlock{
-		ParentRoot: zeroHash,
-		StateRoot:  stateRoot,
-		Body:       &ethpb.BeaconBlockBody{},
-	}
-	return &ethpb.SignedBeaconBlock{
-		Block:     genBlock,
+	block := &ethpb.SignedBeaconBlock{
+		Block: &ethpb.BeaconBlock{
+			ParentRoot: zeroHash,
+			StateRoot:  bytesutil.PadTo(stateRoot, 32),
+			Body: &ethpb.BeaconBlockBody{
+				RandaoReveal: make([]byte, 96),
+				Eth1Data: &ethpb.Eth1Data{
+					DepositRoot: make([]byte, 32),
+					BlockHash:   make([]byte, 32),
+				},
+				Graffiti: make([]byte, 32),
+			},
+		},
 		Signature: params.BeaconConfig().EmptySignature[:],
 	}
+	return block
 }

beacon-chain/core/blocks/genesis_test.go

@@ -4,11 +4,12 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 )
 
 func TestGenesisBlock_InitializedCorrectly(t *testing.T) {
-	stateHash := []byte{0}
+	stateHash := bytesutil.PadTo([]byte{0}, 32)
 	b1 := blocks.NewGenesisBlock(stateHash)
 
 	assert.NotNil(t, b1.Block.ParentRoot, "Genesis block missing ParentHash field")

beacon-chain/core/blocks/header.go

@@ -2,13 +2,13 @@ package blocks
 
 import (
 	"bytes"
+	"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/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
@@ -37,6 +37,7 @@ import (
 //    # Verify proposer signature
 //    assert bls_verify(proposer.pubkey, signing_root(block), block.signature, get_domain(state, DOMAIN_BEACON_PROPOSER))
 func ProcessBlockHeader(
+	_ context.Context,
 	beaconState *stateTrie.BeaconState,
 	block *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
@@ -99,7 +100,7 @@ func ProcessBlockHeaderNoVerify(
 	if parentHeader.Slot >= block.Slot {
 		return nil, fmt.Errorf("block.Slot %d must be greater than state.LatestBlockHeader.Slot %d", block.Slot, parentHeader.Slot)
 	}
-	parentRoot, err := stateutil.BlockHeaderRoot(parentHeader)
+	parentRoot, err := parentHeader.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
@@ -118,7 +119,7 @@ func ProcessBlockHeaderNoVerify(
 		return nil, fmt.Errorf("proposer at index %d was previously slashed", idx)
 	}
 
-	bodyRoot, err := stateutil.BlockBodyRoot(block.Body)
+	bodyRoot, err := block.Body.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/blocks/header_test.go

@@ -1,23 +1,22 @@
 package blocks_test
 
 import (
+	"context"
 	"io/ioutil"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
+	"github.com/sirupsen/logrus"
+
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"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() {
@@ -28,40 +27,36 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			Slashed:   true,
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
 		}
 	}
 
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators:        validators,
-		Slot:              10,
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 10}, // Must be less than block.Slot
-		Fork: &pb.Fork{
-			PreviousVersion: []byte{0, 0, 0, 0},
-			CurrentVersion:  []byte{0, 0, 0, 0},
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
+	state := testutil.NewBeaconState()
+	require.NoError(t, state.SetSlot(10))
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+		Slot:       10, // Must be less than block.Slot
+		ParentRoot: make([]byte, 32),
+		StateRoot:  make([]byte, 32),
+		BodyRoot:   make([]byte, 32),
+	}))
 
-	latestBlockSignedRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader())
+	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
 
 	currentEpoch := helpers.CurrentEpoch(state)
-	priv := bls.RandKey()
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
 	pID, err := helpers.BeaconProposerIndex(state)
 	require.NoError(t, err)
-	block := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			ProposerIndex: pID,
-			Slot:          10,
-			Body: &ethpb.BeaconBlockBody{
-				RandaoReveal: []byte{'A', 'B', 'C'},
-			},
-			ParentRoot: latestBlockSignedRoot[:],
-		},
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.ProposerIndex = pID
+	block.Block.Slot = 10
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = latestBlockSignedRoot[:]
 	block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 
@@ -72,36 +67,36 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	_, err = blocks.ProcessBlockHeader(state, block)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, block)
 	assert.ErrorContains(t, "block.Slot 10 must be greater than state.LatestBlockHeader.Slot 10", err)
 }
 
 func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 	testutil.ResetCache()
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	require.NoError(t, beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{Slot: 9}))
+	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.SetSlot(10))
 
-	lbhdr, err := stateutil.BlockHeaderRoot(beaconState.LatestBlockHeader())
+	lbhdr, err := beaconState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
 
 	proposerIdx, err := helpers.BeaconProposerIndex(beaconState)
 	require.NoError(t, err)
 
-	block := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			ProposerIndex: proposerIdx,
-			Slot:          10,
-			Body: &ethpb.BeaconBlockBody{
-				RandaoReveal: []byte{'A', 'B', 'C'},
-			},
-			ParentRoot: lbhdr[:],
-		},
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.ProposerIndex = proposerIdx
+	block.Block.Slot = 10
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = lbhdr[:]
 	block.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx+1])
 	require.NoError(t, err)
 
-	_, err = blocks.ProcessBlockHeader(beaconState, block)
+	_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, block)
 	want := "signature did not verify"
 	assert.ErrorContains(t, want, err)
 }
@@ -110,28 +105,30 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			Slashed:   true,
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
 		}
 	}
 
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators:        validators,
-		Slot:              10,
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
-		Fork: &pb.Fork{
-			PreviousVersion: []byte{0, 0, 0, 0},
-			CurrentVersion:  []byte{0, 0, 0, 0},
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
+	state := testutil.NewBeaconState()
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(10))
+	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+		Slot:          9,
+		ProposerIndex: 0,
+		ParentRoot:    make([]byte, 32),
+		StateRoot:     make([]byte, 32),
+		BodyRoot:      make([]byte, 32),
+	}))
 
-	lbhsr, err := ssz.HashTreeRoot(state.LatestBlockHeader())
+	lbhsr, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
 	currentEpoch := helpers.CurrentEpoch(state)
 
-	priv := bls.RandKey()
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
 	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 	validators[5896].PublicKey = priv.PublicKey().Marshal()
@@ -146,7 +143,7 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 		Signature: blockSig,
 	}
 
-	_, err = blocks.ProcessBlockHeader(state, block)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, block)
 	want := "is different than block slot"
 	assert.ErrorContains(t, want, err)
 }
@@ -155,43 +152,35 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			Slashed:   true,
+			PublicKey:             make([]byte, 48),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
 		}
 	}
 
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators:        validators,
-		Slot:              10,
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
-		Fork: &pb.Fork{
-			PreviousVersion: []byte{0, 0, 0, 0},
-			CurrentVersion:  []byte{0, 0, 0, 0},
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
-
+	state := testutil.NewBeaconState()
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(10))
+	bh := state.LatestBlockHeader()
+	bh.Slot = 9
+	require.NoError(t, state.SetLatestBlockHeader(bh))
 	currentEpoch := helpers.CurrentEpoch(state)
-	priv := bls.RandKey()
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
 	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 	validators[5896].PublicKey = priv.PublicKey().Marshal()
 	pID, err := helpers.BeaconProposerIndex(state)
 	require.NoError(t, err)
-	block := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			ProposerIndex: pID,
-			Slot:          10,
-			Body: &ethpb.BeaconBlockBody{
-				RandaoReveal: []byte{'A', 'B', 'C'},
-			},
-			ParentRoot: []byte{'A'},
-		},
-		Signature: blockSig,
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.Slot = 10
+	block.Block.ProposerIndex = pID
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, 32)
+	block.Signature = blockSig
 
-	_, err = blocks.ProcessBlockHeader(state, block)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, block)
 	want := "does not match"
 	assert.ErrorContains(t, want, err)
 }
@@ -200,46 +189,38 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			Slashed:   true,
+			PublicKey:             make([]byte, 48),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
 		}
 	}
 
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators:        validators,
-		Slot:              10,
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
-		Fork: &pb.Fork{
-			PreviousVersion: []byte{0, 0, 0, 0},
-			CurrentVersion:  []byte{0, 0, 0, 0},
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
-
-	parentRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader())
+	state := testutil.NewBeaconState()
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(10))
+	bh := state.LatestBlockHeader()
+	bh.Slot = 9
+	require.NoError(t, state.SetLatestBlockHeader(bh))
+	parentRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
 	currentEpoch := helpers.CurrentEpoch(state)
-	priv := bls.RandKey()
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
 	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 
 	validators[12683].PublicKey = priv.PublicKey().Marshal()
 	pID, err := helpers.BeaconProposerIndex(state)
 	require.NoError(t, err)
-	block := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			ProposerIndex: pID,
-			Slot:          10,
-			Body: &ethpb.BeaconBlockBody{
-				RandaoReveal: []byte{'A', 'B', 'C'},
-			},
-			ParentRoot: parentRoot[:],
-		},
-		Signature: blockSig,
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.Slot = 10
+	block.Block.ProposerIndex = pID
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = parentRoot[:]
+	block.Signature = blockSig
 
-	_, err = blocks.ProcessBlockHeader(state, block)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, block)
 	want := "was previously slashed"
 	assert.ErrorContains(t, want, err)
 }
@@ -248,43 +229,40 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			Slashed:   true,
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
 		}
 	}
 
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators:        validators,
-		Slot:              10,
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
-		Fork: &pb.Fork{
-			PreviousVersion: []byte{0, 0, 0, 0},
-			CurrentVersion:  []byte{0, 0, 0, 0},
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
+	state := testutil.NewBeaconState()
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(10))
+	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+		Slot:          9,
+		ProposerIndex: 0,
+		ParentRoot:    make([]byte, 32),
+		StateRoot:     make([]byte, 32),
+		BodyRoot:      make([]byte, 32),
+	}))
 
-	latestBlockSignedRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader())
+	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
 
 	currentEpoch := helpers.CurrentEpoch(state)
-	priv := bls.RandKey()
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
 	pID, err := helpers.BeaconProposerIndex(state)
 	require.NoError(t, err)
-	block := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			ProposerIndex: pID,
-			Slot:          10,
-			Body: &ethpb.BeaconBlockBody{
-				RandaoReveal: []byte{'A', 'B', 'C'},
-			},
-			ParentRoot: latestBlockSignedRoot[:],
-		},
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.ProposerIndex = pID
+	block.Block.Slot = 10
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = latestBlockSignedRoot[:]
 	block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
-	bodyRoot, err := stateutil.BlockBodyRoot(block.Block.Body)
+	bodyRoot, err := block.Block.Body.HashTreeRoot()
 	require.NoError(t, err, "Failed to hash block bytes got")
 
 	proposerIdx, err := helpers.BeaconProposerIndex(state)
@@ -294,7 +272,7 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	newState, err := blocks.ProcessBlockHeader(state, block)
+	newState, err := blocks.ProcessBlockHeader(context.Background(), state, block)
 	require.NoError(t, err, "Failed to process block header got")
 	var zeroHash [32]byte
 	nsh := newState.LatestBlockHeader()
@@ -312,40 +290,37 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
-			Slashed:   true,
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
 		}
 	}
 
-	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Validators:        validators,
-		Slot:              10,
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
-		Fork: &pb.Fork{
-			PreviousVersion: []byte{0, 0, 0, 0},
-			CurrentVersion:  []byte{0, 0, 0, 0},
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
+	state := testutil.NewBeaconState()
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(10))
+	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+		Slot:          9,
+		ProposerIndex: 0,
+		ParentRoot:    make([]byte, 32),
+		StateRoot:     make([]byte, 32),
+		BodyRoot:      make([]byte, 32),
+	}))
 
-	latestBlockSignedRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader())
+	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
 
 	currentEpoch := helpers.CurrentEpoch(state)
-	priv := bls.RandKey()
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
 	pID, err := helpers.BeaconProposerIndex(state)
 	require.NoError(t, err)
-	block := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			ProposerIndex: pID,
-			Slot:          10,
-			Body: &ethpb.BeaconBlockBody{
-				RandaoReveal: []byte{'A', 'B', 'C'},
-			},
-			ParentRoot: latestBlockSignedRoot[:],
-		},
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.Slot = 10
+	block.Block.ProposerIndex = pID
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = latestBlockSignedRoot[:]
 	block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 	proposerIdx, err := helpers.BeaconProposerIndex(state)

beacon-chain/core/blocks/proposer_slashing.go

@@ -36,10 +36,15 @@ import (
 //
 //    slash_validator(state, proposer_slashing.proposer_index)
 func ProcessProposerSlashings(
-	ctx context.Context,
+	_ context.Context,
 	beaconState *stateTrie.BeaconState,
-	body *ethpb.BeaconBlockBody,
+	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
+	if b.Block == nil || b.Block.Body == nil {
+		return nil, errors.New("block and block body can't be nil")
+	}
+
+	body := b.Block.Body
 	var err error
 	for idx, slashing := range body.ProposerSlashings {
 		if slashing == nil {
@@ -74,14 +79,14 @@ func VerifyProposerSlashing(
 	if pIdx != slashing.Header_2.Header.ProposerIndex {
 		return fmt.Errorf("mismatched indices, received %d == %d", slashing.Header_1.Header.ProposerIndex, slashing.Header_2.Header.ProposerIndex)
 	}
-	if proto.Equal(slashing.Header_1, slashing.Header_2) {
+	if proto.Equal(slashing.Header_1.Header, slashing.Header_2.Header) {
 		return errors.New("expected slashing headers to differ")
 	}
 	proposer, err := beaconState.ValidatorAtIndexReadOnly(slashing.Header_1.Header.ProposerIndex)
 	if err != nil {
 		return err
 	}
-	if !helpers.IsSlashableValidatorUsingTrie(proposer, helpers.SlotToEpoch(beaconState.Slot())) {
+	if !helpers.IsSlashableValidatorUsingTrie(proposer, helpers.SlotToEpoch(hSlot)) {
 		return fmt.Errorf("validator with key %#x is not slashable", proposer.PublicKey())
 	}
 	headers := []*ethpb.SignedBeaconBlockHeader{slashing.Header_1, slashing.Header_2}

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -10,6 +10,7 @@ import (
 	"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"
+	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
@@ -39,13 +40,14 @@ func TestProcessProposerSlashings_UnmatchedHeaderSlots(t *testing.T) {
 	}
 	require.NoError(t, beaconState.SetSlot(currentSlot))
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			ProposerSlashings: slashings,
 		},
 	}
 	want := "mismatched header slots"
-	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Body)
+	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -71,13 +73,14 @@ func TestProcessProposerSlashings_SameHeaders(t *testing.T) {
 	}
 
 	require.NoError(t, beaconState.SetSlot(currentSlot))
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			ProposerSlashings: slashings,
 		},
 	}
 	want := "expected slashing headers to differ"
-	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Body)
+	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -97,15 +100,17 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 0,
 					Slot:          0,
+					BodyRoot:      []byte("foo"),
 				},
-				Signature: []byte("A"),
+				Signature: bytesutil.PadTo([]byte("A"), 96),
 			},
 			Header_2: &ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 0,
 					Slot:          0,
+					BodyRoot:      []byte("bar"),
 				},
-				Signature: []byte("B"),
+				Signature: bytesutil.PadTo([]byte("B"), 96),
 			},
 		},
 	}
@@ -115,7 +120,8 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
 		Slot:       currentSlot,
 	})
 	require.NoError(t, err)
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			ProposerSlashings: slashings,
 		},
@@ -124,7 +130,7 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
 		"validator with key %#x is not slashable",
 		bytesutil.ToBytes48(beaconState.Validators()[0].PublicKey),
 	)
-	_, err = blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessProposerSlashings(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -138,7 +144,9 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerIdx,
 			Slot:          0,
-			StateRoot:     []byte("A"),
+			ParentRoot:    make([]byte, 32),
+			BodyRoot:      make([]byte, 32),
+			StateRoot:     bytesutil.PadTo([]byte("A"), 32),
 		},
 	}
 	var err error
@@ -149,7 +157,9 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerIdx,
 			Slot:          0,
-			StateRoot:     []byte("B"),
+			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])
@@ -162,13 +172,10 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 		},
 	}
 
-	block := &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			ProposerSlashings: slashings,
-		},
-	}
+	block := testutil.NewBeaconBlock()
+	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Body)
+	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()
@@ -177,3 +184,132 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 			newStateVals[1].ExitEpoch, beaconState.Validators()[1].ExitEpoch)
 	}
 }
+
+func TestVerifyProposerSlashing(t *testing.T) {
+	type args struct {
+		beaconState *stateTrie.BeaconState
+		slashing    *ethpb.ProposerSlashing
+	}
+
+	beaconState, sks := testutil.DeterministicGenesisState(t, 2)
+	currentSlot := uint64(0)
+	require.NoError(t, beaconState.SetSlot(currentSlot))
+	rand1, err := bls.RandKey()
+	require.NoError(t, err)
+	sig1 := rand1.Sign([]byte("foo")).Marshal()
+
+	rand2, err := bls.RandKey()
+	require.NoError(t, err)
+	sig2 := rand2.Sign([]byte("bar")).Marshal()
+
+	tests := []struct {
+		name    string
+		args    args
+		wantErr string
+	}{
+		{
+			name: "same header, same slot as state",
+			args: args{
+				slashing: &ethpb.ProposerSlashing{
+					Header_1: &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: &ethpb.BeaconBlockHeader{
+							ProposerIndex: 1,
+							Slot:          currentSlot,
+							StateRoot:     bytesutil.PadTo([]byte{}, 32),
+							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
+							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
+						},
+					},
+				},
+				beaconState: beaconState,
+			},
+			wantErr: "expected slashing headers to differ",
+		},
+		{ // Regression test for https://github.com/sigp/beacon-fuzz/issues/74
+			name: "same header, different signatures",
+			args: args{
+				slashing: &ethpb.ProposerSlashing{
+					Header_1: &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: &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,
+			},
+			wantErr: "expected slashing headers to differ",
+		},
+		{
+			name: "slashing in future epoch",
+			args: args{
+				slashing: &ethpb.ProposerSlashing{
+					Header_1: &ethpb.SignedBeaconBlockHeader{
+						Header: &ethpb.BeaconBlockHeader{
+							ProposerIndex: 1,
+							Slot:          65,
+							StateRoot:     bytesutil.PadTo([]byte{}, 32),
+							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
+							ParentRoot:    bytesutil.PadTo([]byte("foo"), 32),
+						},
+					},
+					Header_2: &ethpb.SignedBeaconBlockHeader{
+						Header: &ethpb.BeaconBlockHeader{
+							ProposerIndex: 1,
+							Slot:          65,
+							StateRoot:     bytesutil.PadTo([]byte{}, 32),
+							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
+							ParentRoot:    bytesutil.PadTo([]byte("bar"), 32),
+						},
+					},
+				},
+				beaconState: beaconState,
+			},
+			wantErr: "",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testutil.ResetCache()
+			sk := sks[tt.args.slashing.Header_1.Header.ProposerIndex]
+			d, err := helpers.Domain(tt.args.beaconState.Fork(), helpers.SlotToEpoch(tt.args.slashing.Header_1.Header.Slot), params.BeaconConfig().DomainBeaconProposer, tt.args.beaconState.GenesisValidatorRoot())
+			require.NoError(t, err)
+			if tt.args.slashing.Header_1.Signature == nil {
+				sr, err := helpers.ComputeSigningRoot(tt.args.slashing.Header_1.Header, d)
+				require.NoError(t, err)
+				tt.args.slashing.Header_1.Signature = sk.Sign(sr[:]).Marshal()
+			}
+			if tt.args.slashing.Header_2.Signature == nil {
+				sr, err := helpers.ComputeSigningRoot(tt.args.slashing.Header_2.Header, d)
+				require.NoError(t, err)
+				tt.args.slashing.Header_2.Signature = sk.Sign(sr[:]).Marshal()
+			}
+			if err := blocks.VerifyProposerSlashing(tt.args.beaconState, tt.args.slashing); (err != nil || tt.wantErr != "") && err.Error() != tt.wantErr {
+				t.Errorf("VerifyProposerSlashing() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

beacon-chain/core/blocks/randao.go

@@ -1,6 +1,8 @@
 package blocks
 
 import (
+	"context"
+
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -24,14 +26,20 @@ import (
 //    mix = xor(get_randao_mix(state, epoch), hash(body.randao_reveal))
 //    state.randao_mixes[epoch % EPOCHS_PER_HISTORICAL_VECTOR] = mix
 func ProcessRandao(
+	_ context.Context,
 	beaconState *stateTrie.BeaconState,
-	body *ethpb.BeaconBlockBody,
+	b *ethpb.SignedBeaconBlock,
 ) (*stateTrie.BeaconState, error) {
+	if b.Block == nil || b.Block.Body == nil {
+		return nil, errors.New("block and block body can't be nil")
+	}
+
+	body := b.Block.Body
 	buf, proposerPub, domain, err := randaoSigningData(beaconState)
 	if err != nil {
 		return nil, err
 	}
-	if err := verifySignature(buf, proposerPub[:], body.RandaoReveal, domain); err != nil {
+	if err := verifySignature(buf, proposerPub, body.RandaoReveal, domain); err != nil {
 		return nil, errors.Wrap(err, "could not verify block randao")
 	}
 

beacon-chain/core/blocks/randao_test.go

@@ -2,11 +2,11 @@ package blocks_test
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -26,18 +26,19 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	binary.LittleEndian.PutUint64(buf, epoch)
 	domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
 	require.NoError(t, err)
-	root, err := ssz.HashTreeRoot(&pb.SigningData{ObjectRoot: buf, Domain: domain})
+	root, err := (&pb.SigningData{ObjectRoot: buf, Domain: domain}).HashTreeRoot()
 	require.NoError(t, err)
 	// We make the previous validator's index sign the message instead of the proposer.
 	epochSignature := privKeys[proposerIdx-1].Sign(root[:])
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			RandaoReveal: epochSignature.Marshal(),
 		},
 	}
 
 	want := "block randao: signature did not verify"
-	_, err = blocks.ProcessRandao(beaconState, block.Body)
+	_, err = blocks.ProcessRandao(context.Background(), beaconState, b)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -48,15 +49,17 @@ func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T)
 	epochSignature, err := testutil.RandaoReveal(beaconState, epoch, privKeys)
 	require.NoError(t, err)
 
-	block := &ethpb.BeaconBlock{
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			RandaoReveal: epochSignature,
 		},
 	}
 
 	newState, err := blocks.ProcessRandao(
+		context.Background(),
 		beaconState,
-		block.Body,
+		b,
 	)
 	require.NoError(t, err, "Unexpected error processing block randao")
 	currentEpoch := helpers.CurrentEpoch(beaconState)

beacon-chain/core/blocks/signature.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"
@@ -16,32 +15,28 @@ import (
 )
 
 // retrieves the signature set from the raw data, public key,signature and domain provided.
-func retrieveSignatureSet(signedData []byte, pub []byte, signature []byte, domain []byte) (*bls.SignatureSet, error) {
+func retrieveSignatureSet(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")
 	}
-	sig, err := bls.SignatureFromBytes(signature)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert bytes to signature")
-	}
 	signingData := &pb.SigningData{
 		ObjectRoot: signedData,
 		Domain:     domain,
 	}
-	root, err := ssz.HashTreeRoot(signingData)
+	root, err := signingData.HashTreeRoot()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not hash container")
 	}
 	return &bls.SignatureSet{
-		Signatures: []bls.Signature{sig},
+		Signatures: [][]byte{signature},
 		PublicKeys: []bls.PublicKey{publicKey},
 		Messages:   [][32]byte{root},
 	}, nil
 }
 
 // verifies the signature from the raw data, public key and domain provided.
-func verifySignature(signedData []byte, pub []byte, signature []byte, domain []byte) error {
+func verifySignature(signedData, pub, signature, domain []byte) error {
 	set, err := retrieveSignatureSet(signedData, pub, signature, domain)
 	if err != nil {
 		return err
@@ -53,7 +48,11 @@ func verifySignature(signedData []byte, pub []byte, signature []byte, domain []b
 	sig := set.Signatures[0]
 	publicKey := set.PublicKeys[0]
 	root := set.Messages[0]
-	if !sig.Verify(publicKey, root[:]) {
+	rSig, err := bls.SignatureFromBytes(sig)
+	if err != nil {
+		return err
+	}
+	if !rSig.Verify(publicKey, root[:]) {
 		return helpers.ErrSigFailedToVerify
 	}
 	return nil
@@ -71,7 +70,7 @@ func VerifyBlockSignature(beaconState *stateTrie.BeaconState, block *ethpb.Signe
 		return err
 	}
 	proposerPubKey := proposer.PublicKey
-	return helpers.VerifyBlockSigningRoot(block.Block, proposerPubKey[:], block.Signature, domain)
+	return helpers.VerifyBlockSigningRoot(block.Block, proposerPubKey, block.Signature, domain)
 }
 
 // BlockSignatureSet retrieves the block signature set from the provided block and its corresponding state.
@@ -98,7 +97,7 @@ func RandaoSignatureSet(beaconState *stateTrie.BeaconState,
 	if err != nil {
 		return nil, nil, err
 	}
-	set, err := retrieveSignatureSet(buf, proposerPub[:], body.RandaoReveal, domain)
+	set, err := retrieveSignatureSet(buf, proposerPub, body.RandaoReveal, domain)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -130,15 +129,11 @@ func createAttestationSignatureSet(ctx context.Context, beaconState *stateTrie.B
 		return nil, nil
 	}
 
-	sigs := make([]bls.Signature, len(atts))
+	sigs := make([][]byte, len(atts))
 	pks := make([]bls.PublicKey, len(atts))
 	msgs := make([][32]byte, len(atts))
 	for i, a := range atts {
-		sig, err := bls.SignatureFromBytes(a.Signature)
-		if err != nil {
-			return nil, err
-		}
-		sigs[i] = sig
+		sigs[i] = a.Signature
 		c, err := helpers.BeaconCommitteeFromState(beaconState, a.Data.Slot, a.Data.CommitteeIndex)
 		if err != nil {
 			return nil, err
@@ -148,20 +143,16 @@ func createAttestationSignatureSet(ctx context.Context, beaconState *stateTrie.B
 			return nil, err
 		}
 		indices := ia.AttestingIndices
-		var pk bls.PublicKey
+		pubkeys := make([][]byte, len(indices))
 		for i := 0; i < len(indices); i++ {
 			pubkeyAtIdx := beaconState.PubkeyAtIndex(indices[i])
-			p, err := bls.PublicKeyFromBytes(pubkeyAtIdx[:])
-			if err != nil {
-				return nil, errors.Wrap(err, "could not deserialize validator public key")
-			}
-			if pk == nil {
-				pk = p
-			} else {
-				pk.Aggregate(p)
-			}
+			pubkeys[i] = pubkeyAtIdx[:]
 		}
-		pks[i] = pk
+		aggP, err := bls.AggregatePublicKeys(pubkeys)
+		if err != nil {
+			return nil, err
+		}
+		pks[i] = aggP
 
 		root, err := helpers.ComputeSigningRoot(ia.Data, domain)
 		if err != nil {

beacon-chain/core/blocks/spectest/block_header_test.go

@@ -41,8 +41,8 @@ func runBlockHeaderTest(t *testing.T, config string) {
 			postSSZExists := true
 			if err != nil && strings.Contains(err.Error(), "could not locate file") {
 				postSSZExists = false
-			} else if err != nil {
-				t.Fatal(err)
+			} else {
+				require.NoError(t, err)
 			}
 
 			// Spectest blocks are not signed, so we'll call NoVerify to skip sig verification.

beacon-chain/core/blocks/spectest/deposit_test.go

@@ -1,13 +1,11 @@
 package spectest
 
 import (
-	"context"
 	"path"
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/params/spectest"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
@@ -26,9 +24,7 @@ func runDepositTest(t *testing.T, config string) {
 			require.NoError(t, deposit.UnmarshalSSZ(depositFile), "Failed to unmarshal")
 
 			body := &ethpb.BeaconBlockBody{Deposits: []*ethpb.Deposit{deposit}}
-			testutil.RunBlockOperationTest(t, folderPath, body, func(ctx context.Context, state *state.BeaconState, body *ethpb.BeaconBlockBody) (*state.BeaconState, error) {
-				return blocks.ProcessDeposits(ctx, state, body.Deposits)
-			})
+			testutil.RunBlockOperationTest(t, folderPath, body, blocks.ProcessDeposits)
 		})
 	}
 }

beacon-chain/core/epoch/BUILD.bazel

@@ -16,7 +16,6 @@ go_library(
         "//shared/params: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",
     ],
 )
 
@@ -33,6 +32,7 @@ go_test(
         "//beacon-chain/state:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",

beacon-chain/core/epoch/epoch_processing.go

@@ -10,7 +10,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"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -46,7 +45,7 @@ func (s sortableIndices) Less(i, j int) bool {
 //  def get_attesting_balance(state: BeaconState, attestations: List[PendingAttestation]) -> Gwei:
 //    return get_total_balance(state, get_unslashed_attesting_indices(state, attestations))
 func AttestingBalance(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) (uint64, error) {
-	indices, err := unslashedAttestingIndices(state, atts)
+	indices, err := UnslashedAttestingIndices(state, atts)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get attesting indices")
 	}
@@ -148,10 +147,11 @@ func ProcessRegistryUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconStat
 //  def process_slashings(state: BeaconState) -> None:
 //    epoch = get_current_epoch(state)
 //    total_balance = get_total_active_balance(state)
+//    adjusted_total_slashing_balance = min(sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER, total_balance)
 //    for index, validator in enumerate(state.validators):
 //        if validator.slashed and epoch + EPOCHS_PER_SLASHINGS_VECTOR // 2 == validator.withdrawable_epoch:
 //            increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from penalty numerator to avoid uint64 overflow
-//			  penalty_numerator = validator.effective_balance // increment * min(sum(state.slashings) * 3, total_balance)
+//			  penalty_numerator = validator.effective_balance // increment * adjusted_total_slashing_balance
 //            penalty = penalty_numerator // total_balance * increment
 //            decrease_balance(state, ValidatorIndex(index), penalty)
 func ProcessSlashings(state *stateTrie.BeaconState) (*stateTrie.BeaconState, error) {
@@ -174,10 +174,10 @@ func ProcessSlashings(state *stateTrie.BeaconState) (*stateTrie.BeaconState, err
 	// a callback is used here to apply the following actions  to all validators
 	// below equally.
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
+	minSlashing := mathutil.Min(totalSlashing*params.BeaconConfig().ProportionalSlashingMultiplier, totalBalance)
 	err = state.ApplyToEveryValidator(func(idx int, val *ethpb.Validator) (bool, error) {
 		correctEpoch := (currentEpoch + exitLength/2) == val.WithdrawableEpoch
 		if val.Slashed && correctEpoch {
-			minSlashing := mathutil.Min(totalSlashing*3, totalBalance)
 			penaltyNumerator := val.EffectiveBalance / increment * minSlashing
 			penalty := penaltyNumerator / totalBalance * increment
 			if err := helpers.DecreaseBalance(state, uint64(idx), penalty); err != nil {
@@ -311,7 +311,7 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
 			BlockRoots: state.BlockRoots(),
 			StateRoots: state.StateRoots(),
 		}
-		batchRoot, err := ssz.HashTreeRoot(historicalBatch)
+		batchRoot, err := historicalBatch.HashTreeRoot()
 		if err != nil {
 			return nil, errors.Wrap(err, "could not hash historical batch")
 		}
@@ -330,7 +330,7 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
 	return state, nil
 }
 
-// unslashedAttestingIndices returns all the attesting indices from a list of attestations,
+// UnslashedAttestingIndices returns all the attesting indices from a list of attestations,
 // it sorts the indices and filters out the slashed ones.
 //
 // Spec pseudocode definition:
@@ -340,7 +340,7 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
 //    for a in attestations:
 //        output = output.union(get_attesting_indices(state, a.data, a.aggregation_bits))
 //    return set(filter(lambda index: not state.validators[index].slashed, output))
-func unslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) ([]uint64, error) {
+func UnslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) ([]uint64, error) {
 	var setIndices []uint64
 	seen := make(map[uint64]bool)
 

beacon-chain/core/epoch/epoch_processing_fuzz_test.go

@@ -18,5 +18,6 @@ func TestFuzzFinalUpdates_10000(t *testing.T) {
 		s, err := beaconstate.InitializeFromProtoUnsafe(base)
 		require.NoError(t, err)
 		_, err = ProcessFinalUpdates(s)
+		_ = err
 	}
 }

beacon-chain/core/epoch/epoch_processing_test.go

@@ -1,16 +1,17 @@
-package epoch
+package epoch_test
 
 import (
-	"bytes"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"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"
 )
@@ -20,8 +21,8 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
 	atts := make([]*pb.PendingAttestation, 2)
 	for i := 0; i < len(atts); i++ {
 		atts[i] = &pb.PendingAttestation{
-			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{},
-				Target: &ethpb.Checkpoint{Epoch: 0},
+			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},
 		}
@@ -42,7 +43,7 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
 	state, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	indices, err := unslashedAttestingIndices(state, atts)
+	indices, err := epoch.UnslashedAttestingIndices(state, atts)
 	require.NoError(t, err)
 	for i := 0; i < len(indices)-1; i++ {
 		if indices[i] >= indices[i+1] {
@@ -55,7 +56,7 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
 	validators = state.Validators()
 	validators[slashedValidator].Slashed = true
 	require.NoError(t, state.SetValidators(validators))
-	indices, err = unslashedAttestingIndices(state, atts)
+	indices, err = epoch.UnslashedAttestingIndices(state, 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)
@@ -67,7 +68,7 @@ func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
 	atts := make([]*pb.PendingAttestation, 5)
 	for i := 0; i < len(atts); i++ {
 		atts[i] = &pb.PendingAttestation{
-			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{},
+			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 				Target: &ethpb.Checkpoint{Epoch: 0}},
 			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF},
 		}
@@ -88,7 +89,7 @@ func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
 	state, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	indices, err := unslashedAttestingIndices(state, atts)
+	indices, err := epoch.UnslashedAttestingIndices(state, atts)
 	require.NoError(t, err)
 
 	for i := 0; i < len(indices)-1; i++ {
@@ -105,8 +106,8 @@ func TestAttestingBalance_CorrectBalance(t *testing.T) {
 	for i := 0; i < len(atts); i++ {
 		atts[i] = &pb.PendingAttestation{
 			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{},
-				Source: &ethpb.Checkpoint{},
+				Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
+				Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 				Slot:   uint64(i),
 			},
 			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
@@ -134,7 +135,7 @@ func TestAttestingBalance_CorrectBalance(t *testing.T) {
 	state, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
 
-	balance, err := AttestingBalance(state, atts)
+	balance, err := epoch.AttestingBalance(state, atts)
 	require.NoError(t, err)
 	wanted := 256 * params.BeaconConfig().MaxEffectiveBalance
 	assert.Equal(t, wanted, balance)
@@ -159,9 +160,9 @@ func TestBaseReward_AccurateRewards(t *testing.T) {
 		}
 		state, err := state.InitializeFromProto(base)
 		require.NoError(t, err)
-		c, err := BaseReward(state, 0)
+		c, err := epoch.BaseReward(state, 0)
 		require.NoError(t, err)
-		assert.Equal(t, tt.c, c, "BaseReward(%d)", tt.a)
+		assert.Equal(t, tt.c, c, "epoch.BaseReward(%d)", tt.a)
 	}
 }
 
@@ -174,7 +175,7 @@ func TestProcessSlashings_NotSlashed(t *testing.T) {
 	}
 	s, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := ProcessSlashings(s)
+	newState, err := epoch.ProcessSlashings(s)
 	require.NoError(t, err)
 	wanted := params.BeaconConfig().MaxEffectiveBalance
 	assert.Equal(t, wanted, newState.Balances()[0], "Unexpected slashed balance")
@@ -252,7 +253,7 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
 			original := proto.Clone(tt.state)
 			s, err := state.InitializeFromProto(tt.state)
 			require.NoError(t, err)
-			newState, err := ProcessSlashings(s)
+			newState, err := epoch.ProcessSlashings(s)
 			require.NoError(t, err)
 			assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
 		})
@@ -260,7 +261,7 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
 }
 
 func TestProcessFinalUpdates_CanProcess(t *testing.T) {
-	s := buildState(params.BeaconConfig().SlotsPerHistoricalRoot-1, params.BeaconConfig().SlotsPerEpoch)
+	s := buildState(t, params.BeaconConfig().SlotsPerHistoricalRoot-1, params.BeaconConfig().SlotsPerEpoch)
 	ce := helpers.CurrentEpoch(s)
 	ne := ce + 1
 	require.NoError(t, s.SetEth1DataVotes([]*ethpb.Eth1Data{}))
@@ -275,7 +276,7 @@ func TestProcessFinalUpdates_CanProcess(t *testing.T) {
 	mixes := s.RandaoMixes()
 	mixes[ce] = []byte{'A'}
 	require.NoError(t, s.SetRandaoMixes(mixes))
-	newS, err := ProcessFinalUpdates(s)
+	newS, err := epoch.ProcessFinalUpdates(s)
 	require.NoError(t, err)
 
 	// Verify effective balance is correctly updated.
@@ -286,9 +287,9 @@ func TestProcessFinalUpdates_CanProcess(t *testing.T) {
 	assert.Equal(t, newS.Slashings()[ce], newS.Slashings()[ne], "Unexpected slashed balance")
 
 	// Verify randao is correctly updated in the right position.
-	if mix, err := newS.RandaoMixAtIndex(ne); err != nil || bytes.Equal(mix, params.BeaconConfig().ZeroHash[:]) {
-		t.Error("latest RANDAO still zero hashes")
-	}
+	mix, err := newS.RandaoMixAtIndex(ne)
+	assert.NoError(t, err)
+	assert.DeepNotEqual(t, params.BeaconConfig().ZeroHash[:], mix, "latest RANDAO still zero hashes")
 
 	// Verify historical root accumulator was appended.
 	assert.Equal(t, 1, len(newS.HistoricalRoots()), "Unexpected slashed balance")
@@ -306,11 +307,11 @@ func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
 			params.BeaconConfig().MaxEffectiveBalance,
 			params.BeaconConfig().MaxEffectiveBalance,
 		},
-		FinalizedCheckpoint: &ethpb.Checkpoint{},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
 	state, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(state)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d", i)
@@ -320,7 +321,7 @@ func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
 func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
 	base := &pb.BeaconState{
 		Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
-		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6, Root: make([]byte, 32)},
 	}
 	limit, err := helpers.ValidatorChurnLimit(0)
 	require.NoError(t, err)
@@ -332,8 +333,9 @@ func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
 		})
 	}
 	state, err := state.InitializeFromProto(base)
+	require.NoError(t, err)
 	currentEpoch := helpers.CurrentEpoch(state)
-	newState, err := ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(state)
 	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)
@@ -357,11 +359,11 @@ func TestProcessRegistryUpdates_ActivationCompletes(t *testing.T) {
 			{ExitEpoch: params.BeaconConfig().MaxSeedLookahead,
 				ActivationEpoch: 5 + params.BeaconConfig().MaxSeedLookahead + 1},
 		},
-		FinalizedCheckpoint: &ethpb.Checkpoint{},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
 	state, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(state)
 	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)
@@ -381,11 +383,11 @@ func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
 				EffectiveBalance: params.BeaconConfig().EjectionBalance - 1,
 			},
 		},
-		FinalizedCheckpoint: &ethpb.Checkpoint{},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
 	state, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(state)
 	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)
@@ -393,11 +395,11 @@ func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
 }
 
 func TestProcessRegistryUpdates_CanExits(t *testing.T) {
-	epoch := uint64(5)
-	exitEpoch := helpers.ActivationExitEpoch(epoch)
+	e := uint64(5)
+	exitEpoch := helpers.ActivationExitEpoch(e)
 	minWithdrawalDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
 	base := &pb.BeaconState{
-		Slot: epoch * params.BeaconConfig().SlotsPerEpoch,
+		Slot: e * params.BeaconConfig().SlotsPerEpoch,
 		Validators: []*ethpb.Validator{
 			{
 				ExitEpoch:         exitEpoch,
@@ -406,18 +408,18 @@ func TestProcessRegistryUpdates_CanExits(t *testing.T) {
 				ExitEpoch:         exitEpoch,
 				WithdrawableEpoch: exitEpoch + minWithdrawalDelay},
 		},
-		FinalizedCheckpoint: &ethpb.Checkpoint{},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
 	state, err := state.InitializeFromProto(base)
 	require.NoError(t, err)
-	newState, err := ProcessRegistryUpdates(state)
+	newState, err := epoch.ProcessRegistryUpdates(state)
 	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)
 	}
 }
 
-func buildState(slot uint64, validatorCount uint64) *state.BeaconState {
+func buildState(t testing.TB, slot, validatorCount uint64) *state.BeaconState {
 	validators := make([]*ethpb.Validator, validatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
@@ -443,19 +445,15 @@ func buildState(slot uint64, validatorCount uint64) *state.BeaconState {
 	for i := 0; i < len(latestRandaoMixes); i++ {
 		latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
 	}
-	s, err := state.InitializeFromProto(&pb.BeaconState{
-		Slot:                        slot,
-		Balances:                    validatorBalances,
-		Validators:                  validators,
-		RandaoMixes:                 make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		Slashings:                   make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
-		BlockRoots:                  make([][]byte, params.BeaconConfig().SlotsPerEpoch*10),
-		FinalizedCheckpoint:         &ethpb.Checkpoint{},
-		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{},
-		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{},
-	})
-	if err != nil {
-		panic(err)
+	s := testutil.NewBeaconState()
+	if err := s.SetSlot(slot); err != nil {
+		t.Error(err)
+	}
+	if err := s.SetBalances(validatorBalances); err != nil {
+		t.Error(err)
+	}
+	if err := s.SetValidators(validators); err != nil {
+		t.Error(err)
 	}
 	return s
 }

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

@@ -14,10 +14,6 @@ import (
 	"go.opencensus.io/trace"
 )
 
-// Balances stores balances such as prev/current total validator balances, attested balances and more.
-// It's used for metrics reporting.
-var Balances *Balance
-
 // ProcessAttestations process the attestations in state and update individual validator's pre computes,
 // it also tracks and updates epoch attesting balances.
 func ProcessAttestations(
@@ -56,7 +52,6 @@ func ProcessAttestations(
 	}
 
 	pBal = UpdateBalance(vp, pBal)
-	Balances = pBal
 
 	return vp, pBal, nil
 }

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

@@ -178,8 +178,7 @@ func TestProcessAttestations(t *testing.T) {
 	for i := 0; i < len(pVals); i++ {
 		pVals[i] = &precompute.Validator{CurrentEpochEffectiveBalance: 100}
 	}
-	pBal := &precompute.Balance{}
-	pVals, pBal, err = precompute.ProcessAttestations(context.Background(), beaconState, pVals, pBal)
+	pVals, _, err = precompute.ProcessAttestations(context.Background(), beaconState, pVals, &precompute.Balance{})
 	require.NoError(t, err)
 
 	committee, err := helpers.BeaconCommitteeFromState(beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)

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

@@ -49,7 +49,11 @@ import (
 //    if all(bits[0:2]) and old_current_justified_checkpoint.epoch + 1 == current_epoch:
 //        state.finalized_checkpoint = old_current_justified_checkpoint
 func ProcessJustificationAndFinalizationPreCompute(state *stateTrie.BeaconState, pBal *Balance) (*stateTrie.BeaconState, error) {
-	if state.Slot() <= helpers.StartSlot(2) {
+	canProcessSlot, err := helpers.StartSlot(2 /*epoch*/)
+	if err != nil {
+		return nil, err
+	}
+	if state.Slot() <= canProcessSlot {
 		return state, nil
 	}
 

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

@@ -30,7 +30,7 @@ func TestProcessJustificationAndFinalizationPreCompute_ConsecutiveEpochs(t *test
 			Epoch: 0,
 			Root:  params.BeaconConfig().ZeroHash[:],
 		},
-		FinalizedCheckpoint: &ethpb.Checkpoint{},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 		JustificationBits:   bitfield.Bitvector4{0x0F}, // 0b1111
 		Validators:          []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
 		Balances:            []uint64{a, a, a, a}, // validator total balance should be 128000000000
@@ -67,7 +67,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyCurrentEpoch(t *te
 			Epoch: 0,
 			Root:  params.BeaconConfig().ZeroHash[:],
 		},
-		FinalizedCheckpoint: &ethpb.Checkpoint{},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 		JustificationBits:   bitfield.Bitvector4{0x03}, // 0b0011
 		Validators:          []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
 		Balances:            []uint64{a, a, a, a}, // validator total balance should be 128000000000
@@ -107,7 +107,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testi
 		JustificationBits: bitfield.Bitvector4{0x03}, // 0b0011
 		Validators:        []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
 		Balances:          []uint64{a, a, a, a}, // validator total balance should be 128000000000
-		BlockRoots:        blockRoots, FinalizedCheckpoint: &ethpb.Checkpoint{},
+		BlockRoots:        blockRoots, FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
 	state, err := beaconstate.InitializeFromProto(base)
 	require.NoError(t, err)

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

@@ -68,7 +68,7 @@ func AttestationsDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Valida
 	return rewards, penalties, nil
 }
 
-func attestationDelta(pBal *Balance, v *Validator, prevEpoch uint64, finalizedEpoch uint64) (uint64, uint64) {
+func attestationDelta(pBal *Balance, v *Validator, prevEpoch, finalizedEpoch uint64) (uint64, uint64) {
 	eligible := v.IsActivePrevEpoch || (v.IsSlashed && !v.IsWithdrawableCurrentEpoch)
 	if !eligible || pBal.ActiveCurrentEpoch == 0 {
 		return 0, 0
@@ -182,7 +182,7 @@ func ProposersDelta(state *stateTrie.BeaconState, pBal *Balance, vp []*Validator
 // Spec code:
 // def is_in_inactivity_leak(state: BeaconState) -> bool:
 //    return get_finality_delay(state) > MIN_EPOCHS_TO_INACTIVITY_PENALTY
-func isInInactivityLeak(prevEpoch uint64, finalizedEpoch uint64) bool {
+func isInInactivityLeak(prevEpoch, finalizedEpoch uint64) bool {
 	return finalityDelay(prevEpoch, finalizedEpoch) > params.BeaconConfig().MinEpochsToInactivityPenalty
 }
 
@@ -191,6 +191,6 @@ func isInInactivityLeak(prevEpoch uint64, finalizedEpoch uint64) bool {
 // Spec code:
 // def get_finality_delay(state: BeaconState) -> uint64:
 //    return get_previous_epoch(state) - state.finalized_checkpoint.epoch
-func finalityDelay(prevEpoch uint64, finalizedEpoch uint64) uint64 {
+func finalityDelay(prevEpoch, finalizedEpoch uint64) uint64 {
 	return prevEpoch - finalizedEpoch
 }

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

@@ -24,8 +24,8 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 	for i := 0; i < len(atts); i++ {
 		atts[i] = &pb.PendingAttestation{
 			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{},
-				Source: &ethpb.Checkpoint{},
+				Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
+				Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 			},
 			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
 			InclusionDelay:  1,
@@ -122,7 +122,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) {
 		base, err := epoch.BaseReward(state, 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, uint64(3*base), penalties[i], "Unexpected slashed indices penalty balance")
+		assert.Equal(t, 3*base, penalties[i], "Unexpected slashed indices penalty balance")
 	}
 
 	nonAttestedIndices := []uint64{434, 677, 872, 791}
@@ -202,7 +202,7 @@ func TestAttestationDeltas_ZeroInclusionDelay(t *testing.T) {
 
 	pVals, pBal, err := New(context.Background(), state)
 	require.NoError(t, err)
-	pVals, pBal, err = ProcessAttestations(context.Background(), state, pVals, pBal)
+	_, _, err = ProcessAttestations(context.Background(), state, pVals, pBal)
 	require.ErrorContains(t, "attestation with inclusion delay of 0", err)
 }
 
@@ -214,8 +214,8 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 	for i := 0; i < len(atts); i++ {
 		atts[i] = &pb.PendingAttestation{
 			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{},
-				Source: &ethpb.Checkpoint{},
+				Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
+				Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
 			},
 			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
 			InclusionDelay:  1,
@@ -254,7 +254,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 	}
 }
 
-func buildState(slot uint64, validatorCount uint64) *pb.BeaconState {
+func buildState(slot, validatorCount uint64) *pb.BeaconState {
 	validators := make([]*ethpb.Validator, validatorCount)
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
@@ -287,9 +287,9 @@ func buildState(slot uint64, validatorCount uint64) *pb.BeaconState {
 		RandaoMixes:                 make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 		Slashings:                   make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
 		BlockRoots:                  make([][]byte, params.BeaconConfig().SlotsPerEpoch*10),
-		FinalizedCheckpoint:         &ethpb.Checkpoint{},
-		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{},
-		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{},
+		FinalizedCheckpoint:         &ethpb.Checkpoint{Root: make([]byte, 32)},
+		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
+		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
 }
 

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

@@ -1,6 +1,8 @@
 package precompute
 
 import (
+	"errors"
+
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -21,8 +23,27 @@ func ProcessSlashingsPrecompute(state *stateTrie.BeaconState, pBal *Balance) err
 		totalSlashing += slashing
 	}
 
-	minSlashing := mathutil.Min(totalSlashing*3, pBal.ActiveCurrentEpoch)
+	minSlashing := mathutil.Min(totalSlashing*params.BeaconConfig().ProportionalSlashingMultiplier, pBal.ActiveCurrentEpoch)
 	epochToWithdraw := currentEpoch + exitLength/2
+
+	vs := state.ValidatorsReadOnly()
+	var hasSlashing bool
+	// Iterate through validator list in state, stop until a validator satisfies slashing condition of current epoch.
+	for _, v := range vs {
+		if v == nil {
+			return errors.New("nil validator in state")
+		}
+		correctEpoch := epochToWithdraw == v.WithdrawableEpoch()
+		if v.Slashed() && correctEpoch {
+			hasSlashing = true
+			break
+		}
+	}
+	// Exit early if there's no meaningful slashing to process.
+	if !hasSlashing {
+		return nil
+	}
+
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
 	validatorFunc := func(idx int, val *ethpb.Validator) (bool, error) {
 		correctEpoch := epochToWithdraw == val.WithdrawableEpoch

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

@@ -13,7 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
-func TestProcessSlashingsPrecompute_NotSlashed(t *testing.T) {
+func TestProcessSlashingsPrecompute_NotSlashedWithSlashedTrue(t *testing.T) {
 	s, err := beaconstate.InitializeFromProto(&pb.BeaconState{
 		Slot:       0,
 		Validators: []*ethpb.Validator{{Slashed: true}},
@@ -28,6 +28,21 @@ func TestProcessSlashingsPrecompute_NotSlashed(t *testing.T) {
 	assert.Equal(t, wanted, s.Balances()[0], "Unexpected slashed balance")
 }
 
+func TestProcessSlashingsPrecompute_NotSlashedWithSlashedFalse(t *testing.T) {
+	s, err := beaconstate.InitializeFromProto(&pb.BeaconState{
+		Slot:       0,
+		Validators: []*ethpb.Validator{{}},
+		Balances:   []uint64{params.BeaconConfig().MaxEffectiveBalance},
+		Slashings:  []uint64{0, 1e9},
+	})
+	require.NoError(t, err)
+	pBal := &precompute.Balance{ActiveCurrentEpoch: params.BeaconConfig().MaxEffectiveBalance}
+	require.NoError(t, precompute.ProcessSlashingsPrecompute(s, pBal))
+
+	wanted := params.BeaconConfig().MaxEffectiveBalance
+	assert.Equal(t, wanted, s.Balances()[0], "Unexpected slashed balance")
+}
+
 func TestProcessSlashingsPrecompute_SlashedLess(t *testing.T) {
 	tests := []struct {
 		state *pb.BeaconState