Forkchoice: update read only lock to regular lock (#7633)

* fix snappy errors

* gaz

* Update beacon-chain/p2p/pubsub.go

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

.bazelrc

@@ -33,9 +33,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 +77,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

@@ -2,24 +2,14 @@
 # across machines, developers, and workspaces.
 # 
 # This config is loaded from https://github.com/bazelbuild/bazel-toolchains/blob/master/bazelrc/latest.bazelrc
-build:remote-cache --remote_cache=grpcs://remotebuildexecution.googleapis.com
 build:remote-cache --remote_timeout=3600
-build:remote-cache --auth_enabled=true
-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 results backend.                                                        
-#build:remote-cache --bes_results_url="https://source.cloud.google.com/results/invocations/"
-#build:remote-cache --bes_backend=buildeventservice.googleapis.com               
-#build:remote-cache --bes_timeout=60s                                            
-#build:remote-cache --project_id=prysmaticlabs
+#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=
-build:remote-cache --host_platform_remote_properties_override='properties:{name:\"cache-silo-key\" value:\"prysm\"}' 
-build:remote-cache --remote_instance_name=projects/prysmaticlabs/instances/default_instance
+#build:remote-cache --disk_cache=
 build:remote-cache --remote_download_minimal
 
 # Import workspace options.
@@ -44,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/CODEOWNERS

@@ -3,3 +3,6 @@
 
 # Starlark code owners
 *.bzl @prestonvanloon
+
+# Anyone on prylabs team can approve dependency updates.
+deps.bzl @prysmaticlabs/core-team

.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,9 +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": [],

CONTRIBUTING.md

@@ -1,6 +1,8 @@
 # Contribution Guidelines
 
-Excited by our work and want to get involved in building out our sharding releases? Or maybe you haven't learned as much about the Ethereum protocol but are a savvy developer? Our [READINGS.md](https://github.com/prysmaticlabs/prysm/blob/master/docs/READINGS.md) doc includes comprehensive information on Ethereum and sharding for both part-time and core contributors to the project.
+Note: The latest and most up to date documenation can be found on our [docs portal](https://docs.prylabs.network/docs/contribute/contribution-guidelines).
+
+Excited by our work and want to get involved in building out our sharding releases? Or maybe you haven't learned as much about the Ethereum protocol but are a savvy developer? 
 
 You can explore our [Open Issues](https://github.com/prysmaticlabs/prysm/issues) in-the works for our different releases. Feel free to fork our repo and start creating PR’s after assigning yourself to an issue of interest. We are always chatting on [Discord](https://discord.gg/che9auJ) or [Gitter](https://gitter.im/prysmaticlabs/geth-sharding) drop us a line there if you want to get more involved or have any questions on our implementation!
 

README.md

@@ -1,8 +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)
-[![fuzzit](https://app.fuzzit.dev/badge?org_id=prysmaticlabs-gh)](https://app.fuzzit.dev/orgs/prysmaticlabs-gh/dashboard)
-[![ETH2.0_Spec_Version 0.12.1](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v0.12.1-blue.svg)](https://github.com/ethereum/eth2.0-specs/tree/v0.12.1)
+[![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 = "678c50336ce39bef19b2a0dc69e20a7bda37a673ae07dc0577386e9876e0a525",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.1/general.tar.gz",
+    sha256 = "7e5f838e0f9110471ef8be9401ea687a8ed4d499664dc0eac34ecfdfd03c2ac3",
+    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.3/general.tar.gz",
 )
 
 http_archive(
@@ -231,8 +235,8 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "d0ce95a3ca0d30df24f96a1b5cfad1f7e6fcc07ad84ca221d92480add051af3e",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.1/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 = "1dfa1ae6822912508dbf6d1fe7608169372daa3ad1e53a3ed0867cb2d6e0ccb0",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v0.12.1/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,16 +19,17 @@ 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",
-        "@org_uber_go_automaxprocs//: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",
-        "@org_uber_go_automaxprocs//:go_default_library",
     ],
 )
 

beacon-chain/archiver/BUILD.bazel

@@ -1,46 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-load("@io_bazel_rules_go//go:def.bzl", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["service.go"],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/archiver",
-    visibility = ["//beacon-chain:__subpackages__"],
-    deps = [
-        "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/core/feed:go_default_library",
-        "//beacon-chain/core/feed/state:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/validators:go_default_library",
-        "//beacon-chain/db:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//proto/beacon/p2p/v1:go_default_library",
-        "//shared/params:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["service_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
-        "//beacon-chain/core/feed:go_default_library",
-        "//beacon-chain/core/feed/state:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/db:go_default_library",
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//proto/beacon/p2p/v1:go_default_library",
-        "//shared/params:go_default_library",
-        "//shared/testutil:go_default_library",
-        "@com_github_gogo_protobuf//proto:go_default_library",
-        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-    ],
-)

beacon-chain/archiver/service.go

@@ -1,200 +0,0 @@
-package archiver
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
-	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/sirupsen/logrus"
-)
-
-var log = logrus.WithField("prefix", "archiver")
-
-// Service defining archiver functionality for persisting checkpointed
-// beacon chain information to a database backend for historical purposes.
-type Service struct {
-	ctx                  context.Context
-	cancel               context.CancelFunc
-	beaconDB             db.NoHeadAccessDatabase
-	headFetcher          blockchain.HeadFetcher
-	participationFetcher blockchain.ParticipationFetcher
-	stateNotifier        statefeed.Notifier
-	lastArchivedEpoch    uint64
-}
-
-// Config options for the archiver service.
-type Config struct {
-	BeaconDB             db.NoHeadAccessDatabase
-	HeadFetcher          blockchain.HeadFetcher
-	ParticipationFetcher blockchain.ParticipationFetcher
-	StateNotifier        statefeed.Notifier
-}
-
-// NewArchiverService initializes the service from configuration options.
-func NewArchiverService(ctx context.Context, cfg *Config) *Service {
-	ctx, cancel := context.WithCancel(ctx)
-	return &Service{
-		ctx:                  ctx,
-		cancel:               cancel,
-		beaconDB:             cfg.BeaconDB,
-		headFetcher:          cfg.HeadFetcher,
-		participationFetcher: cfg.ParticipationFetcher,
-		stateNotifier:        cfg.StateNotifier,
-	}
-}
-
-// Start the archiver service event loop.
-func (s *Service) Start() {
-	go s.run(s.ctx)
-}
-
-// Stop the archiver service event loop.
-func (s *Service) Stop() error {
-	defer s.cancel()
-	return nil
-}
-
-// Status reports the healthy status of the archiver. Returning nil means service
-// is correctly running without error.
-func (s *Service) Status() error {
-	return nil
-}
-
-// We archive committee information pertaining to the head state's epoch.
-func (s *Service) archiveCommitteeInfo(ctx context.Context, headState *state.BeaconState, epoch uint64) error {
-	proposerSeed, err := helpers.Seed(headState, epoch, params.BeaconConfig().DomainBeaconProposer)
-	if err != nil {
-		return errors.Wrap(err, "could not generate seed")
-	}
-	attesterSeed, err := helpers.Seed(headState, epoch, params.BeaconConfig().DomainBeaconAttester)
-	if err != nil {
-		return errors.Wrap(err, "could not generate seed")
-	}
-
-	info := &pb.ArchivedCommitteeInfo{
-		ProposerSeed: proposerSeed[:],
-		AttesterSeed: attesterSeed[:],
-	}
-	if err := s.beaconDB.SaveArchivedCommitteeInfo(ctx, epoch, info); err != nil {
-		return errors.Wrap(err, "could not archive committee info")
-	}
-	return nil
-}
-
-// We archive active validator set changes that happened during the previous epoch.
-func (s *Service) archiveActiveSetChanges(ctx context.Context, headState *state.BeaconState, epoch uint64) error {
-	prevEpoch := epoch - 1
-	vals := headState.Validators()
-	activations := validators.ActivatedValidatorIndices(prevEpoch, vals)
-	slashings := validators.SlashedValidatorIndices(prevEpoch, vals)
-	activeValidatorCount, err := helpers.ActiveValidatorCount(headState, prevEpoch)
-	if err != nil {
-		return errors.Wrap(err, "could not get active validator count")
-	}
-	exited, err := validators.ExitedValidatorIndices(prevEpoch, vals, activeValidatorCount)
-	if err != nil {
-		return errors.Wrap(err, "could not determine exited validator indices")
-	}
-	activeSetChanges := &pb.ArchivedActiveSetChanges{
-		Activated: activations,
-		Exited:    exited,
-		Slashed:   slashings,
-	}
-	if err := s.beaconDB.SaveArchivedActiveValidatorChanges(ctx, prevEpoch, activeSetChanges); err != nil {
-		return errors.Wrap(err, "could not archive active validator set changes")
-	}
-	return nil
-}
-
-// We compute participation metrics by first retrieving the head state and
-// matching validator attestations during the epoch.
-func (s *Service) archiveParticipation(ctx context.Context, epoch uint64) error {
-	pBal := s.participationFetcher.Participation(epoch)
-	participation := &ethpb.ValidatorParticipation{}
-	if pBal != nil {
-		participation = &ethpb.ValidatorParticipation{
-			EligibleEther:           pBal.ActivePrevEpoch,
-			VotedEther:              pBal.PrevEpochTargetAttested,
-			GlobalParticipationRate: float32(pBal.PrevEpochTargetAttested) / float32(pBal.ActivePrevEpoch),
-		}
-	}
-	return s.beaconDB.SaveArchivedValidatorParticipation(ctx, epoch, participation)
-}
-
-// We archive validator balances and active indices.
-func (s *Service) archiveBalances(ctx context.Context, balances []uint64, epoch uint64) error {
-	if err := s.beaconDB.SaveArchivedBalances(ctx, epoch, balances); err != nil {
-		return errors.Wrap(err, "could not archive balances")
-	}
-	return nil
-}
-
-func (s *Service) run(ctx context.Context) {
-	stateChannel := make(chan *feed.Event, 1)
-	stateSub := s.stateNotifier.StateFeed().Subscribe(stateChannel)
-	defer stateSub.Unsubscribe()
-	for {
-		select {
-		case event := <-stateChannel:
-			if event.Type == statefeed.BlockProcessed {
-				data, ok := event.Data.(*statefeed.BlockProcessedData)
-				if !ok {
-					log.Error("Event feed data is not type *statefeed.BlockProcessedData")
-					continue
-				}
-				log.WithField("headRoot", fmt.Sprintf("%#x", data.BlockRoot)).Debug("Received block processed event")
-				headState, err := s.headFetcher.HeadState(ctx)
-				if err != nil {
-					log.WithError(err).Error("Head state is not available")
-					continue
-				}
-				slot := headState.Slot()
-				currentEpoch := helpers.SlotToEpoch(slot)
-				if !helpers.IsEpochEnd(slot) && currentEpoch <= s.lastArchivedEpoch {
-					continue
-				}
-				epochToArchive := currentEpoch
-				if !helpers.IsEpochEnd(slot) {
-					epochToArchive--
-				}
-				if err := s.archiveCommitteeInfo(ctx, headState, epochToArchive); err != nil {
-					log.WithError(err).Error("Could not archive committee info")
-					continue
-				}
-				if err := s.archiveActiveSetChanges(ctx, headState, epochToArchive); err != nil {
-					log.WithError(err).Error("Could not archive active validator set changes")
-					continue
-				}
-				if err := s.archiveParticipation(ctx, epochToArchive); err != nil {
-					log.WithError(err).Error("Could not archive validator participation")
-					continue
-				}
-				if err := s.archiveBalances(ctx, headState.Balances(), epochToArchive); err != nil {
-					log.WithError(err).Error("Could not archive validator balances and active indices")
-					continue
-				}
-				log.WithField(
-					"epoch",
-					epochToArchive,
-				).Debug("Successfully archived beacon chain data during epoch")
-				s.lastArchivedEpoch = epochToArchive
-			}
-		case <-s.ctx.Done():
-			log.Debug("Context closed, exiting goroutine")
-			return
-		case err := <-stateSub.Err():
-			log.WithError(err).Error("Subscription to state feed notifier failed")
-			return
-		}
-	}
-}

beacon-chain/archiver/service_test.go

@@ -1,474 +0,0 @@
-package archiver
-
-import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"reflect"
-	"testing"
-
-	"github.com/gogo/protobuf/proto"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
-	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	dbutil "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	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/shared/testutil"
-	"github.com/sirupsen/logrus"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-)
-
-func init() {
-	logrus.SetLevel(logrus.DebugLevel)
-	logrus.SetOutput(ioutil.Discard)
-}
-
-func TestArchiverService_ReceivesBlockProcessedEvent(t *testing.T) {
-	hook := logTest.NewGlobal()
-	svc, _ := setupService(t)
-	st := testutil.NewBeaconState()
-	if err := st.SetSlot(1); err != nil {
-		t.Fatal(err)
-	}
-	svc.headFetcher = &mock.ChainService{
-		State: st,
-	}
-
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-	testutil.AssertLogsContain(t, hook, fmt.Sprintf("%#x", event.Data.(*statefeed.BlockProcessedData).BlockRoot))
-	testutil.AssertLogsContain(t, hook, "Received block processed event")
-}
-
-func TestArchiverService_OnlyArchiveAtEpochEnd(t *testing.T) {
-	hook := logTest.NewGlobal()
-	svc, _ := setupService(t)
-	// The head state is NOT an epoch end.
-	st := testutil.NewBeaconState()
-	if err := st.SetSlot(params.BeaconConfig().SlotsPerEpoch - 2); err != nil {
-		t.Fatal(err)
-	}
-	svc.headFetcher = &mock.ChainService{
-		State: st,
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-
-	// The context should have been canceled.
-	if svc.ctx.Err() != context.Canceled {
-		t.Error("context was not canceled")
-	}
-	testutil.AssertLogsContain(t, hook, "Received block processed event")
-	// The service should ONLY log any archival logs if we receive a
-	// head slot that is an epoch end.
-	testutil.AssertLogsDoNotContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_ArchivesEvenThroughSkipSlot(t *testing.T) {
-	hook := logTest.NewGlobal()
-	svc, _ := setupService(t)
-	validatorCount := uint64(100)
-	headState, err := setupState(validatorCount)
-	if err != nil {
-		t.Fatal(err)
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-
-	exitRoutine := make(chan bool)
-	go func() {
-		svc.run(svc.ctx)
-		<-exitRoutine
-	}()
-
-	// Send out an event every slot, skipping the end slot of the epoch.
-	for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch+1; i++ {
-		if err := headState.SetSlot(i); err != nil {
-			t.Fatal(err)
-		}
-		svc.headFetcher = &mock.ChainService{
-			State: headState,
-		}
-		if helpers.IsEpochEnd(i) {
-			continue
-		}
-		// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
-		for sent := 0; sent == 0; {
-			sent = svc.stateNotifier.StateFeed().Send(event)
-		}
-	}
-	if err := svc.Stop(); err != nil {
-		t.Fatal(err)
-	}
-	exitRoutine <- true
-
-	// The context should have been canceled.
-	if svc.ctx.Err() != context.Canceled {
-		t.Error("context was not canceled")
-	}
-
-	testutil.AssertLogsContain(t, hook, "Received block processed event")
-	// Even though there was a skip slot, we should still be able to archive
-	// upon the next block event afterwards.
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_ComputesAndSavesParticipation(t *testing.T) {
-	hook := logTest.NewGlobal()
-	validatorCount := uint64(100)
-	headState, err := setupState(validatorCount)
-	if err != nil {
-		t.Fatal(err)
-	}
-	svc, _ := setupService(t)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-
-	attestedBalance := uint64(1)
-
-	currentEpoch := helpers.CurrentEpoch(headState)
-	wanted := &ethpb.ValidatorParticipation{
-		VotedEther:              attestedBalance,
-		EligibleEther:           validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-		GlobalParticipationRate: float32(attestedBalance) / float32(validatorCount*params.BeaconConfig().MaxEffectiveBalance),
-	}
-
-	retrieved, err := svc.beaconDB.ArchivedValidatorParticipation(svc.ctx, currentEpoch)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !proto.Equal(wanted, retrieved) {
-		t.Errorf("Wanted participation for epoch %d %v, retrieved %v", currentEpoch-1, wanted, retrieved)
-	}
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_SavesIndicesAndBalances(t *testing.T) {
-	hook := logTest.NewGlobal()
-	validatorCount := uint64(100)
-	headState, err := setupState(validatorCount)
-	if err != nil {
-		t.Fatal(err)
-	}
-	svc, _ := setupService(t)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-
-	retrieved, err := svc.beaconDB.ArchivedBalances(svc.ctx, helpers.CurrentEpoch(headState))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(headState.Balances(), retrieved) {
-		t.Errorf(
-			"Wanted balances for epoch %d %v, retrieved %v",
-			helpers.CurrentEpoch(headState),
-			headState.Balances(),
-			retrieved,
-		)
-	}
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_SavesCommitteeInfo(t *testing.T) {
-	hook := logTest.NewGlobal()
-	validatorCount := uint64(100)
-	headState, err := setupState(validatorCount)
-	if err != nil {
-		t.Fatal(err)
-	}
-	svc, _ := setupService(t)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-
-	currentEpoch := helpers.CurrentEpoch(headState)
-	proposerSeed, err := helpers.Seed(headState, currentEpoch, params.BeaconConfig().DomainBeaconProposer)
-	if err != nil {
-		t.Fatal(err)
-	}
-	attesterSeed, err := helpers.Seed(headState, currentEpoch, params.BeaconConfig().DomainBeaconAttester)
-	if err != nil {
-		t.Fatal(err)
-	}
-	wanted := &pb.ArchivedCommitteeInfo{
-		ProposerSeed: proposerSeed[:],
-		AttesterSeed: attesterSeed[:],
-	}
-
-	retrieved, err := svc.beaconDB.ArchivedCommitteeInfo(svc.ctx, helpers.CurrentEpoch(headState))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !proto.Equal(wanted, retrieved) {
-		t.Errorf(
-			"Wanted committee info for epoch %d %v, retrieved %v",
-			helpers.CurrentEpoch(headState),
-			wanted,
-			retrieved,
-		)
-	}
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_SavesActivatedValidatorChanges(t *testing.T) {
-	hook := logTest.NewGlobal()
-	validatorCount := uint64(100)
-	headState, err := setupState(validatorCount)
-	if err != nil {
-		t.Fatal(err)
-	}
-	svc, beaconDB := setupService(t)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	prevEpoch := helpers.PrevEpoch(headState)
-	delayedActEpoch := helpers.ActivationExitEpoch(prevEpoch)
-	val1, err := headState.ValidatorAtIndex(4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	val1.ActivationEpoch = delayedActEpoch
-	val2, err := headState.ValidatorAtIndex(5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	val2.ActivationEpoch = delayedActEpoch
-	if err := headState.UpdateValidatorAtIndex(4, val1); err != nil {
-		t.Fatal(err)
-	}
-	if err := headState.UpdateValidatorAtIndex(5, val1); err != nil {
-		t.Fatal(err)
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-
-	retrieved, err := beaconDB.ArchivedActiveValidatorChanges(svc.ctx, prevEpoch)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if retrieved == nil {
-		t.Fatal("Retrieved indices are nil")
-	}
-	if len(retrieved.Activated) != 98 {
-		t.Error("Did not get wanted active length")
-	}
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_SavesSlashedValidatorChanges(t *testing.T) {
-	hook := logTest.NewGlobal()
-	validatorCount := uint64(100)
-	headState, err := setupState(validatorCount)
-	if err != nil {
-		t.Fatal(err)
-	}
-	svc, beaconDB := setupService(t)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	prevEpoch := helpers.PrevEpoch(headState)
-	val1, err := headState.ValidatorAtIndex(95)
-	if err != nil {
-		t.Fatal(err)
-	}
-	val1.Slashed = true
-	val2, err := headState.ValidatorAtIndex(96)
-	if err != nil {
-		t.Fatal(err)
-	}
-	val2.Slashed = true
-	if err := headState.UpdateValidatorAtIndex(95, val1); err != nil {
-		t.Fatal(err)
-	}
-	if err := headState.UpdateValidatorAtIndex(96, val1); err != nil {
-		t.Fatal(err)
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-
-	retrieved, err := beaconDB.ArchivedActiveValidatorChanges(svc.ctx, prevEpoch)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if retrieved == nil {
-		t.Fatal("Retrieved indices are nil")
-	}
-	if !reflect.DeepEqual(retrieved.Slashed, []uint64{95, 96}) {
-		t.Errorf("Wanted indices 95, 96 slashed, received %v", retrieved.Slashed)
-	}
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_SavesExitedValidatorChanges(t *testing.T) {
-	hook := logTest.NewGlobal()
-	validatorCount := uint64(100)
-	headState, err := setupState(validatorCount)
-	if err != nil {
-		t.Fatal(err)
-	}
-	svc, beaconDB := setupService(t)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	prevEpoch := helpers.PrevEpoch(headState)
-	val, err := headState.ValidatorAtIndex(95)
-	if err != nil {
-		t.Fatal(err)
-	}
-	val.ExitEpoch = prevEpoch
-	val.WithdrawableEpoch = prevEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
-	if err := headState.UpdateValidatorAtIndex(95, val); err != nil {
-		t.Fatal(err)
-	}
-	event := &feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			BlockRoot: [32]byte{1, 2, 3},
-			Verified:  true,
-		},
-	}
-	triggerStateEvent(t, svc, event)
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-	retrieved, err := beaconDB.ArchivedActiveValidatorChanges(svc.ctx, prevEpoch)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if retrieved == nil {
-		t.Fatal("Retrieved indices are nil")
-	}
-	if !reflect.DeepEqual(retrieved.Exited, []uint64{95}) {
-		t.Errorf("Wanted indices 95 exited, received %v", retrieved.Exited)
-	}
-}
-
-func setupState(validatorCount uint64) (*stateTrie.BeaconState, error) {
-	validators := make([]*ethpb.Validator, validatorCount)
-	balances := make([]uint64, validatorCount)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			ExitEpoch:         params.BeaconConfig().FarFutureEpoch,
-			WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance,
-		}
-		balances[i] = params.BeaconConfig().MaxEffectiveBalance
-	}
-
-	atts := []*pb.PendingAttestation{{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{}}}}
-
-	// We initialize a head state that has attestations from participated
-	// validators in a simulated fashion.
-	st := testutil.NewBeaconState()
-	if err := st.SetSlot((2 * params.BeaconConfig().SlotsPerEpoch) - 1); err != nil {
-		return nil, err
-	}
-	if err := st.SetValidators(validators); err != nil {
-		return nil, err
-	}
-	if err := st.SetBalances(balances); err != nil {
-		return nil, err
-	}
-	if err := st.SetCurrentEpochAttestations(atts); err != nil {
-		return nil, err
-	}
-	return st, nil
-}
-
-func setupService(t *testing.T) (*Service, db.Database) {
-	beaconDB := dbutil.SetupDB(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	validatorCount := uint64(100)
-	totalBalance := validatorCount * params.BeaconConfig().MaxEffectiveBalance
-	mockChainService := &mock.ChainService{}
-	return &Service{
-		beaconDB:      beaconDB,
-		ctx:           ctx,
-		cancel:        cancel,
-		stateNotifier: mockChainService.StateNotifier(),
-		participationFetcher: &mock.ChainService{
-			Balance: &precompute.Balance{ActivePrevEpoch: totalBalance, PrevEpochTargetAttested: 1}},
-	}, beaconDB
-}
-
-func triggerStateEvent(t *testing.T, svc *Service, event *feed.Event) {
-	exitRoutine := make(chan bool)
-	go func() {
-		svc.run(svc.ctx)
-		<-exitRoutine
-	}()
-
-	// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
-	for sent := 0; sent == 0; {
-		sent = svc.stateNotifier.StateFeed().Send(event)
-	}
-	if err := svc.Stop(); err != nil {
-		t.Fatal(err)
-	}
-	exitRoutine <- true
-
-	// The context should have been canceled.
-	if svc.ctx.Err() != context.Canceled {
-		t.Error("context was not canceled")
-	}
-}

beacon-chain/blockchain/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "chain_info.go",
+        "checkpoint_info_cache.go",
         "head.go",
         "info.go",
         "init_sync_process_block.go",
@@ -17,9 +18,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",
@@ -41,16 +46,18 @@ 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/hashutil: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_hashicorp_golang_lru//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
@@ -73,15 +80,20 @@ go_test(
     size = "medium",
     srcs = [
         "chain_info_test.go",
+        "checkpoint_info_cache_test.go",
         "head_test.go",
-        "init_sync_process_block_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/testing:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -97,6 +109,8 @@ go_test(
         "//shared/event: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_ethereum_go_ethereum//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
@@ -114,6 +128,7 @@ go_test(
     name = "go_raceon_test",
     srcs = [
         "chain_info_norace_test.go",
+        "receive_block_test.go",
         "service_norace_test.go",
     ],
     embed = [":go_default_library"],
@@ -127,6 +142,7 @@ go_test(
     race = "on",
     tags = ["race_on"],
     deps = [
+        "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -140,6 +156,8 @@ go_test(
         "//shared/event: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_ethereum_go_ethereum//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -5,11 +5,11 @@ import (
 	"time"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
+	"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"
@@ -42,8 +42,8 @@ type HeadFetcher interface {
 	HeadRoot(ctx context.Context) ([]byte, error)
 	HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, error)
 	HeadState(ctx context.Context) (*state.BeaconState, error)
-	HeadValidatorsIndices(epoch uint64) ([]uint64, error)
-	HeadSeed(epoch uint64) ([32]byte, error)
+	HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]uint64, error)
+	HeadSeed(ctx context.Context, epoch uint64) ([32]byte, error)
 	HeadGenesisValidatorRoot() [32]byte
 	HeadETH1Data() *ethpb.Eth1Data
 	ProtoArrayStore() *protoarray.Store
@@ -57,6 +57,7 @@ type ForkFetcher interface {
 // CanonicalFetcher retrieves the current chain's canonical information.
 type CanonicalFetcher interface {
 	IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error)
+	VerifyBlkDescendant(ctx context.Context, blockRoot [32]byte) error
 }
 
 // FinalizationFetcher defines a common interface for methods in blockchain service which
@@ -67,12 +68,6 @@ type FinalizationFetcher interface {
 	PreviousJustifiedCheckpt() *ethpb.Checkpoint
 }
 
-// ParticipationFetcher defines a common interface for methods in blockchain service which
-// directly retrieves validator participation related data.
-type ParticipationFetcher interface {
-	Participation(epoch uint64) *precompute.Balance
-}
-
 // FinalizedCheckpt returns the latest finalized checkpoint from head state.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 	if s.finalizedCheckpt == nil {
@@ -102,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
 	}
@@ -111,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
@@ -124,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
 	}
@@ -133,9 +134,12 @@ func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
 }
 
 // HeadBlock returns the head block of the chain.
-// If the head state is nil from service struct,
+// 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,35 +148,52 @@ func (s *Service) HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, erro
 }
 
 // HeadState returns the head state of the chain.
-// If the head state is nil from service struct,
+// If the head is nil from service struct,
 // it will attempt to get the head state from DB.
 func (s *Service) HeadState(ctx context.Context) (*state.BeaconState, error) {
-	if s.hasHeadState() {
-		return s.headState(), nil
+	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))
+
+	if ok {
+		return s.headState(ctx), nil
 	}
 
 	return s.beaconDB.HeadState(ctx)
 }
 
 // HeadValidatorsIndices returns a list of active validator indices from the head view of a given epoch.
-func (s *Service) HeadValidatorsIndices(epoch uint64) ([]uint64, error) {
+func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]uint64, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return []uint64{}, nil
 	}
-	return helpers.ActiveValidatorIndices(s.headState(), epoch)
+	return helpers.ActiveValidatorIndices(s.headState(ctx), epoch)
 }
 
 // HeadSeed returns the seed from the head view of a given epoch.
-func (s *Service) HeadSeed(epoch uint64) ([32]byte, error) {
+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
 	}
 
-	return helpers.Seed(s.headState(), epoch, params.BeaconConfig().DomainBeaconAttester)
+	return helpers.Seed(s.headState(ctx), epoch, params.BeaconConfig().DomainBeaconAttester)
 }
 
 // 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{}
 	}
@@ -182,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{}
 	}
@@ -201,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{}
 	}
@@ -209,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,
@@ -218,14 +248,6 @@ func (s *Service) CurrentFork() *pb.Fork {
 	return s.head.state.Fork()
 }
 
-// Participation returns the participation stats of a given epoch.
-func (s *Service) Participation(epoch uint64) *precompute.Balance {
-	s.epochParticipationLock.RLock()
-	defer s.epochParticipationLock.RUnlock()
-
-	return s.epochParticipation[epoch]
-}
-
 // IsCanonical returns true if the input block root is part of the canonical chain.
 func (s *Service) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error) {
 	// If the block has been finalized, the block will always be part of the canonical chain.
@@ -233,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_norace_test.go

@@ -5,70 +5,59 @@ import (
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestHeadSlot_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 	s := &Service{
 		beaconDB: db,
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
 	s.HeadSlot()
 }
 
 func TestHeadRoot_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 	s := &Service{
 		beaconDB: db,
 		head:     &head{root: [32]byte{'A'}},
-		stateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		stateGen: stategen.New(db, sc),
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	if _, err := s.HeadRoot(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := s.HeadRoot(context.Background())
+	require.NoError(t, err)
 }
 
 func TestHeadBlock_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 	s := &Service{
 		beaconDB: db,
 		head:     &head{block: &ethpb.SignedBeaconBlock{}},
-		stateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		stateGen: stategen.New(db, sc),
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	if _, err := s.HeadBlock(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := s.HeadBlock(context.Background())
+	require.NoError(t, err)
 }
 
 func TestHeadState_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 	s := &Service{
 		beaconDB: db,
-		stateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		stateGen: stategen.New(db, sc),
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	if _, err := s.HeadState(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := s.HeadState(context.Background())
+	require.NoError(t, err)
 }

beacon-chain/blockchain/chain_info_test.go

@@ -1,9 +1,7 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
-	"reflect"
 	"testing"
 	"time"
 
@@ -12,181 +10,143 @@ 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 := testDB.SetupDB(t)
-	c := setupBeaconChain(t, db)
-	if !bytes.Equal(c.FinalizedCheckpt().Root, params.BeaconConfig().ZeroHash[:]) {
-		t.Error("Incorrect pre chain start value")
-	}
+	db, sc := testDB.SetupDB(t)
+	c := setupBeaconChain(t, db, sc)
+	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], c.FinalizedCheckpt().Root, "Incorrect pre chain start value")
 }
 
 func TestHeadRoot_Nil(t *testing.T) {
-	db := testDB.SetupDB(t)
-	c := setupBeaconChain(t, db)
+	db, sc := testDB.SetupDB(t)
+	c := setupBeaconChain(t, db, sc)
 	headRoot, err := c.HeadRoot(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(headRoot, params.BeaconConfig().ZeroHash[:]) {
-		t.Error("Incorrect pre chain start value")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
 }
 
 func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 5, Root: []byte("foo")}
-	c := setupBeaconChain(t, db)
+	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
+	c := setupBeaconChain(t, db, sc)
 	c.finalizedCheckpt = cp
 
-	if c.FinalizedCheckpt().Epoch != cp.Epoch {
-		t.Errorf("Finalized epoch at genesis should be %d, got: %d", cp.Epoch, c.FinalizedCheckpt().Epoch)
-	}
+	assert.Equal(t, cp.Epoch, c.FinalizedCheckpt().Epoch, "Unexpected finalized epoch")
 }
 
 func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
 	genesisRoot := [32]byte{'A'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db)
+	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 := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 6, Root: []byte("foo")}
-	c := setupBeaconChain(t, db)
+	cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
+	c := setupBeaconChain(t, db, sc)
 	c.justifiedCheckpt = cp
 
-	if c.CurrentJustifiedCheckpt().Epoch != cp.Epoch {
-		t.Errorf("Current Justifiied epoch at genesis should be %d, got: %d", cp.Epoch, c.CurrentJustifiedCheckpt().Epoch)
-	}
+	assert.Equal(t, cp.Epoch, c.CurrentJustifiedCheckpt().Epoch, "Unexpected justified epoch")
 }
 
 func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
 	genesisRoot := [32]byte{'B'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db)
+	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 := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 7, Root: []byte("foo")}
-	c := setupBeaconChain(t, db)
+	cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
+	c := setupBeaconChain(t, db, sc)
 	c.prevJustifiedCheckpt = cp
-
-	if c.PreviousJustifiedCheckpt().Epoch != cp.Epoch {
-		t.Errorf("Previous Justifiied epoch at genesis should be %d, got: %d", cp.Epoch, c.PreviousJustifiedCheckpt().Epoch)
-	}
+	assert.Equal(t, cp.Epoch, c.PreviousJustifiedCheckpt().Epoch, "Unexpected previous justified epoch")
 }
 
 func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
 	genesisRoot := [32]byte{'C'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db)
+	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}
-	if c.HeadSlot() != 100 {
-		t.Errorf("Wanted head slot: %d, got: %d", 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'}}
-	if [32]byte{'A'} != c.headRoot() {
-		t.Errorf("Wanted head root: %v, got: %d", []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{})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{block: b, state: s}
 
 	recevied, err := c.HeadBlock(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(b, recevied) {
-		t.Error("incorrect head block received")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, b, recevied, "Incorrect head block received")
 }
 
 func TestHeadState_CanRetrieve(t *testing.T) {
 	s, err := state.InitializeFromProto(&pb.BeaconState{Slot: 2, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{state: s}
 	headState, err := c.HeadState(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !proto.Equal(s.InnerStateUnsafe(), headState.InnerStateUnsafe()) {
-		t.Error("incorrect head state received")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Incorrect head state received")
 }
 
 func TestGenesisTime_CanRetrieve(t *testing.T) {
 	c := &Service{genesisTime: time.Unix(999, 0)}
 	wanted := time.Unix(999, 0)
-	if c.GenesisTime() != wanted {
-		t.Error("Did not get wanted genesis time")
-	}
+	assert.Equal(t, wanted, c.GenesisTime(), "Did not get wanted genesis time")
 }
 
 func TestCurrentFork_CanRetrieve(t *testing.T) {
 	f := &pb.Fork{Epoch: 999}
 	s, err := state.InitializeFromProto(&pb.BeaconState{Fork: f})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{state: s}
 	if !proto.Equal(c.CurrentFork(), f) {
@@ -197,37 +157,47 @@ func TestCurrentFork_CanRetrieve(t *testing.T) {
 func TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
 	// Should not panic if head state is nil.
 	c := &Service{}
-	if c.GenesisValidatorRoot() != [32]byte{} {
-		t.Error("Did not get correct genesis validator root")
-	}
+	assert.Equal(t, [32]byte{}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
 
 	s, err := state.InitializeFromProto(&pb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	c.head = &head{state: s}
-	if c.GenesisValidatorRoot() != [32]byte{'a'} {
-		t.Error("Did not get correct genesis validator root")
-	}
+	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
 }
 
 func TestHeadETH1Data_Nil(t *testing.T) {
-	db := testDB.SetupDB(t)
-	c := setupBeaconChain(t, db)
-	if !reflect.DeepEqual(c.HeadETH1Data(), &ethpb.Eth1Data{}) {
-		t.Error("Incorrect pre chain start value")
-	}
+	db, sc := testDB.SetupDB(t)
+	c := setupBeaconChain(t, db, sc)
+	assert.DeepEqual(t, &ethpb.Eth1Data{}, c.HeadETH1Data(), "Incorrect pre chain start value")
 }
 
 func TestHeadETH1Data_CanRetrieve(t *testing.T) {
 	d := &ethpb.Eth1Data{DepositCount: 999}
 	s, err := state.InitializeFromProto(&pb.BeaconState{Eth1Data: d})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{state: s}
 	if !proto.Equal(c.HeadETH1Data(), d) {
 		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/checkpoint_info_cache.go

@@ -0,0 +1,83 @@
+package blockchain
+
+import (
+	"sync"
+
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/hashutil"
+)
+
+var (
+	// This defines the max number of checkpoint info this cache can store.
+	// Each cache is calculated at 3MB(30K validators), the total cache size is around 100MB.
+	// Due to reorgs and long finality, it's good to keep the old cache around for quickly switch over.
+	maxInfoSize = 32
+
+	// This tracks the number of check point info requests that aren't present in the cache.
+	infoMiss = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "check_point_info_cache_miss",
+		Help: "The number of check point info requests that aren't present in the cache.",
+	})
+	// This tracks the number of check point info requests that are in the cache.
+	infoHit = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "check_point_info_cache_hit",
+		Help: "The number of check point info requests that are present in the cache.",
+	})
+)
+
+// checkPtInfoCache is a struct with 1 LRU cache for looking up check point info by checkpoint.
+type checkPtInfoCache struct {
+	cache *lru.Cache
+	lock  sync.RWMutex
+}
+
+// newCheckPointInfoCache creates a new checkpoint info cache for storing/accessing processed check point info object.
+func newCheckPointInfoCache() *checkPtInfoCache {
+	cache, err := lru.New(maxInfoSize)
+	if err != nil {
+		panic(err)
+	}
+	return &checkPtInfoCache{
+		cache: cache,
+	}
+}
+
+// get fetches check point info by check point. Returns the reference of the CheckPtInfo, nil if doesn't exist.
+func (c *checkPtInfoCache) get(cp *ethpb.Checkpoint) (*pb.CheckPtInfo, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	h, err := hashutil.HashProto(cp)
+	if err != nil {
+		return nil, err
+	}
+
+	item, exists := c.cache.Get(h)
+
+	if exists && item != nil {
+		infoHit.Inc()
+		// Copy here is unnecessary since the returned check point info object
+		// will only be used to verify attestation signature.
+		return item.(*pb.CheckPtInfo), nil
+	}
+
+	infoMiss.Inc()
+	return nil, nil
+}
+
+// put adds CheckPtInfo object to the cache. This method also trims the least
+// recently added CheckPtInfo object if the cache size has ready the max cache size limit.
+func (c *checkPtInfoCache) put(cp *ethpb.Checkpoint, info *pb.CheckPtInfo) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	h, err := hashutil.HashProto(cp)
+	if err != nil {
+		return err
+	}
+
+	c.cache.Add(h, info)
+	return nil
+}

beacon-chain/blockchain/checkpoint_info_cache_test.go

@@ -0,0 +1,41 @@
+package blockchain
+
+import (
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestHotStateCache_RoundTrip(t *testing.T) {
+	c := newCheckPointInfoCache()
+	cp := &ethpb.Checkpoint{
+		Epoch: 1,
+		Root:  bytesutil.PadTo([]byte{'a'}, 32),
+	}
+	info, err := c.get(cp)
+	require.NoError(t, err)
+	require.Equal(t, (*pb.CheckPtInfo)(nil), info)
+
+	i := &pb.CheckPtInfo{
+		Seed:          bytesutil.PadTo([]byte{'c'}, 32),
+		GenesisRoot:   bytesutil.PadTo([]byte{'d'}, 32),
+		ActiveIndices: []uint64{0, 1, 2, 3},
+	}
+
+	require.NoError(t, c.put(cp, i))
+	info, err = c.get(cp)
+	require.NoError(t, err)
+	require.DeepEqual(t, info, i)
+}
+
+func TestHotStateCache_CanPrune(t *testing.T) {
+	c := newCheckPointInfoCache()
+	for i := 0; i < maxInfoSize+1; i++ {
+		cp := &ethpb.Checkpoint{Epoch: uint64(i), Root: make([]byte, 32)}
+		require.NoError(t, c.put(cp, &pb.CheckPtInfo{}))
+	}
+	require.Equal(t, len(c.cache.Keys()), maxInfoSize)
+}

beacon-chain/blockchain/head.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 
@@ -10,10 +11,8 @@ 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/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -24,13 +23,13 @@ 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.
 }
 
-// This gets head from the fork choice service and saves head related items
-// (ie root, block, state) to the local service cache.
+// Determined the head from the fork choice service and saves its new data
+// (head root, head block, and head state) to the local service cache.
 func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
-	ctx, span := trace.StartSpan(ctx, "blockchain.updateHead")
+	ctx, span := trace.StartSpan(ctx, "blockChain.updateHead")
 	defer span.End()
 
 	// To get the proper head update, a node first checks its best justified
@@ -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
 	}
 
@@ -68,25 +79,22 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 // This saves head info to the local service cache, it also saves the
 // new head root to the DB.
 func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockchain.saveHead")
+	ctx, span := trace.StartSpan(ctx, "blockChain.saveHead")
 	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
 	}
 
 	// If the head state is not available, just return nil.
 	// There's nothing to cache
-	if featureconfig.Get().NewStateMgmt {
-		if !s.stateGen.StateSummaryExists(ctx, headRoot) {
-			return nil
-		}
-	} else {
-		_, cached := s.initSyncState[headRoot]
-		if !cached && !s.beaconDB.HasState(ctx, headRoot) {
-			return nil
-		}
+	if !s.stateGen.StateSummaryExists(ctx, headRoot) {
+		return nil
 	}
 
 	// Get the new head block from DB.
@@ -99,37 +107,26 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 	}
 
 	// Get the new head state from cached state or DB.
-	var newHeadState *state.BeaconState
-	if featureconfig.Get().NewStateMgmt {
-		newHeadState, err = s.stateGen.StateByRoot(ctx, headRoot)
-		if err != nil {
-			return errors.Wrap(err, "could not retrieve head state in DB")
-		}
-	} else {
-		var exists bool
-		newHeadState, exists = s.initSyncState[headRoot]
-		if !exists {
-			newHeadState, err = s.beaconDB.State(ctx, headRoot)
-			if err != nil {
-				return errors.Wrap(err, "could not retrieve head state in DB")
-			}
-		}
+	newHeadState, err := s.stateGen.StateByRoot(ctx, headRoot)
+	if err != nil {
+		return errors.Wrap(err, "could not retrieve head state in DB")
 	}
 	if newHeadState == nil {
 		return errors.New("cannot save nil head state")
 	}
 
 	// 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,
 			},
 		})
 
@@ -148,45 +145,27 @@ 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 inital-sync-cache-state flag, it uses finalized
+// 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) 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")
+	}
+	if bytes.Equal(r[:], cachedHeadRoot) {
+		return nil
+	}
+
 	if b == nil || b.Block == nil {
 		return errors.New("cannot save nil head block")
 	}
 
-	var headState *state.BeaconState
-	var err error
-	if featureconfig.Get().NewStateMgmt {
-		headState, err = s.stateGen.StateByRootInitialSync(ctx, r)
-		if err != nil {
-			return errors.Wrap(err, "could not retrieve head state in DB")
-		}
-	} else {
-		headState, err = s.beaconDB.State(ctx, r)
-		if err != nil {
-			return errors.Wrap(err, "could not retrieve head state in DB")
-		}
-		if headState == nil {
-			s.initSyncStateLock.RLock()
-			cachedHeadState, ok := s.initSyncState[r]
-			if ok {
-				headState = cachedHeadState
-			}
-			s.initSyncStateLock.RUnlock()
-		}
-	}
-	if headState == nil {
-		return errors.New("nil head state")
-	}
-
-	s.setHeadInitialSync(r, stateTrie.CopySignedBeaconBlock(b), headState)
-
+	s.setHeadInitialSync(r, stateTrie.CopySignedBeaconBlock(b), hs)
 	return nil
 }
 
 // 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()
 
@@ -202,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()
 
@@ -216,83 +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.
-func (s *Service) headState() *state.BeaconState {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
+// 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()
 
 	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 {
-	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.
@@ -300,31 +253,38 @@ func (s *Service) cacheJustifiedStateBalances(ctx context.Context, justifiedRoot
 	if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
 		return err
 	}
+
 	s.clearInitSyncBlocks()
 
 	var justifiedState *stateTrie.BeaconState
 	var err error
-	if featureconfig.Get().NewStateMgmt {
-		justifiedState, err = s.stateGen.StateByRoot(ctx, justifiedRoot)
+	if justifiedRoot == s.genesisRoot {
+		justifiedState, err = s.beaconDB.GenesisState(ctx)
 		if err != nil {
 			return err
 		}
 	} else {
-		justifiedState, err = s.beaconDB.State(ctx, justifiedRoot)
+		justifiedState, err = s.stateGen.StateByRoot(ctx, justifiedRoot)
 		if err != nil {
 			return err
 		}
 	}
+	if justifiedState == nil {
+		return errors.New("justified state can't be nil")
+	}
 
 	epoch := helpers.CurrentEpoch(justifiedState)
-	validators := justifiedState.Validators()
-	justifiedBalances := make([]uint64, len(validators))
-	for i, validator := range validators {
-		if helpers.IsActiveValidator(validator, epoch) {
-			justifiedBalances[i] = validator.EffectiveBalance
+
+	justifiedBalances := make([]uint64, justifiedState.NumValidators())
+	if err := justifiedState.ReadFromEveryValidator(func(idx int, val *stateTrie.ReadOnlyValidator) error {
+		if helpers.IsActiveValidatorUsingTrie(val, epoch) {
+			justifiedBalances[idx] = val.EffectiveBalance()
 		} else {
-			justifiedBalances[i] = 0
+			justifiedBalances[idx] = 0
 		}
+		return nil
+	}); err != nil {
+		return err
 	}
 
 	s.justifiedBalancesLock.Lock()

beacon-chain/blockchain/head_test.go

@@ -3,216 +3,121 @@ package blockchain
 import (
 	"bytes"
 	"context"
-	"reflect"
 	"testing"
 
 	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"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 func TestSaveHead_Same(t *testing.T) {
-	db := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db)
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
 
 	r := [32]byte{'A'}
 	service.head = &head{slot: 0, root: r}
 
-	if err := service.saveHead(context.Background(), r); err != nil {
-		t.Fatal(err)
-	}
-
-	if service.headSlot() != 0 {
-		t.Error("Head did not stay the same")
-	}
-
-	if service.headRoot() != r {
-		t.Error("Head did not stay the same")
-	}
+	require.NoError(t, service.saveHead(context.Background(), r))
+	assert.Equal(t, uint64(0), service.headSlot(), "Head did not stay the same")
+	assert.Equal(t, r, service.headRoot(), "Head did not stay the same")
 }
 
 func TestSaveHead_Different(t *testing.T) {
-	db := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db)
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
 
 	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
 
-	if err := service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock); err != nil {
-		t.Fatal(err)
-	}
-	newRoot, err := stateutil.BlockRoot(newHeadBlock)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
+	newRoot, err := newHeadBlock.HashTreeRoot()
+	require.NoError(t, err)
 	headState := testutil.NewBeaconState()
-	if err := headState.SetSlot(1); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveState(context.Background(), headState, newRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.saveHead(context.Background(), newRoot); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, headState.SetSlot(1))
+	require.NoError(t, service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}))
+	require.NoError(t, service.beaconDB.SaveState(context.Background(), headState, newRoot))
+	require.NoError(t, service.saveHead(context.Background(), newRoot))
 
-	if service.HeadSlot() != 1 {
-		t.Error("Head did not change")
-	}
+	assert.Equal(t, uint64(1), service.HeadSlot(), "Head did not change")
 
 	cachedRoot, err := service.HeadRoot(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	if !bytes.Equal(cachedRoot, newRoot[:]) {
 		t.Error("Head did not change")
 	}
-	if !reflect.DeepEqual(service.headBlock(), newHeadSignedBlock) {
-		t.Error("Head did not change")
-	}
-	if !reflect.DeepEqual(service.headState().CloneInnerState(), headState.CloneInnerState()) {
-		t.Error("Head did not change")
-	}
+	assert.DeepEqual(t, newHeadSignedBlock, service.headBlock(), "Head did not change")
+	assert.DeepEqual(t, headState.CloneInnerState(), service.headState(ctx).CloneInnerState(), "Head did not change")
 }
 
 func TestSaveHead_Different_Reorg(t *testing.T) {
+	ctx := context.Background()
 	hook := logTest.NewGlobal()
-	db := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db)
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
 
 	oldRoot := [32]byte{'A'}
 	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
 
-	if err := service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock); err != nil {
-		t.Fatal(err)
-	}
-	newRoot, err := stateutil.BlockRoot(newHeadBlock)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
+	newRoot, err := newHeadBlock.HashTreeRoot()
+	require.NoError(t, err)
 	headState := testutil.NewBeaconState()
-	if err := headState.SetSlot(1); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveState(context.Background(), headState, newRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.saveHead(context.Background(), newRoot); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, headState.SetSlot(1))
+	require.NoError(t, service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}))
+	require.NoError(t, service.beaconDB.SaveState(context.Background(), headState, newRoot))
+	require.NoError(t, service.saveHead(context.Background(), newRoot))
 
-	if service.HeadSlot() != 1 {
-		t.Error("Head did not change")
-	}
+	assert.Equal(t, uint64(1), service.HeadSlot(), "Head did not change")
 
 	cachedRoot, err := service.HeadRoot(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	if !bytes.Equal(cachedRoot, newRoot[:]) {
 		t.Error("Head did not change")
 	}
-	if !reflect.DeepEqual(service.headBlock(), newHeadSignedBlock) {
-		t.Error("Head did not change")
-	}
-	if !reflect.DeepEqual(service.headState().CloneInnerState(), headState.CloneInnerState()) {
-		t.Error("Head did not change")
-	}
-	testutil.AssertLogsContain(t, hook, "Chain reorg occurred")
-}
-
-func TestUpdateRecentCanonicalBlocks_CanUpdateWithoutParent(t *testing.T) {
-	db := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db)
-
-	r := [32]byte{'a'}
-	if err := service.updateRecentCanonicalBlocks(context.Background(), r); err != nil {
-		t.Fatal(err)
-	}
-	canonical, err := service.IsCanonical(context.Background(), r)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !canonical {
-		t.Error("Block should be canonical")
-	}
-}
-
-func TestUpdateRecentCanonicalBlocks_CanUpdateWithParent(t *testing.T) {
-	db := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db)
-	oldHead := [32]byte{'a'}
-	if err := service.forkChoiceStore.ProcessBlock(context.Background(), 1, oldHead, [32]byte{'g'}, [32]byte{}, 0, 0); err != nil {
-		t.Fatal(err)
-	}
-	currentHead := [32]byte{'b'}
-	if err := service.forkChoiceStore.ProcessBlock(context.Background(), 3, currentHead, oldHead, [32]byte{}, 0, 0); err != nil {
-		t.Fatal(err)
-	}
-	forkedRoot := [32]byte{'c'}
-	if err := service.forkChoiceStore.ProcessBlock(context.Background(), 2, forkedRoot, oldHead, [32]byte{}, 0, 0); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := service.updateRecentCanonicalBlocks(context.Background(), currentHead); err != nil {
-		t.Fatal(err)
-	}
-	canonical, err := service.IsCanonical(context.Background(), currentHead)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !canonical {
-		t.Error("Block should be canonical")
-	}
-	canonical, err = service.IsCanonical(context.Background(), oldHead)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !canonical {
-		t.Error("Block should be canonical")
-	}
-	canonical, err = service.IsCanonical(context.Background(), forkedRoot)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if canonical {
-		t.Error("Block should not be canonical")
-	}
+	assert.DeepEqual(t, newHeadSignedBlock, service.headBlock(), "Head did not change")
+	assert.DeepEqual(t, headState.CloneInnerState(), service.headState(ctx).CloneInnerState(), "Head did not change")
+	require.LogsContain(t, hook, "Chain reorg occurred")
 }
 
 func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
-	db := testDB.SetupDB(t)
-	service := setupBeaconChain(t, db)
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
 
 	state, _ := testutil.DeterministicGenesisState(t, 100)
 	r := [32]byte{'a'}
-	if err := service.beaconDB.SaveState(context.Background(), state, r); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := service.cacheJustifiedStateBalances(context.Background(), r); err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(state.Balances(), service.getJustifiedBalances()) {
-		t.Fatal("Incorrect justified balances")
-	}
+	require.NoError(t, service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Root: r[:]}))
+	require.NoError(t, service.beaconDB.SaveState(context.Background(), state, r))
+	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

@@ -4,9 +4,9 @@ import (
 	"encoding/hex"
 	"fmt"
 	"net/http"
-	"strconv"
 
 	"github.com/emicklei/dot"
+	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 const template = `<html>
@@ -33,8 +33,13 @@ const template = `<html>
 </html>`
 
 // TreeHandler is a handler to serve /tree page in metrics.
-func (s *Service) TreeHandler(w http.ResponseWriter, _ *http.Request) {
-	if s.headState() == nil {
+func (s *Service) TreeHandler(w http.ResponseWriter, r *http.Request) {
+	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,24 +52,25 @@ func (s *Service) TreeHandler(w http.ResponseWriter, _ *http.Request) {
 	graph.Attr("labeljust", "l")
 
 	dotNodes := make([]*dot.Node, len(nodes))
-	avgBalance := uint64(averageBalance(s.headState().Balances()))
+	avgBalance := uint64(averageBalance(headState.Balances()))
 
 	for i := len(nodes) - 1; i >= 0; i-- {
 		// Construct label for each node.
-		slot := strconv.Itoa(int(nodes[i].Slot))
-		weight := strconv.Itoa(int(nodes[i].Weight / 1e9)) // Convert unit Gwei to unit ETH.
-		votes := strconv.Itoa(int(nodes[i].Weight / 1e9 / avgBalance))
-		index := strconv.Itoa(i)
-		g := nodes[i].Graffiti[:]
+		slot := fmt.Sprintf("%d", nodes[i].Slot())
+		weight := fmt.Sprintf("%d", nodes[i].Weight()/1e9) // Convert unit Gwei to unit ETH.
+		votes := fmt.Sprintf("%d", nodes[i].Weight()/1e9/avgBalance)
+		index := fmt.Sprintf("%d", i)
+		g := nodes[i].Graffiti()
 		graffiti := hex.EncodeToString(g[:8])
 		label := "slot: " + slot + "\n votes: " + votes + "\n weight: " + weight + "\n graffiti: " + graffiti
 		var dotN dot.Node
-		if nodes[i].Parent != ^uint64(0) {
+		if nodes[i].Parent() != ^uint64(0) {
 			dotN = graph.Node(index).Box().Attr("label", label)
 		}
 
-		if nodes[i].Slot == s.headSlot() &&
-			nodes[i].BestDescendent == ^uint64(0) {
+		if nodes[i].Slot() == s.HeadSlot() &&
+			nodes[i].BestDescendant() == ^uint64(0) &&
+			nodes[i].Parent() != ^uint64(0) {
 			dotN = dotN.Attr("color", "green")
 		}
 
@@ -72,8 +78,8 @@ func (s *Service) TreeHandler(w http.ResponseWriter, _ *http.Request) {
 	}
 
 	for i := len(nodes) - 1; i >= 0; i-- {
-		if nodes[i].Parent != ^uint64(0) && nodes[i].Parent < uint64(len(dotNodes)) {
-			graph.Edge(*dotNodes[i], *dotNodes[nodes[i].Parent])
+		if nodes[i].Parent() != ^uint64(0) && nodes[i].Parent() < uint64(len(dotNodes)) {
+			graph.Edge(*dotNodes[i], *dotNodes[nodes[i].Parent()])
 		}
 	}
 
@@ -83,3 +89,11 @@ func (s *Service) TreeHandler(w http.ResponseWriter, _ *http.Request) {
 		log.WithError(err).Error("Failed to render p2p info page")
 	}
 }
+
+func averageBalance(balances []uint64) float64 {
+	total := uint64(0)
+	for i := 0; i < len(balances); i++ {
+		total += balances[i]
+	}
+	return float64(total) / float64(len(balances)) / float64(params.BeaconConfig().GweiPerEth)
+}

beacon-chain/blockchain/info_test.go

@@ -0,0 +1,47 @@
+package blockchain
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"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"
+)
+
+func TestService_TreeHandler(t *testing.T) {
+	req, err := http.NewRequest("GET", "/tree", nil)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	db, sCache := testDB.SetupDB(t)
+	headState := testutil.NewBeaconState()
+	require.NoError(t, headState.SetBalances([]uint64{params.BeaconConfig().GweiPerEth}))
+	cfg := &Config{
+		BeaconDB: db,
+		ForkChoiceStore: protoarray.New(
+			0, // justifiedEpoch
+			0, // finalizedEpoch
+			[32]byte{'a'},
+		),
+		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)
+
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(s.TreeHandler)
+
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+}

beacon-chain/blockchain/init_sync_process_block.go

@@ -1,220 +1,9 @@
 package blockchain
 
 import (
-	"context"
-	"sort"
-
-	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
-const maxCacheSize = 70
-const initialSyncCacheSize = 45
-const minimumCacheSize = initialSyncCacheSize / 3
-
-func (s *Service) persistCachedStates(ctx context.Context, numOfStates int) error {
-	oldStates := make([]*stateTrie.BeaconState, 0, numOfStates)
-
-	// Add slots to the map and add epoch boundary states to the slice.
-	for _, rt := range s.boundaryRoots[:numOfStates-minimumCacheSize] {
-		oldStates = append(oldStates, s.initSyncState[rt])
-	}
-
-	err := s.beaconDB.SaveStates(ctx, oldStates, s.boundaryRoots[:numOfStates-minimumCacheSize])
-	if err != nil {
-		return err
-	}
-	for _, rt := range s.boundaryRoots[:numOfStates-minimumCacheSize] {
-		delete(s.initSyncState, rt)
-	}
-	s.boundaryRoots = s.boundaryRoots[numOfStates-minimumCacheSize:]
-	return nil
-}
-
-// filter out boundary candidates from our currently processed batch of states.
-func (s *Service) filterBoundaryCandidates(ctx context.Context, root [32]byte, postState *stateTrie.BeaconState) {
-	// Only trigger on epoch start.
-	if !helpers.IsEpochStart(postState.Slot()) {
-		return
-	}
-
-	stateSlice := make([][32]byte, 0, len(s.initSyncState))
-	// Add epoch boundary roots to slice.
-	for rt := range s.initSyncState {
-		stateSlice = append(stateSlice, rt)
-	}
-
-	sort.Slice(stateSlice, func(i int, j int) bool {
-		return s.initSyncState[stateSlice[i]].Slot() < s.initSyncState[stateSlice[j]].Slot()
-	})
-	epochLength := params.BeaconConfig().SlotsPerEpoch
-
-	if len(s.boundaryRoots) > 0 {
-		// Retrieve previous boundary root.
-		previousBoundaryRoot := s.boundaryRoots[len(s.boundaryRoots)-1]
-		previousState, ok := s.initSyncState[previousBoundaryRoot]
-		if !ok {
-			// Remove the non-existent root and exit filtering.
-			s.boundaryRoots = s.boundaryRoots[:len(s.boundaryRoots)-1]
-			return
-		}
-		previousSlot := previousState.Slot()
-
-		// Round up slot number to account for skipped slots.
-		previousSlot = helpers.RoundUpToNearestEpoch(previousSlot)
-		if postState.Slot()-previousSlot >= epochLength {
-			targetSlot := postState.Slot()
-			tempRoots := s.loopThroughCandidates(stateSlice, previousBoundaryRoot, previousSlot, targetSlot)
-			s.boundaryRoots = append(s.boundaryRoots, tempRoots...)
-		}
-	}
-	s.boundaryRoots = append(s.boundaryRoots, root)
-	s.pruneOldStates()
-	s.pruneNonBoundaryStates()
-}
-
-// loop-through the provided candidate roots to filter out which would be appropriate boundary roots.
-func (s *Service) loopThroughCandidates(stateSlice [][32]byte, previousBoundaryRoot [32]byte,
-	previousSlot uint64, targetSlot uint64) [][32]byte {
-	tempRoots := [][32]byte{}
-	epochLength := params.BeaconConfig().SlotsPerEpoch
-
-	// Loop through current states to filter for valid boundary states.
-	for i := len(stateSlice) - 1; stateSlice[i] != previousBoundaryRoot && i >= 0; i-- {
-		currentSlot := s.initSyncState[stateSlice[i]].Slot()
-		// Skip if the current slot is larger than the previous epoch
-		// boundary.
-		if currentSlot > targetSlot-epochLength {
-			continue
-		}
-		tempRoots = append(tempRoots, stateSlice[i])
-
-		// Switch target slot if the current slot is greater than
-		// 1 epoch boundary from the previously saved boundary slot.
-		if currentSlot > previousSlot+epochLength {
-			currentSlot = helpers.RoundUpToNearestEpoch(currentSlot)
-			targetSlot = currentSlot
-			continue
-		}
-		break
-	}
-	// Reverse to append the roots in ascending order corresponding
-	// to the respective slots.
-	tempRoots = bytesutil.ReverseBytes32Slice(tempRoots)
-	return tempRoots
-}
-
-// prune for states past the current finalized checkpoint.
-func (s *Service) pruneOldStates() {
-	prunedBoundaryRoots := [][32]byte{}
-	for _, rt := range s.boundaryRoots {
-		st, ok := s.initSyncState[rt]
-		// Skip non-existent roots.
-		if !ok {
-			continue
-		}
-		if st.Slot() < helpers.StartSlot(s.FinalizedCheckpt().Epoch) {
-			delete(s.initSyncState, rt)
-			continue
-		}
-		prunedBoundaryRoots = append(prunedBoundaryRoots, rt)
-	}
-	s.boundaryRoots = prunedBoundaryRoots
-}
-
-// prune cache for non-boundary states.
-func (s *Service) pruneNonBoundaryStates() {
-	boundaryMap := make(map[[32]byte]bool)
-	for i := range s.boundaryRoots {
-		boundaryMap[s.boundaryRoots[i]] = true
-	}
-	for rt := range s.initSyncState {
-		if !boundaryMap[rt] {
-			delete(s.initSyncState, rt)
-		}
-	}
-}
-
-func (s *Service) pruneOldNonFinalizedStates() {
-	stateSlice := make([][32]byte, 0, len(s.initSyncState))
-	// Add epoch boundary roots to slice.
-	for rt := range s.initSyncState {
-		stateSlice = append(stateSlice, rt)
-	}
-
-	// Sort by slots.
-	sort.Slice(stateSlice, func(i int, j int) bool {
-		return s.initSyncState[stateSlice[i]].Slot() < s.initSyncState[stateSlice[j]].Slot()
-	})
-
-	boundaryMap := make(map[[32]byte]bool)
-	for i := range s.boundaryRoots {
-		boundaryMap[s.boundaryRoots[i]] = true
-	}
-	for _, rt := range stateSlice[:initialSyncCacheSize] {
-		if boundaryMap[rt] {
-			continue
-		}
-		delete(s.initSyncState, rt)
-	}
-}
-
-func (s *Service) generateState(ctx context.Context, startRoot [32]byte, endRoot [32]byte) (*stateTrie.BeaconState, error) {
-	preState, err := s.beaconDB.State(ctx, startRoot)
-	if err != nil {
-		return nil, err
-	}
-	if preState == nil {
-		if !s.stateGen.HasState(ctx, startRoot) {
-			if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-				return nil, errors.Wrap(err, "could not save initial sync blocks")
-			}
-			s.clearInitSyncBlocks()
-		}
-		preState, err = s.stateGen.StateByRoot(ctx, startRoot)
-		if err != nil {
-			return nil, err
-		}
-		if preState == nil {
-			return nil, errors.New("finalized state does not exist in db")
-		}
-	}
-
-	if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-		return nil, err
-	}
-	var endBlock *ethpb.SignedBeaconBlock
-	if !featureconfig.Get().NoInitSyncBatchSaveBlocks && s.hasInitSyncBlock(endRoot) {
-		endBlock = s.getInitSyncBlock(endRoot)
-		s.clearInitSyncBlocks()
-	} else {
-		endBlock, err = s.beaconDB.Block(ctx, endRoot)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if endBlock == nil {
-		return nil, errors.New("provided block root does not have block saved in the db")
-	}
-	log.Warnf("Generating missing state of slot %d and root %#x", endBlock.Block.Slot, endRoot)
-
-	blocks, err := s.stateGen.LoadBlocks(ctx, preState.Slot()+1, endBlock.Block.Slot, endRoot)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not load the required blocks")
-	}
-	postState, err := s.stateGen.ReplayBlocks(ctx, preState, blocks, endBlock.Block.Slot)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not replay the blocks to generate the resultant state")
-	}
-	return postState, nil
-}
-
 // This saves a beacon block to the initial sync blocks cache.
 func (s *Service) saveInitSyncBlock(r [32]byte, b *ethpb.SignedBeaconBlock) {
 	s.initSyncBlocksLock.Lock()

beacon-chain/blockchain/init_sync_process_block_test.go

@@ -1,313 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-
-	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/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	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/testutil"
-	"gopkg.in/d4l3k/messagediff.v1"
-)
-
-func TestFilterBoundaryCandidates_FilterCorrect(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-
-	cfg := &Config{BeaconDB: db}
-	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	st, err := stateTrie.InitializeFromProtoUnsafe(&pb.BeaconState{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i := uint64(0); i < 500; i++ {
-		if err := st.SetSlot(i); err != nil {
-			t.Fatal(err)
-		}
-		root := [32]byte{}
-		copy(root[:], bytesutil.Bytes32(i))
-		service.initSyncState[root] = st.Copy()
-		if helpers.IsEpochStart(i) {
-			service.boundaryRoots = append(service.boundaryRoots, root)
-		}
-	}
-	lastIndex := len(service.boundaryRoots) - 1
-	for i := uint64(500); i < 2000; i++ {
-		if err := st.SetSlot(i); err != nil {
-			t.Fatal(err)
-		}
-		root := [32]byte{}
-		copy(root[:], bytesutil.Bytes32(i))
-		service.initSyncState[root] = st.Copy()
-	}
-	// Set current state.
-	latestSlot := helpers.RoundUpToNearestEpoch(2000)
-	if err := st.SetSlot(latestSlot); err != nil {
-		t.Fatal(err)
-	}
-	lastRoot := [32]byte{}
-	copy(lastRoot[:], bytesutil.Bytes32(latestSlot))
-
-	service.initSyncState[lastRoot] = st.Copy()
-	service.finalizedCheckpt = &ethpb.Checkpoint{
-		Epoch: 0,
-		Root:  []byte{},
-	}
-	service.filterBoundaryCandidates(context.Background(), lastRoot, st)
-	if len(service.boundaryRoots[lastIndex+1:]) == 0 {
-		t.Fatal("Wanted non zero added boundary roots")
-	}
-	for _, rt := range service.boundaryRoots[lastIndex+1:] {
-		st, ok := service.initSyncState[rt]
-		if !ok {
-			t.Error("Root doen't exist in cache map")
-			continue
-		}
-		if !(helpers.IsEpochStart(st.Slot()) || helpers.IsEpochStart(st.Slot()-1) || helpers.IsEpochStart(st.Slot()+1)) {
-			t.Errorf("boundary roots not validly stored. They have slot %d", st.Slot())
-		}
-	}
-}
-
-func TestFilterBoundaryCandidates_HandleSkippedSlots(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-
-	cfg := &Config{BeaconDB: db}
-	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	st, err := stateTrie.InitializeFromProtoUnsafe(&pb.BeaconState{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i := uint64(0); i < 500; i++ {
-		if err := st.SetSlot(i); err != nil {
-			t.Fatal(err)
-		}
-		root := [32]byte{}
-		copy(root[:], bytesutil.Bytes32(i))
-		service.initSyncState[root] = st.Copy()
-		if helpers.IsEpochStart(i) {
-			service.boundaryRoots = append(service.boundaryRoots, root)
-		}
-	}
-	lastIndex := len(service.boundaryRoots) - 1
-	for i := uint64(500); i < 2000; i++ {
-		if err := st.SetSlot(i); err != nil {
-			t.Fatal(err)
-		}
-		root := [32]byte{}
-		copy(root[:], bytesutil.Bytes32(i))
-		// save only for offsetted slots
-		if helpers.IsEpochStart(i + 10) {
-			service.initSyncState[root] = st.Copy()
-		}
-	}
-	// Set current state.
-	latestSlot := helpers.RoundUpToNearestEpoch(2000)
-	if err := st.SetSlot(latestSlot); err != nil {
-		t.Fatal(err)
-	}
-	lastRoot := [32]byte{}
-	copy(lastRoot[:], bytesutil.Bytes32(latestSlot))
-
-	service.initSyncState[lastRoot] = st.Copy()
-	service.finalizedCheckpt = &ethpb.Checkpoint{
-		Epoch: 0,
-		Root:  []byte{},
-	}
-	service.filterBoundaryCandidates(context.Background(), lastRoot, st)
-	if len(service.boundaryRoots[lastIndex+1:]) == 0 {
-		t.Fatal("Wanted non zero added boundary roots")
-	}
-	for _, rt := range service.boundaryRoots[lastIndex+1:] {
-		st, ok := service.initSyncState[rt]
-		if !ok {
-			t.Error("Root doen't exist in cache map")
-			continue
-		}
-		if st.Slot() >= 500 {
-			// Ignore head boundary root.
-			if st.Slot() == 2016 {
-				continue
-			}
-			if !helpers.IsEpochStart(st.Slot() + 10) {
-				t.Errorf("boundary roots not validly stored. They have slot %d "+
-					"instead of the offset from epoch start", st.Slot())
-			}
-		}
-	}
-}
-
-func TestPruneOldStates_AlreadyFinalized(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-
-	cfg := &Config{BeaconDB: db}
-	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	st, err := stateTrie.InitializeFromProtoUnsafe(&pb.BeaconState{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i := uint64(100); i < 200; i++ {
-		if err := st.SetSlot(i); err != nil {
-			t.Fatal(err)
-		}
-		root := [32]byte{}
-		copy(root[:], bytesutil.Bytes32(i))
-		service.initSyncState[root] = st.Copy()
-		service.boundaryRoots = append(service.boundaryRoots, root)
-	}
-	finalizedEpoch := uint64(5)
-	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: finalizedEpoch}
-	service.pruneOldStates()
-	for _, rt := range service.boundaryRoots {
-		st, ok := service.initSyncState[rt]
-		if !ok {
-			t.Error("Root doen't exist in cache map")
-			continue
-		}
-		if st.Slot() < helpers.StartSlot(finalizedEpoch) {
-			t.Errorf("State with slot %d still exists and not pruned", st.Slot())
-		}
-	}
-}
-
-func TestPruneNonBoundary_CanPrune(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-
-	cfg := &Config{BeaconDB: db}
-	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	st, err := stateTrie.InitializeFromProtoUnsafe(&pb.BeaconState{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i := uint64(0); i < 2000; i++ {
-		if err := st.SetSlot(i); err != nil {
-			t.Fatal(err)
-		}
-		root := [32]byte{}
-		copy(root[:], bytesutil.Bytes32(i))
-		service.initSyncState[root] = st.Copy()
-		if helpers.IsEpochStart(i) {
-			service.boundaryRoots = append(service.boundaryRoots, root)
-		}
-	}
-	service.pruneNonBoundaryStates()
-	for _, rt := range service.boundaryRoots {
-		st, ok := service.initSyncState[rt]
-		if !ok {
-			t.Error("Root doesn't exist in cache map")
-			continue
-		}
-		if !helpers.IsEpochStart(st.Slot()) {
-			t.Errorf("Non boundary state with slot %d still exists and not pruned", st.Slot())
-		}
-	}
-}
-
-func TestGenerateState_CorrectlyGenerated(t *testing.T) {
-	db := testDB.SetupDB(t)
-	cfg := &Config{BeaconDB: db, StateGen: stategen.New(db, cache.NewStateSummaryCache())}
-	service, err := NewService(context.Background(), cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	beaconState, privs := testutil.DeterministicGenesisState(t, 32)
-	genesisBlock := testutil.NewBeaconBlock()
-	bodyRoot, err := stateutil.BlockRoot(genesisBlock.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:       genesisBlock.Block.Slot,
-		ParentRoot: genesisBlock.Block.ParentRoot,
-		StateRoot:  params.BeaconConfig().ZeroHash[:],
-		BodyRoot:   bodyRoot[:],
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := beaconState.SetSlashings(make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector)); err != nil {
-		t.Fatal(err)
-	}
-	cp := beaconState.CurrentJustifiedCheckpoint()
-	mockRoot := [32]byte{}
-	copy(mockRoot[:], "hello-world")
-	cp.Root = mockRoot[:]
-	if err := beaconState.SetCurrentJustifiedCheckpoint(cp); err != nil {
-		t.Fatal(err)
-	}
-	if err := beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}); err != nil {
-		t.Fatal(err)
-	}
-	err = db.SaveBlock(context.Background(), genesisBlock)
-	if err != nil {
-		t.Fatal(err)
-	}
-	genRoot, err := stateutil.BlockRoot(genesisBlock.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = db.SaveState(context.Background(), beaconState, genRoot)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	lastBlock := &ethpb.SignedBeaconBlock{}
-	for i := uint64(1); i < 10; i++ {
-		block, err := testutil.GenerateFullBlock(beaconState, privs, testutil.DefaultBlockGenConfig(), i)
-		if err != nil {
-			t.Fatal(err)
-		}
-		beaconState, err = state.ExecuteStateTransition(context.Background(), beaconState, block)
-		if err != nil {
-			t.Fatal(err)
-		}
-		err = db.SaveBlock(context.Background(), block)
-		if err != nil {
-			t.Fatal(err)
-		}
-		lastBlock = block
-	}
-	root, err := stateutil.BlockRoot(lastBlock.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	newState, err := service.generateState(context.Background(), genRoot, root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !ssz.DeepEqual(newState.InnerStateUnsafe(), beaconState.InnerStateUnsafe()) {
-		diff, _ := messagediff.PrettyDiff(newState.InnerStateUnsafe(), beaconState.InnerStateUnsafe())
-		t.Errorf("Generated state is different from what is expected: %s", diff)
-	}
-}

beacon-chain/blockchain/log.go

@@ -6,7 +6,6 @@ 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/shared/params"
 	"github.com/sirupsen/logrus"
 )
@@ -27,36 +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")
 }
-
-func logEpochData(beaconState *stateTrie.BeaconState) {
-	log.WithFields(logrus.Fields{
-		"epoch":                  helpers.CurrentEpoch(beaconState),
-		"finalizedEpoch":         beaconState.FinalizedCheckpointEpoch(),
-		"justifiedEpoch":         beaconState.CurrentJustifiedCheckpoint().Epoch,
-		"previousJustifiedEpoch": beaconState.PreviousJustifiedCheckpoint().Epoch,
-	}).Info("Starting next epoch")
-	activeVals, err := helpers.ActiveValidatorIndices(beaconState, helpers.CurrentEpoch(beaconState))
-	if err != nil {
-		log.WithError(err).Error("Could not get active validator indices")
-		return
-	}
-	log.WithFields(logrus.Fields{
-		"totalValidators":  len(beaconState.Validators()),
-		"activeValidators": len(activeVals),
-		"averageBalance":   fmt.Sprintf("%.5f ETH", averageBalance(beaconState.Balances())),
-	}).Info("Validator registry information")
-}
-
-func averageBalance(balances []uint64) float64 {
-	total := uint64(0)
-	for i := 0; i < len(balances); i++ {
-		total += balances[i]
-	}
-	return float64(total) / float64(len(balances)) / float64(params.BeaconConfig().GweiPerEth)
-}

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",
+	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",
+	})
+	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",
 	})
-	totalVotedTargetBalances = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "total_voted_target_balances",
-		Help: "The total amount of ether, in gwei, that is eligible for voting 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,9 +138,10 @@ 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
 		}
 		if validator.Slashed {
@@ -184,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

@@ -7,11 +7,13 @@ import (
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/flags"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bls"
 	"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/timeutils"
 	"go.opencensus.io/trace"
 )
 
@@ -20,55 +22,30 @@ import (
 var ErrTargetRootNotInDB = errors.New("target root does not exist in db")
 
 // onAttestation is called whenever an attestation is received, verifies the attestation is valid and saves
-/// it to the DB.
+// it to the DB. As a stateless function, this does not hold nor delay attestation based on the spec descriptions.
+// The delay is handled by the caller in `processAttestation`.
 //
 // Spec pseudocode definition:
-//   def on_attestation(store: Service, attestation: Attestation) -> None:
+//   def on_attestation(store: Store, attestation: Attestation) -> None:
 //    """
 //    Run ``on_attestation`` upon receiving a new ``attestation`` from either within a block or directly on the wire.
 //
 //    An ``attestation`` that is asserted as invalid may be valid at a later time,
 //    consider scheduling it for later processing in such case.
 //    """
-//    target = attestation.data.target
+//    validate_on_attestation(store, attestation)
+//    store_target_checkpoint_state(store, attestation.data.target)
 //
-//    # Attestations must be from the current or previous epoch
-//    current_epoch = compute_epoch_at_slot(get_current_slot(store))
-//    # Use GENESIS_EPOCH for previous when genesis to avoid underflow
-//    previous_epoch = current_epoch - 1 if current_epoch > GENESIS_EPOCH else GENESIS_EPOCH
-//    # If attestation target is from a future epoch, delay consideration until the epoch arrives
-//    assert target.epoch in [current_epoch, previous_epoch]
-//    assert target.epoch == compute_epoch_at_slot(attestation.data.slot)
-//
-//    # Attestations target be for a known block. If target block is unknown, delay consideration until the block is found
-//    assert target.root in store.blocks
-//
-//    # Attestations must be for a known block. If block is unknown, delay consideration until the block is found
-//    assert attestation.data.beacon_block_root in store.blocks
-//    # Attestations must not be for blocks in the future. If not, the attestation should not be considered
-//    assert store.blocks[attestation.data.beacon_block_root].slot <= attestation.data.slot
-//
-//    # Service target checkpoint state if not yet seen
-//    if target not in store.checkpoint_states:
-//        process_slots(base_state, compute_start_slot_at_epoch(target.epoch))
-//        store.checkpoint_states[target] = base_state
-//    target_state = store.checkpoint_states[target]
-//
-//    # Attestations can only affect the fork choice of subsequent slots.
-//    # Delay consideration in the fork choice until their slot is in the past.
-//    assert store.time >= (attestation.data.slot + 1) * SECONDS_PER_SLOT
-//
-//    # Get state at the `target` to validate attestation and calculate the committees
+//    # Get state at the `target` to fully validate attestation
+//    target_state = store.checkpoint_states[attestation.data.target]
 //    indexed_attestation = get_indexed_attestation(target_state, attestation)
 //    assert is_valid_indexed_attestation(target_state, indexed_attestation)
 //
-//    # Update latest messages
-//    for i in indexed_attestation.attesting_indices:
-//        if i not in store.latest_messages or target.epoch > store.latest_messages[i].epoch:
-//            store.latest_messages[i] = LatestMessage(epoch=target.epoch, root=attestation.data.beacon_block_root)
+//    # Update latest messages for attesting indices
+//    update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
 // TODO(#6072): This code path is highly untested. Requires comprehensive tests and simpler refactoring.
 func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) ([]uint64, error) {
-	ctx, span := trace.StartSpan(ctx, "blockchain.onAttestation")
+	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 
 	if a == nil {
@@ -92,6 +69,53 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) ([]ui
 		return nil, ErrTargetRootNotInDB
 	}
 
+	if featureconfig.Get().UseCheckPointInfoCache {
+		c, err := s.AttestationCheckPtInfo(ctx, a)
+		if err != nil {
+			return nil, err
+		}
+		if err := s.verifyAttTargetEpoch(ctx, uint64(s.genesisTime.Unix()), uint64(timeutils.Now().Unix()), tgt); err != nil {
+			return nil, err
+		}
+		if err := s.verifyBeaconBlock(ctx, a.Data); err != nil {
+			return nil, errors.Wrap(err, "could not verify attestation beacon block")
+		}
+		if err := s.verifyLMDFFGConsistent(ctx, a.Data.Target.Epoch, a.Data.Target.Root, a.Data.BeaconBlockRoot); err != nil {
+			return nil, errors.Wrap(err, "could not verify attestation beacon block")
+		}
+		if err := helpers.VerifySlotTime(uint64(s.genesisTime.Unix()), a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+			return nil, err
+		}
+		committee, err := helpers.BeaconCommittee(c.ActiveIndices, bytesutil.ToBytes32(c.Seed), a.Data.Slot, a.Data.CommitteeIndex)
+		if err != nil {
+			return nil, err
+		}
+		indexedAtt := attestationutil.ConvertToIndexed(ctx, a, committee)
+		if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
+			return nil, err
+		}
+		domain, err := helpers.Domain(c.Fork, indexedAtt.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, c.GenesisRoot)
+		if err != nil {
+			return nil, 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 nil, err
+			}
+			pubkeys = append(pubkeys, pk)
+		}
+		if err := attestationutil.VerifyIndexedAttestationSig(ctx, indexedAtt, pubkeys, domain); err != nil {
+			return nil, err
+		}
+		s.forkChoiceStore.ProcessAttestation(ctx, indexedAtt.AttestingIndices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
+
+		return indexedAtt.AttestingIndices, nil
+	}
+
 	// Retrieve attestation's data beacon block pre state. Advance pre state to latest epoch if necessary and
 	// save it to the cache.
 	baseState, err := s.getAttPreState(ctx, tgt)
@@ -102,7 +126,7 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) ([]ui
 	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
 	}
 
@@ -121,19 +145,12 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) ([]ui
 		return nil, err
 	}
 
-	// Use the target state to to validate attestation and calculate the committees.
+	// Use the target state to validate attestation and calculate the committees.
 	indexedAtt, err := s.verifyAttestation(ctx, baseState, a)
 	if err != nil {
 		return nil, err
 	}
 
-	// Only save attestation in DB for archival node.
-	if flags.Get().EnableArchive {
-		if err := s.beaconDB.SaveAttestation(ctx, a); err != nil {
-			return nil, err
-		}
-	}
-
 	if indexedAtt.AttestingIndices == nil {
 		return nil, errors.New("nil attesting indices")
 	}

beacon-chain/blockchain/process_attestation_helpers.go

@@ -3,19 +3,17 @@ package blockchain
 import (
 	"bytes"
 	"context"
-	"encoding/hex"
 	"fmt"
 
 	"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"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
@@ -23,6 +21,7 @@ import (
 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)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get cached checkpoint state")
@@ -31,92 +30,103 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*sta
 		return cachedState, nil
 	}
 
-	if featureconfig.Get().NewStateMgmt {
-		if !s.stateGen.HasState(ctx, bytesutil.ToBytes32(c.Root)) {
-			if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-				return nil, errors.Wrap(err, "could not save initial sync blocks")
-			}
-			s.clearInitSyncBlocks()
-		}
+	baseState, err := s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(c.Root))
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get pre state for epoch %d", c.Epoch)
+	}
 
-		baseState, err := s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(c.Root))
+	epochStartSlot, err := helpers.StartSlot(c.Epoch)
+	if err != nil {
+		return nil, err
+	}
+	if epochStartSlot > baseState.Slot() {
+		baseState = baseState.Copy()
+		baseState, err = state.ProcessSlots(ctx, baseState, epochStartSlot)
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not get pre state for slot %d", helpers.StartSlot(c.Epoch))
+			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
 		}
-
-		if helpers.StartSlot(c.Epoch) > baseState.Slot() {
-			baseState = baseState.Copy()
-			baseState, err = state.ProcessSlots(ctx, baseState, helpers.StartSlot(c.Epoch))
-			if err != nil {
-				return nil, errors.Wrapf(err, "could not process slots up to %d", helpers.StartSlot(c.Epoch))
-			}
-		}
-
-		if err := s.checkpointState.AddCheckpointState(&cache.CheckpointState{
-			Checkpoint: c,
-			State:      baseState,
-		}); err != nil {
+		if err := s.checkpointState.AddCheckpointState(c, baseState); err != nil {
 			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
 		}
-
 		return baseState, nil
 	}
 
-	if featureconfig.Get().CheckHeadState {
-		headRoot, err := s.HeadRoot(ctx)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not get head root")
-		}
-		if bytes.Equal(headRoot, c.Root) {
-			st, err := s.HeadState(ctx)
-			if err != nil {
-				return nil, errors.Wrapf(err, "could not get head state")
-			}
-			if err := s.checkpointState.AddCheckpointState(&cache.CheckpointState{
-				Checkpoint: c,
-				State:      st.Copy(),
-			}); err != nil {
-				return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
-			}
-			return st, nil
-		}
-	}
-
-	baseState, err := s.beaconDB.State(ctx, bytesutil.ToBytes32(c.Root))
+	has, err := s.stateGen.HasState(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, err
 	}
-	if baseState == nil {
-		return nil, fmt.Errorf("pre state of target block %d does not exist", helpers.StartSlot(c.Epoch))
-	}
-
-	if helpers.StartSlot(c.Epoch) > baseState.Slot() {
-		savedState := baseState.Copy()
-		savedState, err = state.ProcessSlots(ctx, savedState, helpers.StartSlot(c.Epoch))
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not process slots up to %d", helpers.StartSlot(c.Epoch))
-		}
-		if err := s.checkpointState.AddCheckpointState(&cache.CheckpointState{
-			Checkpoint: c,
-			State:      savedState.Copy(),
-		}); err != nil {
+	if !has {
+		if err := s.checkpointState.AddCheckpointState(c, baseState); err != nil {
 			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
 		}
-		return savedState, nil
 	}
-
-	if err := s.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: c,
-		State:      baseState.Copy(),
-	}); err != nil {
-		return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
-	}
-
 	return baseState, nil
+
+}
+
+// getAttCheckPtInfo retrieves the check point info given a check point. Check point info enables the node
+// to efficiently verify attestation signature without using beacon state. This function utilizes
+// the checkpoint info cache and will update the check point info cache on miss.
+func (s *Service) getAttCheckPtInfo(ctx context.Context, c *ethpb.Checkpoint, e uint64) (*pb.CheckPtInfo, error) {
+	// Return checkpoint info if exists in cache.
+	info, err := s.checkPtInfoCache.get(c)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get cached checkpoint state")
+	}
+	if info != nil {
+		return info, nil
+	}
+
+	// Retrieve checkpoint state to compute checkpoint info.
+	baseState, err := s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(c.Root))
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get pre state for epoch %d", c.Epoch)
+	}
+	epochStartSlot, err := helpers.StartSlot(c.Epoch)
+	if err != nil {
+		return nil, err
+	}
+	if epochStartSlot > baseState.Slot() {
+		baseState = baseState.Copy()
+		baseState, err = state.ProcessSlots(ctx, baseState, epochStartSlot)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+		}
+	}
+	f := baseState.Fork()
+	g := bytesutil.ToBytes32(baseState.GenesisValidatorRoot())
+	seed, err := helpers.Seed(baseState, e, params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return nil, err
+	}
+	indices, err := helpers.ActiveValidatorIndices(baseState, e)
+	if err != nil {
+		return nil, err
+	}
+	validators := baseState.ValidatorsReadOnly()
+	pks := make([][]byte, len(validators))
+	for i := 0; i < len(pks); i++ {
+		pk := validators[i].PublicKey()
+		pks[i] = pk[:]
+	}
+
+	// Cache and return the checkpoint info.
+	info = &pb.CheckPtInfo{
+		Fork:          f,
+		GenesisRoot:   g[:],
+		Seed:          seed[:],
+		ActiveIndices: indices,
+		PubKeys:       pks,
+	}
+	if err := s.checkPtInfoCache.put(c, info); err != nil {
+		return nil, err
+	}
+
+	return info, 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
@@ -132,10 +142,16 @@ func (s *Service) verifyAttTargetEpoch(ctx context.Context, genesisTime uint64,
 
 // verifyBeaconBlock verifies beacon head block is known and not from the future.
 func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.AttestationData) error {
-	b, err := s.beaconDB.Block(ctx, bytesutil.ToBytes32(data.BeaconBlockRoot))
+	r := bytesutil.ToBytes32(data.BeaconBlockRoot)
+	b, err := s.beaconDB.Block(ctx, r)
 	if err != nil {
 		return err
 	}
+	// If the block does not exist in db, check again if block exists in initial sync block cache.
+	// This could happen as the node first syncs to head.
+	if b == nil && s.hasInitSyncBlock(r) {
+		b = s.getInitSyncBlock(r)
+	}
 	if b == nil || b.Block == nil {
 		return fmt.Errorf("beacon block %#x does not exist", bytesutil.Trunc(data.BeaconBlockRoot))
 	}
@@ -146,8 +162,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
@@ -167,48 +186,7 @@ func (s *Service) verifyAttestation(ctx context.Context, baseState *stateTrie.Be
 	}
 	indexedAtt := attestationutil.ConvertToIndexed(ctx, a, committee)
 	if err := blocks.VerifyIndexedAttestation(ctx, baseState, indexedAtt); err != nil {
-		if err == helpers.ErrSigFailedToVerify {
-			// When sig fails to verify, check if there's a differences in committees due to
-			// different seeds.
-			var aState *stateTrie.BeaconState
-			var err error
-			if featureconfig.Get().NewStateMgmt {
-				if !s.stateGen.HasState(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot)) {
-					if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-						return nil, errors.Wrap(err, "could not save initial sync blocks")
-					}
-					s.clearInitSyncBlocks()
-				}
-				aState, err = s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
-				if err != nil {
-					return nil, err
-				}
-			} else {
-				aState, err = s.beaconDB.State(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
-				if err != nil {
-					return nil, err
-				}
-			}
-			if aState == nil {
-				return nil, fmt.Errorf("nil state for block root %#x", a.Data.BeaconBlockRoot)
-			}
-			epoch := helpers.SlotToEpoch(a.Data.Slot)
-			origSeed, err := helpers.Seed(baseState, epoch, params.BeaconConfig().DomainBeaconAttester)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get original seed")
-			}
-
-			aSeed, err := helpers.Seed(aState, epoch, params.BeaconConfig().DomainBeaconAttester)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get attester's seed")
-			}
-			if origSeed != aSeed {
-				return nil, fmt.Errorf("could not verify indexed attestation due to differences in seeds: %v != %v",
-					hex.EncodeToString(bytesutil.Trunc(origSeed[:])), hex.EncodeToString(bytesutil.Trunc(aSeed[:])))
-			}
-		}
 		return nil, errors.Wrap(err, "could not verify indexed attestation")
 	}
-
 	return indexedAtt, nil
 }

beacon-chain/blockchain/process_attestation_test.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"context"
-	"strings"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -12,149 +11,232 @@ 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/featureconfig"
 	"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"
 )
 
 func TestStore_OnAttestation(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
 	cfg := &Config{
 		BeaconDB:        db,
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
-		StateGen:        stategen.New(db, cache.NewStateSummaryCache()),
+		StateGen:        stategen.New(db, sc),
 	}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	_, err = blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	BlkWithOutState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 0}}
-	if err := db.SaveBlock(ctx, BlkWithOutState); err != nil {
-		t.Fatal(err)
-	}
-	BlkWithOutStateRoot, err := stateutil.BlockRoot(BlkWithOutState.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
+	BlkWithOutState := testutil.NewBeaconBlock()
+	BlkWithOutState.Block.Slot = 0
+	require.NoError(t, db.SaveBlock(ctx, BlkWithOutState))
+	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
+	require.NoError(t, err)
 
-	BlkWithStateBadAtt := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
-	if err := db.SaveBlock(ctx, BlkWithStateBadAtt); err != nil {
-		t.Fatal(err)
-	}
-	BlkWithStateBadAttRoot, err := stateutil.BlockRoot(BlkWithStateBadAtt.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
+	BlkWithStateBadAtt := testutil.NewBeaconBlock()
+	BlkWithStateBadAtt.Block.Slot = 1
+	require.NoError(t, db.SaveBlock(ctx, BlkWithStateBadAtt))
+	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
+	require.NoError(t, err)
 
 	s := testutil.NewBeaconState()
-	if err := s.SetSlot(100 * params.BeaconConfig().SlotsPerEpoch); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot); err != nil {
-		t.Fatal(err)
-	}
+	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}}
-	if err := db.SaveBlock(ctx, BlkWithValidState); err != nil {
-		t.Fatal(err)
-	}
+	BlkWithValidState := testutil.NewBeaconBlock()
+	BlkWithValidState.Block.Slot = 2
+	require.NoError(t, db.SaveBlock(ctx, BlkWithValidState))
 
-	BlkWithValidStateRoot, err := stateutil.BlockRoot(BlkWithValidState.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
+	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)
-	}
-	if err := service.beaconDB.SaveState(ctx, s, BlkWithValidStateRoot); 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: "pre state of target block 0 does not exist",
+			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: "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)
+			}
+		})
+	}
+}
+
+func TestStore_OnAttestationUsingCheckptCache(t *testing.T) {
+	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{UseCheckPointInfoCache: true})
+	defer resetCfg()
+
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB:        db,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(db, sc),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	_, err = blockTree1(db, []byte{'g'})
+	require.NoError(t, err)
+
+	BlkWithOutState := testutil.NewBeaconBlock()
+	BlkWithOutState.Block.Slot = 0
+	require.NoError(t, db.SaveBlock(ctx, BlkWithOutState))
+	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	BlkWithStateBadAtt := testutil.NewBeaconBlock()
+	BlkWithStateBadAtt.Block.Slot = 1
+	require.NoError(t, db.SaveBlock(ctx, BlkWithStateBadAtt))
+	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 := testutil.NewBeaconBlock()
+	BlkWithValidState.Block.Slot = 2
+	require.NoError(t, db.SaveBlock(ctx, BlkWithValidState))
+
+	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
+	require.NoError(t, err)
+	s = testutil.NewBeaconState()
+	err = s.SetFork(&pb.Fork{
+		Epoch:           0,
+		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+	})
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveState(ctx, s, BlkWithValidStateRoot))
+
+	tests := []struct {
+		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{Root: make([]byte, 32)}}},
+			wantedErr: "data slot is not in the same epoch as target 1 != 0",
+		},
+		{
+			name:      "attestation's target root not in db",
+			a:         &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)}}},
+			wantedErr: "target root does not exist in db",
+		},
+		{
+			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[:]}}},
+			wantedErr: "target epoch 100 does not match current epoch",
+		},
+		{
+			name:      "process nil attestation",
+			a:         nil,
+			wantedErr: "nil attestation",
+		},
+		{
+			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{
+					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.wantedErr != "" {
+				assert.ErrorContains(t, tt.wantedErr, err)
+			} else {
+				assert.NoError(t, err)
 			}
 		})
 	}
@@ -162,40 +244,28 @@ func TestStore_OnAttestation(t *testing.T) {
 
 func TestStore_SaveCheckpointState(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
 	cfg := &Config{
 		BeaconDB: db,
-		StateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		StateGen: stategen.New(db, sc),
 	}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	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},
-	})
-	if err != nil {
-		t.Fatal(err)
+	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'}
-	if err := service.beaconDB.SaveState(ctx, s, r); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, service.beaconDB.SaveState(ctx, s, r))
 
 	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
 	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
@@ -204,141 +274,81 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 
 	r = bytesutil.ToBytes32([]byte{'A'})
 	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
-	if err := service.beaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'A'})); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'A'}, 32)}); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, service.beaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'A'})))
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'A'}, 32)}))
+
 	s1, err := service.getAttPreState(ctx, cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if s1.Slot() != 1*params.BeaconConfig().SlotsPerEpoch {
-		t.Errorf("Wanted state slot: %d, got: %d", 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot())
-	}
+	require.NoError(t, err)
+	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
 
 	cp2 := &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'B'}, 32)}
-	if err := service.beaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'B'})); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'B'}, 32)}); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, service.beaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'B'})))
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'B'}, 32)}))
 	s2, err := service.getAttPreState(ctx, cp2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if s2.Slot() != 2*params.BeaconConfig().SlotsPerEpoch {
-		t.Errorf("Wanted state slot: %d, got: %d", 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot())
-	}
+	require.NoError(t, err)
+	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
 
 	s1, err = service.getAttPreState(ctx, cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if s1.Slot() != 1*params.BeaconConfig().SlotsPerEpoch {
-		t.Errorf("Wanted state slot: %d, got: %d", 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot())
-	}
+	require.NoError(t, err)
+	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
 
 	s1, err = service.checkpointState.StateByCheckpoint(cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if s1.Slot() != 1*params.BeaconConfig().SlotsPerEpoch {
-		t.Errorf("Wanted state slot: %d, got: %d", 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot())
-	}
+	require.NoError(t, err)
+	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
 
 	s2, err = service.checkpointState.StateByCheckpoint(cp2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if s2.Slot() != 2*params.BeaconConfig().SlotsPerEpoch {
-		t.Errorf("Wanted state slot: %d, got: %d", 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot())
-	}
+	require.NoError(t, err)
+	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
 
-	if err := s.SetSlot(params.BeaconConfig().SlotsPerEpoch + 1); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))
 	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
 	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
 	service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
 	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, 32)}
-	if err := service.beaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'C'})); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, 32)}); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, service.beaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'C'})))
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, 32)}))
 	s3, err := service.getAttPreState(ctx, cp3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if s3.Slot() != s.Slot() {
-		t.Errorf("Wanted state slot: %d, got: %d", s.Slot(), s3.Slot())
-	}
+	require.NoError(t, err)
+	assert.Equal(t, s.Slot(), s3.Slot(), "Unexpected state slot")
 }
 
 func TestStore_UpdateCheckpointState(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
 	cfg := &Config{
 		BeaconDB: db,
-		StateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		StateGen: stategen.New(db, sc),
 	}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	epoch := uint64(1)
 	baseState, _ := testutil.DeterministicGenesisState(t, 1)
-	if err := baseState.SetSlot(epoch * params.BeaconConfig().SlotsPerEpoch); err != nil {
-		t.Fatal(err)
-	}
-	checkpoint := &ethpb.Checkpoint{Epoch: epoch}
-	if err := service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)); err != nil {
-		t.Fatal(err)
-	}
+	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)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if baseState.Slot() != returned.Slot() {
-		t.Error("Incorrectly returned base state")
-	}
+	require.NoError(t, err)
+	assert.Equal(t, returned.Slot(), checkpoint.Epoch*params.BeaconConfig().SlotsPerEpoch, "Incorrectly returned base state")
 
 	cached, err := service.checkpointState.StateByCheckpoint(checkpoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if cached == nil {
-		t.Error("State should have been cached")
-	}
+	require.NoError(t, err)
+	assert.Equal(t, returned.Slot(), cached.Slot(), "State should have been cached")
 
 	epoch = uint64(2)
-	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch}
-	if err := service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)); err != nil {
-		t.Fatal(err)
-	}
+	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)
-	if err != nil {
-		t.Fatal(err)
-	}
-	baseState, err = state.ProcessSlots(ctx, baseState, helpers.StartSlot(newCheckpoint.Epoch))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if baseState.Slot() != returned.Slot() {
-		t.Error("Incorrectly returned base state")
-	}
+	require.NoError(t, err)
+	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)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	if !proto.Equal(returned.InnerStateUnsafe(), cached.InnerStateUnsafe()) {
 		t.Error("Incorrectly cached base state")
 	}
@@ -346,190 +356,265 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 
 func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: db}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	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) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: db}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	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) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: db}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	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) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: db}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	d := &ethpb.AttestationData{}
-	if err := service.verifyBeaconBlock(ctx, d); !strings.Contains(err.Error(), "beacon block  does not exist") {
-		t.Error("Did not receive the wanted error")
+	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) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: db}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
-	if err := service.beaconDB.SaveBlock(ctx, b); err != nil {
-		t.Fatal(err)
-	}
-	r, err := stateutil.BlockRoot(b.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 2
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
 
-	err = service.verifyBeaconBlock(ctx, d)
-	if err == nil || !strings.Contains(err.Error(), "could not process attestation for future block") {
-		t.Error("Did not receive the wanted error")
-	}
+	assert.ErrorContains(t, "could not process attestation for future block", service.verifyBeaconBlock(ctx, d))
 }
 
 func TestVerifyBeaconBlock_OK(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
 	cfg := &Config{BeaconDB: db}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
-	if err := service.beaconDB.SaveBlock(ctx, b); err != nil {
-		t.Fatal(err)
-	}
-	r, err := stateutil.BlockRoot(b.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 2
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
 
-	if err := service.verifyBeaconBlock(ctx, d); err != nil {
-		t.Error("Did not receive the wanted error")
-	}
+	assert.NoError(t, service.verifyBeaconBlock(ctx, d), "Did not receive the wanted error")
 }
 
 func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
-	cfg := &Config{BeaconDB: db}
+	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
-	if err := service.beaconDB.SaveBlock(ctx, b32); err != nil {
-		t.Fatal(err)
-	}
-	r32, err := stateutil.BlockRoot(b32.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
-	if err := service.beaconDB.SaveBlock(ctx, b33); err != nil {
-		t.Fatal(err)
-	}
-	r33, err := stateutil.BlockRoot(b33.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
+	b32 := testutil.NewBeaconBlock()
+	b32.Block.Slot = 32
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
+	r32, err := b32.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b33 := testutil.NewBeaconBlock()
+	b33.Block.Slot = 33
+	b33.Block.ParentRoot = r32[:]
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
+	r33, err := b33.Block.HashTreeRoot()
+	require.NoError(t, err)
 
 	wanted := "FFG and LMD votes are not consistent"
-	if err := service.verifyLMDFFGConsistent(context.Background(), 1, []byte{'a'}, r33[:]); err.Error() != wanted {
-		t.Error("Did not get wanted error")
-	}
+	assert.ErrorContains(t, wanted, service.verifyLMDFFGConsistent(context.Background(), 1, []byte{'a'}, r33[:]))
 }
 
 func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 
-	cfg := &Config{BeaconDB: db}
+	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
 	service, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
-	if err := service.beaconDB.SaveBlock(ctx, b32); err != nil {
-		t.Fatal(err)
-	}
-	r32, err := stateutil.BlockRoot(b32.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
-	if err := service.beaconDB.SaveBlock(ctx, b33); err != nil {
-		t.Fatal(err)
-	}
-	r33, err := stateutil.BlockRoot(b33.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
+	b32 := testutil.NewBeaconBlock()
+	b32.Block.Slot = 32
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
+	r32, err := b32.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b33 := testutil.NewBeaconBlock()
+	b33.Block.Slot = 33
+	b33.Block.ParentRoot = r32[:]
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
+	r33, err := b33.Block.HashTreeRoot()
+	require.NoError(t, err)
 
-	if err := service.verifyLMDFFGConsistent(context.Background(), 1, r32[:], r33[:]); err != nil {
-		t.Errorf("Could not verify LMD and FFG votes to be consistent: %v", 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)
+}
+
+func TestGetAttCheckptInfo(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+	cfg := &Config{BeaconDB: db, StateGen: stategen.New(db, cache.NewStateSummaryCache())}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	baseState, _ := testutil.DeterministicGenesisState(t, 128)
+	b := testutil.NewBeaconBlock()
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, r))
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
+	require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, r))
+	checkpoint := &ethpb.Checkpoint{Root: r[:]}
+
+	returned, err := service.getAttCheckPtInfo(ctx, checkpoint, 0)
+	require.NoError(t, err)
+
+	seed, err := helpers.Seed(baseState, 0, params.BeaconConfig().DomainBeaconAttester)
+	require.NoError(t, err)
+	indices, err := helpers.ActiveValidatorIndices(baseState, 0)
+	require.NoError(t, err)
+	validators := baseState.ValidatorsReadOnly()
+	pks := make([][]byte, len(validators))
+	for i := 0; i < len(pks); i++ {
+		pk := validators[i].PublicKey()
+		pks[i] = pk[:]
+	}
+
+	wanted := &pb.CheckPtInfo{
+		Fork:          baseState.Fork(),
+		GenesisRoot:   baseState.GenesisValidatorRoot(),
+		Seed:          seed[:],
+		ActiveIndices: indices,
+		PubKeys:       pks,
+	}
+	require.DeepEqual(t, wanted, returned)
+
+	cached, err := service.checkPtInfoCache.get(checkpoint)
+	require.NoError(t, err)
+	require.DeepEqual(t, wanted, cached)
 }

beacon-chain/blockchain/process_block.go

@@ -2,20 +2,18 @@ package blockchain
 
 import (
 	"context"
-	"encoding/hex"
 	"fmt"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/flags"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
@@ -27,173 +25,130 @@ var initialSyncBlockCacheSize = 2 * params.BeaconConfig().SlotsPerEpoch
 // computation in this method and methods it calls into.
 //
 // Spec pseudocode definition:
-//   def on_block(store: Store, block: BeaconBlock) -> None:
-//    # Make a copy of the state to avoid mutability issues
+//   def on_block(store: Store, signed_block: SignedBeaconBlock) -> None:
+//    block = signed_block.message
+//    # Parent block must be known
 //    assert block.parent_root in store.block_states
-//    pre_state = store.block_states[block.parent_root].copy()
+//    # Make a copy of the state to avoid mutability issues
+//    pre_state = copy(store.block_states[block.parent_root])
 //    # Blocks cannot be in the future. If they are, their consideration must be delayed until the are in the past.
-//    assert store.time >= pre_state.genesis_time + block.slot * SECONDS_PER_SLOT
-//    # Add new block to the store
-//    store.blocks[signing_root(block)] = block
-//    # Check block is a descendant of the finalized block
-//    assert (
-//        get_ancestor(store, signing_root(block), store.blocks[store.finalized_checkpoint.root].slot) ==
-//        store.finalized_checkpoint.root
-//    )
-//    # Check that block is later than the finalized epoch slot
-//    assert block.slot > compute_start_slot_of_epoch(store.finalized_checkpoint.epoch)
+//    assert get_current_slot(store) >= block.slot
+//
+//    # Check that block is later than the finalized epoch slot (optimization to reduce calls to get_ancestor)
+//    finalized_slot = compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)
+//    assert block.slot > finalized_slot
+//    # Check block is a descendant of the finalized block at the checkpoint finalized slot
+//    assert get_ancestor(store, block.parent_root, finalized_slot) == store.finalized_checkpoint.root
+//
 //    # Check the block is valid and compute the post-state
-//    state = state_transition(pre_state, block)
+//    state = state_transition(pre_state, signed_block, True)
+//    # Add new block to the store
+//    store.blocks[hash_tree_root(block)] = block
 //    # Add new state for this block to the store
-//    store.block_states[signing_root(block)] = state
+//    store.block_states[hash_tree_root(block)] = state
 //
 //    # Update justified checkpoint
 //    if state.current_justified_checkpoint.epoch > store.justified_checkpoint.epoch:
 //        if state.current_justified_checkpoint.epoch > store.best_justified_checkpoint.epoch:
 //            store.best_justified_checkpoint = state.current_justified_checkpoint
+//        if should_update_justified_checkpoint(store, state.current_justified_checkpoint):
+//            store.justified_checkpoint = state.current_justified_checkpoint
 //
 //    # Update finalized checkpoint
 //    if state.finalized_checkpoint.epoch > store.finalized_checkpoint.epoch:
 //        store.finalized_checkpoint = state.finalized_checkpoint
-func (s *Service) onBlock(ctx context.Context, signed *ethpb.SignedBeaconBlock, blockRoot [32]byte) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "blockchain.onBlock")
+//
+//        # Potentially update justified if different from store
+//        if store.justified_checkpoint != state.current_justified_checkpoint:
+//            # Update justified if new justified is later than store justified
+//            if state.current_justified_checkpoint.epoch > store.justified_checkpoint.epoch:
+//                store.justified_checkpoint = state.current_justified_checkpoint
+//                return
+//
+//            # Update justified if store justified is not in chain with finalized checkpoint
+//            finalized_slot = compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)
+//            ancestor_at_finalized_slot = get_ancestor(store, store.justified_checkpoint.root, finalized_slot)
+//            if ancestor_at_finalized_slot != store.finalized_checkpoint.root:
+//                store.justified_checkpoint = state.current_justified_checkpoint
+func (s *Service) onBlock(ctx context.Context, signed *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.onBlock")
 	defer span.End()
 
 	if signed == nil || signed.Block == nil {
-		return nil, errors.New("nil block")
+		return errors.New("nil block")
 	}
-
 	b := signed.Block
 
-	// Retrieve incoming block's pre state.
 	preState, err := s.getBlockPreState(ctx, b)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	log.WithFields(logrus.Fields{
-		"slot": b.Slot,
-		"root": fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
-	}).Debug("Executing state transition on block")
-
 	postState, err := state.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not execute state transition")
+		return errors.Wrap(err, "could not execute state transition")
 	}
 
-	if err := s.beaconDB.SaveBlock(ctx, signed); err != nil {
-		return nil, errors.Wrapf(err, "could not save block from slot %d", b.Slot)
-	}
-
-	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, postState); err != nil {
-		return nil, errors.Wrapf(err, "could not insert block %d to fork choice store", b.Slot)
-	}
-
-	if featureconfig.Get().NewStateMgmt {
-		if err := s.stateGen.SaveState(ctx, blockRoot, postState); err != nil {
-			return nil, errors.Wrap(err, "could not save state")
-		}
-	} else {
-		if err := s.beaconDB.SaveState(ctx, postState, blockRoot); err != nil {
-			return nil, errors.Wrap(err, "could not save state")
-		}
+	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, false /* reg sync */); err != nil {
+		return err
 	}
 
 	// Update justified check point.
 	if postState.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
 		if err := s.updateJustified(ctx, postState); err != nil {
-			return nil, err
+			return err
 		}
 	}
 
-	// Update finalized check point. Prune the block cache and helper caches on every new finalized epoch.
+	// Update finalized check point.
 	if postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch {
-		if !featureconfig.Get().NoInitSyncBatchSaveBlocks {
-			if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-				return nil, err
-			}
-			s.clearInitSyncBlocks()
+		if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+			return err
+		}
+		s.clearInitSyncBlocks()
+
+		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
+			return err
 		}
 
-		if err := s.beaconDB.SaveFinalizedCheckpoint(ctx, postState.FinalizedCheckpoint()); err != nil {
-			return nil, errors.Wrap(err, "could not save finalized checkpoint")
-		}
-
-		if !featureconfig.Get().NewStateMgmt {
-			startSlot := helpers.StartSlot(s.prevFinalizedCheckpt.Epoch)
-			endSlot := helpers.StartSlot(s.finalizedCheckpt.Epoch)
-			if endSlot > startSlot {
-				if err := s.rmStatesOlderThanLastFinalized(ctx, startSlot, endSlot); err != nil {
-					return nil, errors.Wrapf(err, "could not delete states prior to finalized check point, range: %d, %d",
-						startSlot, endSlot)
-				}
-			}
-		}
 		fRoot := bytesutil.ToBytes32(postState.FinalizedCheckpoint().Root)
-
-		// Prune proto array fork choice nodes, all nodes before finalized check point will
-		// be pruned.
 		if err := s.forkChoiceStore.Prune(ctx, fRoot); err != nil {
-			return nil, errors.Wrap(err, "could not prune proto array fork choice nodes")
+			return errors.Wrap(err, "could not prune proto array fork choice nodes")
 		}
 
-		s.prevFinalizedCheckpt = s.finalizedCheckpt
-		s.finalizedCheckpt = postState.FinalizedCheckpoint()
-
 		if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
-			return nil, errors.Wrap(err, "could not save new justified")
+			return errors.Wrap(err, "could not save new justified")
 		}
 
-		if featureconfig.Get().NewStateMgmt {
-			fRoot := bytesutil.ToBytes32(postState.FinalizedCheckpoint().Root)
-			fBlock, err := s.beaconDB.Block(ctx, fRoot)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get finalized block to migrate")
-			}
-			if err := s.stateGen.MigrateToCold(ctx, fBlock.Block.Slot, fRoot); err != nil {
-				return nil, errors.Wrap(err, "could not migrate to cold")
+		// Update deposit cache.
+		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")
 			}
 		}
 	}
 
-	// Epoch boundary bookkeeping such as logging epoch summaries.
-	if postState.Slot() >= s.nextEpochBoundarySlot {
-		logEpochData(postState)
-		reportEpochMetrics(postState)
-
-		// Update committees cache at epoch boundary slot.
-		if err := helpers.UpdateCommitteeCache(postState, helpers.CurrentEpoch(postState)); err != nil {
-			return nil, err
-		}
-		if err := helpers.UpdateProposerIndicesInCache(postState, helpers.CurrentEpoch(postState)); err != nil {
-			return nil, err
-		}
-
-		s.nextEpochBoundarySlot = helpers.StartSlot(helpers.NextEpoch(postState))
-	}
-
-	// Delete the processed block attestations from attestation pool.
-	if err := s.deletePoolAtts(b.Body.Attestations); err != nil {
-		return nil, err
-	}
-
-	// Delete the processed block attester slashings from slashings pool.
-	for i := 0; i < len(b.Body.AttesterSlashings); i++ {
-		s.slashingPool.MarkIncludedAttesterSlashing(b.Body.AttesterSlashings[i])
-	}
-
 	defer reportAttestationInclusion(b)
 
-	return postState, nil
+	return s.handleEpochBoundary(ctx, postState)
 }
 
 // onBlockInitialSyncStateTransition is called when an initial sync block is received.
-// It runs state transition on the block and without any BLS verification. The excluded BLS verification
-// includes attestation's aggregated signature. It also does not save attestations.
+// It runs state transition on the block and without fork choice and post operation pool processes.
 // The block's signing root should be computed before calling this method to avoid redundant
 // computation in this method and methods it calls into.
 func (s *Service) onBlockInitialSyncStateTransition(ctx context.Context, signed *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockchain.onBlock")
+	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockInitialSyncStateTransition")
 	defer span.End()
 
 	if signed == nil || signed.Block == nil {
@@ -203,126 +158,180 @@ func (s *Service) onBlockInitialSyncStateTransition(ctx context.Context, signed
 	b := signed.Block
 
 	// Retrieve incoming block's pre state.
-	preState, err := s.verifyBlkPreState(ctx, b)
+	if err := s.verifyBlkPreState(ctx, b); err != nil {
+		return err
+	}
+
+	preState, err := s.stateGen.StateByRootInitialSync(ctx, bytesutil.ToBytes32(signed.Block.ParentRoot))
 	if err != nil {
 		return err
 	}
-	// To invalidate cache for parent root because pre state will get mutated.
-	s.stateGen.DeleteHotStateInCache(bytesutil.ToBytes32(b.ParentRoot))
+	if preState == nil {
+		return fmt.Errorf("nil pre state for slot %d", b.Slot)
+	}
 
 	// Exit early if the pre state slot is higher than incoming block's slot.
 	if preState.Slot() >= signed.Block.Slot {
 		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")
 	}
 
-	if !featureconfig.Get().NoInitSyncBatchSaveBlocks {
-		s.saveInitSyncBlock(blockRoot, signed)
-	} else {
-		if err := s.beaconDB.SaveBlock(ctx, signed); err != nil {
-			return errors.Wrapf(err, "could not save block from slot %d", b.Slot)
-		}
+	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, true /* init sync */); err != nil {
+		return err
 	}
-
-	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, postState); err != nil {
-		return errors.Wrapf(err, "could not insert block %d to fork choice store", b.Slot)
-	}
-
-	if featureconfig.Get().NewStateMgmt {
-		if err := s.stateGen.SaveState(ctx, blockRoot, postState); err != nil {
-			return errors.Wrap(err, "could not save state")
-		}
-	} else {
-		s.initSyncStateLock.Lock()
-		defer s.initSyncStateLock.Unlock()
-		s.initSyncState[blockRoot] = postState.Copy()
-		s.filterBoundaryCandidates(ctx, blockRoot, postState)
-	}
-
-	if flags.Get().EnableArchive {
-		atts := signed.Block.Body.Attestations
-		if err := s.beaconDB.SaveAttestations(ctx, atts); err != nil {
-			return errors.Wrapf(err, "could not save block attestations from slot %d", b.Slot)
-		}
+	// Save the latest block as head in cache.
+	if err := s.saveHeadNoDB(ctx, signed, blockRoot, postState); err != nil {
+		return err
 	}
 
 	// Rate limit how many blocks (2 epochs worth of blocks) a node keeps in the memory.
-	if len(s.getInitSyncBlocks()) > int(initialSyncBlockCacheSize) {
+	if uint64(len(s.getInitSyncBlocks())) > initialSyncBlockCacheSize {
 		if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
 			return err
 		}
 		s.clearInitSyncBlocks()
 	}
 
+	if postState.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
+		if err := s.updateJustifiedInitSync(ctx, postState.CurrentJustifiedCheckpoint()); err != nil {
+			return err
+		}
+	}
+
 	// Update finalized check point. Prune the block cache and helper caches on every new finalized epoch.
 	if postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch {
-		if !featureconfig.Get().NewStateMgmt {
-			startSlot := helpers.StartSlot(s.prevFinalizedCheckpt.Epoch)
-			endSlot := helpers.StartSlot(s.finalizedCheckpt.Epoch)
-			if endSlot > startSlot {
-				if err := s.rmStatesOlderThanLastFinalized(ctx, startSlot, endSlot); err != nil {
-					return errors.Wrapf(err, "could not delete states prior to finalized check point, range: %d, %d",
-						startSlot, endSlot)
-				}
-			}
-
-			if err := s.saveInitState(ctx, postState); err != nil {
-				return errors.Wrap(err, "could not save init sync finalized state")
-			}
-		}
-
-		if !featureconfig.Get().NoInitSyncBatchSaveBlocks {
-			if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-				return err
-			}
-			s.clearInitSyncBlocks()
-		}
-
-		if err := s.beaconDB.SaveFinalizedCheckpoint(ctx, postState.FinalizedCheckpoint()); err != nil {
-			return errors.Wrap(err, "could not save finalized checkpoint")
-		}
-
-		s.prevFinalizedCheckpt = s.finalizedCheckpt
-		s.finalizedCheckpt = postState.FinalizedCheckpoint()
-
-		if featureconfig.Get().NewStateMgmt {
-			fRoot := bytesutil.ToBytes32(postState.FinalizedCheckpoint().Root)
-			fBlock, err := s.beaconDB.Block(ctx, fRoot)
-			if err != nil {
-				return errors.Wrap(err, "could not get finalized block to migrate")
-			}
-			if err := s.stateGen.MigrateToCold(ctx, fBlock.Block.Slot, fRoot); err != nil {
-				return errors.Wrap(err, "could not migrate to cold")
-			}
+		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
+			return err
 		}
 	}
 
-	if !featureconfig.Get().NewStateMgmt {
-		numOfStates := len(s.boundaryRoots)
-		if numOfStates > initialSyncCacheSize {
-			if err = s.persistCachedStates(ctx, numOfStates); err != nil {
-				return err
+	return s.handleEpochBoundary(ctx, postState)
+}
+
+func (s *Service) onBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock,
+	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
+	defer span.End()
+
+	if len(blks) == 0 || len(blockRoots) == 0 {
+		return nil, nil, errors.New("no blocks provided")
+	}
+	if blks[0] == nil || blks[0].Block == nil {
+		return nil, nil, errors.New("nil block")
+	}
+	b := blks[0].Block
+
+	// Retrieve incoming block's pre state.
+	if err := s.verifyBlkPreState(ctx, b); err != nil {
+		return nil, nil, err
+	}
+	preState, err := s.stateGen.StateByRootInitialSync(ctx, bytesutil.ToBytes32(b.ParentRoot))
+	if err != nil {
+		return nil, nil, err
+	}
+	if preState == nil {
+		return nil, nil, fmt.Errorf("nil pre state for slot %d", b.Slot)
+	}
+
+	jCheckpoints := make([]*ethpb.Checkpoint, len(blks))
+	fCheckpoints := make([]*ethpb.Checkpoint, len(blks))
+	sigSet := &bls.SignatureSet{
+		Signatures: [][]byte{},
+		PublicKeys: []bls.PublicKey{},
+		Messages:   [][32]byte{},
+	}
+	var set *bls.SignatureSet
+	boundaries := make(map[[32]byte]*stateTrie.BeaconState)
+	for i, b := range blks {
+		set, preState, err = state.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
+		if err != nil {
+			return nil, nil, err
+		}
+		// Save potential boundary states.
+		if helpers.IsEpochStart(preState.Slot()) {
+			boundaries[blockRoots[i]] = preState.Copy()
+			if err := s.handleEpochBoundary(ctx, preState); err != nil {
+				return nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
 			}
 		}
-		if len(s.initSyncState) > maxCacheSize {
-			s.pruneOldNonFinalizedStates()
+		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
+		fCheckpoints[i] = preState.FinalizedCheckpoint()
+		sigSet.Join(set)
+	}
+	verify, err := sigSet.Verify()
+	if err != nil {
+		return nil, nil, err
+	}
+	if !verify {
+		return nil, nil, errors.New("batch block signature verification failed")
+	}
+	for r, st := range boundaries {
+		if err := s.stateGen.SaveState(ctx, r, st); err != nil {
+			return nil, nil, err
+		}
+	}
+	// Also saves the last post state which to be used as pre state for the next batch.
+	lastB := blks[len(blks)-1]
+	lastBR := blockRoots[len(blockRoots)-1]
+	if err := s.stateGen.SaveState(ctx, lastBR, preState); err != nil {
+		return nil, nil, err
+	}
+	if err := s.saveHeadNoDB(ctx, lastB, lastBR, preState); err != nil {
+		return nil, nil, err
+	}
+	return fCheckpoints, jCheckpoints, nil
+}
+
+// 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, jCheckpoint *ethpb.Checkpoint) error {
+	b := signed.Block
+
+	s.saveInitSyncBlock(blockRoot, signed)
+	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
+		return err
+	}
+	s.stateGen.SaveStateSummary(ctx, signed, blockRoot)
+
+	// Rate limit how many blocks (2 epochs worth of blocks) a node keeps in the memory.
+	if uint64(len(s.getInitSyncBlocks())) > initialSyncBlockCacheSize {
+		if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+			return err
+		}
+		s.clearInitSyncBlocks()
+	}
+
+	if jCheckpoint.Epoch > s.justifiedCheckpt.Epoch {
+		if err := s.updateJustifiedInitSync(ctx, jCheckpoint); err != nil {
+			return err
 		}
 	}
 
-	// Epoch boundary bookkeeping such as logging epoch summaries.
+	// Update finalized check point. Prune the block cache and helper caches on every new finalized epoch.
+	if fCheckpoint.Epoch > s.finalizedCheckpt.Epoch {
+		if err := s.updateFinalized(ctx, fCheckpoint); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Epoch boundary bookkeeping such as logging epoch summaries.
+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
@@ -330,32 +339,19 @@ func (s *Service) onBlockInitialSyncStateTransition(ctx context.Context, signed
 		if err := helpers.UpdateProposerIndicesInCache(postState, helpers.CurrentEpoch(postState)); err != nil {
 			return err
 		}
-
-		if !featureconfig.Get().NewStateMgmt && helpers.IsEpochStart(postState.Slot()) {
-			if err := s.beaconDB.SaveState(ctx, postState, blockRoot); err != nil {
-				return errors.Wrap(err, "could not save state")
-			}
-		}
 	}
-
 	return nil
 }
 
 // This feeds in the block and block's attestations to fork choice store. It's allows fork choice store
 // to gain information on the most current chain.
-func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk *ethpb.BeaconBlock, root [32]byte, state *stateTrie.BeaconState) error {
-	if err := s.fillInForkChoiceMissingBlocks(ctx, blk, state); err != nil {
+func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Context, blk *ethpb.BeaconBlock, root [32]byte,
+	state *stateTrie.BeaconState) error {
+	fCheckpoint := state.FinalizedCheckpoint()
+	jCheckpoint := state.CurrentJustifiedCheckpoint()
+	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
-
-	// Feed in block to fork choice store.
-	if err := s.forkChoiceStore.ProcessBlock(ctx,
-		blk.Slot, root, bytesutil.ToBytes32(blk.ParentRoot), bytesutil.ToBytes32(blk.Body.Graffiti),
-		state.CurrentJustifiedCheckpoint().Epoch,
-		state.FinalizedCheckpointEpoch()); err != nil {
-		return errors.Wrap(err, "could not process block for proto array fork choice")
-	}
-
 	// Feed in block's attestations to fork choice store.
 	for _, a := range blk.Body.Attestations {
 		committee, err := helpers.BeaconCommitteeFromState(state, a.Data.Slot, a.Data.CommitteeIndex)
@@ -365,6 +361,39 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk *ethpb.B
 		indices := attestationutil.AttestingIndices(a.AggregationBits, committee)
 		s.forkChoiceStore.ProcessAttestation(ctx, indices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
 	}
-
+	return nil
+}
+
+func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk *ethpb.BeaconBlock,
+	root [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
+	if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
+		return err
+	}
+	// Feed in block to fork choice store.
+	if err := s.forkChoiceStore.ProcessBlock(ctx,
+		blk.Slot, root, bytesutil.ToBytes32(blk.ParentRoot), bytesutil.ToBytes32(blk.Body.Graffiti),
+		jCheckpoint.Epoch,
+		fCheckpoint.Epoch); err != nil {
+		return errors.Wrap(err, "could not process block for proto array fork choice")
+	}
+	return nil
+}
+
+// This saves post state info to DB or cache. This also saves post state info to fork choice store.
+// Post state info consists of processed block and state. Do not call this method unless the block and state are verified.
+func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b *ethpb.SignedBeaconBlock, state *stateTrie.BeaconState, initSync bool) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.savePostStateInfo")
+	defer span.End()
+	if initSync {
+		s.saveInitSyncBlock(r, b)
+	} else if err := s.beaconDB.SaveBlock(ctx, b); err != nil {
+		return errors.Wrapf(err, "could not save block from slot %d", b.Block.Slot)
+	}
+	if err := s.stateGen.SaveState(ctx, r, state); err != nil {
+		return errors.Wrap(err, "could not save state")
+	}
+	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, b.Block, r, state); err != nil {
+		return errors.Wrapf(err, "could not insert block %d to fork choice store", b.Block.Slot)
+	}
 	return nil
 }

beacon-chain/blockchain/process_block_helpers.go

@@ -8,63 +8,44 @@ import (
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	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/featureconfig"
 	"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.
-	preState, err := s.verifyBlkPreState(ctx, b)
+	if err := s.verifyBlkPreState(ctx, b); err != nil {
+		return nil, err
+	}
+
+	preState, err := s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(b.ParentRoot))
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "could not get pre state for slot %d", b.Slot)
+	}
+	if preState == nil {
+		return nil, errors.Wrapf(err, "nil pre state for slot %d", b.Slot)
 	}
 
-	//  For new state management, this ensures the state does not get mutated since initial syncing
-	//  uses verifyBlkPreState.
-	if featureconfig.Get().NewStateMgmt {
-		preState, err = s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(b.ParentRoot))
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not get pre state for slot %d", b.Slot)
-		}
-		if preState == nil {
-			return nil, errors.Wrapf(err, "nil pre state for slot %d", b.Slot)
-		}
-	}
-
-	// Verify block slot time is not from the feature.
+	// Verify block slot time is not from the future.
 	if err := helpers.VerifySlotTime(preState.GenesisTime(), 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), b.Slot); err != nil {
-		return nil, err
-	}
-
 	// Verify block is later than the finalized epoch slot.
 	if err := s.verifyBlkFinalizedSlot(b); err != nil {
 		return nil, err
@@ -74,88 +55,61 @@ 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) (*stateTrie.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "chainService.verifyBlkPreState")
+func (s *Service) verifyBlkPreState(ctx context.Context, b *ethpb.BeaconBlock) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.verifyBlkPreState")
 	defer span.End()
 
-	if featureconfig.Get().NewStateMgmt {
-		parentRoot := bytesutil.ToBytes32(b.ParentRoot)
-		// Loosen the check to HasBlock because state summary gets saved in batches
-		// during initial syncing. There's no risk given a state summary object is just a
-		// a subset of the block object.
-		if !s.stateGen.StateSummaryExists(ctx, parentRoot) && !s.beaconDB.HasBlock(ctx, parentRoot) {
-			return nil, errors.New("could not reconstruct parent state")
-		}
-		if !s.stateGen.HasState(ctx, parentRoot) {
-			if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-				return nil, errors.Wrap(err, "could not save initial sync blocks")
-			}
-			s.clearInitSyncBlocks()
-		}
-		preState, err := s.stateGen.StateByRootInitialSync(ctx, parentRoot)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not get pre state for slot %d", b.Slot)
-		}
-		if preState == nil {
-			return nil, errors.Wrapf(err, "nil pre state for slot %d", b.Slot)
-		}
-
-		return preState, nil // No copy needed from newly hydrated state gen object.
+	parentRoot := bytesutil.ToBytes32(b.ParentRoot)
+	// Loosen the check to HasBlock because state summary gets saved in batches
+	// during initial syncing. There's no risk given a state summary object is just a
+	// a subset of the block object.
+	if !s.stateGen.StateSummaryExists(ctx, parentRoot) && !s.beaconDB.HasBlock(ctx, parentRoot) {
+		return errors.New("could not reconstruct parent state")
 	}
 
-	preState := s.initSyncState[bytesutil.ToBytes32(b.ParentRoot)]
-	var err error
-	if preState == nil {
-		if featureconfig.Get().CheckHeadState {
-			headRoot, err := s.HeadRoot(ctx)
-			if err != nil {
-				return nil, errors.Wrapf(err, "could not get head root")
-			}
-			if bytes.Equal(headRoot, b.ParentRoot) {
-				return s.HeadState(ctx)
-			}
-		}
-		preState, err = s.beaconDB.State(ctx, bytesutil.ToBytes32(b.ParentRoot))
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not get pre state for slot %d", b.Slot)
-		}
-		if preState == nil {
-			if bytes.Equal(s.finalizedCheckpt.Root, b.ParentRoot) {
-				return nil, fmt.Errorf("pre state of slot %d does not exist", b.Slot)
-			}
-			preState, err = s.generateState(ctx, bytesutil.ToBytes32(s.finalizedCheckpt.Root), bytesutil.ToBytes32(b.ParentRoot))
-			if err != nil {
-				return nil, err
-			}
-		}
-		return preState, nil // No copy needed from newly hydrated DB object.
+	if err := s.VerifyBlkDescendant(ctx, bytesutil.ToBytes32(b.ParentRoot)); err != nil {
+		return err
 	}
-	return preState.Copy(), nil
+
+	has, err := s.stateGen.HasState(ctx, parentRoot)
+	if err != nil {
+		return err
+	}
+	if !has {
+		if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+			return errors.Wrap(err, "could not save initial sync blocks")
+		}
+		s.clearInitSyncBlocks()
+	}
+	return nil
 }
 
-// verifyBlkDescendant validates input block root is a descendant of the
+// VerifyBlkDescendant validates input block root is a descendant of the
 // current finalized block root.
-func (s *Service) verifyBlkDescendant(ctx context.Context, root [32]byte, slot uint64) error {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.verifyBlkDescendant")
+func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.VerifyBlkDescendant")
 	defer span.End()
-
-	finalizedBlkSigned, err := s.beaconDB.Block(ctx, bytesutil.ToBytes32(s.finalizedCheckpt.Root))
-	if err != nil || finalizedBlkSigned == nil || finalizedBlkSigned.Block == nil {
-		return errors.Wrap(err, "could not get finalized block")
+	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.finalizedCheckpt.Root))
+	finalizedBlkSigned, err := s.beaconDB.Block(ctx, fRoot)
+	if err != nil {
+		return err
+	}
+	if finalizedBlkSigned == nil || finalizedBlkSigned.Block == nil {
+		return errors.New("nil finalized block")
 	}
 	finalizedBlk := finalizedBlkSigned.Block
-
 	bFinalizedRoot, err := s.ancestor(ctx, root[:], finalizedBlk.Slot)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized block root")
 	}
 	if bFinalizedRoot == nil {
-		return fmt.Errorf("no finalized block known for block from slot %d", slot)
+		return fmt.Errorf("no finalized block known for block %#x", bytesutil.Trunc(root[:]))
 	}
 
-	if !bytes.Equal(bFinalizedRoot, s.finalizedCheckpt.Root) {
-		err := fmt.Errorf("block from slot %d is not a descendent of the current finalized block slot %d, %#x != %#x",
-			slot, finalizedBlk.Slot, bytesutil.Trunc(bFinalizedRoot), bytesutil.Trunc(s.finalizedCheckpt.Root))
+	if !bytes.Equal(bFinalizedRoot, fRoot[:]) {
+		err := fmt.Errorf("block %#x is not a descendent of the current finalized block slot %d, %#x != %#x",
+			bytesutil.Trunc(root[:]), finalizedBlk.Slot, bytesutil.Trunc(bFinalizedRoot),
+			bytesutil.Trunc(fRoot[:]))
 		traceutil.AnnotateError(span, err)
 		return err
 	}
@@ -165,71 +119,16 @@ func (s *Service) verifyBlkDescendant(ctx context.Context, root [32]byte, slot u
 // 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)
 	}
 	return nil
 }
 
-// rmStatesOlderThanLastFinalized deletes the states in db since last finalized check point.
-func (s *Service) rmStatesOlderThanLastFinalized(ctx context.Context, startSlot uint64, endSlot uint64) error {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.rmStatesBySlots")
-	defer span.End()
-
-	// Make sure start slot is not a skipped slot
-	for i := startSlot; i > 0; i-- {
-		filter := filters.NewFilter().SetStartSlot(i).SetEndSlot(i)
-		b, err := s.beaconDB.Blocks(ctx, filter)
-		if err != nil {
-			return err
-		}
-		if len(b) > 0 {
-			startSlot = i
-			break
-		}
-	}
-
-	// Make sure finalized slot is not a skipped slot.
-	for i := endSlot; i > 0; i-- {
-		filter := filters.NewFilter().SetStartSlot(i).SetEndSlot(i)
-		b, err := s.beaconDB.Blocks(ctx, filter)
-		if err != nil {
-			return err
-		}
-		if len(b) > 0 {
-			endSlot = i - 1
-			break
-		}
-	}
-
-	// Do not remove genesis state
-	if startSlot == 0 {
-		startSlot++
-	}
-	// If end slot comes less than start slot
-	if endSlot < startSlot {
-		endSlot = startSlot
-	}
-
-	filter := filters.NewFilter().SetStartSlot(startSlot).SetEndSlot(endSlot)
-	roots, err := s.beaconDB.BlockRoots(ctx, filter)
-	if err != nil {
-		return err
-	}
-
-	roots, err = s.filterBlockRoots(ctx, roots)
-	if err != nil {
-		return err
-	}
-
-	if err := s.beaconDB.DeleteStates(ctx, roots); err != nil {
-		log.Warnf("Could not delete states: %v", err)
-	}
-
-	return nil
-}
-
 // shouldUpdateCurrentJustified prevents bouncing attack, by only update conflicting justified
 // checkpoints in the fork choice if in the early slots of the epoch.
 // Otherwise, delay incorporation of new justified checkpoint until next epoch boundary.
@@ -241,7 +140,7 @@ func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustified
 	var newJustifiedBlockSigned *ethpb.SignedBeaconBlock
 	justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(newJustifiedCheckpt.Root))
 	var err error
-	if !featureconfig.Get().NoInitSyncBatchSaveBlocks && s.hasInitSyncBlock(justifiedRoot) {
+	if s.hasInitSyncBlock(justifiedRoot) {
 		newJustifiedBlockSigned = s.getInitSyncBlock(justifiedRoot)
 	} else {
 		newJustifiedBlockSigned, err = s.beaconDB.Block(ctx, justifiedRoot)
@@ -254,12 +153,16 @@ 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
 	cachedJustifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))
-	if !featureconfig.Get().NoInitSyncBatchSaveBlocks && s.hasInitSyncBlock(cachedJustifiedRoot) {
+	if s.hasInitSyncBlock(cachedJustifiedRoot) {
 		justifiedBlockSigned = s.getInitSyncBlock(cachedJustifiedRoot)
 	} else {
 		justifiedBlockSigned, err = s.beaconDB.Block(ctx, cachedJustifiedRoot)
@@ -300,84 +203,43 @@ func (s *Service) updateJustified(ctx context.Context, state *stateTrie.BeaconSt
 		}
 	}
 
-	if !featureconfig.Get().NewStateMgmt {
-		justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(cpt.Root))
-		justifiedState := s.initSyncState[justifiedRoot]
-		// If justified state is nil, resume back to normal syncing process and save
-		// justified check point.
-		var err error
-		if justifiedState == nil {
-			if s.beaconDB.HasState(ctx, justifiedRoot) {
-				return s.beaconDB.SaveJustifiedCheckpoint(ctx, cpt)
-			}
-			justifiedState, err = s.generateState(ctx, bytesutil.ToBytes32(s.finalizedCheckpt.Root), justifiedRoot)
-			if err != nil {
-				log.Error(err)
-				return s.beaconDB.SaveJustifiedCheckpoint(ctx, cpt)
-			}
-		}
-		if err := s.beaconDB.SaveState(ctx, justifiedState, justifiedRoot); err != nil {
-			return errors.Wrap(err, "could not save justified state")
-		}
-	}
-
 	return s.beaconDB.SaveJustifiedCheckpoint(ctx, cpt)
 }
 
-// This saves every finalized state in DB during initial sync, needed as part of optimization to
-// use cache state during initial sync in case of restart.
-func (s *Service) saveInitState(ctx context.Context, state *stateTrie.BeaconState) error {
-	cpt := state.FinalizedCheckpoint()
-	finalizedRoot := bytesutil.ToBytes32(cpt.Root)
-	fs := s.initSyncState[finalizedRoot]
-	if fs == nil {
-		var err error
-		fs, err = s.beaconDB.State(ctx, finalizedRoot)
-		if err != nil {
-			return err
-		}
-		if fs == nil {
-			fs, err = s.generateState(ctx, bytesutil.ToBytes32(s.prevFinalizedCheckpt.Root), finalizedRoot)
-			if err != nil {
-				// This might happen if the client was in sync and is now re-syncing for whatever reason.
-				log.Warn("Initial sync cache did not have finalized state root cached")
-				return err
-			}
-		}
+// This caches input checkpoint as justified for the service struct. It rotates current justified to previous justified,
+// caches justified checkpoint balances for fork choice and save justified checkpoint in DB.
+// This method does not have defense against fork choice bouncing attack, which is why it's only recommend to be used during initial syncing.
+func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpoint) error {
+	s.prevJustifiedCheckpt = s.justifiedCheckpt
+	s.justifiedCheckpt = cp
+	if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+		return err
 	}
 
-	if err := s.beaconDB.SaveState(ctx, fs, finalizedRoot); err != nil {
-		return errors.Wrap(err, "could not save state")
-	}
-	return nil
+	return s.beaconDB.SaveJustifiedCheckpoint(ctx, cp)
 }
 
-// This filters block roots that are not known as head root and finalized root in DB.
-// It serves as the last line of defence before we prune states.
-func (s *Service) filterBlockRoots(ctx context.Context, roots [][32]byte) ([][32]byte, error) {
-	f, err := s.beaconDB.FinalizedCheckpoint(ctx)
-	if err != nil {
-		return nil, err
+func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
+	// Blocks need to be saved so that we can retrieve finalized block from
+	// DB when migrating states.
+	if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+		return err
 	}
-	fRoot := f.Root
-	h, err := s.beaconDB.HeadBlock(ctx)
-	if err != nil {
-		return nil, err
-	}
-	hRoot, err := stateutil.BlockRoot(h.Block)
-	if err != nil {
-		return nil, err
+	s.clearInitSyncBlocks()
+
+	if err := s.beaconDB.SaveFinalizedCheckpoint(ctx, cp); err != nil {
+		return err
 	}
 
-	filtered := make([][32]byte, 0, len(roots))
-	for _, root := range roots {
-		if bytes.Equal(root[:], fRoot[:]) || bytes.Equal(root[:], hRoot[:]) {
-			continue
-		}
-		filtered = append(filtered, root)
+	s.prevFinalizedCheckpt = s.finalizedCheckpt
+	s.finalizedCheckpt = cp
+
+	fRoot := bytesutil.ToBytes32(cp.Root)
+	if err := s.stateGen.MigrateToCold(ctx, fRoot); err != nil {
+		return errors.Wrap(err, "could not migrate to cold")
 	}
 
-	return filtered, nil
+	return nil
 }
 
 // ancestor returns the block root of an ancestry block from the input block root.
@@ -393,7 +255,39 @@ func (s *Service) filterBlockRoots(ctx context.Context, roots [][32]byte) ([][32
 //        # 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.
@@ -401,25 +295,24 @@ func (s *Service) ancestor(ctx context.Context, root []byte, slot uint64) ([]byt
 		return nil, ctx.Err()
 	}
 
-	signed, err := s.beaconDB.Block(ctx, bytesutil.ToBytes32(root))
+	signed, err := s.beaconDB.Block(ctx, r)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get ancestor block")
 	}
 
-	if !featureconfig.Get().NoInitSyncBatchSaveBlocks && s.hasInitSyncBlock(bytesutil.ToBytes32(root)) {
-		signed = s.getInitSyncBlock(bytesutil.ToBytes32(root))
+	if s.hasInitSyncBlock(r) {
+		signed = s.getInitSyncBlock(r)
 	}
 
 	if signed == nil || signed.Block == nil {
 		return nil, errors.New("nil block")
 	}
 	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
@@ -442,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 {
@@ -465,15 +358,20 @@ func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state *state
 	return nil
 }
 
-// This retrieves missing blocks from DB (ie. the blocks that couldn't received over sync) and inserts them to fork choice store.
+// 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, state *stateTrie.BeaconState) error {
+func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk *ethpb.BeaconBlock,
+	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)
@@ -484,22 +382,22 @@ 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
 		}
 
 		if err := s.forkChoiceStore.ProcessBlock(ctx,
 			b.Slot, r, bytesutil.ToBytes32(b.ParentRoot), bytesutil.ToBytes32(b.Body.Graffiti),
-			state.CurrentJustifiedCheckpoint().Epoch,
-			state.FinalizedCheckpointEpoch()); err != nil {
+			jCheckpoint.Epoch,
+			fCheckpoint.Epoch); err != nil {
 			return errors.Wrap(err, "could not process block for proto array fork choice")
 		}
 	}

beacon-chain/blockchain/receive_attestation.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 
@@ -10,11 +11,11 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	"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/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/prysmaticlabs/prysm/shared/timeutils"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -24,9 +25,12 @@ 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)
+	AttestationCheckPtInfo(ctx context.Context, att *ethpb.Attestation) (*pb.CheckPtInfo, 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 preformed on
+// ReceiveAttestationNoPubsub is a function that defines the operations that are performed on
 // attestation that is received from regular sync. The operations consist of:
 //  1. Validate attestation, update validator's latest vote
 //  2. Apply fork choice to the processed attestation
@@ -40,14 +44,9 @@ 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
@@ -61,7 +60,7 @@ func (s *Service) IsValidAttestation(ctx context.Context, att *ethpb.Attestation
 		return false
 	}
 
-	if err := blocks.VerifyAttestation(ctx, baseState, att); err != nil {
+	if err := blocks.VerifyAttestationSignature(ctx, baseState, att); err != nil {
 		log.WithError(err).Error("Failed to validate attestation")
 		return false
 	}
@@ -71,9 +70,60 @@ func (s *Service) IsValidAttestation(ctx context.Context, att *ethpb.Attestation
 
 // 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)
 }
 
+// AttestationCheckPtInfo returns the check point info of attestation that can be used to verify the attestation
+// contents and signatures.
+func (s *Service) AttestationCheckPtInfo(ctx context.Context, att *ethpb.Attestation) (*pb.CheckPtInfo, 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.getAttCheckPtInfo(ctx, att.Data.Target, helpers.SlotToEpoch(att.Data.Slot))
+}
+
+// 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 +139,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.
@@ -100,13 +150,7 @@ func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 					continue
 				}
 
-				var hasState bool
-				if featureconfig.Get().NewStateMgmt {
-					hasState = s.stateGen.StateSummaryExists(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
-				} else {
-					hasState = s.beaconDB.HasState(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot)) && s.beaconDB.HasState(ctx, bytesutil.ToBytes32(a.Data.Target.Root))
-				}
-
+				hasState := s.stateGen.StateSummaryExists(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
 				hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
 				if !(hasState && hasBlock) {
 					continue
@@ -137,7 +181,7 @@ 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())
+	now := uint64(timeutils.Now().Unix())
 	genesisTime := uint64(s.genesisTime.Unix())
 	currentSlot := (now - genesisTime) / params.BeaconConfig().SecondsPerSlot
 	currentEpoch := helpers.SlotToEpoch(currentSlot)

beacon-chain/blockchain/receive_attestation_test.go

@@ -1,26 +1,49 @@
 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/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
 	helpers.ClearCache()
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
-	chainService := setupBeaconChain(t, db)
+	chainService := setupBeaconChain(t, db, sc)
 	chainService.genesisTime = time.Now()
 
-	if !chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{}) {
-		t.Error("Wanted true, got false")
-	}
-
-	if chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 1}) {
-		t.Error("Wanted false, got true")
-	}
+	assert.Equal(t, true, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{Root: make([]byte, 32)}))
+	assert.Equal(t, false, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 1}))
+}
+
+func TestAttestationPreState_FarFutureSlot(t *testing.T) {
+	helpers.ClearCache()
+	db, sc := testDB.SetupDB(t)
+
+	chainService := setupBeaconChain(t, db, sc)
+	chainService.genesisTime = time.Now()
+
+	e := helpers.MaxSlotBuffer/params.BeaconConfig().SlotsPerEpoch + 1
+	_, err := chainService.AttestationCheckPtInfo(context.Background(), &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: e}}})
+	require.ErrorContains(t, "exceeds max allowed value relative to the local clock", err)
+}
+
+func TestAttestationCheckPtInfo_FarFutureSlot(t *testing.T) {
+	helpers.ClearCache()
+	db, sc := testDB.SetupDB(t)
+
+	chainService := setupBeaconChain(t, db, sc)
+	chainService.genesisTime = time.Now()
+
+	e := helpers.MaxSlotBuffer/params.BeaconConfig().SlotsPerEpoch + 1
+	_, err := chainService.AttestationPreState(context.Background(), &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: e}}})
+	require.ErrorContains(t, "exceeds max allowed value relative to the local clock", err)
 }

beacon-chain/blockchain/receive_block.go

@@ -1,100 +1,50 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
-	"encoding/hex"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"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/featureconfig"
 	"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
-	ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error
 	ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error
+	ReceiveBlockBatch(ctx context.Context, blocks []*ethpb.SignedBeaconBlock, blkRoots [][32]byte) error
 	HasInitSyncBlock(root [32]byte) bool
 }
 
-// ReceiveBlock is a function that defines the operations that are preformed on
-// blocks that is received from rpc service. The operations consists of:
-//   1. Gossip block to other peers
-//   2. Validate block, apply state transition and update check points
-//   3. Apply fork choice to the processed block
-//   4. Save latest head info
-func (s *Service) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlock")
-	defer span.End()
-
-	// Broadcast the new block to the network.
-	if err := s.p2p.Broadcast(ctx, block); err != nil {
-		return errors.Wrap(err, "could not broadcast block")
-	}
-	log.WithFields(logrus.Fields{
-		"blockRoot": hex.EncodeToString(blockRoot[:]),
-	}).Debug("Broadcasting block")
-
-	if err := captureSentTimeMetric(uint64(s.genesisTime.Unix()), block.Block.Slot); err != nil {
-		// If a node fails to capture metric, this shouldn't cause the block processing to fail.
-		log.Warnf("Could not capture block sent time metric: %v", err)
-	}
-
-	if err := s.ReceiveBlockNoPubsub(ctx, block, blockRoot); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// ReceiveBlockNoPubsub is a function that defines the the operations (minus pubsub)
-// that are preformed on blocks that is received from regular sync service. The operations consists of:
+// ReceiveBlock is a function that defines the the operations (minus pubsub)
+// that are performed on blocks that is received from regular sync service. The operations consists of:
 //   1. Validate block, apply state transition and update check points
 //   2. Apply fork choice to the processed block
 //   3. Save latest head info
-func (s *Service) ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlockNoPubsub")
+func (s *Service) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
 	blockCopy := stateTrie.CopySignedBeaconBlock(block)
 
 	// Apply state transition on the new block.
-	_, err := s.onBlock(ctx, blockCopy, blockRoot)
-	if err != nil {
+	if err := s.onBlock(ctx, blockCopy, blockRoot); err != nil {
 		err := errors.Wrap(err, "could not process block")
 		traceutil.AnnotateError(span, err)
 		return err
 	}
 
-	// Add attestations from the block to the pool for fork choice.
-	if err := s.attPool.SaveBlockAttestations(blockCopy.Block.Body.Attestations); err != nil {
-		log.Errorf("Could not save attestation for fork choice: %v", err)
-		return nil
-	}
-	for _, exit := range block.Block.Body.VoluntaryExits {
-		s.exitPool.MarkIncluded(exit)
-	}
-
-	s.epochParticipationLock.Lock()
-	defer s.epochParticipationLock.Unlock()
-	s.epochParticipation[helpers.SlotToEpoch(blockCopy.Block.Slot)] = precompute.Balances
-
-	if featureconfig.Get().DisableForkChoice && block.Block.Slot > s.headSlot() {
-		if err := s.saveHead(ctx, blockRoot); err != nil {
-			return errors.Wrap(err, "could not save head")
-		}
-	} else {
-		if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
-			return errors.Wrap(err, "could not save head")
-		}
+	// Update and save head block after fork choice.
+	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
+		log.WithError(err).Warn("Could not update head")
 	}
 
 	// Send notification of the processed block to the state feed.
@@ -107,8 +57,18 @@ func (s *Service) ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.SignedB
 		},
 	})
 
+	// Handle post block operations such as attestations and exits.
+	if err := s.handlePostBlockOperations(blockCopy.Block); err != nil {
+		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)
@@ -122,42 +82,29 @@ func (s *Service) ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.SignedB
 // ReceiveBlockInitialSync processes the input block for the purpose of initial syncing.
 // This method should only be used on blocks during initial syncing phase.
 func (s *Service) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlockNoVerify")
+	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlockNoVerify")
 	defer span.End()
 	blockCopy := stateTrie.CopySignedBeaconBlock(block)
 
-	// Apply state transition on the incoming newly received blockCopy without verifying its BLS contents.
+	// Apply state transition on the new block.
 	if err := s.onBlockInitialSyncStateTransition(ctx, blockCopy, blockRoot); err != nil {
 		err := errors.Wrap(err, "could not process block")
 		traceutil.AnnotateError(span, err)
 		return err
 	}
 
-	cachedHeadRoot, err := s.HeadRoot(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get head root from cache")
-	}
-
-	if !bytes.Equal(blockRoot[:], cachedHeadRoot) {
-		if err := s.saveHeadNoDB(ctx, blockCopy, blockRoot); err != nil {
-			err := errors.Wrap(err, "could not save head")
-			traceutil.AnnotateError(span, err)
-			return err
-		}
-	}
-
 	// Send notification of the processed block to the state feed.
 	s.stateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
 			Slot:      blockCopy.Block.Slot,
 			BlockRoot: blockRoot,
-			Verified:  false,
+			Verified:  true,
 		},
 	})
 
 	// 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{
@@ -166,9 +113,50 @@ func (s *Service) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.Sign
 		"deposits":     len(blockCopy.Block.Body.Deposits),
 	}).Debug("Finished applying state transition")
 
-	s.epochParticipationLock.Lock()
-	defer s.epochParticipationLock.Unlock()
-	s.epochParticipation[helpers.SlotToEpoch(blockCopy.Block.Slot)] = precompute.Balances
+	return nil
+}
+
+// ReceiveBlockBatch processes the whole block batch at once, assuming the block batch is linear ,transitioning
+// the state, performing batch verification of all collected signatures and then performing the appropriate
+// actions for a block post-transition.
+func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []*ethpb.SignedBeaconBlock, blkRoots [][32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlockBatch")
+	defer span.End()
+
+	// Apply state transition on the incoming newly received blockCopy without verifying its BLS contents.
+	fCheckpoints, jCheckpoints, err := s.onBlockBatch(ctx, blocks, blkRoots)
+	if err != nil {
+		err := errors.Wrap(err, "could not process block in batch")
+		traceutil.AnnotateError(span, err)
+		return err
+	}
+
+	for i, b := range blocks {
+		blockCopy := stateTrie.CopySignedBeaconBlock(b)
+		if err = s.handleBlockAfterBatchVerify(ctx, blockCopy, blkRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
+			traceutil.AnnotateError(span, err)
+			return err
+		}
+		// Send notification of the processed block to the state feed.
+		s.stateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.BlockProcessed,
+			Data: &statefeed.BlockProcessedData{
+				Slot:      blockCopy.Block.Slot,
+				BlockRoot: blkRoots[i],
+				Verified:  true,
+			},
+		})
+
+		// Reports on blockCopy and fork choice metrics.
+		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
 }
@@ -177,3 +165,44 @@ func (s *Service) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.Sign
 func (s *Service) HasInitSyncBlock(root [32]byte) bool {
 	return s.hasInitSyncBlock(root)
 }
+
+func (s *Service) handlePostBlockOperations(b *ethpb.BeaconBlock) error {
+	// Delete the processed block attestations from attestation pool.
+	if err := s.deletePoolAtts(b.Body.Attestations); err != nil {
+		return err
+	}
+
+	// Add block attestations to the fork choice pool to compute head.
+	if err := s.attPool.SaveBlockAttestations(b.Body.Attestations); err != nil {
+		log.Errorf("Could not save block attestations for fork choice: %v", err)
+		return nil
+	}
+	// Mark block exits as seen so we don't include same ones in future blocks.
+	for _, e := range b.Body.VoluntaryExits {
+		s.exitPool.MarkIncluded(e)
+	}
+
+	//  Mark attester slashings as seen so we don't include same ones in future blocks.
+	for _, as := range b.Body.AttesterSlashings {
+		s.slashingPool.MarkIncludedAttesterSlashing(as)
+	}
+	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

@@ -0,0 +1,415 @@
+package blockchain
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	blockchainTesting "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+)
+
+func TestService_ReceiveBlock(t *testing.T) {
+	ctx := context.Background()
+
+	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)
+		assert.NoError(t, err)
+		return blk
+	}
+	bc := params.BeaconConfig()
+	bc.ShardCommitteePeriod = 0 // Required for voluntary exits test in reasonable time.
+	params.OverrideBeaconConfig(bc)
+
+	type args struct {
+		block *ethpb.SignedBeaconBlock
+	}
+	tests := []struct {
+		name      string
+		args      args
+		wantedErr string
+		check     func(*testing.T, *Service)
+	}{
+		{
+			name: "applies block with state transition",
+			args: args{
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
+			},
+			check: func(t *testing.T, s *Service) {
+				if hs := s.head.state.Slot(); hs != 2 {
+					t.Errorf("Unexpected state slot. Got %d but wanted %d", hs, 2)
+				}
+				if bs := s.head.block.Block.Slot; bs != 2 {
+					t.Errorf("Unexpected head block slot. Got %d but wanted %d", bs, 2)
+				}
+			},
+		},
+		{
+			name: "saves attestations to pool",
+			args: args{
+				block: genFullBlock(t,
+					&testutil.BlockGenConfig{
+						NumProposerSlashings: 0,
+						NumAttesterSlashings: 0,
+						NumAttestations:      2,
+						NumDeposits:          0,
+						NumVoluntaryExits:    0,
+					},
+					1, /*slot*/
+				),
+			},
+			check: func(t *testing.T, s *Service) {
+				if baCount := len(s.attPool.BlockAttestations()); baCount != 2 {
+					t.Errorf("Did not get the correct number of block attestations saved to the pool. "+
+						"Got %d but wanted %d", baCount, 2)
+				}
+			},
+		},
+
+		{
+			name: "updates exit pool",
+			args: args{
+				block: genFullBlock(t, &testutil.BlockGenConfig{
+					NumProposerSlashings: 0,
+					NumAttesterSlashings: 0,
+					NumAttestations:      0,
+					NumDeposits:          0,
+					NumVoluntaryExits:    3,
+				},
+					1, /*slot*/
+				),
+			},
+			check: func(t *testing.T, s *Service) {
+				var n int
+				for i := uint64(0); int(i) < genesis.NumValidators(); i++ {
+					if s.exitPool.HasBeenIncluded(i) {
+						n++
+					}
+				}
+				if n != 3 {
+					t.Errorf("Did not mark the correct number of exits. Got %d but wanted %d", n, 3)
+				}
+			},
+		},
+		{
+			name: "notifies block processed on state feed",
+			args: args{
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
+			},
+			check: func(t *testing.T, s *Service) {
+				if recvd := len(s.stateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db, stateSummaryCache := testDB.SetupDB(t)
+			genesisBlockRoot := bytesutil.ToBytes32(nil)
+			require.NoError(t, db.SaveState(ctx, genesis, genesisBlockRoot))
+
+			cfg := &Config{
+				BeaconDB: db,
+				ForkChoiceStore: protoarray.New(
+					0, // justifiedEpoch
+					0, // finalizedEpoch
+					genesisBlockRoot,
+				),
+				AttPool:       attestations.NewPool(),
+				ExitPool:      voluntaryexits.NewPool(),
+				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+				StateGen:      stategen.New(db, stateSummaryCache),
+			}
+			s, err := NewService(ctx, cfg)
+			require.NoError(t, err)
+			require.NoError(t, s.saveGenesisData(ctx, genesis))
+			gBlk, err := s.beaconDB.GenesisBlock(ctx)
+			require.NoError(t, err)
+			gRoot, err := gBlk.Block.HashTreeRoot()
+			require.NoError(t, err)
+			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)
+			}
+		})
+	}
+}
+
+func TestService_ReceiveBlockUpdateHead(t *testing.T) {
+	ctx := context.Background()
+	genesis, keys := testutil.DeterministicGenesisState(t, 64)
+	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
+	assert.NoError(t, err)
+	db, stateSummaryCache := testDB.SetupDB(t)
+	genesisBlockRoot := bytesutil.ToBytes32(nil)
+	require.NoError(t, db.SaveState(ctx, genesis, genesisBlockRoot))
+	cfg := &Config{
+		BeaconDB: db,
+		ForkChoiceStore: protoarray.New(
+			0, // justifiedEpoch
+			0, // finalizedEpoch
+			genesisBlockRoot,
+		),
+		AttPool:       attestations.NewPool(),
+		ExitPool:      voluntaryexits.NewPool(),
+		StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+		StateGen:      stategen.New(db, stateSummaryCache),
+	}
+	s, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+	require.NoError(t, s.saveGenesisData(ctx, genesis))
+	gBlk, err := s.beaconDB.GenesisBlock(ctx)
+	require.NoError(t, err)
+	gRoot, err := gBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	root, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		require.NoError(t, s.ReceiveBlock(ctx, b, root))
+		wg.Done()
+	}()
+	wg.Wait()
+	if recvd := len(s.stateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+		t.Errorf("Received %d state notifications, expected at least 1", recvd)
+	}
+	// Verify fork choice has processed the block. (Genesis block and the new block)
+	assert.Equal(t, 2, len(s.forkChoiceStore.Nodes()))
+}
+
+func TestService_ReceiveBlockInitialSync(t *testing.T) {
+	ctx := context.Background()
+
+	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)
+		assert.NoError(t, err)
+		return blk
+	}
+
+	type args struct {
+		block *ethpb.SignedBeaconBlock
+	}
+	tests := []struct {
+		name      string
+		args      args
+		wantedErr string
+		check     func(*testing.T, *Service)
+	}{
+		{
+			name: "applies block with state transition",
+			args: args{
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
+			},
+			check: func(t *testing.T, s *Service) {
+				assert.Equal(t, uint64(2), s.head.state.Slot(), "Incorrect head state slot")
+				assert.Equal(t, uint64(2), s.head.block.Block.Slot, "Incorrect head block slot")
+			},
+		},
+		{
+			name: "notifies block processed on state feed",
+			args: args{
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
+			},
+			check: func(t *testing.T, s *Service) {
+				if recvd := len(s.stateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db, stateSummaryCache := testDB.SetupDB(t)
+			genesisBlockRoot := bytesutil.ToBytes32(nil)
+
+			cfg := &Config{
+				BeaconDB: db,
+				ForkChoiceStore: protoarray.New(
+					0, // justifiedEpoch
+					0, // finalizedEpoch
+					genesisBlockRoot,
+				),
+				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+				StateGen:      stategen.New(db, stateSummaryCache),
+			}
+			s, err := NewService(ctx, cfg)
+			require.NoError(t, err)
+			err = s.saveGenesisData(ctx, genesis)
+			require.NoError(t, err)
+			gBlk, err := s.beaconDB.GenesisBlock(ctx)
+			require.NoError(t, err)
+
+			gRoot, err := gBlk.Block.HashTreeRoot()
+			require.NoError(t, err)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			root, err := tt.args.block.Block.HashTreeRoot()
+			require.NoError(t, err)
+
+			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)
+			}
+		})
+	}
+}
+
+func TestService_ReceiveBlockBatch(t *testing.T) {
+	ctx := context.Background()
+
+	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)
+		assert.NoError(t, err)
+		return blk
+	}
+
+	type args struct {
+		block *ethpb.SignedBeaconBlock
+	}
+	tests := []struct {
+		name      string
+		args      args
+		wantedErr string
+		check     func(*testing.T, *Service)
+	}{
+		{
+			name: "applies block with state transition",
+			args: args{
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
+			},
+			check: func(t *testing.T, s *Service) {
+				assert.Equal(t, uint64(2), s.head.state.Slot(), "Incorrect head state slot")
+				assert.Equal(t, uint64(2), s.head.block.Block.Slot, "Incorrect head block slot")
+			},
+		},
+		{
+			name: "notifies block processed on state feed",
+			args: args{
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
+			},
+			check: func(t *testing.T, s *Service) {
+				if recvd := len(s.stateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db, stateSummaryCache := testDB.SetupDB(t)
+			genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			cfg := &Config{
+				BeaconDB: db,
+				ForkChoiceStore: protoarray.New(
+					0, // justifiedEpoch
+					0, // finalizedEpoch
+					genesisBlockRoot,
+				),
+				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+				StateGen:      stategen.New(db, stateSummaryCache),
+			}
+			s, err := NewService(ctx, cfg)
+			require.NoError(t, err)
+			err = s.saveGenesisData(ctx, genesis)
+			require.NoError(t, err)
+			gBlk, err := s.beaconDB.GenesisBlock(ctx)
+			require.NoError(t, err)
+
+			gRoot, err := gBlk.Block.HashTreeRoot()
+			require.NoError(t, err)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			root, err := tt.args.block.Block.HashTreeRoot()
+			require.NoError(t, err)
+			blks := []*ethpb.SignedBeaconBlock{tt.args.block}
+			roots := [][32]byte{root}
+			err = s.ReceiveBlockBatch(ctx, blks, roots)
+			if tt.wantedErr != "" {
+				assert.ErrorContains(t, tt.wantedErr, err)
+			} else {
+				assert.NoError(t, err)
+				tt.check(t, s)
+			}
+		})
+	}
+}
+
+func TestService_HasInitSyncBlock(t *testing.T) {
+	s, err := NewService(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
+	require.NoError(t, err)
+	r := [32]byte{'a'}
+	if s.HasInitSyncBlock(r) {
+		t.Error("Should not have block")
+	}
+	s.saveInitSyncBlock(r, testutil.NewBeaconBlock())
+	if !s.HasInitSyncBlock(r) {
+		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

@@ -15,13 +15,11 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	"github.com/prysmaticlabs/prysm/beacon-chain/flags"
 	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
@@ -32,10 +30,8 @@ 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/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/slotutil"
 	"go.opencensus.io/trace"
@@ -44,44 +40,42 @@ import (
 // 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               int64
-	head                      *head
-	headLock                  sync.RWMutex
-	stateNotifier             statefeed.Notifier
-	genesisRoot               [32]byte
-	epochParticipation        map[uint64]*precompute.Balance
-	epochParticipationLock    sync.RWMutex
-	forkChoiceStore           f.ForkChoicer
-	justifiedCheckpt          *ethpb.Checkpoint
-	prevJustifiedCheckpt      *ethpb.Checkpoint
-	bestJustifiedCheckpt      *ethpb.Checkpoint
-	finalizedCheckpt          *ethpb.Checkpoint
-	prevFinalizedCheckpt      *ethpb.Checkpoint
-	nextEpochBoundarySlot     uint64
-	voteLock                  sync.RWMutex
-	initSyncState             map[[32]byte]*stateTrie.BeaconState
-	boundaryRoots             [][32]byte
-	initSyncStateLock         sync.RWMutex
-	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
+	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
+	justifiedBalances     []uint64
+	justifiedBalancesLock sync.RWMutex
+	checkPtInfoCache      *checkPtInfoCache
+	wsEpoch               uint64
+	wsRoot                []byte
+	wsVerified            bool
 }
 
 // Config options for the service.
@@ -94,11 +88,13 @@ type Config struct {
 	ExitPool          *voluntaryexits.Pool
 	SlashingPool      *slashings.Pool
 	P2p               p2p.Broadcaster
-	MaxRoutines       int64
+	MaxRoutines       int
 	StateNotifier     statefeed.Notifier
 	ForkChoiceStore   f.ForkChoicer
 	OpsService        *attestations.Service
 	StateGen          *stategen.State
+	WspBlockRoot      []byte
+	WspEpoch          uint64
 }
 
 // NewService instantiates a new block service instance that will
@@ -106,34 +102,34 @@ 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,
-		epochParticipation:    make(map[uint64]*precompute.Balance),
-		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,
+		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),
+		justifiedBalances: make([]uint64, 0),
+		checkPtInfoCache:  newCheckPointInfoCache(),
+		wsEpoch:           cfg.WspEpoch,
+		wsRoot:            cfg.WspBlockRoot,
 	}, nil
 }
 
 // Start a blockchain service's main event loop.
 func (s *Service) Start() {
-	ctx := context.TODO()
-	beaconState, err := s.beaconDB.HeadState(ctx)
+	beaconState, err := s.beaconDB.HeadState(s.ctx)
 	if err != nil {
 		log.Fatalf("Could not fetch beacon state: %v", err)
 	}
@@ -141,23 +137,32 @@ func (s *Service) Start() {
 	// 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.
-	cp, err := s.beaconDB.FinalizedCheckpoint(ctx)
+	cp, err := s.beaconDB.FinalizedCheckpoint(s.ctx)
 	if err != nil {
 		log.Fatalf("Could not fetch finalized cp: %v", err)
 	}
 
 	if beaconState == nil {
-		if featureconfig.Get().NewStateMgmt {
-			beaconState, err = s.stateGen.StateByRoot(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)
 			}
-		} else {
-			beaconState, err = s.beaconDB.State(ctx, bytesutil.ToBytes32(cp.Root))
-			if err != nil {
-				log.Fatalf("Could not fetch beacon state: %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.
@@ -168,25 +173,29 @@ func (s *Service) Start() {
 		log.Info("Blockchain data already exists in DB, initializing...")
 		s.genesisTime = time.Unix(int64(beaconState.GenesisTime()), 0)
 		s.opsService.SetGenesisTime(beaconState.GenesisTime())
-		if err := s.initializeChainInfo(ctx); err != nil {
+		if err := s.initializeChainInfo(s.ctx); err != nil {
 			log.Fatalf("Could not set up chain info: %v", err)
 		}
 
 		// We start a counter to genesis, if needed.
-		go slotutil.CountdownToGenesis(ctx, s.genesisTime, uint64(beaconState.NumValidators()))
+		gState, err := s.beaconDB.GenesisState(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not retrieve genesis state: %v", err)
+		}
+		go slotutil.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()))
 
-		justifiedCheckpoint, err := s.beaconDB.JustifiedCheckpoint(ctx)
+		justifiedCheckpoint, err := s.beaconDB.JustifiedCheckpoint(s.ctx)
 		if err != nil {
 			log.Fatalf("Could not get justified checkpoint: %v", err)
 		}
-		finalizedCheckpoint, err := s.beaconDB.FinalizedCheckpoint(ctx)
+		finalizedCheckpoint, err := s.beaconDB.FinalizedCheckpoint(s.ctx)
 		if err != nil {
 			log.Fatalf("Could not get finalized checkpoint: %v", err)
 		}
 
 		// Resume fork choice.
 		s.justifiedCheckpt = stateTrie.CopyCheckpoint(justifiedCheckpoint)
-		if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+		if err := s.cacheJustifiedStateBalances(s.ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))); err != nil {
 			log.Fatalf("Could not cache justified state balances: %v", err)
 		}
 		s.prevJustifiedCheckpt = stateTrie.CopyCheckpoint(justifiedCheckpoint)
@@ -195,12 +204,9 @@ func (s *Service) Start() {
 		s.prevFinalizedCheckpt = stateTrie.CopyCheckpoint(finalizedCheckpoint)
 		s.resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint)
 
-		if !featureconfig.Get().NewStateMgmt {
-			if finalizedCheckpoint.Epoch > 1 {
-				if err := s.pruneGarbageState(ctx, helpers.StartSlot(finalizedCheckpoint.Epoch)-params.BeaconConfig().SlotsPerEpoch); err != nil {
-					log.WithError(err).Warn("Could not prune old states")
-				}
-			}
+		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{
@@ -231,7 +237,7 @@ func (s *Service) Start() {
 							return
 						}
 						log.WithField("starttime", data.StartTime).Debug("Received chain start event")
-						s.processChainStartTime(ctx, data.StartTime)
+						s.processChainStartTime(s.ctx, data.StartTime)
 						return
 					}
 				case <-s.ctx.Done():
@@ -278,7 +284,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())
@@ -313,13 +319,21 @@ func (s *Service) initializeBeaconChain(
 // Stop the blockchain service's main event loop and associated goroutines.
 func (s *Service) Stop() error {
 	defer s.cancel()
-	return nil
+
+	if s.stateGen != nil && s.head != nil && s.head.state != nil {
+		if err := s.stateGen.ForceCheckpoint(s.ctx, s.head.state.FinalizedCheckpoint().Root); err != nil {
+			return err
+		}
+	}
+
+	// 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
 // this service to be unhealthy.
 func (s *Service) Status() error {
-	if runtime.NumGoroutine() > int(s.maxRoutines) {
+	if runtime.NumGoroutine() > s.maxRoutines {
 		return fmt.Errorf("too many goroutines %d", runtime.NumGoroutine())
 	}
 	return nil
@@ -338,7 +352,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")
 	}
@@ -347,26 +361,23 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState *stateTrie.B
 	if err := s.beaconDB.SaveBlock(ctx, genesisBlk); err != nil {
 		return errors.Wrap(err, "could not save genesis block")
 	}
-	if featureconfig.Get().NewStateMgmt {
-		if err := s.stateGen.SaveState(ctx, genesisBlkRoot, genesisState); err != nil {
-			return errors.Wrap(err, "could not save genesis state")
-		}
-		if err := s.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{
-			Slot: 0,
-			Root: genesisBlkRoot[:],
-		}); err != nil {
-			return err
-		}
-	} else {
-		if err := s.beaconDB.SaveState(ctx, genesisState, genesisBlkRoot); err != nil {
-			return errors.Wrap(err, "could not save genesis state")
-		}
+	if err := s.beaconDB.SaveState(ctx, genesisState, genesisBlkRoot); err != nil {
+		return errors.Wrap(err, "could not save genesis state")
 	}
+	if err := s.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{
+		Slot: 0,
+		Root: genesisBlkRoot[:],
+	}); err != nil {
+		return err
+	}
+
+	s.stateGen.SaveFinalizedState(0, genesisBlkRoot, genesisState)
+
 	if err := s.beaconDB.SaveHeadBlockRoot(ctx, genesisBlkRoot); err != nil {
 		return errors.Wrap(err, "could not save head block root")
 	}
 	if err := s.beaconDB.SaveGenesisBlockRoot(ctx, genesisBlkRoot); err != nil {
-		return errors.Wrap(err, "could save genesis block root")
+		return errors.Wrap(err, "could not save genesis block root")
 	}
 
 	// Finalized checkpoint at genesis is a zero hash.
@@ -405,22 +416,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")
 		}
@@ -437,46 +454,19 @@ 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
 
-	if featureconfig.Get().NewStateMgmt {
-		finalizedState, err = s.stateGen.Resume(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not get finalized state from db")
-		}
-		if !featureconfig.Get().SkipRegenHistoricalStates {
-			// Since historical states were skipped, the node should start from last finalized check point.
-			finalizedRoot = s.beaconDB.LastArchivedIndexRoot(ctx)
-			if finalizedRoot == params.BeaconConfig().ZeroHash {
-				finalizedRoot = bytesutil.ToBytes32(finalized.Root)
-			}
-		}
-	} else {
-		finalizedState, err = s.beaconDB.State(ctx, bytesutil.ToBytes32(finalized.Root))
-		if err != nil {
-			return errors.Wrap(err, "could not get finalized state from db")
-		}
+	finalizedState, err = s.stateGen.Resume(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized state from db")
 	}
+
 	finalizedBlock, err := s.beaconDB.Block(ctx, finalizedRoot)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized block from db")
 	}
 
-	// To skip the regeneration of historical state, the node has to generate the parent of the last finalized state.
-	// We don't need to do this for genesis.
-	atGenesis := s.CurrentSlot() == 0
-	if featureconfig.Get().NewStateMgmt && featureconfig.Get().SkipRegenHistoricalStates && !atGenesis {
-		parentRoot := bytesutil.ToBytes32(finalizedBlock.Block.ParentRoot)
-		parentState, err := s.generateState(ctx, finalizedRoot, parentRoot)
-		if err != nil {
-			return err
-		}
-		if s.beaconDB.SaveState(ctx, parentState, parentRoot) != nil {
-			return err
-		}
-	}
-
 	if finalizedState == nil || finalizedBlock == nil {
 		return errors.New("finalized state and block can't be nil")
 	}
@@ -485,32 +475,9 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 	return nil
 }
 
-// This is called when a client starts from a non-genesis slot. It deletes the states in DB
-// from slot 1 (avoid genesis state) to `slot`.
-func (s *Service) pruneGarbageState(ctx context.Context, slot uint64) error {
-	if featureconfig.Get().DontPruneStateStartUp {
-		return nil
-	}
-
-	filter := filters.NewFilter().SetStartSlot(1).SetEndSlot(slot)
-	roots, err := s.beaconDB.BlockRoots(ctx, filter)
-	if err != nil {
-		return err
-	}
-	if err := s.beaconDB.DeleteStates(ctx, roots); err != nil {
-		return err
-	}
-
-	if err := s.beaconDB.SaveLastArchivedIndex(ctx, 0); err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // 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_norace_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"github.com/sirupsen/logrus"
 )
 
@@ -15,16 +16,12 @@ func init() {
 }
 
 func TestChainService_SaveHead_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, _ := testDB.SetupDB(t)
 	s := &Service{
 		beaconDB: db,
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	if err := s.saveHead(context.Background(), [32]byte{}); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 }

beacon-chain/blockchain/service_test.go

@@ -11,16 +11,12 @@ 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"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
-	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
@@ -28,13 +24,14 @@ 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"
 	"github.com/prysmaticlabs/prysm/shared/event"
 	"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"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
@@ -70,9 +67,9 @@ 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) *Service {
+func setupBeaconChain(t *testing.T, beaconDB db.Database, sc *cache.StateSummaryCache) *Service {
 	endpoint := "http://127.0.0.1"
 	ctx := context.Background()
 	var web3Service *powchain.Service
@@ -93,435 +90,331 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		},
 		DepositContainers: []*protodb.DepositContainer{},
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	web3Service, err = powchain.NewService(ctx, &powchain.Web3ServiceConfig{
 		BeaconDB:        beaconDB,
 		HTTPEndPoint:    endpoint,
 		DepositContract: common.Address{},
 	})
-	if err != nil {
-		t.Fatalf("unable to set up web3 service: %v", err)
-	}
+	require.NoError(t, err, "Unable to set up web3 service")
 
 	opsService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
+
+	depositCache, err := depositcache.New()
+	require.NoError(t, err)
+
 	cfg := &Config{
 		BeaconBlockBuf:    0,
 		BeaconDB:          beaconDB,
-		DepositCache:      depositcache.NewDepositCache(),
+		DepositCache:      depositCache,
 		ChainStartFetcher: web3Service,
 		P2p:               &mockBroadcaster{},
 		StateNotifier:     &mockBeaconNode{},
 		AttPool:           attestations.NewPool(),
-		StateGen:          stategen.New(beaconDB, cache.NewStateSummaryCache()),
+		StateGen:          stategen.New(beaconDB, sc),
 		ForkChoiceStore:   protoarray.New(0, 0, params.BeaconConfig().ZeroHash),
 		OpsService:        opsService,
 	}
 
+	// Safe a state in stategen to purposes of testing a service stop / shutdown.
+	require.NoError(t, cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
+
 	chainService, err := NewService(ctx, cfg)
-	if err != nil {
-		t.Fatalf("unable to setup chain service: %v", err)
-	}
+	require.NoError(t, err, "Unable to setup chain service")
 	chainService.genesisTime = time.Unix(1, 0) // non-zero time
 
 	return chainService
 }
 
-func TestChainStartStop_Uninitialized(t *testing.T) {
-	hook := logTest.NewGlobal()
-	db := testDB.SetupDB(t)
-	chainService := setupBeaconChain(t, db)
-
-	// Listen for state events.
-	stateSubChannel := make(chan *feed.Event, 1)
-	stateSub := chainService.stateNotifier.StateFeed().Subscribe(stateSubChannel)
-
-	// Test the chain start state notifier.
-	genesisTime := time.Unix(1, 0)
-	chainService.Start()
-	event := &feed.Event{
-		Type: statefeed.ChainStarted,
-		Data: &statefeed.ChainStartedData{
-			StartTime: genesisTime,
-		},
-	}
-	// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
-	for sent := 1; sent == 1; {
-		sent = chainService.stateNotifier.StateFeed().Send(event)
-		if sent == 1 {
-			// Flush our local subscriber.
-			<-stateSubChannel
-		}
-	}
-
-	// Now wait for notification the state is ready.
-	for stateInitialized := false; stateInitialized == false; {
-		recv := <-stateSubChannel
-		if recv.Type == statefeed.Initialized {
-			stateInitialized = true
-		}
-	}
-	stateSub.Unsubscribe()
-
-	beaconState, err := db.HeadState(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if beaconState == nil || beaconState.Slot() != 0 {
-		t.Error("Expected canonical state feed to send a state with genesis block")
-	}
-	if err := chainService.Stop(); err != nil {
-		t.Fatalf("Unable to stop chain service: %v", err)
-	}
-	// The context should have been canceled.
-	if chainService.ctx.Err() != context.Canceled {
-		t.Error("Context was not canceled")
-	}
-	testutil.AssertLogsContain(t, hook, "Waiting")
-	testutil.AssertLogsContain(t, hook, "Initialized beacon chain genesis state")
-}
-
 func TestChainStartStop_Initialized(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 
-	chainService := setupBeaconChain(t, db)
+	chainService := setupBeaconChain(t, db, sc)
 
 	genesisBlk := testutil.NewBeaconBlock()
-	blkRoot, err := stateutil.BlockRoot(genesisBlk.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveBlock(ctx, genesisBlk); err != nil {
-		t.Fatal(err)
-	}
+	blkRoot, err := genesisBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, genesisBlk))
 	s := testutil.NewBeaconState()
-	if err := s.SetSlot(1); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, s, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveHeadBlockRoot(ctx, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveGenesisBlockRoot(ctx, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, s.SetSlot(1))
+	require.NoError(t, db.SaveState(ctx, s, blkRoot))
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot))
+	require.NoError(t, db.SaveGenesisBlockRoot(ctx, blkRoot))
+	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	require.NoError(t, db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
 
 	// Test the start function.
 	chainService.Start()
 
-	if err := chainService.Stop(); err != nil {
-		t.Fatalf("unable to stop chain service: %v", err)
-	}
+	require.NoError(t, chainService.Stop(), "Unable to stop chain service")
 
 	// The context should have been canceled.
-	if chainService.ctx.Err() != context.Canceled {
-		t.Error("context was not canceled")
-	}
-	testutil.AssertLogsContain(t, hook, "data already exists")
+	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()
+
+	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 TestChainService_InitializeBeaconChain(t *testing.T) {
 	helpers.ClearCache()
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	bc := setupBeaconChain(t, db)
+	bc := setupBeaconChain(t, db, sc)
 	var err error
 
 	// Set up 10 deposits pre chain start for validators to register
 	count := uint64(10)
 	deposits, _, err := testutil.DeterministicDepositsAndKeys(count)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	trie, _, err := testutil.DepositTrieFromDeposits(deposits)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	hashTreeRoot := trie.HashTreeRoot()
 	genState, err := state.EmptyGenesisState()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	err = genState.SetEth1Data(&ethpb.Eth1Data{
 		DepositRoot:  hashTreeRoot[:],
 		DepositCount: uint64(len(deposits)),
+		BlockHash:    make([]byte, 32),
 	})
-	for _, deposit := range deposits {
-		genState, err = b.ProcessPreGenesisDeposit(ctx, genState, deposit)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
+	require.NoError(t, err)
+	genState, err = b.ProcessPreGenesisDeposits(ctx, genState, deposits)
+	require.NoError(t, err)
 
-	if _, err := bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{
-		DepositRoot: hashTreeRoot[:],
-	}); err != nil {
-		t.Fatal(err)
-	}
+	_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:], BlockHash: make([]byte, 32)})
+	require.NoError(t, err)
 
-	if _, err := bc.HeadState(ctx); err != nil {
-		t.Error(err)
-	}
+	_, err = bc.HeadState(ctx)
+	assert.NoError(t, err)
 	headBlk, err := bc.HeadBlock(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	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")
 	}
 }
 
+func TestChainService_CorrectGenesisRoots(t *testing.T) {
+	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, s.SetSlot(0))
+	require.NoError(t, db.SaveState(ctx, s, blkRoot))
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot))
+	require.NoError(t, db.SaveGenesisBlockRoot(ctx, blkRoot))
+	require.NoError(t, db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+
+	// Test the start function.
+	chainService.Start()
+
+	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")
+
+}
+
 func TestChainService_InitializeChainInfo(t *testing.T) {
-	db := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 	ctx := context.Background()
 
 	genesis := testutil.NewBeaconBlock()
-	genesisRoot, err := stateutil.BlockRoot(genesis.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveGenesisBlockRoot(ctx, genesisRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveBlock(ctx, genesis); err != nil {
-		t.Fatal(err)
-	}
+	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()
-	if err := headState.SetSlot(finalizedSlot); err != nil {
-		t.Fatal(err)
-	}
-	if err := headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]); err != nil {
-		t.Fatal(err)
-	}
-	headRoot, err := stateutil.BlockRoot(headBlock.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, headState, headRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, headState, genesisRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveBlock(ctx, headBlock); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
-		Epoch: helpers.SlotToEpoch(finalizedSlot),
-		Root:  headRoot[:],
-	}); err != nil {
-		t.Fatal(err)
-	}
-	c := &Service{beaconDB: db, stateGen: stategen.New(db, cache.NewStateSummaryCache())}
-	if err := c.initializeChainInfo(ctx); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, headState.SetSlot(finalizedSlot))
+	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	headRoot, err := headBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, db.SaveState(ctx, headState, headRoot))
+	require.NoError(t, db.SaveState(ctx, headState, genesisRoot))
+	require.NoError(t, db.SaveBlock(ctx, headBlock))
+	require.NoError(t, db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: helpers.SlotToEpoch(finalizedSlot), Root: headRoot[:]}))
+	c := &Service{beaconDB: db, stateGen: stategen.New(db, sc)}
+	require.NoError(t, c.initializeChainInfo(ctx))
 	headBlk, err := c.HeadBlock(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(headBlk, headBlock) {
-		t.Error("head block incorrect")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, headBlock, headBlk, "Head block incorrect")
 	s, err := c.HeadState(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(s.InnerStateUnsafe(), headState.InnerStateUnsafe()) {
-		t.Error("head state incorrect")
-	}
-	if headBlock.Block.Slot != c.HeadSlot() {
-		t.Error("head slot incorrect")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
+	assert.Equal(t, c.HeadSlot(), headBlock.Block.Slot, "Head slot incorrect")
 	r, err := c.HeadRoot(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	if !bytes.Equal(headRoot[:], r) {
 		t.Error("head slot incorrect")
 	}
-	if c.genesisRoot != genesisRoot {
-		t.Error("genesis block root incorrect")
-	}
+	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 := testDB.SetupDB(t)
+	db, sc := testDB.SetupDB(t)
 	ctx := context.Background()
 	s := &Service{
 		beaconDB: db,
-		stateGen: stategen.New(db, cache.NewStateSummaryCache()),
-	}
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
-	r, err := ssz.HashTreeRoot(b)
-	if err != nil {
-		t.Fatal(err)
+		stateGen: stategen.New(db, sc),
 	}
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 1
+	r, err := b.HashTreeRoot()
+	require.NoError(t, err)
 	newState := testutil.NewBeaconState()
-	if err := s.stateGen.SaveState(ctx, r, newState); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := s.saveHeadNoDB(ctx, b, r); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, s.stateGen.SaveState(ctx, r, newState))
+	require.NoError(t, s.saveHeadNoDB(ctx, b, r, newState))
 
 	newB, err := s.beaconDB.HeadBlock(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	if reflect.DeepEqual(newB, b) {
 		t.Error("head block should not be equal")
 	}
 }
 
-func TestChainService_PruneOldStates(t *testing.T) {
-	db := testDB.SetupDB(t)
-	ctx := context.Background()
-	s := &Service{
-		beaconDB: db,
-	}
-
-	for i := 0; i < 100; i++ {
-		block := &ethpb.BeaconBlock{Slot: uint64(i)}
-		if err := s.beaconDB.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: block}); err != nil {
-			t.Fatal(err)
-		}
-		r, err := stateutil.BlockRoot(block)
-		if err != nil {
-			t.Fatal(err)
-		}
-		newState := testutil.NewBeaconState()
-		if err := newState.SetSlot(uint64(i)); err != nil {
-			t.Fatal(err)
-		}
-		if err := s.beaconDB.SaveState(ctx, newState, r); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	// Delete half of the states.
-	if err := s.pruneGarbageState(ctx, 50); err != nil {
-		t.Fatal(err)
-	}
-
-	filter := filters.NewFilter().SetStartSlot(1).SetEndSlot(100)
-	roots, err := s.beaconDB.BlockRoots(ctx, filter)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i := 1; i < 50; i++ {
-		s, err := s.beaconDB.State(ctx, roots[i])
-		if err != nil {
-			t.Fatal(err)
-		}
-		if s != nil {
-			t.Errorf("wanted nil for slot %d", i)
-		}
-	}
-}
-
 func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
 	ctx := context.Background()
-	db := testDB.SetupDB(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)
-	if err != nil {
-		t.Fatal(err)
-	}
-	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
-	state, err := beaconstate.InitializeFromProto(bs)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := s.insertBlockToForkChoiceStore(ctx, block.Block, r, state); err != nil {
-		t.Fatal(err)
-	}
+	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))
 
-	if s.hasBlock(ctx, [32]byte{}) {
-		t.Error("Should not have block")
-	}
+	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
+	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
+}
 
-	if !s.hasBlock(ctx, r) {
-		t.Error("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)
+	db, _ := testDB.SetupDB(b)
 	ctx := context.Background()
 	s := &Service{
 		beaconDB: db,
 	}
-	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
-	if err := s.beaconDB.SaveBlock(ctx, block); err != nil {
-		b.Fatal(err)
-	}
-	r, err := stateutil.BlockRoot(block.Block)
-	if err != nil {
-		b.Fatal(err)
-	}
+	block := testutil.NewBeaconBlock()
+	require.NoError(b, s.beaconDB.SaveBlock(ctx, block))
+	r, err := block.Block.HashTreeRoot()
+	require.NoError(b, err)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		if !s.beaconDB.HasBlock(ctx, r) {
-			b.Fatal("Block is not in DB")
-		}
+		require.Equal(b, true, s.beaconDB.HasBlock(ctx, r), "Block is not in DB")
 	}
 }
 
 func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
 	ctx := context.Background()
-	db := testDB.SetupDB(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)
-	if err != nil {
-		b.Fatal(err)
-	}
-	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
+	r, err := block.Block.HashTreeRoot()
+	require.NoError(b, err)
+	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	state, err := beaconstate.InitializeFromProto(bs)
-	if err != nil {
-		b.Fatal(err)
-	}
-	if err := s.insertBlockToForkChoiceStore(ctx, block.Block, r, state); err != nil {
-		b.Fatal(err)
-	}
+	require.NoError(b, err)
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		if !s.forkChoiceStore.HasNode(r) {
-			b.Fatal("Block is not in fork choice store")
-		}
+		require.Equal(b, true, s.forkChoiceStore.HasNode(r), "Block is not in fork choice store")
 	}
 }

beacon-chain/blockchain/testing/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
     ],
     deps = [
         "//beacon-chain/core/epoch/precompute:go_default_library",
+        "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
@@ -18,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

@@ -5,11 +5,13 @@ package testing
 import (
 	"bytes"
 	"context"
+	"sync"
 	"time"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/block"
 	opfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
@@ -17,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"
@@ -36,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
@@ -44,6 +47,7 @@ type ChainService struct {
 	opNotifier                  opfeed.Notifier
 	ValidAttestation            bool
 	ForkChoiceStore             *protoarray.Store
+	VerifyBlkDescendantErr      error
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -77,13 +81,45 @@ 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
+	recvCh   chan *feed.Event
+
+	RecordEvents bool
+}
+
+// ReceivedEvents returns the events received by the state feed in this mock.
+func (msn *MockStateNotifier) ReceivedEvents() []*feed.Event {
+	msn.recvLock.Lock()
+	defer msn.recvLock.Unlock()
+	return msn.recv
 }
 
 // StateFeed returns a state feed.
 func (msn *MockStateNotifier) StateFeed() *event.Feed {
-	if msn.feed == nil {
+	msn.feedLock.Lock()
+	defer msn.feedLock.Unlock()
+
+	if msn.feed == nil && msn.recvCh == nil {
 		msn.feed = new(event.Feed)
+		if msn.RecordEvents {
+			msn.recvCh = make(chan *feed.Event)
+			sub := msn.feed.Subscribe(msn.recvCh)
+
+			go func() {
+				select {
+				case evt := <-msn.recvCh:
+					msn.recvLock.Lock()
+					msn.recv = append(msn.recv, evt)
+					msn.recvLock.Unlock()
+				case <-sub.Err():
+					sub.Unsubscribe()
+				}
+			}()
+		}
 	}
 	return msn.feed
 }
@@ -109,13 +145,8 @@ func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
 	return mon.feed
 }
 
-// ReceiveBlock mocks ReceiveBlock method in chain service.
-func (ms *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
-	return nil
-}
-
 // 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{}
 	}
@@ -126,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
 	}
@@ -141,8 +172,37 @@ func (ms *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethp
 	return nil
 }
 
-// ReceiveBlockNoPubsub mocks ReceiveBlockNoPubsub method in chain service.
-func (ms *ChainService) ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
+// ReceiveBlockBatch processes blocks in batches from initial-sync.
+func (ms *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock, _ [][32]byte) error {
+	if ms.State == nil {
+		ms.State = &stateTrie.BeaconState{}
+	}
+	for _, block := range blks {
+		if !bytes.Equal(ms.Root, block.Block.ParentRoot) {
+			return errors.Errorf("wanted %#x but got %#x", ms.Root, block.Block.ParentRoot)
+		}
+		if err := ms.State.SetSlot(block.Block.Slot); err != nil {
+			return err
+		}
+		ms.BlocksReceived = append(ms.BlocksReceived, block)
+		signingRoot, err := block.Block.HashTreeRoot()
+		if err != nil {
+			return err
+		}
+		if ms.DB != nil {
+			if err := ms.DB.SaveBlock(ctx, block); err != nil {
+				return err
+			}
+			logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block.Slot)
+		}
+		ms.Root = signingRoot[:]
+		ms.Block = block
+	}
+	return nil
+}
+
+// ReceiveBlock mocks ReceiveBlock method in chain service.
+func (ms *ChainService) ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock, _ [32]byte) error {
 	if ms.State == nil {
 		ms.State = &stateTrie.BeaconState{}
 	}
@@ -153,7 +213,7 @@ func (ms *ChainService) ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.S
 		return err
 	}
 	ms.BlocksReceived = append(ms.BlocksReceived, block)
-	signingRoot, err := stateutil.BlockRoot(block.Block)
+	signingRoot, err := block.Block.HashTreeRoot()
 	if err != nil {
 		return err
 	}
@@ -177,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.
@@ -213,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
 }
 
@@ -223,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(epoch uint64) ([]uint64, error) {
+func (ms *ChainService) HeadValidatorsIndices(_ context.Context, epoch uint64) ([]uint64, error) {
 	if ms.State == nil {
 		return []uint64{}, nil
 	}
@@ -236,7 +298,7 @@ func (ms *ChainService) HeadValidatorsIndices(epoch uint64) ([]uint64, error) {
 }
 
 // HeadSeed mocks the same method in the chain service.
-func (ms *ChainService) HeadSeed(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)
 }
 
@@ -266,18 +328,22 @@ 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
 }
 
@@ -285,7 +351,7 @@ func (ms *ChainService) IsCanonical(ctx context.Context, blockRoot [32]byte) (bo
 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
 }
 
@@ -293,3 +359,54 @@ func (ms *ChainService) HasInitSyncBlock(root [32]byte) bool {
 func (ms *ChainService) HeadGenesisValidatorRoot() [32]byte {
 	return [32]byte{}
 }
+
+// VerifyBlkDescendant mocks VerifyBlkDescendant and always returns nil.
+func (ms *ChainService) VerifyBlkDescendant(_ context.Context, _ [32]byte) error {
+	return ms.VerifyBlkDescendantErr
+}
+
+// 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 = [
@@ -56,8 +69,9 @@ go_test(
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/featureconfig:go_default_library",
-        "//shared/hashutil:go_default_library",
         "//shared/params:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",

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

@@ -7,6 +7,7 @@ import (
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 )
 
 func TestAttestationCache_RoundTrip(t *testing.T) {
@@ -19,34 +20,20 @@ func TestAttestationCache_RoundTrip(t *testing.T) {
 	}
 
 	response, err := c.Get(ctx, req)
-	if err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, err)
+	assert.Equal(t, (*ethpb.AttestationData)(nil), response)
 
-	if response != nil {
-		t.Errorf("Empty cache returned an object: %v", response)
-	}
-
-	if err := c.MarkInProgress(req); err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, c.MarkInProgress(req))
 
 	res := &ethpb.AttestationData{
-		Target: &ethpb.Checkpoint{Epoch: 5},
+		Target: &ethpb.Checkpoint{Epoch: 5, Root: make([]byte, 32)},
 	}
 
-	if err = c.Put(ctx, req, res); err != nil {
-		t.Error(err)
-	}
-
-	if err := c.MarkNotInProgress(req); err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, c.Put(ctx, req, res))
+	assert.NoError(t, c.MarkNotInProgress(req))
 
 	response, err = c.Get(ctx, req)
-	if err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, err)
 
 	if !proto.Equal(response, res) {
 		t.Error("Expected equal protos to return from cache")

beacon-chain/cache/checkpoint_state.go

@@ -1,22 +1,17 @@
 package cache
 
 import (
-	"errors"
 	"sync"
 
+	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/hashutil"
-	"k8s.io/client-go/tools/cache"
 )
 
 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.
@@ -24,7 +19,7 @@ var (
 
 	// Metrics.
 	checkpointStateMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "check_point_statecache_miss",
+		Name: "check_point_state_cache_miss",
 		Help: "The number of check point state requests that aren't present in the cache.",
 	})
 	checkpointStateHit = promauto.NewCounter(prometheus.CounterOpts{
@@ -33,36 +28,20 @@ var (
 	})
 )
 
-// CheckpointState defines the active validator indices per epoch.
-type CheckpointState struct {
-	Checkpoint *ethpb.Checkpoint
-	State      *stateTrie.BeaconState
-}
-
 // CheckpointStateCache is a struct with 1 queue for looking up state by checkpoint.
 type CheckpointStateCache struct {
-	cache *cache.FIFO
+	cache *lru.Cache
 	lock  sync.RWMutex
 }
 
-// checkpointState takes the checkpoint as the key of the resulting state.
-func checkpointState(obj interface{}) (string, error) {
-	info, ok := obj.(*CheckpointState)
-	if !ok {
-		return "", ErrNotCheckpointState
-	}
-
-	h, err := hashutil.HashProto(info.Checkpoint)
-	if err != nil {
-		return "", err
-	}
-	return string(h[:]), nil
-}
-
 // NewCheckpointStateCache creates a new checkpoint state cache for storing/accessing processed state.
 func NewCheckpointStateCache() *CheckpointStateCache {
+	cache, err := lru.New(maxCheckpointStateSize)
+	if err != nil {
+		panic(err)
+	}
 	return &CheckpointStateCache{
-		cache: cache.NewFIFO(checkpointState),
+		cache: cache,
 	}
 }
 
@@ -76,44 +55,27 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (*stateTr
 		return nil, err
 	}
 
-	obj, exists, err := c.cache.GetByKey(string(h[:]))
-	if err != nil {
-		return nil, err
-	}
+	item, exists := c.cache.Get(h)
 
-	if exists {
+	if exists && item != nil {
 		checkpointStateHit.Inc()
-	} else {
-		checkpointStateMiss.Inc()
-		return nil, nil
+		// Copy here is unnecessary since the return will only be used to verify attestation signature.
+		return item.(*stateTrie.BeaconState), nil
 	}
 
-	info, ok := obj.(*CheckpointState)
-	if !ok {
-		return nil, ErrNotCheckpointState
-	}
-
-	// Copy here is unnecessary since the return will only be used to verify attestation signature.
-	return info.State, nil
+	checkpointStateMiss.Inc()
+	return nil, nil
 }
 
 // AddCheckpointState adds CheckpointState object to the cache. This method also trims the least
 // recently added CheckpointState object if the cache size has ready the max cache size limit.
-func (c *CheckpointStateCache) AddCheckpointState(cp *CheckpointState) error {
+func (c *CheckpointStateCache) AddCheckpointState(cp *ethpb.Checkpoint, s *stateTrie.BeaconState) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
-	if err := c.cache.AddIfNotPresent(&CheckpointState{
-		Checkpoint: stateTrie.CopyCheckpoint(cp.Checkpoint),
-		State:      cp.State.Copy(),
-	}); err != nil {
+	h, err := hashutil.HashProto(cp)
+	if err != nil {
 		return err
 	}
-
-	trim(c.cache, maxCheckpointStateSize)
+	c.cache.Add(h, s)
 	return nil
 }
-
-// CheckpointStateKeys returns the keys of the state in cache.
-func (c *CheckpointStateCache) CheckpointStateKeys() []string {
-	return c.cache.ListKeys()
-}

beacon-chain/cache/checkpoint_state_test.go

@@ -1,7 +1,6 @@
 package cache
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -9,42 +8,11 @@ import (
 	stateTrie "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/hashutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
-func TestCheckpointStateCacheKeyFn_OK(t *testing.T) {
-	cp := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
-	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
-		Slot: 64,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	info := &CheckpointState{
-		Checkpoint: cp,
-		State:      st,
-	}
-	key, err := checkpointState(info)
-	if err != nil {
-		t.Fatal(err)
-	}
-	wantedKey, err := hashutil.HashProto(cp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if key != string(wantedKey[:]) {
-		t.Errorf("Incorrect hash key: %s, expected %s", key, string(wantedKey[:]))
-	}
-}
-
-func TestCheckpointStateCacheKeyFn_InvalidObj(t *testing.T) {
-	_, err := checkpointState("bad")
-	if err != ErrNotCheckpointState {
-		t.Errorf("Expected error %v, got %v", ErrNotCheckpointState, err)
-	}
-}
-
 func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 	cache := NewCheckpointStateCache()
 
@@ -53,29 +21,18 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 		GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:],
 		Slot:                  64,
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	info1 := &CheckpointState{
-		Checkpoint: cp1,
-		State:      st,
-	}
-	state, err := cache.StateByCheckpoint(cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if state != nil {
-		t.Error("Expected state not to exist in empty cache")
-	}
+	require.NoError(t, err)
+
+	state, err := cache.StateByCheckpoint(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))
 
-	if err := cache.AddCheckpointState(info1); err != nil {
-		t.Fatal(err)
-	}
 	state, err = cache.StateByCheckpoint(cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !proto.Equal(state.InnerStateUnsafe(), info1.State.InnerStateUnsafe()) {
+	require.NoError(t, err)
+
+	if !proto.Equal(state.InnerStateUnsafe(), st.InnerStateUnsafe()) {
 		t.Error("incorrectly cached state")
 	}
 
@@ -83,31 +40,16 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 	st2, err := stateTrie.InitializeFromProto(&pb.BeaconState{
 		Slot: 128,
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	info2 := &CheckpointState{
-		Checkpoint: cp2,
-		State:      st2,
-	}
-	if err := cache.AddCheckpointState(info2); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
+	require.NoError(t, cache.AddCheckpointState(cp2, st2))
+
 	state, err = cache.StateByCheckpoint(cp2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(state.CloneInnerState(), info2.State.CloneInnerState()) {
-		t.Error("incorrectly cached state")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, st2.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")
 
 	state, err = cache.StateByCheckpoint(cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(state.CloneInnerState(), info1.State.CloneInnerState()) {
-		t.Error("incorrectly cached state")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, st.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")
 }
 
 func TestCheckpointStateCache_MaxSize(t *testing.T) {
@@ -115,27 +57,12 @@ func TestCheckpointStateCache_MaxSize(t *testing.T) {
 	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
 		Slot: 0,
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i := 0; i < maxCheckpointStateSize+100; i++ {
-		if err := st.SetSlot(uint64(i)); err != nil {
-			t.Fatal(err)
-		}
-		info := &CheckpointState{
-			Checkpoint: &ethpb.Checkpoint{Epoch: uint64(i)},
-			State:      st,
-		}
-		if err := c.AddCheckpointState(info); err != nil {
-			t.Fatal(err)
-		}
+	require.NoError(t, err)
+
+	for i := uint64(0); i < uint64(maxCheckpointStateSize+100); i++ {
+		require.NoError(t, st.SetSlot(i))
+		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: i, Root: make([]byte, 32)}, st))
 	}
 
-	if len(c.cache.ListKeys()) != maxCheckpointStateSize {
-		t.Errorf(
-			"Expected hash cache key size to be %d, got %d",
-			maxCheckpointStateSize,
-			len(c.cache.ListKeys()),
-		)
-	}
+	assert.Equal(t, maxCheckpointStateSize, len(c.cache.Keys()))
 }

beacon-chain/cache/committee.go

@@ -1,3 +1,5 @@
+// +build !libfuzzer
+
 package cache
 
 import (
@@ -12,14 +14,9 @@ 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, it's good to keep the old cache around for quickly switch over. 10 is a generous
-	// cache size as it considers 3 concurrent branches over 3 epochs.
-	maxCommitteesCacheSize = 10
+	// Due to reorgs and long finality, it's good to keep the old cache around for quickly switch over.
+	maxCommitteesCacheSize = uint64(32)
 
 	// CommitteeCacheMiss tracks the number of committee requests that aren't present in the cache.
 	CommitteeCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
@@ -33,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
@@ -96,7 +84,7 @@ func (c *CommitteeCache) Committee(slot uint64, seed [32]byte, index uint64) ([]
 	indexOffSet := index + (slot%params.BeaconConfig().SlotsPerEpoch)*committeeCountPerSlot
 	start, end := startEndIndices(item, indexOffSet)
 
-	if int(end) > len(item.ShuffledIndices) || end < start {
+	if end > uint64(len(item.ShuffledIndices)) || end < start {
 		return nil, errors.New("requested index out of bound")
 	}
 
@@ -116,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()
@@ -193,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_fuzz_test.go

@@ -1,10 +1,11 @@
 package cache
 
 import (
-	"reflect"
 	"testing"
 
 	fuzz "github.com/google/gofuzz"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestCommitteeKeyFuzz_OK(t *testing.T) {
@@ -14,12 +15,8 @@ func TestCommitteeKeyFuzz_OK(t *testing.T) {
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
 		k, err := committeeKeyFn(c)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if k != key(c.Seed) {
-			t.Errorf("Incorrect hash k: %s, expected %s", k, key(c.Seed))
-		}
+		require.NoError(t, err)
+		assert.Equal(t, key(c.Seed), k)
 	}
 }
 
@@ -30,17 +27,12 @@ func TestCommitteeCache_FuzzCommitteesByEpoch(t *testing.T) {
 
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
-		if err := cache.AddCommitteeShuffledList(c); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := cache.Committee(0, c.Seed, 0); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, cache.AddCommitteeShuffledList(c))
+		_, err := cache.Committee(0, c.Seed, 0)
+		require.NoError(t, err)
 	}
 
-	if len(cache.CommitteeCache.ListKeys()) != maxCommitteesCacheSize {
-		t.Error("Incorrect key size")
-	}
+	assert.Equal(t, maxCommitteesCacheSize, uint64(len(cache.CommitteeCache.ListKeys())), "Incorrect key size")
 }
 
 func TestCommitteeCache_FuzzActiveIndices(t *testing.T) {
@@ -50,19 +42,12 @@ func TestCommitteeCache_FuzzActiveIndices(t *testing.T) {
 
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
-		if err := cache.AddCommitteeShuffledList(c); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, cache.AddCommitteeShuffledList(c))
+
 		indices, err := cache.ActiveIndices(c.Seed)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !reflect.DeepEqual(indices, c.SortedIndices) {
-			t.Error("Saved indices not the same")
-		}
+		require.NoError(t, err)
+		assert.DeepEqual(t, c.SortedIndices, indices)
 	}
 
-	if len(cache.CommitteeCache.ListKeys()) != maxCommitteesCacheSize {
-		t.Error("Incorrect key size")
-	}
+	assert.Equal(t, maxCommitteesCacheSize, uint64(len(cache.CommitteeCache.ListKeys())), "Incorrect key size")
 }

beacon-chain/cache/committee_test.go

@@ -2,13 +2,14 @@ package cache
 
 import (
 	"math"
-	"reflect"
 	"sort"
 	"strconv"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestCommitteeKeyFn_OK(t *testing.T) {
@@ -19,19 +20,13 @@ func TestCommitteeKeyFn_OK(t *testing.T) {
 	}
 
 	k, err := committeeKeyFn(item)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if k != key(item.Seed) {
-		t.Errorf("Incorrect hash k: %s, expected %s", k, key(item.Seed))
-	}
+	require.NoError(t, err)
+	assert.Equal(t, key(item.Seed), k)
 }
 
 func TestCommitteeKeyFn_InvalidObj(t *testing.T) {
 	_, err := committeeKeyFn("bad")
-	if err != ErrNotCommittee {
-		t.Errorf("Expected error %v, got %v", ErrNotCommittee, err)
-	}
+	assert.Equal(t, ErrNotCommittee, err)
 }
 
 func TestCommitteeCache_CommitteesByEpoch(t *testing.T) {
@@ -46,30 +41,18 @@ func TestCommitteeCache_CommitteesByEpoch(t *testing.T) {
 	slot := params.BeaconConfig().SlotsPerEpoch
 	committeeIndex := uint64(1)
 	indices, err := cache.Committee(slot, item.Seed, committeeIndex)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	if indices != nil {
 		t.Error("Expected committee not to exist in empty cache")
 	}
+	require.NoError(t, cache.AddCommitteeShuffledList(item))
 
-	if err := cache.AddCommitteeShuffledList(item); err != nil {
-		t.Fatal(err)
-	}
 	wantedIndex := uint64(0)
 	indices, err = cache.Committee(slot, item.Seed, wantedIndex)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	start, end := startEndIndices(item, wantedIndex)
-	if !reflect.DeepEqual(indices, item.ShuffledIndices[start:end]) {
-		t.Errorf(
-			"Expected fetched active indices to be %v, got %v",
-			indices,
-			item.ShuffledIndices[start:end],
-		)
-	}
+	assert.DeepEqual(t, item.ShuffledIndices[start:end], indices)
 }
 
 func TestCommitteeCache_ActiveIndices(t *testing.T) {
@@ -77,24 +60,16 @@ func TestCommitteeCache_ActiveIndices(t *testing.T) {
 
 	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
 	indices, err := cache.ActiveIndices(item.Seed)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	if indices != nil {
-		t.Error("Expected committee count not to exist in empty cache")
+		t.Error("Expected committee not to exist in empty cache")
 	}
 
-	if err := cache.AddCommitteeShuffledList(item); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, cache.AddCommitteeShuffledList(item))
 
 	indices, err = cache.ActiveIndices(item.Seed)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(indices, item.SortedIndices) {
-		t.Error("Did not receive correct active indices from cache")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, item.SortedIndices, indices)
 }
 
 func TestCommitteeCache_ActiveCount(t *testing.T) {
@@ -102,101 +77,40 @@ func TestCommitteeCache_ActiveCount(t *testing.T) {
 
 	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
 	count, err := cache.ActiveIndicesCount(item.Seed)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count != 0 {
-		t.Error("Expected active count not to exist in empty cache")
-	}
+	require.NoError(t, err)
+	assert.Equal(t, 0, count, "Expected active count not to exist in empty cache")
 
-	if err := cache.AddCommitteeShuffledList(item); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, cache.AddCommitteeShuffledList(item))
 
 	count, err = cache.ActiveIndicesCount(item.Seed)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count != len(item.SortedIndices) {
-		t.Error("Did not receive correct active acount from cache")
-	}
-}
-
-func TestCommitteeCache_AddProposerIndicesList(t *testing.T) {
-	cache := NewCommitteesCache()
-
-	seed := [32]byte{'A'}
-	indices := []uint64{1, 2, 3, 4, 5}
-	indices, err := cache.ProposerIndices(seed)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if indices != nil {
-		t.Error("Expected committee count not to exist in empty cache")
-	}
-	if err := cache.AddProposerIndicesList(seed, indices); err != nil {
-		t.Fatal(err)
-	}
-	received, err := cache.ProposerIndices(seed)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(indices, received) {
-		t.Error("Did not receive correct proposer indices from cache")
-	}
-
-	item := &Committees{Seed: [32]byte{'B'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
-	if err := cache.AddCommitteeShuffledList(item); err != nil {
-		t.Fatal(err)
-	}
-	indices, err = cache.ProposerIndices(item.Seed)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if indices != nil {
-		t.Error("Expected committee count not to exist in empty cache")
-	}
-	if err := cache.AddProposerIndicesList(item.Seed, indices); err != nil {
-		t.Fatal(err)
-	}
-	received, err = cache.ProposerIndices(item.Seed)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(indices, received) {
-		t.Error("Did not receive correct proposer indices from cache")
-	}
-
+	require.NoError(t, err)
+	assert.Equal(t, len(item.SortedIndices), count)
 }
 
 func TestCommitteeCache_CanRotate(t *testing.T) {
 	cache := NewCommitteesCache()
 
 	// Should rotate out all the epochs except 190 through 199.
-	for i := 100; i < 200; i++ {
+	start := 100
+	end := 200
+	for i := start; i < end; i++ {
 		s := []byte(strconv.Itoa(i))
 		item := &Committees{Seed: bytesutil.ToBytes32(s)}
-		if err := cache.AddCommitteeShuffledList(item); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, cache.AddCommitteeShuffledList(item))
 	}
 
 	k := cache.CommitteeCache.ListKeys()
-	if len(k) != maxCommitteesCacheSize {
-		t.Errorf("wanted: %d, got: %d", maxCommitteesCacheSize, len(k))
-	}
+	assert.Equal(t, maxCommitteesCacheSize, uint64(len(k)))
 
 	sort.Slice(k, func(i, j int) bool {
 		return k[i] < k[j]
 	})
-	s := bytesutil.ToBytes32([]byte(strconv.Itoa(190)))
-	if k[0] != key(s) {
-		t.Error("incorrect key received for slot 190")
-	}
+	wanted := end - int(maxCommitteesCacheSize)
+	s := bytesutil.ToBytes32([]byte(strconv.Itoa(wanted)))
+	assert.Equal(t, key(s), k[0], "incorrect key received for slot 190")
+
 	s = bytesutil.ToBytes32([]byte(strconv.Itoa(199)))
-	if k[len(k)-1] != key(s) {
-		t.Error("incorrect key received for slot 199")
-	}
+	assert.Equal(t, key(s), k[len(k)-1], "incorrect key received for slot 199")
 }
 
 func TestCommitteeCacheOutOfRange(t *testing.T) {
@@ -207,13 +121,9 @@ func TestCommitteeCacheOutOfRange(t *testing.T) {
 		Seed:            seed,
 		ShuffledIndices: []uint64{0},
 		SortedIndices:   []uint64{},
-		ProposerIndices: []uint64{},
 	})
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
+
 	_, err = cache.Committee(0, seed, math.MaxUint64) // Overflow!
-	if err == nil {
-		t.Fatal("Did not fail as expected")
-	}
+	require.NotNil(t, err, "Did not fail as expected")
 }

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

@@ -8,12 +8,12 @@ import (
 var (
 	// maxCacheSize is 4x of the epoch length for additional cache padding.
 	// Requests should be only accessing committees within defined epoch length.
-	maxCacheSize = int(4 * params.BeaconConfig().SlotsPerEpoch)
+	maxCacheSize = 4 * params.BeaconConfig().SlotsPerEpoch
 )
 
 // trim the FIFO queue to the maxSize.
-func trim(queue *cache.FIFO, maxSize int) {
-	for s := len(queue.ListKeys()); s > maxSize; s-- {
+func trim(queue *cache.FIFO, maxSize uint64) {
+	for s := uint64(len(queue.ListKeys())); s > maxSize; s-- {
 		_, err := queue.Pop(popProcessNoopFunc)
 		if err != nil {
 			// popProcessNoopFunc never returns an error, but we handle this anyway to make linter
@@ -24,6 +24,6 @@ func trim(queue *cache.FIFO, maxSize int) {
 }
 
 // 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

@@ -13,6 +13,8 @@ go_library(
         "//proto/beacon/db:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/hashutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/trieutil:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
@@ -24,13 +26,17 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "deposits_test.go",
+        "deposits_cache_test.go",
         "pending_deposits_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
         "//proto/beacon/db:go_default_library",
         "//shared/bytesutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
+        "//shared/trieutil:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",

beacon-chain/cache/depositcache/deposits_cache.go

@@ -17,6 +17,8 @@ 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/trieutil"
 	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -30,9 +32,18 @@ var (
 
 // DepositFetcher defines a struct which can retrieve deposit information from a store.
 type DepositFetcher interface {
-	AllDeposits(ctx context.Context, beforeBlk *big.Int) []*ethpb.Deposit
+	AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit
 	DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int)
 	DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte)
+	FinalizedDeposits(ctx context.Context) *FinalizedDeposits
+	NonFinalizedDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit
+}
+
+// FinalizedDeposits stores the trie of deposits that have been included
+// in the beacon state up to the latest finalized checkpoint.
+type FinalizedDeposits struct {
+	Deposits        *trieutil.SparseMerkleTrie
+	MerkleTrieIndex int64
 }
 
 // DepositCache stores all in-memory deposit objects. This
@@ -41,19 +52,28 @@ 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
 }
 
-// NewDepositCache instantiates a new deposit cache
-func NewDepositCache() *DepositCache {
+// New instantiates a new deposit cache
+func New() (*DepositCache, error) {
+	finalizedDepositsTrie, err := trieutil.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
+	if err != nil {
+		return nil, err
+	}
+
+	// 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),
-	}
+	}, nil
 }
 
 // InsertDeposit into the database. If deposit or block number are nil
@@ -91,9 +111,40 @@ func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*dbp
 	historicalDepositsCount.Add(float64(len(ctrs)))
 }
 
-// AllDepositContainers returns a list of deposits all historical deposit containers until the given block number.
+// InsertFinalizedDeposits inserts deposits up to eth1DepositIndex (inclusive) into the finalized deposits cache.
+func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1DepositIndex int64) {
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertFinalizedDeposits")
+	defer span.End()
+	dc.depositsLock.Lock()
+	defer dc.depositsLock.Unlock()
+
+	depositTrie := dc.finalizedDeposits.Deposits
+	insertIndex := int(dc.finalizedDeposits.MerkleTrieIndex + 1)
+	for _, d := range dc.deposits {
+		if d.Index <= dc.finalizedDeposits.MerkleTrieIndex {
+			continue
+		}
+		if d.Index > eth1DepositIndex {
+			break
+		}
+		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[:], insertIndex)
+		insertIndex++
+	}
+
+	dc.finalizedDeposits = &FinalizedDeposits{
+		Deposits:        depositTrie,
+		MerkleTrieIndex: eth1DepositIndex,
+	}
+}
+
+// AllDepositContainers returns all historical deposit containers.
 func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*dbpb.DepositContainer {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.AllDepositContainers")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.AllDepositContainers")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -119,9 +170,9 @@ func (dc *DepositCache) PubkeyInChainstart(ctx context.Context, pubkey string) b
 	return false
 }
 
-// AllDeposits returns a list of deposits all historical deposits until the given block number
+// AllDeposits returns a list of historical deposits until the given block number
 // (inclusive). If no block is specified then this method returns all historical deposits.
-func (dc *DepositCache) AllDeposits(ctx context.Context, beforeBlk *big.Int) []*ethpb.Deposit {
+func (dc *DepositCache) AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.AllDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
@@ -129,7 +180,7 @@ func (dc *DepositCache) AllDeposits(ctx context.Context, beforeBlk *big.Int) []*
 
 	var deposits []*ethpb.Deposit
 	for _, ctnr := range dc.deposits {
-		if beforeBlk == nil || beforeBlk.Uint64() >= ctnr.Eth1BlockHeight {
+		if untilBlk == nil || untilBlk.Uint64() >= ctnr.Eth1BlockHeight {
 			deposits = append(deposits, ctnr.Deposit)
 		}
 	}
@@ -171,3 +222,64 @@ func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*et
 	}
 	return deposit, blockNum
 }
+
+// FinalizedDeposits returns the finalized deposits trie.
+func (dc *DepositCache) FinalizedDeposits(ctx context.Context) *FinalizedDeposits {
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.FinalizedDeposits")
+	defer span.End()
+	dc.depositsLock.RLock()
+	defer dc.depositsLock.RUnlock()
+
+	return &FinalizedDeposits{
+		Deposits:        dc.finalizedDeposits.Deposits.Copy(),
+		MerkleTrieIndex: dc.finalizedDeposits.MerkleTrieIndex,
+	}
+}
+
+// NonFinalizedDeposits returns the list of non-finalized deposits until the given block number (inclusive).
+// If no block is specified then this method returns all non-finalized deposits.
+func (dc *DepositCache) NonFinalizedDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.NonFinalizedDeposits")
+	defer span.End()
+	dc.depositsLock.RLock()
+	defer dc.depositsLock.RUnlock()
+
+	if dc.finalizedDeposits == nil {
+		return dc.AllDeposits(ctx, untilBlk)
+	}
+
+	lastFinalizedDepositIndex := dc.finalizedDeposits.MerkleTrieIndex
+	var deposits []*ethpb.Deposit
+	for _, d := range dc.deposits {
+		if (d.Index > lastFinalizedDepositIndex) && (untilBlk == nil || untilBlk.Uint64() >= d.Eth1BlockHeight) {
+			deposits = append(deposits, d.Deposit)
+		}
+	}
+
+	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

@@ -0,0 +1,709 @@
+package depositcache
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"math/big"
+	"testing"
+
+	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"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/trieutil"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+)
+
+const nilDepositErr = "Ignoring nil deposit insertion"
+
+var _ DepositFetcher = (*DepositCache)(nil)
+
+func TestInsertDeposit_LogsOnNilDepositInsertion(t *testing.T) {
+	hook := logTest.NewGlobal()
+	dc, err := New()
+	require.NoError(t, err)
+
+	dc.InsertDeposit(context.Background(), nil, 1, 0, [32]byte{})
+
+	require.Equal(t, 0, len(dc.deposits), "Number of deposits changed")
+	assert.Equal(t, nilDepositErr, hook.LastEntry().Message)
+}
+
+func TestInsertDeposit_MaintainsSortedOrderByIndex(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	insertions := []struct {
+		blkNum  uint64
+		deposit *ethpb.Deposit
+		index   int64
+	}{
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{},
+			index:   0,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{},
+			index:   3,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{},
+			index:   1,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{},
+			index:   4,
+		},
+	}
+
+	for _, ins := range insertions {
+		dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{})
+	}
+
+	expectedIndices := []int64{0, 1, 3, 4}
+	for i, ei := range expectedIndices {
+		assert.Equal(t, ei, dc.deposits[i].Index,
+			fmt.Sprintf("dc.deposits[%d].Index = %d, wanted %d", i, dc.deposits[i].Index, ei))
+	}
+}
+
+func TestAllDeposits_ReturnsAllDeposits(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	deposits := []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 11,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 11,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 12,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 12,
+			Deposit:         &ethpb.Deposit{},
+		},
+	}
+	dc.deposits = deposits
+
+	d := dc.AllDeposits(context.Background(), nil)
+	assert.Equal(t, len(deposits), len(d))
+}
+
+func TestAllDeposits_FiltersDepositUpToAndIncludingBlockNumber(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	deposits := []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 11,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 11,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 12,
+			Deposit:         &ethpb.Deposit{},
+		},
+		{
+			Eth1BlockHeight: 12,
+			Deposit:         &ethpb.Deposit{},
+		},
+	}
+	dc.deposits = deposits
+
+	d := dc.AllDeposits(context.Background(), big.NewInt(11))
+	assert.Equal(t, 5, len(d))
+}
+
+func TestDepositsNumberAndRootAtHeight_ReturnsAppropriateCountAndRoot(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	dc.deposits = []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 11,
+			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{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 12,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+	}
+
+	n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(11))
+	assert.Equal(t, 5, int(n))
+	assert.Equal(t, bytesutil.ToBytes32([]byte("root")), root)
+}
+
+func TestDepositsNumberAndRootAtHeight_ReturnsEmptyTrieIfBlockHeightLessThanOldestDeposit(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	dc.deposits = []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			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{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             make([]byte, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			DepositRoot: bytesutil.PadTo([]byte("root"), 32),
+		},
+	}
+
+	n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(2))
+	assert.Equal(t, 0, int(n))
+	assert.Equal(t, [32]byte{}, root)
+}
+
+func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	dc.deposits = []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 9,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte("pk0"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte("pk1"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 11,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte("pk1"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+		{
+			Eth1BlockHeight: 12,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte("pk2"), 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+		},
+	}
+
+	pk1 := bytesutil.PadTo([]byte("pk1"), 48)
+	dep, blkNum := dc.DepositByPubkey(context.Background(), pk1)
+
+	if dep == nil || !bytes.Equal(dep.Data.PublicKey, pk1) {
+		t.Error("Returned wrong deposit")
+	}
+	assert.Equal(t, 0, blkNum.Cmp(big.NewInt(10)),
+		fmt.Sprintf("Returned wrong block number %v", blkNum))
+}
+
+func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	finalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 0,
+		},
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 1,
+		},
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 2,
+		},
+	}
+	dc.deposits = append(finalizedDeposits, &dbpb.DepositContainer{
+		Deposit: &ethpb.Deposit{
+			Data: &ethpb.Deposit_Data{
+				PublicKey:             bytesutil.PadTo([]byte{3}, 48),
+				WithdrawalCredentials: make([]byte, 32),
+				Signature:             make([]byte, 96),
+			},
+		},
+		Index: 3,
+	})
+
+	dc.InsertFinalizedDeposits(context.Background(), 2)
+
+	cachedDeposits := dc.FinalizedDeposits(context.Background())
+	require.NotNil(t, cachedDeposits, "Deposits not cached")
+	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex)
+
+	var deps [][]byte
+	for _, d := range finalizedDeposits {
+		hash, err := d.Deposit.Data.HashTreeRoot()
+		require.NoError(t, err, "Could not hash deposit data")
+		deps = append(deps, hash[:])
+	}
+	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 := New()
+	require.NoError(t, err)
+
+	oldFinalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 0,
+		},
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 1,
+		},
+	}
+	newFinalizedDeposit := dbpb.DepositContainer{
+		Deposit: &ethpb.Deposit{
+			Data: &ethpb.Deposit_Data{
+				PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+				WithdrawalCredentials: make([]byte, 32),
+				Signature:             make([]byte, 96),
+			},
+		},
+		Index: 2,
+	}
+	dc.deposits = oldFinalizedDeposits
+	dc.InsertFinalizedDeposits(context.Background(), 1)
+	// Artificially exclude old deposits so that they can only be retrieved from previously finalized deposits.
+	dc.deposits = []*dbpb.DepositContainer{&newFinalizedDeposit}
+
+	dc.InsertFinalizedDeposits(context.Background(), 2)
+
+	cachedDeposits := dc.FinalizedDeposits(context.Background())
+	require.NotNil(t, cachedDeposits, "Deposits not cached")
+	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex)
+
+	var deps [][]byte
+	for _, d := range append(oldFinalizedDeposits, &newFinalizedDeposit) {
+		hash, err := d.Deposit.Data.HashTreeRoot()
+		require.NoError(t, err, "Could not hash deposit data")
+		deps = append(deps, hash[:])
+	}
+	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 := New()
+	require.NoError(t, err)
+
+	finalizedDeposits := dc.finalizedDeposits
+	assert.NotNil(t, finalizedDeposits)
+	assert.NotNil(t, finalizedDeposits.Deposits)
+	assert.Equal(t, int64(-1), finalizedDeposits.MerkleTrieIndex)
+}
+
+func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	finalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 0,
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 1,
+		},
+	}
+	dc.deposits = append(finalizedDeposits,
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 2,
+		},
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 11,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{3}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 3,
+		})
+	dc.InsertFinalizedDeposits(context.Background(), 1)
+
+	deps := dc.NonFinalizedDeposits(context.Background(), nil)
+	assert.Equal(t, 2, len(deps))
+}
+
+func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *testing.T) {
+	dc, err := New()
+	require.NoError(t, err)
+
+	finalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{0}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 0,
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{1}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 1,
+		},
+	}
+	dc.deposits = append(finalizedDeposits,
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{2}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 2,
+		},
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 11,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             bytesutil.PadTo([]byte{3}, 48),
+					WithdrawalCredentials: make([]byte, 32),
+					Signature:             make([]byte, 96),
+				},
+			},
+			Index: 3,
+		})
+	dc.InsertFinalizedDeposits(context.Background(), 1)
+
+	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/deposits_test.go

@@ -1,275 +0,0 @@
-package depositcache
-
-import (
-	"bytes"
-	"context"
-	"math/big"
-	"testing"
-
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-)
-
-const nilDepositErr = "Ignoring nil deposit insertion"
-
-var _ = DepositFetcher(&DepositCache{})
-
-func TestBeaconDB_InsertDeposit_LogsOnNilDepositInsertion(t *testing.T) {
-	hook := logTest.NewGlobal()
-	dc := DepositCache{}
-
-	dc.InsertDeposit(context.Background(), nil, 1, 0, [32]byte{})
-
-	if len(dc.deposits) != 0 {
-		t.Fatal("Number of deposits changed")
-	}
-	if hook.LastEntry().Message != nilDepositErr {
-		t.Errorf("Did not log correct message, wanted \"Ignoring nil deposit insertion\", got \"%s\"", hook.LastEntry().Message)
-	}
-}
-
-func TestBeaconDB_InsertDeposit_MaintainsSortedOrderByIndex(t *testing.T) {
-	dc := DepositCache{}
-
-	insertions := []struct {
-		blkNum  uint64
-		deposit *ethpb.Deposit
-		index   int64
-	}{
-		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{},
-			index:   0,
-		},
-		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{},
-			index:   3,
-		},
-		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{},
-			index:   1,
-		},
-		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{},
-			index:   4,
-		},
-	}
-
-	for _, ins := range insertions {
-		dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{})
-	}
-
-	expectedIndices := []int64{0, 1, 3, 4}
-	for i, ei := range expectedIndices {
-		if dc.deposits[i].Index != ei {
-			t.Errorf("dc.deposits[%d].Index = %d, wanted %d", i, dc.deposits[i].Index, ei)
-		}
-	}
-}
-
-func TestBeaconDB_AllDeposits_ReturnsAllDeposits(t *testing.T) {
-	dc := DepositCache{}
-
-	deposits := []*dbpb.DepositContainer{
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
-		},
-	}
-	dc.deposits = deposits
-
-	d := dc.AllDeposits(context.Background(), nil)
-	if len(d) != len(deposits) {
-		t.Errorf("Return the wrong number of deposits (%d) wanted %d", len(d), len(deposits))
-	}
-}
-
-func TestBeaconDB_AllDeposits_FiltersDepositUpToAndIncludingBlockNumber(t *testing.T) {
-	dc := DepositCache{}
-
-	deposits := []*dbpb.DepositContainer{
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
-		},
-	}
-	dc.deposits = deposits
-
-	d := dc.AllDeposits(context.Background(), big.NewInt(11))
-	expected := 5
-	if len(d) != expected {
-		t.Errorf("Return the wrong number of deposits (%d) wanted %d", len(d), expected)
-	}
-}
-
-func TestBeaconDB_DepositsNumberAndRootAtHeight_ReturnsAppropriateCountAndRoot(t *testing.T) {
-	dc := DepositCache{}
-
-	dc.deposits = []*dbpb.DepositContainer{
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-			DepositRoot:     []byte("root"),
-		},
-		{
-			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
-		},
-		{
-			Eth1BlockHeight: 12,
-			Deposit:         &ethpb.Deposit{},
-		},
-	}
-
-	n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(11))
-	if int(n) != 5 {
-		t.Errorf("Returned unexpected deposits number %d wanted %d", n, 5)
-	}
-
-	if root != bytesutil.ToBytes32([]byte("root")) {
-		t.Errorf("Returned unexpected root: %v", root)
-	}
-}
-
-func TestBeaconDB_DepositsNumberAndRootAtHeight_ReturnsEmptyTrieIfBlockHeightLessThanOldestDeposit(t *testing.T) {
-	dc := DepositCache{}
-
-	dc.deposits = []*dbpb.DepositContainer{
-		{
-			Eth1BlockHeight: 10,
-			Deposit:         &ethpb.Deposit{},
-			DepositRoot:     []byte("root"),
-		},
-		{
-			Eth1BlockHeight: 11,
-			Deposit:         &ethpb.Deposit{},
-			DepositRoot:     []byte("root"),
-		},
-	}
-
-	n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(2))
-	if int(n) != 0 {
-		t.Errorf("Returned unexpected deposits number %d wanted %d", n, 0)
-	}
-
-	if root != [32]byte{} {
-		t.Errorf("Returned unexpected root: %v", root)
-	}
-}
-
-func TestBeaconDB_DepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
-	dc := DepositCache{}
-
-	dc.deposits = []*dbpb.DepositContainer{
-		{
-			Eth1BlockHeight: 9,
-			Deposit: &ethpb.Deposit{
-				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk0"),
-				},
-			},
-		},
-		{
-			Eth1BlockHeight: 10,
-			Deposit: &ethpb.Deposit{
-				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk1"),
-				},
-			},
-		},
-		{
-			Eth1BlockHeight: 11,
-			Deposit: &ethpb.Deposit{
-				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk1"),
-				},
-			},
-		},
-		{
-			Eth1BlockHeight: 12,
-			Deposit: &ethpb.Deposit{
-				Data: &ethpb.Deposit_Data{
-					PublicKey: []byte("pk2"),
-				},
-			},
-		},
-	}
-
-	dep, blkNum := dc.DepositByPubkey(context.Background(), []byte("pk1"))
-
-	if !bytes.Equal(dep.Data.PublicKey, []byte("pk1")) {
-		t.Error("Returned wrong deposit")
-	}
-	if blkNum.Cmp(big.NewInt(10)) != 0 {
-		t.Errorf("Returned wrong block number %v", blkNum)
-	}
-}

beacon-chain/cache/depositcache/pending_deposits.go

@@ -24,7 +24,7 @@ var (
 // PendingDepositsFetcher specifically outlines a struct that can retrieve deposits
 // which have not yet been included in the chain.
 type PendingDepositsFetcher interface {
-	PendingContainers(ctx context.Context, beforeBlk *big.Int) []*dbpb.DepositContainer
+	PendingContainers(ctx context.Context, untilBlk *big.Int) []*dbpb.DepositContainer
 }
 
 // InsertPendingDeposit into the database. If deposit or block number are nil
@@ -50,36 +50,23 @@ func (dc *DepositCache) InsertPendingDeposit(ctx context.Context, d *ethpb.Depos
 // PendingDeposits returns a list of deposits until the given block number
 // (inclusive). If no block is specified then this method returns all pending
 // deposits.
-func (dc *DepositCache) PendingDeposits(ctx context.Context, beforeBlk *big.Int) []*ethpb.Deposit {
+func (dc *DepositCache) PendingDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
 	defer span.End()
-	dc.depositsLock.RLock()
-	defer dc.depositsLock.RUnlock()
 
-	var depositCntrs []*dbpb.DepositContainer
-	for _, ctnr := range dc.pendingDeposits {
-		if beforeBlk == nil || beforeBlk.Uint64() >= ctnr.Eth1BlockHeight {
-			depositCntrs = append(depositCntrs, ctnr)
-		}
-	}
-	// Sort the deposits by Merkle index.
-	sort.SliceStable(depositCntrs, func(i, j int) bool {
-		return depositCntrs[i].Index < depositCntrs[j].Index
-	})
+	depositCntrs := dc.PendingContainers(ctx, untilBlk)
 
 	var deposits []*ethpb.Deposit
 	for _, dep := range depositCntrs {
 		deposits = append(deposits, dep.Deposit)
 	}
 
-	span.AddAttributes(trace.Int64Attribute("count", int64(len(deposits))))
-
 	return deposits
 }
 
 // PendingContainers returns a list of deposit containers until the given block number
 // (inclusive).
-func (dc *DepositCache) PendingContainers(ctx context.Context, beforeBlk *big.Int) []*dbpb.DepositContainer {
+func (dc *DepositCache) PendingContainers(ctx context.Context, untilBlk *big.Int) []*dbpb.DepositContainer {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
@@ -87,7 +74,7 @@ func (dc *DepositCache) PendingContainers(ctx context.Context, beforeBlk *big.In
 
 	var depositCntrs []*dbpb.DepositContainer
 	for _, ctnr := range dc.pendingDeposits {
-		if beforeBlk == nil || beforeBlk.Uint64() >= ctnr.Eth1BlockHeight {
+		if untilBlk == nil || untilBlk.Uint64() >= ctnr.Eth1BlockHeight {
 			depositCntrs = append(depositCntrs, ctnr)
 		}
 	}
@@ -141,7 +128,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 }
 
 // PrunePendingDeposits removes any deposit which is older than the given deposit merkle tree index.
-func (dc *DepositCache) PrunePendingDeposits(ctx context.Context, merkleTreeIndex int) {
+func (dc *DepositCache) PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64) {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.PrunePendingDeposits")
 	defer span.End()
 
@@ -155,7 +142,7 @@ func (dc *DepositCache) PrunePendingDeposits(ctx context.Context, merkleTreeInde
 
 	var cleanDeposits []*dbpb.DepositContainer
 	for _, dp := range dc.pendingDeposits {
-		if dp.Index >= int64(merkleTreeIndex) {
+		if dp.Index >= merkleTreeIndex {
 			cleanDeposits = append(cleanDeposits, dp)
 		}
 	}

beacon-chain/cache/depositcache/pending_deposits_test.go

@@ -3,43 +3,45 @@ package depositcache
 import (
 	"context"
 	"math/big"
-	"reflect"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
 	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/testutil/assert"
 )
 
-var _ = PendingDepositsFetcher(&DepositCache{})
+var _ PendingDepositsFetcher = (*DepositCache)(nil)
 
 func TestInsertPendingDeposit_OK(t *testing.T) {
 	dc := DepositCache{}
 	dc.InsertPendingDeposit(context.Background(), &ethpb.Deposit{}, 111, 100, [32]byte{})
 
-	if len(dc.pendingDeposits) != 1 {
-		t.Error("Deposit not inserted")
-	}
+	assert.Equal(t, 1, len(dc.pendingDeposits), "Deposit not inserted")
 }
 
 func TestInsertPendingDeposit_ignoresNilDeposit(t *testing.T) {
 	dc := DepositCache{}
 	dc.InsertPendingDeposit(context.Background(), nil /*deposit*/, 0 /*blockNum*/, 0, [32]byte{})
 
-	if len(dc.pendingDeposits) > 0 {
-		t.Error("Unexpected deposit insertion")
-	}
+	assert.Equal(t, 0, len(dc.pendingDeposits))
 }
 
 func TestRemovePendingDeposit_OK(t *testing.T) {
 	db := DepositCache{}
-	proof1 := make([][]byte, 33)
+	proof1 := makeDepositProof()
 	proof1[0] = bytesutil.PadTo([]byte{'A'}, 32)
-	proof2 := make([][]byte, 33)
+	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},
@@ -55,21 +57,23 @@ func TestRemovePendingDeposit_IgnoresNilDeposit(t *testing.T) {
 	dc := DepositCache{}
 	dc.pendingDeposits = []*dbpb.DepositContainer{{Deposit: &ethpb.Deposit{}}}
 	dc.RemovePendingDeposit(context.Background(), nil /*deposit*/)
-	if len(dc.pendingDeposits) != 1 {
-		t.Errorf("Deposit unexpectedly removed")
-	}
+	assert.Equal(t, 1, len(dc.pendingDeposits), "Deposit unexpectedly removed")
 }
 
 func TestPendingDeposit_RoundTrip(t *testing.T) {
 	dc := DepositCache{}
-	proof := make([][]byte, 33)
+	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)
-	if len(dc.pendingDeposits) != 0 {
-		t.Error("Failed to insert & delete a pending deposit")
-	}
+	assert.Equal(t, 0, len(dc.pendingDeposits), "Failed to insert & delete a pending deposit")
 }
 
 func TestPendingDeposits_OK(t *testing.T) {
@@ -86,15 +90,10 @@ func TestPendingDeposits_OK(t *testing.T) {
 		{Proof: [][]byte{[]byte("A")}},
 		{Proof: [][]byte{[]byte("B")}},
 	}
-
-	if !reflect.DeepEqual(deposits, expected) {
-		t.Errorf("Unexpected deposits. got=%+v want=%+v", deposits, expected)
-	}
+	assert.DeepEqual(t, expected, deposits)
 
 	all := dc.PendingDeposits(context.Background(), nil)
-	if len(all) != len(dc.pendingDeposits) {
-		t.Error("PendingDeposits(ctx, nil) did not return all deposits")
-	}
+	assert.Equal(t, len(dc.pendingDeposits), len(all), "PendingDeposits(ctx, nil) did not return all deposits")
 }
 
 func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
@@ -118,9 +117,7 @@ func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
 		{Eth1BlockHeight: 10, Index: 10},
 		{Eth1BlockHeight: 12, Index: 12},
 	}
-	if !reflect.DeepEqual(dc.pendingDeposits, expected) {
-		t.Errorf("Unexpected deposits. got=%+v want=%+v", dc.pendingDeposits, expected)
-	}
+	assert.DeepEqual(t, expected, dc.pendingDeposits)
 }
 
 func TestPrunePendingDeposits_OK(t *testing.T) {
@@ -143,9 +140,7 @@ func TestPrunePendingDeposits_OK(t *testing.T) {
 		{Eth1BlockHeight: 12, Index: 12},
 	}
 
-	if !reflect.DeepEqual(dc.pendingDeposits, expected) {
-		t.Errorf("Unexpected deposits. got=%+v want=%+v", dc.pendingDeposits, expected)
-	}
+	assert.DeepEqual(t, expected, dc.pendingDeposits)
 
 	dc.pendingDeposits = []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},
@@ -162,8 +157,5 @@ func TestPrunePendingDeposits_OK(t *testing.T) {
 		{Eth1BlockHeight: 12, Index: 12},
 	}
 
-	if !reflect.DeepEqual(dc.pendingDeposits, expected) {
-		t.Errorf("Unexpected deposits. got=%+v want=%+v", dc.pendingDeposits, expected)
-	}
-
+	assert.DeepEqual(t, expected, dc.pendingDeposits)
 }

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

@@ -1,6 +1,8 @@
 package cache
 
 import (
+	"sync"
+
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -24,6 +26,7 @@ var (
 // HotStateCache is used to store the processed beacon state after finalized check point..
 type HotStateCache struct {
 	cache *lru.Cache
+	lock  sync.RWMutex
 }
 
 // NewHotStateCache initializes the map and underlying cache.
@@ -40,6 +43,8 @@ func NewHotStateCache() *HotStateCache {
 // Get returns a cached response via input block root, if any.
 // The response is copied by default.
 func (c *HotStateCache) Get(root [32]byte) *stateTrie.BeaconState {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
 	item, exists := c.cache.Get(root)
 
 	if exists && item != nil {
@@ -52,6 +57,8 @@ func (c *HotStateCache) Get(root [32]byte) *stateTrie.BeaconState {
 
 // GetWithoutCopy returns a non-copied cached response via input block root.
 func (c *HotStateCache) GetWithoutCopy(root [32]byte) *stateTrie.BeaconState {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
 	item, exists := c.cache.Get(root)
 	if exists && item != nil {
 		hotStateCacheHit.Inc()
@@ -63,15 +70,21 @@ func (c *HotStateCache) GetWithoutCopy(root [32]byte) *stateTrie.BeaconState {
 
 // Put the response in the cache.
 func (c *HotStateCache) Put(root [32]byte, state *stateTrie.BeaconState) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
 	c.cache.Add(root, state)
 }
 
 // Has returns true if the key exists in the cache.
 func (c *HotStateCache) Has(root [32]byte) bool {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
 	return c.cache.Contains(root)
 }
 
 // Delete deletes the key exists in the cache.
 func (c *HotStateCache) Delete(root [32]byte) bool {
+	c.lock.Lock()
+	defer c.lock.Unlock()
 	return c.cache.Remove(root)
 }

beacon-chain/cache/hot_state_cache_test.go

@@ -1,46 +1,34 @@
 package cache_test
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestHotStateCache_RoundTrip(t *testing.T) {
 	c := cache.NewHotStateCache()
 	root := [32]byte{'A'}
 	state := c.Get(root)
-	if state != nil {
-		t.Errorf("Empty cache returned an object: %v", state)
-	}
-	if c.Has(root) {
-		t.Error("Empty cache has an object")
-	}
+	assert.Equal(t, (*stateTrie.BeaconState)(nil), state)
+	assert.Equal(t, false, c.Has(root), "Empty cache has an object")
 
 	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
 		Slot: 10,
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	c.Put(root, state)
+	require.NoError(t, err)
+
+	c.Put(root, state)
+	assert.Equal(t, true, c.Has(root), "Empty cache does not have an object")
 
-	if !c.Has(root) {
-		t.Error("Empty cache does not have an object")
-	}
 	res := c.Get(root)
-	if state == nil {
-		t.Errorf("Empty cache returned an object: %v", state)
-	}
-	if !reflect.DeepEqual(state.CloneInnerState(), res.CloneInnerState()) {
-		t.Error("Expected equal protos to return from cache")
-	}
+	assert.NotNil(t, state)
+	assert.DeepEqual(t, res.CloneInnerState(), state.CloneInnerState(), "Expected equal protos to return from cache")
 
 	c.Delete(root)
-	if c.Has(root) {
-		t.Error("Cache not suppose to have the object")
-	}
+	assert.Equal(t, false, c.Has(root), "Cache not supposed to have the object")
 }

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

@@ -136,7 +136,7 @@ func (c *SkipSlotCache) MarkNotInProgress(slot uint64) error {
 }
 
 // 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, slot uint64, state *stateTrie.BeaconState) error {
 	if c.disabled {
 		return nil
 	}

beacon-chain/cache/skip_slot_cache_test.go

@@ -2,12 +2,13 @@ package cache_test
 
 import (
 	"context"
-	"reflect"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestSkipSlotCache_RoundTrip(t *testing.T) {
@@ -15,39 +16,20 @@ func TestSkipSlotCache_RoundTrip(t *testing.T) {
 	c := cache.NewSkipSlotCache()
 
 	state, err := c.Get(ctx, 5)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
+	assert.Equal(t, (*stateTrie.BeaconState)(nil), state, "Empty cache returned an object")
 
-	if state != nil {
-		t.Errorf("Empty cache returned an object: %v", state)
-	}
-
-	if err := c.MarkInProgress(5); err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, c.MarkInProgress(5))
 
 	state, err = stateTrie.InitializeFromProto(&pb.BeaconState{
 		Slot: 10,
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if err = c.Put(ctx, 5, state); err != nil {
-		t.Error(err)
-	}
-
-	if err := c.MarkNotInProgress(5); err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, c.Put(ctx, 5, state))
+	require.NoError(t, c.MarkNotInProgress(5))
 
 	res, err := c.Get(ctx, 5)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if !reflect.DeepEqual(state.CloneInnerState(), res.CloneInnerState()) {
-		t.Error("Expected equal protos to return from cache")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, res.CloneInnerState(), state.CloneInnerState(), "Expected equal protos to return from cache")
 }

beacon-chain/cache/subnet_ids.go

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

@@ -1,71 +1,55 @@
 package cache
 
 import (
-	"reflect"
 	"testing"
+
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestSubnetIDsCache_RoundTrip(t *testing.T) {
 	c := newSubnetIDs()
 	slot := uint64(100)
 	committeeIDs := c.GetAggregatorSubnetIDs(slot)
-	if len(committeeIDs) != 0 {
-		t.Errorf("Empty cache returned an object: %v", committeeIDs)
-	}
+	assert.Equal(t, 0, len(committeeIDs), "Empty cache returned an object")
 
 	c.AddAggregatorSubnetID(slot, 1)
 	res := c.GetAggregatorSubnetIDs(slot)
-	if !reflect.DeepEqual(res, []uint64{1}) {
-		t.Error("Expected equal value to return from cache")
-	}
+	assert.DeepEqual(t, []uint64{1}, res)
 
 	c.AddAggregatorSubnetID(slot, 2)
 	res = c.GetAggregatorSubnetIDs(slot)
-	if !reflect.DeepEqual(res, []uint64{1, 2}) {
-		t.Error("Expected equal value to return from cache")
-	}
+	assert.DeepEqual(t, []uint64{1, 2}, res)
 
 	c.AddAggregatorSubnetID(slot, 3)
 	res = c.GetAggregatorSubnetIDs(slot)
-	if !reflect.DeepEqual(res, []uint64{1, 2, 3}) {
-		t.Error("Expected equal value to return from cache")
-	}
+	assert.DeepEqual(t, []uint64{1, 2, 3}, res)
 
 	committeeIDs = c.GetAttesterSubnetIDs(slot)
-	if len(committeeIDs) != 0 {
-		t.Errorf("Empty cache returned an object: %v", committeeIDs)
-	}
+	assert.Equal(t, 0, len(committeeIDs), "Empty cache returned an object")
 
 	c.AddAttesterSubnetID(slot, 11)
 	res = c.GetAttesterSubnetIDs(slot)
-	if !reflect.DeepEqual(res, []uint64{11}) {
-		t.Error("Expected equal value to return from cache")
-	}
+	assert.DeepEqual(t, []uint64{11}, res)
 
 	c.AddAttesterSubnetID(slot, 22)
 	res = c.GetAttesterSubnetIDs(slot)
-	if !reflect.DeepEqual(res, []uint64{11, 22}) {
-		t.Error("Expected equal value to return from cache")
-	}
+	assert.DeepEqual(t, []uint64{11, 22}, res)
 
 	c.AddAttesterSubnetID(slot, 33)
 	res = c.GetAttesterSubnetIDs(slot)
-	if !reflect.DeepEqual(res, []uint64{11, 22, 33}) {
-		t.Error("Expected equal value to return from cache")
-	}
+	assert.DeepEqual(t, []uint64{11, 22, 33}, res)
 }
 
 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)
 	}
 
-	for i := 0; i < 20; i++ {
+	for i := uint64(0); i < 20; i++ {
 		pubkey := [48]byte{byte(i)}
 
 		idxs, ok, _ := c.GetPersistentSubnets(pubkey[:])
@@ -73,12 +57,8 @@ func TestSubnetIDsCache_PersistentCommitteeRoundtrip(t *testing.T) {
 			t.Errorf("Couldn't find entry in cache for pubkey %#x", pubkey)
 			continue
 		}
-		if int(idxs[0]) != i {
-			t.Fatalf("Wanted index of %d but got %d", i, idxs[0])
-		}
+		require.Equal(t, i, idxs[0])
 	}
 	coms := c.GetAllSubnets()
-	if len(coms) != 20 {
-		t.Errorf("Number of committees is not %d but is %d", 20, len(coms))
-	}
+	assert.Equal(t, 20, len(coms))
 }

beacon-chain/core/blocks/BUILD.bazel

@@ -4,24 +4,34 @@ load("@io_bazel_rules_go//go:def.bzl", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "block.go",
-        "block_operations.go",
+        "attestation.go",
+        "attester_slashing.go",
+        "deposit.go",
+        "eth1_data.go",
+        "exit.go",
+        "genesis.go",
+        "header.go",
+        "log.go",
+        "proposer_slashing.go",
+        "randao.go",
+        "signature.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks",
     visibility = [
         "//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",
         "//shared/bytesutil:go_default_library",
+        "//shared/depositutil:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/mathutil:go_default_library",
         "//shared/params:go_default_library",
@@ -40,30 +50,38 @@ go_test(
     name = "go_default_test",
     size = "medium",
     srcs = [
+        "attestation_test.go",
+        "attester_slashing_test.go",
         "block_operations_fuzz_test.go",
-        "block_operations_test.go",
         "block_regression_test.go",
-        "block_test.go",
+        "deposit_test.go",
         "eth1_data_test.go",
+        "exit_test.go",
+        "genesis_test.go",
+        "header_test.go",
+        "proposer_slashing_test.go",
+        "randao_test.go",
     ],
     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",
         "//shared/attestationutil:go_default_library",
         "//shared/bls:go_default_library",
         "//shared/bytesutil: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",
         "//shared/trieutil:go_default_library",
         "@com_github_gogo_protobuf//proto:go_default_library",
         "@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",
-        "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
     ],
 )

beacon-chain/core/blocks/attestation.go

@@ -0,0 +1,379 @@
+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"
+	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"
+)
+
+// ProcessAttestations applies processing operations to a block's inner attestation
+// records.
+func ProcessAttestations(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	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 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)
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessAttestation verifies an input attestation can pass through processing using the given beacon state.
+//
+// Spec pseudocode definition:
+//  def process_attestation(state: BeaconState, attestation: Attestation) -> None:
+//    data = attestation.data
+//    assert data.target.epoch in (get_previous_epoch(state), get_current_epoch(state))
+//    assert data.target.epoch == compute_epoch_at_slot(data.slot)
+//    assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= state.slot <= data.slot + SLOTS_PER_EPOCH
+//    assert data.index < get_committee_count_per_slot(state, data.target.epoch)
+//
+//    committee = get_beacon_committee(state, data.slot, data.index)
+//    assert len(attestation.aggregation_bits) == len(committee)
+//
+//    pending_attestation = PendingAttestation(
+//        data=data,
+//        aggregation_bits=attestation.aggregation_bits,
+//        inclusion_delay=state.slot - data.slot,
+//        proposer_index=get_beacon_proposer_index(state),
+//    )
+//
+//    if data.target.epoch == get_current_epoch(state):
+//        assert data.source == state.current_justified_checkpoint
+//        state.current_epoch_attestations.append(pending_attestation)
+//    else:
+//        assert data.source == state.previous_justified_checkpoint
+//        state.previous_epoch_attestations.append(pending_attestation)
+//
+//    # Check signature
+//    assert is_valid_indexed_attestation(state, get_indexed_attestation(state, attestation))
+func ProcessAttestation(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	att *ethpb.Attestation,
+) (*stateTrie.BeaconState, error) {
+	beaconState, err := ProcessAttestationNoVerifySignature(ctx, beaconState, att)
+	if err != nil {
+		return nil, err
+	}
+	return beaconState, VerifyAttestationSignature(ctx, beaconState, att)
+}
+
+// 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 ProcessAttestationsNoVerifySignature(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	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 = ProcessAttestationNoVerifySignature(ctx, beaconState, attestation)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not verify attestation at index %d in block", idx)
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessAttestationNoVerifySignature processes the attestation without verifying the attestation signature. This
+// method is used to validate attestations whose signatures have already been verified.
+func ProcessAttestationNoVerifySignature(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	att *ethpb.Attestation,
+) (*stateTrie.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "core.ProcessAttestationNoVerifySignature")
+	defer span.End()
+
+	if att == nil || att.Data == nil || att.Data.Target == nil {
+		return nil, errors.New("nil attestation data target")
+	}
+
+	currEpoch := helpers.SlotToEpoch(beaconState.Slot())
+	var prevEpoch uint64
+	if currEpoch == 0 {
+		prevEpoch = 0
+	} else {
+		prevEpoch = currEpoch - 1
+	}
+	data := att.Data
+	if data.Target.Epoch != prevEpoch && data.Target.Epoch != currEpoch {
+		return nil, fmt.Errorf(
+			"expected target epoch (%d) to be the previous epoch (%d) or the current epoch (%d)",
+			data.Target.Epoch,
+			prevEpoch,
+			currEpoch,
+		)
+	}
+	if helpers.SlotToEpoch(data.Slot) != data.Target.Epoch {
+		return nil, fmt.Errorf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(data.Slot), data.Target.Epoch)
+	}
+
+	s := att.Data.Slot
+	minInclusionCheck := s+params.BeaconConfig().MinAttestationInclusionDelay <= beaconState.Slot()
+	epochInclusionCheck := beaconState.Slot() <= s+params.BeaconConfig().SlotsPerEpoch
+	if !minInclusionCheck {
+		return nil, fmt.Errorf(
+			"attestation slot %d + inclusion delay %d > state slot %d",
+			s,
+			params.BeaconConfig().MinAttestationInclusionDelay,
+			beaconState.Slot(),
+		)
+	}
+	if !epochInclusionCheck {
+		return nil, fmt.Errorf(
+			"state slot %d > attestation slot %d + SLOTS_PER_EPOCH %d",
+			beaconState.Slot(),
+			s,
+			params.BeaconConfig().SlotsPerEpoch,
+		)
+	}
+	activeValidatorCount, err := helpers.ActiveValidatorCount(beaconState, att.Data.Target.Epoch)
+	if err != nil {
+		return nil, err
+	}
+	c := helpers.SlotCommitteeCount(activeValidatorCount)
+	if att.Data.CommitteeIndex > c {
+		return nil, fmt.Errorf("committee index %d >= committee count %d", att.Data.CommitteeIndex, c)
+	}
+
+	if err := helpers.VerifyAttestationBitfieldLengths(beaconState, att); err != nil {
+		return nil, errors.Wrap(err, "could not verify attestation bitfields")
+	}
+
+	proposerIndex, err := helpers.BeaconProposerIndex(beaconState)
+	if err != nil {
+		return nil, err
+	}
+	pendingAtt := &pb.PendingAttestation{
+		Data:            data,
+		AggregationBits: att.AggregationBits,
+		InclusionDelay:  beaconState.Slot() - s,
+		ProposerIndex:   proposerIndex,
+	}
+
+	var ffgSourceEpoch uint64
+	var ffgSourceRoot []byte
+	var ffgTargetEpoch uint64
+	if data.Target.Epoch == currEpoch {
+		ffgSourceEpoch = beaconState.CurrentJustifiedCheckpoint().Epoch
+		ffgSourceRoot = beaconState.CurrentJustifiedCheckpoint().Root
+		ffgTargetEpoch = currEpoch
+		if err := beaconState.AppendCurrentEpochAttestations(pendingAtt); err != nil {
+			return nil, err
+		}
+	} else {
+		ffgSourceEpoch = beaconState.PreviousJustifiedCheckpoint().Epoch
+		ffgSourceRoot = beaconState.PreviousJustifiedCheckpoint().Root
+		ffgTargetEpoch = prevEpoch
+		if err := beaconState.AppendPreviousEpochAttestations(pendingAtt); err != nil {
+			return nil, err
+		}
+	}
+	if data.Source.Epoch != ffgSourceEpoch {
+		return nil, fmt.Errorf("expected source epoch %d, received %d", ffgSourceEpoch, data.Source.Epoch)
+	}
+	if !bytes.Equal(data.Source.Root, ffgSourceRoot) {
+		return nil, fmt.Errorf("expected source root %#x, received %#x", ffgSourceRoot, data.Source.Root)
+	}
+	if data.Target.Epoch != ffgTargetEpoch {
+		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
+}
+
+// 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 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 {
+		return nil
+	}
+
+	fork := beaconState.Fork()
+	gvr := beaconState.GenesisValidatorRoot()
+	dt := params.BeaconConfig().DomainBeaconAttester
+
+	// Split attestations by fork. Note: the signature domain will differ based on the fork.
+	var preForkAtts []*ethpb.Attestation
+	var postForkAtts []*ethpb.Attestation
+	for _, a := range atts {
+		if helpers.SlotToEpoch(a.Data.Slot) < fork.Epoch {
+			preForkAtts = append(preForkAtts, a)
+		} else {
+			postForkAtts = append(postForkAtts, a)
+		}
+	}
+
+	// Check attestations from before the fork.
+	if fork.Epoch > 0 { // Check to prevent underflow.
+		prevDomain, err := helpers.Domain(fork, fork.Epoch-1, dt, gvr)
+		if err != nil {
+			return err
+		}
+		if err := verifyAttestationsSigWithDomain(ctx, beaconState, preForkAtts, prevDomain); err != nil {
+			return err
+		}
+	} else if len(preForkAtts) > 0 {
+		// This is a sanity check that preForkAtts were not ignored when fork.Epoch == 0. This
+		// condition is not possible, but it doesn't hurt to check anyway.
+		return errors.New("some attestations were not verified from previous fork before genesis")
+	}
+
+	// Then check attestations from after the fork.
+	currDomain, err := helpers.Domain(fork, fork.Epoch, dt, gvr)
+	if err != nil {
+		return err
+	}
+
+	return verifyAttestationsSigWithDomain(ctx, beaconState, postForkAtts, currDomain)
+}
+
+// VerifyAttestationSignature converts and attestation into an indexed attestation and verifies
+// the signature in that attestation.
+func VerifyAttestationSignature(ctx context.Context, beaconState *stateTrie.BeaconState, att *ethpb.Attestation) error {
+	if att == nil || att.Data == nil || att.AggregationBits.Count() == 0 {
+		return fmt.Errorf("nil or missing attestation data: %v", att)
+	}
+	committee, err := helpers.BeaconCommitteeFromState(beaconState, att.Data.Slot, att.Data.CommitteeIndex)
+	if err != nil {
+		return err
+	}
+	indexedAtt := attestationutil.ConvertToIndexed(ctx, att, committee)
+	return VerifyIndexedAttestation(ctx, beaconState, indexedAtt)
+}
+
+// VerifyIndexedAttestation determines the validity of an indexed attestation.
+//
+// Spec pseudocode definition:
+//  def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: IndexedAttestation) -> bool:
+//    """
+//    Check if ``indexed_attestation`` is not empty, has sorted and unique indices and has a valid aggregate signature.
+//    """
+//    # Verify indices are sorted and unique
+//    indices = indexed_attestation.attesting_indices
+//    if len(indices) == 0 or not indices == sorted(set(indices)):
+//        return False
+//    # Verify aggregate signature
+//    pubkeys = [state.validators[i].pubkey for i in indices]
+//    domain = get_domain(state, DOMAIN_BEACON_ATTESTER, indexed_attestation.data.target.epoch)
+//    signing_root = compute_signing_root(indexed_attestation.data, domain)
+//    return bls.FastAggregateVerify(pubkeys, signing_root, indexed_attestation.signature)
+func VerifyIndexedAttestation(ctx context.Context, beaconState *stateTrie.BeaconState, indexedAtt *ethpb.IndexedAttestation) error {
+	ctx, span := trace.StartSpan(ctx, "core.VerifyIndexedAttestation")
+	defer span.End()
+
+	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
+		return err
+	}
+	domain, err := helpers.Domain(beaconState.Fork(), indexedAtt.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	if err != nil {
+		return err
+	}
+	indices := indexedAtt.AttestingIndices
+	var pubkeys []bls.PublicKey
+	for i := 0; i < len(indices); i++ {
+		pubkeyAtIdx := beaconState.PubkeyAtIndex(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)
+}
+
+// Inner method to verify attestations. This abstraction allows for the domain to be provided as an
+// argument.
+func verifyAttestationsSigWithDomain(ctx context.Context, beaconState *stateTrie.BeaconState, atts []*ethpb.Attestation, domain []byte) error {
+	if len(atts) == 0 {
+		return nil
+	}
+	set, err := createAttestationSignatureSet(ctx, beaconState, atts, domain)
+	if err != nil {
+		return err
+	}
+	verify, err := set.Verify()
+	if err != nil {
+		return errors.Errorf("got error in multiple verification: %v", err)
+	}
+	if !verify {
+		return errors.New("one or more attestation signatures did not verify")
+	}
+	return nil
+}
+
+// VerifyAttSigUseCheckPt uses the checkpoint info object to verify attestation signature.
+func VerifyAttSigUseCheckPt(ctx context.Context, c *pb.CheckPtInfo, att *ethpb.Attestation) error {
+	if att == nil || att.Data == nil || att.AggregationBits.Count() == 0 {
+		return fmt.Errorf("nil or missing attestation data: %v", att)
+	}
+	seed := bytesutil.ToBytes32(c.Seed)
+	committee, err := helpers.BeaconCommittee(c.ActiveIndices, seed, att.Data.Slot, att.Data.CommitteeIndex)
+	if err != nil {
+		return err
+	}
+	indexedAtt := attestationutil.ConvertToIndexed(ctx, att, committee)
+	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
+		return err
+	}
+	domain, err := helpers.Domain(c.Fork, indexedAtt.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, c.GenesisRoot)
+	if err != nil {
+		return err
+	}
+	indices := indexedAtt.AttestingIndices
+	var pubkeys []bls.PublicKey
+	for i := 0; i < len(indices); i++ {
+		pubkeyAtIdx := c.PubKeys[indices[i]]
+		pk, err := bls.PublicKeyFromBytes(pubkeyAtIdx)
+		if err != nil {
+			return errors.Wrap(err, "could not deserialize validator public key")
+		}
+		pubkeys = append(pubkeys, pk)
+	}
+
+	return attestationutil.VerifyIndexedAttestationSig(ctx, indexedAtt, pubkeys, domain)
+}

beacon-chain/core/blocks/attestation_test.go

@@ -0,0 +1,894 @@
+package blocks_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"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/aggregation"
+	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"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
+	attestations := []*ethpb.Attestation{
+		{
+			Data: &ethpb.AttestationData{
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+				Slot:   5,
+			},
+		},
+	}
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Attestations: attestations,
+		},
+	}
+	beaconState, _ := testutil.DeterministicGenesisState(t, 100)
+
+	want := fmt.Sprintf(
+		"attestation slot %d + inclusion delay %d > state slot %d",
+		attestations[0].Data.Slot,
+		params.BeaconConfig().MinAttestationInclusionDelay,
+		beaconState.Slot(),
+	)
+	_, err := blocks.ProcessAttestations(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
+	att := &ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
+			Target: &ethpb.Checkpoint{Epoch: 0}}}
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Attestations: []*ethpb.Attestation{att},
+		},
+	}
+	beaconState, _ := testutil.DeterministicGenesisState(t, 100)
+	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().SlotsPerEpoch*4 + params.BeaconConfig().MinAttestationInclusionDelay)
+	require.NoError(t, err)
+	pfc := beaconState.PreviousJustifiedCheckpoint()
+	pfc.Root = []byte("hello-world")
+	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc))
+	require.NoError(t, beaconState.SetPreviousEpochAttestations([]*pb.PendingAttestation{}))
+
+	want := fmt.Sprintf(
+		"expected target epoch (%d) to be the previous epoch (%d) or the current epoch (%d)",
+		att.Data.Target.Epoch,
+		helpers.PrevEpoch(beaconState),
+		helpers.CurrentEpoch(beaconState),
+	)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
+	aggBits := bitfield.NewBitlist(3)
+	attestations := []*ethpb.Attestation{
+		{
+			Data: &ethpb.AttestationData{
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+				Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+			},
+			AggregationBits: aggBits,
+		},
+	}
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Attestations: attestations,
+		},
+	}
+	beaconState, _ := testutil.DeterministicGenesisState(t, 100)
+	require.NoError(t, beaconState.SetSlot(beaconState.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
+	cfc := beaconState.CurrentJustifiedCheckpoint()
+	cfc.Root = []byte("hello-world")
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
+
+	want := fmt.Sprintf(
+		"expected source epoch %d, received %d",
+		helpers.CurrentEpoch(beaconState),
+		attestations[0].Data.Source.Epoch,
+	)
+	_, err := blocks.ProcessAttestations(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+
+	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, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
+	beaconState, _ := testutil.DeterministicGenesisState(t, 100)
+
+	aggBits := bitfield.NewBitlist(3)
+	aggBits.SetBitAt(0, true)
+	attestations := []*ethpb.Attestation{
+		{
+			Data: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+				Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+				Slot:   params.BeaconConfig().SlotsPerEpoch,
+			},
+			AggregationBits: aggBits,
+		},
+	}
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Attestations: attestations,
+		},
+	}
+
+	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().SlotsPerEpoch + params.BeaconConfig().MinAttestationInclusionDelay)
+	require.NoError(t, err)
+	pfc := beaconState.PreviousJustifiedCheckpoint()
+	pfc.Root = []byte("hello-world")
+	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc))
+	require.NoError(t, beaconState.SetPreviousEpochAttestations([]*pb.PendingAttestation{}))
+
+	want := fmt.Sprintf(
+		"expected source epoch %d, received %d",
+		helpers.PrevEpoch(beaconState),
+		attestations[0].Data.Source.Epoch,
+	)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+
+	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, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
+	beaconState, _ := testutil.DeterministicGenesisState(t, 100)
+
+	aggBits := bitfield.NewBitlist(4)
+	att := &ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
+			Target: &ethpb.Checkpoint{Epoch: 0}},
+		AggregationBits: aggBits,
+	}
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Attestations: []*ethpb.Attestation{att},
+		},
+	}
+
+	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
+	require.NoError(t, err)
+
+	cfc := beaconState.CurrentJustifiedCheckpoint()
+	cfc.Root = []byte("hello-world")
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+	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, b)
+	assert.ErrorContains(t, expected, err)
+}
+
+func TestProcessAttestations_OK(t *testing.T) {
+	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
+
+	aggBits := bitfield.NewBitlist(3)
+	aggBits.SetBitAt(0, true)
+	var mockRoot [32]byte
+	copy(mockRoot[:], "hello-world")
+	att := &ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			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()
+	cfc.Root = mockRoot[:]
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
+
+	committee, err := helpers.BeaconCommitteeFromState(beaconState, att.Data.Slot, att.Data.CommitteeIndex)
+	require.NoError(t, err)
+	attestingIndices := attestationutil.AttestingIndices(att.AggregationBits, committee)
+	require.NoError(t, err)
+	sigs := make([]bls.Signature, len(attestingIndices))
+	for i, indice := range attestingIndices {
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
+		sigs[i] = sig
+	}
+	att.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	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)
+	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: 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)
+	aggBits1.SetBitAt(1, true)
+	aggBits1.SetBitAt(2, true)
+	att1 := &ethpb.Attestation{
+		Data:            data,
+		AggregationBits: aggBits1,
+	}
+
+	cfc := beaconState.CurrentJustifiedCheckpoint()
+	cfc.Root = bytesutil.PadTo([]byte("hello-world"), 32)
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
+
+	committee, err := helpers.BeaconCommitteeFromState(beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
+	require.NoError(t, err)
+	attestingIndices1 := attestationutil.AttestingIndices(att1.AggregationBits, committee)
+	require.NoError(t, err)
+	sigs := make([]bls.Signature, len(attestingIndices1))
+	for i, indice := range attestingIndices1 {
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att1.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
+		sigs[i] = sig
+	}
+	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	aggBits2 := bitfield.NewBitlist(4)
+	aggBits2.SetBitAt(1, true)
+	aggBits2.SetBitAt(2, true)
+	aggBits2.SetBitAt(3, true)
+	att2 := &ethpb.Attestation{
+		Data:            data,
+		AggregationBits: aggBits2,
+	}
+
+	committee, err = helpers.BeaconCommitteeFromState(beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
+	require.NoError(t, err)
+	attestingIndices2 := attestationutil.AttestingIndices(att2.AggregationBits, committee)
+	require.NoError(t, err)
+	sigs = make([]bls.Signature, len(attestingIndices2))
+	for i, indice := range attestingIndices2 {
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att2.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
+		sigs[i] = sig
+	}
+	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	_, err = attaggregation.AggregatePair(att1, att2)
+	assert.ErrorContains(t, aggregation.ErrBitsOverlap.Error(), err)
+}
+
+func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
+	beaconState, privKeys := testutil.DeterministicGenesisState(t, 300)
+
+	var mockRoot [32]byte
+	copy(mockRoot[:], "hello-world")
+	data := &ethpb.AttestationData{
+		Source:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+		Target:          &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+		BeaconBlockRoot: make([]byte, 32),
+	}
+	aggBits1 := bitfield.NewBitlist(9)
+	aggBits1.SetBitAt(0, true)
+	aggBits1.SetBitAt(1, true)
+	att1 := &ethpb.Attestation{
+		Data:            data,
+		AggregationBits: aggBits1,
+		Signature:       make([]byte, 32),
+	}
+
+	cfc := beaconState.CurrentJustifiedCheckpoint()
+	cfc.Root = mockRoot[:]
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
+	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
+
+	committee, err := helpers.BeaconCommitteeFromState(beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
+	require.NoError(t, err)
+	attestingIndices1 := attestationutil.AttestingIndices(att1.AggregationBits, committee)
+	require.NoError(t, err)
+	sigs := make([]bls.Signature, len(attestingIndices1))
+	for i, indice := range attestingIndices1 {
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
+		sigs[i] = sig
+	}
+	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	aggBits2 := bitfield.NewBitlist(9)
+	aggBits2.SetBitAt(2, true)
+	aggBits2.SetBitAt(3, true)
+	att2 := &ethpb.Attestation{
+		Data:            data,
+		AggregationBits: aggBits2,
+		Signature:       make([]byte, 32),
+	}
+
+	committee, err = helpers.BeaconCommitteeFromState(beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
+	require.NoError(t, err)
+	attestingIndices2 := attestationutil.AttestingIndices(att2.AggregationBits, committee)
+	require.NoError(t, err)
+	sigs = make([]bls.Signature, len(attestingIndices2))
+	for i, indice := range attestingIndices2 {
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att2.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
+		sigs[i] = sig
+	}
+	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	aggregatedAtt, err := attaggregation.AggregatePair(att1, att2)
+	require.NoError(t, err)
+	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)
+	assert.NoError(t, err)
+}
+
+func TestProcessAttestationsNoVerify_IncorrectSlotTargetEpoch(t *testing.T) {
+	beaconState, _ := testutil.DeterministicGenesisState(t, 1)
+
+	att := &ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			Slot:   params.BeaconConfig().SlotsPerEpoch,
+			Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
+		},
+	}
+	wanted := fmt.Sprintf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(att.Data.Slot), att.Data.Target.Epoch)
+	_, err := blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
+	assert.ErrorContains(t, wanted, err)
+}
+
+func TestProcessAttestationsNoVerify_OK(t *testing.T) {
+	// Attestation with an empty signature
+
+	beaconState, _ := testutil.DeterministicGenesisState(t, 100)
+
+	aggBits := bitfield.NewBitlist(3)
+	aggBits.SetBitAt(1, true)
+	var mockRoot [32]byte
+	copy(mockRoot[:], "hello-world")
+	att := &ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+		},
+		AggregationBits: aggBits,
+	}
+
+	zeroSig := [96]byte{}
+	att.Signature = zeroSig[:]
+
+	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
+	require.NoError(t, err)
+	ckp := beaconState.CurrentJustifiedCheckpoint()
+	copy(ckp.Root, "hello-world")
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
+	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
+
+	_, err = blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
+	assert.NoError(t, err)
+}
+
+func TestProcessAttestationsNoVerify_BadAttIdx(t *testing.T) {
+	beaconState, _ := testutil.DeterministicGenesisState(t, 100)
+	aggBits := bitfield.NewBitlist(3)
+	aggBits.SetBitAt(1, true)
+	var mockRoot [32]byte
+	copy(mockRoot[:], "hello-world")
+	att := &ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			CommitteeIndex: 100,
+			Source:         &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+			Target:         &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+		},
+		AggregationBits: aggBits,
+	}
+	zeroSig := [96]byte{}
+	att.Signature = zeroSig[:]
+	require.NoError(t, beaconState.SetSlot(beaconState.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
+	ckp := beaconState.CurrentJustifiedCheckpoint()
+	copy(ckp.Root, "hello-world")
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
+	require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
+	_, err := blocks.ProcessAttestationNoVerifySignature(context.TODO(), beaconState, att)
+	require.ErrorContains(t, "committee index 100 >= committee count 1", err)
+}
+
+func TestConvertToIndexed_OK(t *testing.T) {
+	helpers.ClearCache()
+	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Slot:        5,
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+	tests := []struct {
+		aggregationBitfield    bitfield.Bitlist
+		wantedAttestingIndices []uint64
+	}{
+		{
+			aggregationBitfield:    bitfield.Bitlist{0x07},
+			wantedAttestingIndices: []uint64{43, 47},
+		},
+		{
+			aggregationBitfield:    bitfield.Bitlist{0x03},
+			wantedAttestingIndices: []uint64{47},
+		},
+		{
+			aggregationBitfield:    bitfield.Bitlist{0x01},
+			wantedAttestingIndices: []uint64{},
+		},
+	}
+
+	var sig [96]byte
+	copy(sig[:], "signed")
+	attestation := &ethpb.Attestation{
+		Signature: sig[:],
+		Data: &ethpb.AttestationData{
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+		},
+	}
+	for _, tt := range tests {
+		attestation.AggregationBits = tt.aggregationBitfield
+		wanted := &ethpb.IndexedAttestation{
+			AttestingIndices: tt.wantedAttestingIndices,
+			Data:             attestation.Data,
+			Signature:        attestation.Signature,
+		}
+
+		committee, err := helpers.BeaconCommitteeFromState(state, attestation.Data.Slot, attestation.Data.CommitteeIndex)
+		require.NoError(t, err)
+		ia := attestationutil.ConvertToIndexed(context.Background(), attestation, committee)
+		assert.DeepEqual(t, wanted, ia, "Convert attestation to indexed attestation didn't result as wanted")
+	}
+}
+
+func TestVerifyIndexedAttestation_OK(t *testing.T) {
+	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
+	validators := make([]*ethpb.Validator, numOfValidators)
+	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
+	require.NoError(t, err)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
+		}
+	}
+
+	state, 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),
+	})
+	require.NoError(t, err)
+	tests := []struct {
+		attestation *ethpb.IndexedAttestation
+	}{
+		{attestation: &ethpb.IndexedAttestation{
+			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),
+		}},
+	}
+
+	for _, tt := range tests {
+		var sig []bls.Signature
+		for _, idx := range tt.attestation.AttestingIndices {
+			sb, err := helpers.ComputeDomainAndSign(state, tt.attestation.Data.Target.Epoch, tt.attestation.Data, params.BeaconConfig().DomainBeaconAttester, keys[idx])
+			require.NoError(t, err)
+			validatorSig, err := bls.SignatureFromBytes(sb)
+			require.NoError(t, err)
+			sig = append(sig, validatorSig)
+		}
+		aggSig := bls.AggregateSignatures(sig)
+		marshalledSig := aggSig.Marshal()
+
+		tt.attestation.Signature = marshalledSig
+
+		err = blocks.VerifyIndexedAttestation(context.Background(), state, tt.attestation)
+		assert.NoError(t, err, "Failed to verify indexed attestation")
+	}
+}
+
+func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
+	indexedAtt1 := &ethpb.IndexedAttestation{
+		AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+5),
+	}
+
+	for i := uint64(0); i < params.BeaconConfig().MaxValidatorsPerCommittee+5; i++ {
+		indexedAtt1.AttestingIndices[i] = i
+		indexedAtt1.Data = &ethpb.AttestationData{
+			Target: &ethpb.Checkpoint{
+				Epoch: i,
+			},
+		}
+	}
+
+	want := "validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE"
+	err := blocks.VerifyIndexedAttestation(context.Background(), &stateTrie.BeaconState{}, indexedAtt1)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
+	beaconState, keys := testutil.DeterministicGenesisState(t, 1000)
+
+	sig := keys[0].Sign([]byte{'t', 'e', 's', 't'})
+	list := bitfield.Bitlist{0b11111111}
+	var atts []*ethpb.Attestation
+	for i := uint64(0); i < 1000; i++ {
+		atts = append(atts, &ethpb.Attestation{
+			Data: &ethpb.AttestationData{
+				CommitteeIndex: 1,
+				Slot:           1,
+			},
+			Signature:       sig.Marshal(),
+			AggregationBits: list,
+		})
+	}
+
+	want := "nil or missing indexed attestation data"
+	_, err := blocks.AttestationSignatureSet(context.Background(), beaconState, atts)
+	assert.ErrorContains(t, want, err)
+
+	atts = []*ethpb.Attestation{}
+	list = bitfield.Bitlist{0b00000000}
+	for i := uint64(0); i < 1000; i++ {
+		atts = append(atts, &ethpb.Attestation{
+			Data: &ethpb.AttestationData{
+				CommitteeIndex: 1,
+				Slot:           1,
+				Target: &ethpb.Checkpoint{
+					Root: []byte{},
+				},
+			},
+			Signature:       sig.Marshal(),
+			AggregationBits: list,
+		})
+	}
+
+	want = "expected non-empty attesting indices"
+	_, err = blocks.AttestationSignatureSet(context.Background(), beaconState, atts)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
+	ctx := context.Background()
+	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
+	validators := make([]*ethpb.Validator, numOfValidators)
+	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
+	require.NoError(t, err)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
+		}
+	}
+
+	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,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		},
+		Signature: make([]byte, 96),
+	}
+	domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	require.NoError(t, err)
+	root, err := helpers.ComputeSigningRoot(att1.Data, domain)
+	require.NoError(t, err)
+	var sigs []bls.Signature
+	for i, u := range comm1 {
+		att1.AggregationBits.SetBitAt(uint64(i), true)
+		sigs = append(sigs, keys[u].Sign(root[:]))
+	}
+	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	comm2, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 1 /*committeeIndex*/)
+	require.NoError(t, err)
+	att2 := &ethpb.Attestation{
+		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
+		Data: &ethpb.AttestationData{
+			Slot:            1,
+			CommitteeIndex:  1,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		},
+		Signature: make([]byte, 96),
+	}
+	root, err = helpers.ComputeSigningRoot(att2.Data, domain)
+	require.NoError(t, err)
+	sigs = nil
+	for i, u := range comm2 {
+		att2.AggregationBits.SetBitAt(uint64(i), true)
+		sigs = append(sigs, keys[u].Sign(root[:]))
+	}
+	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	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) {
+	// In this test, att1 is from the prior fork and att2 is from the new fork.
+	ctx := context.Background()
+	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
+	validators := make([]*ethpb.Validator, numOfValidators)
+	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
+	require.NoError(t, err)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
+		}
+	}
+
+	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,
+			BeaconBlockRoot: make([]byte, 32),
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		},
+		Signature: make([]byte, 96),
+	}
+	prevDomain, err := helpers.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	require.NoError(t, err)
+	root, err := helpers.ComputeSigningRoot(att1.Data, prevDomain)
+	require.NoError(t, err)
+	var sigs []bls.Signature
+	for i, u := range comm1 {
+		att1.AggregationBits.SetBitAt(uint64(i), true)
+		sigs = append(sigs, keys[u].Sign(root[:]))
+	}
+	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	comm2, err := helpers.BeaconCommitteeFromState(st, 1*params.BeaconConfig().SlotsPerEpoch+1 /*slot*/, 1 /*committeeIndex*/)
+	require.NoError(t, err)
+	att2 := &ethpb.Attestation{
+		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
+		Data: &ethpb.AttestationData{
+			Slot:            1*params.BeaconConfig().SlotsPerEpoch + 1,
+			CommitteeIndex:  1,
+			BeaconBlockRoot: make([]byte, 32),
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		},
+		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
+	for i, u := range comm2 {
+		att2.AggregationBits.SetBitAt(uint64(i), true)
+		sigs = append(sigs, keys[u].Sign(root[:]))
+	}
+	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	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) {
+	ctx := context.Background()
+	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
+	validators := make([]*ethpb.Validator, numOfValidators)
+	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
+	require.NoError(t, err)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
+		}
+	}
+
+	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,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		},
+		Signature: make([]byte, 96),
+	}
+	domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	require.NoError(t, err)
+	root, err := helpers.ComputeSigningRoot(att1.Data, domain)
+	require.NoError(t, err)
+	var sigs []bls.Signature
+	for i, u := range comm1 {
+		att1.AggregationBits.SetBitAt(uint64(i), true)
+		sigs = append(sigs, keys[u].Sign(root[:]))
+	}
+	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	comm2, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 1 /*committeeIndex*/)
+	require.NoError(t, err)
+	att2 := &ethpb.Attestation{
+		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
+		Data: &ethpb.AttestationData{
+			Slot:            1,
+			CommitteeIndex:  1,
+			BeaconBlockRoot: make([]byte, 32),
+			Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+			Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		},
+		Signature: make([]byte, 96),
+	}
+	root, err = helpers.ComputeSigningRoot(att2.Data, domain)
+	require.NoError(t, err)
+	sigs = nil
+	for i, u := range comm2 {
+		att2.AggregationBits.SetBitAt(uint64(i), true)
+		sigs = append(sigs, keys[u].Sign(root[:]))
+	}
+	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
+
+	set, err := blocks.AttestationSignatureSet(ctx, st, []*ethpb.Attestation{att1, att2})
+	require.NoError(t, err)
+	verified, err := set.Verify()
+	require.NoError(t, err)
+	assert.Equal(t, true, verified, "Multiple signatures were unable to be verified.")
+}

beacon-chain/core/blocks/attester_slashing.go

@@ -0,0 +1,134 @@
+package blocks
+
+import (
+	"context"
+	"sort"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/sliceutil"
+)
+
+// ProcessAttesterSlashings is one of the operations performed
+// on each processed beacon block to slash attesters based on
+// Casper FFG slashing conditions if any slashable events occurred.
+//
+// Spec pseudocode definition:
+//   def process_attester_slashing(state: BeaconState, attester_slashing: AttesterSlashing) -> None:
+//    attestation_1 = attester_slashing.attestation_1
+//    attestation_2 = attester_slashing.attestation_2
+//    assert is_slashable_attestation_data(attestation_1.data, attestation_2.data)
+//    assert is_valid_indexed_attestation(state, attestation_1)
+//    assert is_valid_indexed_attestation(state, attestation_2)
+//
+//    slashed_any = False
+//    indices = set(attestation_1.attesting_indices).intersection(attestation_2.attesting_indices)
+//    for index in sorted(indices):
+//        if is_slashable_validator(state.validators[index], get_current_epoch(state)):
+//            slash_validator(state, index)
+//            slashed_any = True
+//    assert slashed_any
+func ProcessAttesterSlashings(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	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)
+		}
+		slashableIndices := slashableAttesterIndices(slashing)
+		sort.SliceStable(slashableIndices, func(i, j int) bool {
+			return slashableIndices[i] < slashableIndices[j]
+		})
+		currentEpoch := helpers.SlotToEpoch(beaconState.Slot())
+		var err error
+		var slashedAny bool
+		var val *stateTrie.ReadOnlyValidator
+		for _, validatorIndex := range slashableIndices {
+			val, err = beaconState.ValidatorAtIndexReadOnly(validatorIndex)
+			if err != nil {
+				return nil, err
+			}
+			if helpers.IsSlashableValidator(val.ActivationEpoch(), val.WithdrawableEpoch(), val.Slashed(), currentEpoch) {
+				beaconState, err = v.SlashValidator(beaconState, validatorIndex)
+				if err != nil {
+					return nil, errors.Wrapf(err, "could not slash validator index %d",
+						validatorIndex)
+				}
+				slashedAny = true
+			}
+		}
+		if !slashedAny {
+			return nil, errors.New("unable to slash any validator despite confirmed attester slashing")
+		}
+	}
+	return beaconState, nil
+}
+
+// VerifyAttesterSlashing validates the attestation data in both attestations in the slashing object.
+func VerifyAttesterSlashing(ctx context.Context, beaconState *stateTrie.BeaconState, slashing *ethpb.AttesterSlashing) error {
+	if slashing == nil {
+		return errors.New("nil slashing")
+	}
+	if slashing.Attestation_1 == nil || slashing.Attestation_2 == nil {
+		return errors.New("nil attestation")
+	}
+	if slashing.Attestation_1.Data == nil || slashing.Attestation_2.Data == nil {
+		return errors.New("nil attestation data")
+	}
+	att1 := slashing.Attestation_1
+	att2 := slashing.Attestation_2
+	data1 := att1.Data
+	data2 := att2.Data
+	if !IsSlashableAttestationData(data1, data2) {
+		return errors.New("attestations are not slashable")
+	}
+	if err := VerifyIndexedAttestation(ctx, beaconState, att1); err != nil {
+		return errors.Wrap(err, "could not validate indexed attestation")
+	}
+	if err := VerifyIndexedAttestation(ctx, beaconState, att2); err != nil {
+		return errors.Wrap(err, "could not validate indexed attestation")
+	}
+	return nil
+}
+
+// IsSlashableAttestationData verifies a slashing against the Casper Proof of Stake FFG rules.
+//
+// Spec pseudocode definition:
+//   def is_slashable_attestation_data(data_1: AttestationData, data_2: AttestationData) -> bool:
+//    """
+//    Check if ``data_1`` and ``data_2`` are slashable according to Casper FFG rules.
+//    """
+//    return (
+//        # Double vote
+//        (data_1 != data_2 and data_1.target.epoch == data_2.target.epoch) or
+//        # Surround vote
+//        (data_1.source.epoch < data_2.source.epoch and data_2.target.epoch < data_1.target.epoch)
+//    )
+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
+	}
+	isDoubleVote := !attestationutil.AttDataIsEqual(data1, data2) && data1.Target.Epoch == data2.Target.Epoch
+	isSurroundVote := data1.Source.Epoch < data2.Source.Epoch && data2.Target.Epoch < data1.Target.Epoch
+	return isDoubleVote || isSurroundVote
+}
+
+func slashableAttesterIndices(slashing *ethpb.AttesterSlashing) []uint64 {
+	if slashing == nil || slashing.Attestation_1 == nil || slashing.Attestation_2 == nil {
+		return nil
+	}
+	indices1 := slashing.Attestation_1.AttestingIndices
+	indices2 := slashing.Attestation_2.AttestingIndices
+	return sliceutil.IntersectionUint64(indices1, indices2)
+}

beacon-chain/core/blocks/attester_slashing_test.go

@@ -0,0 +1,192 @@
+package blocks_test
+
+import (
+	"context"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"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"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestSlashableAttestationData_CanSlash(t *testing.T) {
+	att1 := &ethpb.AttestationData{
+		Target:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+		Source:          &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)},
+		BeaconBlockRoot: make([]byte, 32),
+	}
+	att2 := &ethpb.AttestationData{
+		Target:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+		Source:          &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'B'}, 32)},
+		BeaconBlockRoot: make([]byte, 32),
+	}
+	assert.Equal(t, true, blocks.IsSlashableAttestationData(att1, att2), "Atts should have been slashable")
+	att1.Target.Epoch = 4
+	att1.Source.Epoch = 2
+	att2.Source.Epoch = 3
+	assert.Equal(t, true, blocks.IsSlashableAttestationData(att1, att2), "Atts should have been slashable")
+}
+
+func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
+	slashings := []*ethpb.AttesterSlashing{
+		{
+			Attestation_1: &ethpb.IndexedAttestation{
+				Data: &ethpb.AttestationData{
+					Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					BeaconBlockRoot: make([]byte, 32),
+				},
+				Signature: make([]byte, 96),
+			},
+			Attestation_2: &ethpb.IndexedAttestation{
+				Data: &ethpb.AttestationData{
+					Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+					Target:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+					BeaconBlockRoot: make([]byte, 32),
+				},
+				Signature: make([]byte, 96),
+			},
+		},
+	}
+	var registry []*ethpb.Validator
+	currentSlot := uint64(0)
+
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Slot:       currentSlot,
+	})
+	require.NoError(t, err)
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			AttesterSlashings: slashings,
+		},
+	}
+	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, b)
+	assert.ErrorContains(t, "attestations are not slashable", err)
+}
+
+func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T) {
+	var registry []*ethpb.Validator
+	currentSlot := uint64(0)
+
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Slot:       currentSlot,
+	})
+	require.NoError(t, err)
+
+	slashings := []*ethpb.AttesterSlashing{
+		{
+			Attestation_1: &ethpb.IndexedAttestation{
+				Data: &ethpb.AttestationData{
+					Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					BeaconBlockRoot: make([]byte, 32),
+				},
+				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
+				Signature:        make([]byte, 96),
+			},
+			Attestation_2: &ethpb.IndexedAttestation{
+				Data: &ethpb.AttestationData{
+					Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+					BeaconBlockRoot: make([]byte, 32),
+				},
+				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
+				Signature:        make([]byte, 96),
+			},
+		},
+	}
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			AttesterSlashings: slashings,
+		},
+	}
+
+	_, 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) {
+	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
+	for _, vv := range beaconState.Validators() {
+		vv.WithdrawableEpoch = 1 * params.BeaconConfig().SlotsPerEpoch
+	}
+
+	att1 := &ethpb.IndexedAttestation{
+		Data: &ethpb.AttestationData{
+			Source:          &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			BeaconBlockRoot: make([]byte, 32),
+		},
+		AttestingIndices: []uint64{0, 1},
+	}
+	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	require.NoError(t, err)
+	signingRoot, err := helpers.ComputeSigningRoot(att1.Data, domain)
+	assert.NoError(t, err, "Could not get signing root of beacon block header")
+	sig0 := privKeys[0].Sign(signingRoot[:])
+	sig1 := privKeys[1].Sign(signingRoot[:])
+	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
+	att1.Signature = aggregateSig.Marshal()
+
+	att2 := &ethpb.IndexedAttestation{
+		Data: &ethpb.AttestationData{
+			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			BeaconBlockRoot: make([]byte, 32),
+		},
+		AttestingIndices: []uint64{0, 1},
+	}
+	signingRoot, err = helpers.ComputeSigningRoot(att2.Data, domain)
+	assert.NoError(t, err, "Could not get signing root of beacon block header")
+	sig0 = privKeys[0].Sign(signingRoot[:])
+	sig1 = privKeys[1].Sign(signingRoot[:])
+	aggregateSig = bls.AggregateSignatures([]bls.Signature{sig0, sig1})
+	att2.Signature = aggregateSig.Marshal()
+
+	slashings := []*ethpb.AttesterSlashing{
+		{
+			Attestation_1: att1,
+			Attestation_2: att2,
+		},
+	}
+
+	currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch
+	require.NoError(t, beaconState.SetSlot(currentSlot))
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			AttesterSlashings: slashings,
+		},
+	}
+
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b)
+	require.NoError(t, err)
+	newRegistry := newState.Validators()
+
+	// Given the intersection of slashable indices is [1], only validator
+	// at index 1 should be slashed and exited. We confirm this below.
+	if newRegistry[1].ExitEpoch != beaconState.Validators()[1].ExitEpoch {
+		t.Errorf(
+			`
+			Expected validator at index 1's exit epoch to match
+			%d, received %d instead
+			`,
+			beaconState.Validators()[1].ExitEpoch,
+			newRegistry[1].ExitEpoch,
+		)
+	}
+}

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)
 		}
 	}
 }
@@ -90,21 +90,22 @@ func TestFuzzareEth1DataEqual_10000(t *testing.T) {
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(eth1data)
 		fuzzer.Fuzz(eth1data2)
-		areEth1DataEqual(eth1data, eth1data2)
-		areEth1DataEqual(eth1data, eth1data)
+		AreEth1DataEqual(eth1data, eth1data2)
+		AreEth1DataEqual(eth1data, eth1data)
 	}
 }
 
 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,45 +314,48 @@ 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)
+		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)
-		r, err := ProcessPreGenesisDeposit(ctx, s, deposit)
+		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,14 +364,15 @@ 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)
-		r, err := ProcessDeposit(s, deposit)
+		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

@@ -10,6 +10,8 @@ import (
 	"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"
 )
 
 func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
@@ -37,46 +39,44 @@ 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())
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	signingRoot, err := helpers.ComputeSigningRoot(att1.Data, domain)
-	if err != nil {
-		t.Errorf("Could not get signing root of beacon block header: %v", err)
-	}
-	aggSigs := []*bls.Signature{}
+	require.NoError(t, err, "Could not get signing root of beacon block header")
+	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)
-	if err != nil {
-		t.Errorf("Could not get signing root of beacon block header: %v", err)
-	}
-	aggSigs = []*bls.Signature{}
+	assert.NoError(t, err, "Could not get signing root of beacon block header")
+	aggSigs = []bls.Signature{}
 	for _, index := range setB {
 		sig := privKeys[index].Sign(signingRoot[:])
 		aggSigs = append(aggSigs, sig)
 	}
 	aggregateSig = bls.AggregateSignatures(aggSigs)
-	att2.Signature = aggregateSig.Marshal()[:]
+	att2.Signature = aggregateSig.Marshal()
 
 	slashings := []*ethpb.AttesterSlashing{
 		{
@@ -86,20 +86,17 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 	}
 
 	currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch
-	if err := beaconState.SetSlot(currentSlot); err != nil {
-		t.Fatal(err)
-	}
+	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)
-	if err != nil {
-		t.Fatal(err)
-	}
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b)
+	require.NoError(t, err)
 	newRegistry := newState.Validators()
 	if !newRegistry[expectedSlashedVal].Slashed {
 		t.Errorf("Validator with index %d was not slashed despite performing a double vote", expectedSlashedVal)

beacon-chain/core/blocks/block_test.go

@@ -1,21 +0,0 @@
-package blocks_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-)
-
-func TestGenesisBlock_InitializedCorrectly(t *testing.T) {
-	stateHash := []byte{0}
-	b1 := blocks.NewGenesisBlock(stateHash)
-
-	if b1.Block.ParentRoot == nil {
-		t.Error("genesis block missing ParentHash field")
-	}
-
-	if !bytes.Equal(b1.Block.StateRoot, stateHash) {
-		t.Error("genesis block StateRootHash32 isn't initialized correctly")
-	}
-}

beacon-chain/core/blocks/deposit.go

@@ -0,0 +1,271 @@
+package blocks
+
+import (
+	"context"
+	"fmt"
+
+	"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"
+	"github.com/prysmaticlabs/prysm/shared/bls"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/depositutil"
+	"github.com/prysmaticlabs/prysm/shared/mathutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/trieutil"
+)
+
+// ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.
+func ProcessPreGenesisDeposits(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	deposits []*ethpb.Deposit,
+) (*stateTrie.BeaconState, error) {
+	var err error
+	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")
+	}
+	for _, deposit := range deposits {
+		pubkey := deposit.Data.PublicKey
+		index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubkey))
+		if !ok {
+			return beaconState, nil
+		}
+		balance, err := beaconState.BalanceAtIndex(index)
+		if err != nil {
+			return nil, err
+		}
+		validator, err := beaconState.ValidatorAtIndex(index)
+		if err != nil {
+			return nil, err
+		}
+		validator.EffectiveBalance = mathutil.Min(balance-balance%params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalance)
+		if validator.EffectiveBalance ==
+			params.BeaconConfig().MaxEffectiveBalance {
+			validator.ActivationEligibilityEpoch = 0
+			validator.ActivationEpoch = 0
+		}
+		if err := beaconState.UpdateValidatorAtIndex(index, validator); err != nil {
+			return nil, err
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessDeposits is one of the operations performed on each processed
+// beacon block to verify queued validators from the Ethereum 1.0 Deposit Contract
+// into the beacon chain.
+//
+// Spec pseudocode definition:
+//   For each deposit in block.body.deposits:
+//     process_deposit(state, deposit)
+func ProcessDeposits(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	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")
+	}
+
+	deposits := b.Block.Body.Deposits
+	var err error
+	domain, err := helpers.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Attempt to verify all deposit signatures at once, if this fails then fall back to processing
+	// individual deposits with signature verification enabled.
+	var verifySignature bool
+	if err := verifyDepositDataWithDomain(ctx, deposits, domain); err != nil {
+		log.WithError(err).Debug("Failed to verify deposit data, verifying signatures individually")
+		verifySignature = true
+	}
+
+	for _, deposit := range deposits {
+		if deposit == nil || deposit.Data == nil {
+			return nil, errors.New("got a nil deposit in block")
+		}
+		beaconState, err = ProcessDeposit(beaconState, deposit, verifySignature)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessDeposit takes in a deposit object and inserts it
+// into the registry as a new validator or balance change.
+//
+// Spec pseudocode definition:
+// def process_deposit(state: BeaconState, deposit: Deposit) -> None:
+//    # Verify the Merkle branch
+//    assert is_valid_merkle_branch(
+//        leaf=hash_tree_root(deposit.data),
+//        branch=deposit.proof,
+//        depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
+//        index=state.eth1_deposit_index,
+//        root=state.eth1_data.deposit_root,
+//    )
+//
+//    # Deposits must be processed in order
+//    state.eth1_deposit_index += 1
+//
+//    pubkey = deposit.data.pubkey
+//    amount = deposit.data.amount
+//    validator_pubkeys = [v.pubkey for v in state.validators]
+//    if pubkey not in validator_pubkeys:
+//        # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//        deposit_message = DepositMessage(
+//            pubkey=deposit.data.pubkey,
+//            withdrawal_credentials=deposit.data.withdrawal_credentials,
+//            amount=deposit.data.amount,
+//        )
+//        domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
+//        signing_root = compute_signing_root(deposit_message, domain)
+//        if not bls.Verify(pubkey, signing_root, deposit.data.signature):
+//            return
+//
+//        # Add validator and balance entries
+//        state.validators.append(get_validator_from_deposit(state, deposit))
+//        state.balances.append(amount)
+//    else:
+//        # Increase balance by deposit amount
+//        index = ValidatorIndex(validator_pubkeys.index(pubkey))
+//        increase_balance(state, index, amount)
+func ProcessDeposit(beaconState *stateTrie.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (*stateTrie.BeaconState, error) {
+	if err := verifyDeposit(beaconState, deposit); err != nil {
+		if deposit == nil || deposit.Data == nil {
+			return nil, err
+		}
+		return nil, errors.Wrapf(err, "could not verify deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
+	}
+	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
+		return nil, err
+	}
+	pubKey := deposit.Data.PublicKey
+	amount := deposit.Data.Amount
+	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
+	if !ok {
+		if verifySignature {
+			domain, err := helpers.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+			if err != nil {
+				return nil, err
+			}
+			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
+			}
+		}
+
+		effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
+		if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
+			effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+		}
+		if err := beaconState.AppendValidator(&ethpb.Validator{
+			PublicKey:                  pubKey,
+			WithdrawalCredentials:      deposit.Data.WithdrawalCredentials,
+			ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+			ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+			WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance:           effectiveBalance,
+		}); err != nil {
+			return nil, err
+		}
+		if err := beaconState.AppendBalance(amount); err != nil {
+			return nil, err
+		}
+	} else if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
+		return nil, err
+	}
+
+	return beaconState, nil
+}
+
+func verifyDeposit(beaconState *stateTrie.BeaconState, deposit *ethpb.Deposit) error {
+	// Verify Merkle proof of deposit and deposit trie root.
+	if deposit == nil || deposit.Data == nil {
+		return errors.New("received nil deposit or nil deposit data")
+	}
+	eth1Data := beaconState.Eth1Data()
+	if eth1Data == nil {
+		return errors.New("received nil eth1data in the beacon state")
+	}
+
+	receiptRoot := eth1Data.DepositRoot
+	leaf, err := deposit.Data.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not tree hash deposit data")
+	}
+	if ok := trieutil.VerifyMerkleBranch(
+		receiptRoot,
+		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, domain []byte) error {
+	return depositutil.VerifyDepositSignature(obj, domain)
+}
+
+func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, domain []byte) error {
+	if len(deps) == 0 {
+		return nil
+	}
+	pks := make([]bls.PublicKey, len(deps))
+	sigs := make([][]byte, len(deps))
+	msgs := make([][32]byte, len(deps))
+	for i, dep := range deps {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		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
+		sigs[i] = dep.Data.Signature
+		root, err := ssz.SigningRoot(dep.Data)
+		if err != nil {
+			return errors.Wrap(err, "could not get signing root")
+		}
+		signingData := &pb.SigningData{
+			ObjectRoot: root[:],
+			Domain:     domain,
+		}
+		ctrRoot, err := signingData.HashTreeRoot()
+		if err != nil {
+			return errors.Wrap(err, "could not get container root")
+		}
+		msgs[i] = ctrRoot
+	}
+	verify, err := bls.VerifyMultipleSignatures(sigs, msgs, pks)
+	if err != nil {
+		return errors.Errorf("could not verify multiple signatures: %v", err)
+	}
+	if !verify {
+		return errors.New("one or more deposit signatures did not verify")
+	}
+	return nil
+}

beacon-chain/core/blocks/deposit_test.go

@@ -0,0 +1,273 @@
+package blocks_test
+
+import (
+	"context"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"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"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/trieutil"
+)
+
+func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
+	// Same validator created 3 valid deposits within the same block
+	testutil.ResetCache()
+	dep, _, err := testutil.DeterministicDepositsAndKeysSameValidator(3)
+	require.NoError(t, err)
+	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
+	require.NoError(t, err)
+	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]},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &pb.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	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")
+}
+
+func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, 96),
+		},
+	}
+	leaf, err := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	// We then create a merkle branch for the test.
+	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
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Deposits: []*ethpb.Deposit{deposit},
+		},
+	}
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: []byte{0},
+			BlockHash:   []byte{1},
+		},
+	})
+	require.NoError(t, err)
+	want := "deposit root did not verify"
+	_, err = blocks.ProcessDeposits(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
+	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	require.NoError(t, err)
+	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
+	require.NoError(t, err)
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Deposits: []*ethpb.Deposit{dep[0]},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &pb.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	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(
+			"Expected state validator balances index 0 to equal %d, received %d",
+			dep[0].Data.Amount,
+			newState.Balances()[1],
+		)
+	}
+}
+
+func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
+	sk := bls.RandKey()
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             sk.PublicKey().Marshal(),
+			Amount:                1000,
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, 96),
+		},
+	}
+	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 := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	// We then create a merkle branch for the test.
+	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
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Deposits: []*ethpb.Deposit{deposit},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			PublicKey: []byte{1, 2, 3},
+		},
+		{
+			PublicKey:             sk.PublicKey().Marshal(),
+			WithdrawalCredentials: []byte{1},
+		},
+	}
+	balances := []uint64{0, 50}
+	root := depositTrie.Root()
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: root[:],
+			BlockHash:   root[:],
+		},
+	})
+	require.NoError(t, err)
+	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")
+}
+
+func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
+	//Similar to TestProcessDeposits_AddsNewValidatorDeposit except that this test directly calls ProcessDeposit
+	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	require.NoError(t, err)
+	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
+	require.NoError(t, err)
+
+	registry := []*ethpb.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &pb.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	newState, err := blocks.ProcessDeposit(beaconState, dep[0], true)
+	require.NoError(t, err, "Process deposit failed")
+	assert.Equal(t, 2, len(newState.Validators()), "Expected validator list to have length 2")
+	assert.Equal(t, 2, len(newState.Balances()), "Expected validator balances list to have length 2")
+	if newState.Balances()[1] != dep[0].Data.Amount {
+		t.Errorf(
+			"Expected state validator balances index 1 to equal %d, received %d",
+			dep[0].Data.Amount,
+			newState.Balances()[1],
+		)
+	}
+}
+
+func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
+	// Same test settings as in TestProcessDeposit_AddsNewValidatorDeposit, except that we use an invalid signature
+	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	require.NoError(t, err)
+	dep[0].Data.Signature = make([]byte, 96)
+	trie, _, err := testutil.DepositTrieFromDeposits(dep)
+	require.NoError(t, err)
+	root := trie.Root()
+	eth1Data := &ethpb.Eth1Data{
+		DepositRoot:  root[:],
+		DepositCount: 1,
+	}
+	registry := []*ethpb.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &pb.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	newState, err := blocks.ProcessDeposit(beaconState, dep[0], true)
+	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
+
+	if newState.Eth1DepositIndex() != 1 {
+		t.Errorf(
+			"Expected Eth1DepositIndex to be increased by 1 after processing an invalid deposit, received change: %v",
+			newState.Eth1DepositIndex(),
+		)
+	}
+	if len(newState.Validators()) != 1 {
+		t.Errorf("Expected validator list to have length 1, received: %v", len(newState.Validators()))
+	}
+	if len(newState.Balances()) != 1 {
+		t.Errorf("Expected validator balances list to have length 1, received: %v", len(newState.Balances()))
+	}
+	if newState.Balances()[0] != 0 {
+		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
+	}
+}

beacon-chain/core/blocks/eth1_data.go

@@ -0,0 +1,76 @@
+package blocks
+
+import (
+	"bytes"
+	"context"
+	"errors"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// ProcessEth1DataInBlock is an operation performed on each
+// beacon block to ensure the ETH1 data votes are processed
+// into the beacon state.
+//
+// Official spec definition:
+//   def process_eth1_data(state: BeaconState, body: BeaconBlockBody) -> None:
+//    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(_ context.Context, beaconState *stateTrie.BeaconState, b *ethpb.SignedBeaconBlock) (*stateTrie.BeaconState, error) {
+	block := b.Block
+	if beaconState == nil {
+		return nil, errors.New("nil state")
+	}
+	if block == nil || block.Body == nil {
+		return nil, errors.New("nil block or block withought body")
+	}
+	if err := beaconState.AppendEth1DataVotes(block.Body.Eth1Data); err != nil {
+		return nil, err
+	}
+	hasSupport, err := Eth1DataHasEnoughSupport(beaconState, block.Body.Eth1Data)
+	if err != nil {
+		return nil, err
+	}
+	if hasSupport {
+		if err := beaconState.SetEth1Data(block.Body.Eth1Data); err != nil {
+			return nil, err
+		}
+	}
+	return beaconState, nil
+}
+
+// AreEth1DataEqual checks equality between two eth1 data objects.
+func AreEth1DataEqual(a, b *ethpb.Eth1Data) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return a.DepositCount == b.DepositCount &&
+		bytes.Equal(a.BlockHash, b.BlockHash) &&
+		bytes.Equal(a.DepositRoot, b.DepositRoot)
+}
+
+// Eth1DataHasEnoughSupport returns true when the given eth1data has more than 50% votes in the
+// eth1 voting period. A vote is cast by including eth1data in a block and part of state processing
+// appends eth1data to the state in the Eth1DataVotes list. Iterating through this list checks the
+// votes to see if they match the eth1data.
+func Eth1DataHasEnoughSupport(beaconState *stateTrie.BeaconState, data *ethpb.Eth1Data) (bool, error) {
+	voteCount := uint64(0)
+	data = stateTrie.CopyETH1Data(data)
+
+	for _, vote := range beaconState.Eth1DataVotes() {
+		if AreEth1DataEqual(vote, data) {
+			voteCount++
+		}
+	}
+
+	// If 50+% majority converged on the same eth1data, then it has enough support to update the
+	// state.
+	support := params.BeaconConfig().EpochsPerEth1VotingPeriod * params.BeaconConfig().SlotsPerEpoch
+	return voteCount*2 > support, nil
+}

beacon-chain/core/blocks/eth1_data_test.go

@@ -1,22 +1,28 @@
 package blocks_test
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
+	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"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"
 )
 
-func FakeDeposits(n int) []*ethpb.Eth1Data {
+func FakeDeposits(n uint64) []*ethpb.Eth1Data {
 	deposits := make([]*ethpb.Eth1Data, n)
-	for i := 0; i < n; i++ {
+	for i := uint64(0); i < n; i++ {
 		deposits[i] = &ethpb.Eth1Data{
 			DepositCount: 1,
-			DepositRoot:  []byte("root"),
+			DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 		}
 	}
 	return deposits
@@ -30,26 +36,26 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 		votingPeriodLength uint64
 	}{
 		{
-			stateVotes: FakeDeposits(4 * int(params.BeaconConfig().SlotsPerEpoch)),
+			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
-				DepositRoot:  []byte("root"),
+				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 			},
 			hasSupport:         true,
 			votingPeriodLength: 7,
 		}, {
-			stateVotes: FakeDeposits(4 * int(params.BeaconConfig().SlotsPerEpoch)),
+			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
-				DepositRoot:  []byte("root"),
+				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 			},
 			hasSupport:         false,
 			votingPeriodLength: 8,
 		}, {
-			stateVotes: FakeDeposits(4 * int(params.BeaconConfig().SlotsPerEpoch)),
+			stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
 			data: &ethpb.Eth1Data{
 				DepositCount: 1,
-				DepositRoot:  []byte("root"),
+				DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
 			},
 			hasSupport:         false,
 			votingPeriodLength: 10,
@@ -66,13 +72,9 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 			s, err := beaconstate.InitializeFromProto(&pb.BeaconState{
 				Eth1DataVotes: tt.stateVotes,
 			})
-			if err != nil {
-				t.Fatal(err)
-			}
+			require.NoError(t, err)
 			result, err := blocks.Eth1DataHasEnoughSupport(s, tt.data)
-			if err != nil {
-				t.Fatal(err)
-			}
+			require.NoError(t, err)
 
 			if result != tt.hasSupport {
 				t.Errorf(
@@ -85,3 +87,108 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
 		})
 	}
 }
+
+func TestAreEth1DataEqual(t *testing.T) {
+	type args struct {
+		a *ethpb.Eth1Data
+		b *ethpb.Eth1Data
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "true when both are nil",
+			args: args{
+				a: nil,
+				b: nil,
+			},
+			want: true,
+		},
+		{
+			name: "false when only one is nil",
+			args: args{
+				a: nil,
+				b: &ethpb.Eth1Data{
+					DepositRoot:  make([]byte, 32),
+					DepositCount: 0,
+					BlockHash:    make([]byte, 32),
+				},
+			},
+			want: false,
+		},
+		{
+			name: "true when real equality",
+			args: args{
+				a: &ethpb.Eth1Data{
+					DepositRoot:  make([]byte, 32),
+					DepositCount: 0,
+					BlockHash:    make([]byte, 32),
+				},
+				b: &ethpb.Eth1Data{
+					DepositRoot:  make([]byte, 32),
+					DepositCount: 0,
+					BlockHash:    make([]byte, 32),
+				},
+			},
+			want: true,
+		},
+		{
+			name: "false is field value differs",
+			args: args{
+				a: &ethpb.Eth1Data{
+					DepositRoot:  make([]byte, 32),
+					DepositCount: 0,
+					BlockHash:    make([]byte, 32),
+				},
+				b: &ethpb.Eth1Data{
+					DepositRoot:  make([]byte, 32),
+					DepositCount: 64,
+					BlockHash:    make([]byte, 32),
+				},
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, blocks.AreEth1DataEqual(tt.args.a, tt.args.b))
+		})
+	}
+}
+
+func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
+	beaconState, err := beaconstate.InitializeFromProto(&pb.BeaconState{
+		Eth1DataVotes: []*ethpb.Eth1Data{},
+	})
+	require.NoError(t, err)
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Eth1Data: &ethpb.Eth1Data{
+				DepositRoot: []byte{2},
+				BlockHash:   []byte{3},
+			},
+		},
+	}
+
+	period := params.BeaconConfig().EpochsPerEth1VotingPeriod * params.BeaconConfig().SlotsPerEpoch
+	for i := uint64(0); i < period; i++ {
+		beaconState, err = blocks.ProcessEth1DataInBlock(context.Background(), beaconState, b)
+		require.NoError(t, err)
+	}
+
+	newETH1DataVotes := beaconState.Eth1DataVotes()
+	if len(newETH1DataVotes) <= 1 {
+		t.Error("Expected new ETH1 data votes to have length > 1")
+	}
+	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",
+			b.Block.Body.Eth1Data,
+			beaconState.Eth1Data(),
+		)
+	}
+}

beacon-chain/core/blocks/exit.go

@@ -0,0 +1,188 @@
+package blocks
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"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.
+//
+// Spec pseudocode definition:
+//   def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
+//    """
+//    Process ``VoluntaryExit`` operation.
+//    """
+//    validator = state.validator_registry[exit.validator_index]
+//    # Verify the validator is active
+//    assert is_active_validator(validator, get_current_epoch(state))
+//    # Verify the validator has not yet exited
+//    assert validator.exit_epoch == FAR_FUTURE_EPOCH
+//    # Exits must specify an epoch when they become valid; they are not valid before then
+//    assert get_current_epoch(state) >= exit.epoch
+//    # Verify the validator has been active long enough
+//    assert get_current_epoch(state) >= validator.activation_epoch + PERSISTENT_COMMITTEE_PERIOD
+//    # Verify signature
+//    domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, exit.epoch)
+//    assert bls_verify(validator.pubkey, signing_root(exit), exit.signature, domain)
+//    # Initiate exit
+//    initiate_validator_exit(state, exit.validator_index)
+func ProcessVoluntaryExits(
+	_ context.Context,
+	beaconState *stateTrie.BeaconState,
+	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 {
+			return nil, errors.New("nil voluntary exit in block body")
+		}
+		val, err := beaconState.ValidatorAtIndexReadOnly(exit.Exit.ValidatorIndex)
+		if err != nil {
+			return nil, err
+		}
+		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)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessVoluntaryExitsNoVerifySignature processes all the voluntary exits in
+// a block body, without verifying their BLS signatures.
+// This function is here to satisfy fuzz tests.
+func ProcessVoluntaryExitsNoVerifySignature(
+	beaconState *stateTrie.BeaconState,
+	body *ethpb.BeaconBlockBody,
+) (*stateTrie.BeaconState, error) {
+	exits := body.VoluntaryExits
+
+	for idx, exit := range exits {
+		if exit == nil || exit.Exit == nil {
+			return nil, errors.New("nil exit")
+		}
+		val, err := beaconState.ValidatorAtIndexReadOnly(exit.Exit.ValidatorIndex)
+		if err != nil {
+			return nil, err
+		}
+		if err := verifyExitConditions(val, beaconState.Slot(), exit.Exit); err != nil {
+			return nil, err
+		}
+		// Validate that fork and genesis root are valid.
+		_, err = helpers.Domain(beaconState.Fork(), exit.Exit.Epoch, params.BeaconConfig().DomainVoluntaryExit, beaconState.GenesisValidatorRoot())
+		if err != nil {
+			return nil, err
+		}
+		beaconState, err = v.InitiateValidatorExit(beaconState, exit.Exit.ValidatorIndex)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to process voluntary exit at index %d", idx)
+		}
+	}
+	return beaconState, nil
+}
+
+// VerifyExitAndSignature implements the spec defined validation for voluntary exits.
+//
+// Spec pseudocode definition:
+//   def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
+//    """
+//    Process ``VoluntaryExit`` operation.
+//    """
+//    validator = state.validator_registry[exit.validator_index]
+//    # Verify the validator is active
+//    assert is_active_validator(validator, get_current_epoch(state))
+//    # Verify the validator has not yet exited
+//    assert validator.exit_epoch == FAR_FUTURE_EPOCH
+//    # Exits must specify an epoch when they become valid; they are not valid before then
+//    assert get_current_epoch(state) >= exit.epoch
+//    # Verify the validator has been active long enough
+//    assert get_current_epoch(state) >= validator.activation_epoch + PERSISTENT_COMMITTEE_PERIOD
+//    # Verify signature
+//    domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, exit.epoch)
+//    assert bls_verify(validator.pubkey, signing_root(exit), exit.signature, domain)
+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")
+	}
+
+	exit := signed.Exit
+	if err := verifyExitConditions(validator, currentSlot, exit); err != nil {
+		return err
+	}
+	domain, err := helpers.Domain(fork, exit.Epoch, params.BeaconConfig().DomainVoluntaryExit, genesisRoot)
+	if err != nil {
+		return err
+	}
+	valPubKey := validator.PublicKey()
+	if err := helpers.VerifySigningRoot(exit, valPubKey[:], signed.Signature, domain); err != nil {
+		return helpers.ErrSigFailedToVerify
+	}
+	return nil
+}
+
+// verifyExitConditions implements the spec defined validation for voluntary exits(excluding signatures).
+//
+// Spec pseudocode definition:
+//   def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
+//    """
+//    Process ``VoluntaryExit`` operation.
+//    """
+//    validator = state.validator_registry[exit.validator_index]
+//    # Verify the validator is active
+//    assert is_active_validator(validator, get_current_epoch(state))
+//    # Verify the validator has not yet exited
+//    assert validator.exit_epoch == FAR_FUTURE_EPOCH
+//    # Exits must specify an epoch when they become valid; they are not valid before then
+//    assert get_current_epoch(state) >= exit.epoch
+//    # Verify the validator has been active long enough
+//    assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD
+func verifyExitConditions(validator *stateTrie.ReadOnlyValidator, currentSlot uint64, exit *ethpb.VoluntaryExit) error {
+	currentEpoch := helpers.SlotToEpoch(currentSlot)
+	// Verify the validator is active.
+	if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {
+		return errors.New("non-active validator cannot exit")
+	}
+	// Verify the validator has not yet submitted an exit.
+	if validator.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
+		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 {
+		return fmt.Errorf("expected current epoch >= exit epoch, received %d < %d", currentEpoch, exit.Epoch)
+	}
+	// Verify the validator has been active long enough.
+	if currentEpoch < validator.ActivationEpoch()+params.BeaconConfig().ShardCommitteePeriod {
+		return fmt.Errorf(
+			"%s: %d epochs vs required %d epochs",
+			ValidatorCannotExitYetMsg,
+			currentEpoch,
+			validator.ActivationEpoch()+params.BeaconConfig().ShardCommitteePeriod,
+		)
+	}
+	return nil
+}

beacon-chain/core/blocks/exit_test.go

@@ -0,0 +1,206 @@
+package blocks_test
+
+import (
+	"context"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"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/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestProcessVoluntaryExits_ValidatorNotActive(t *testing.T) {
+	exits := []*ethpb.SignedVoluntaryExit{
+		{
+			Exit: &ethpb.VoluntaryExit{
+				ValidatorIndex: 0,
+			},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			ExitEpoch: 0,
+		},
+	}
+	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+	})
+	require.NoError(t, err)
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			VoluntaryExits: exits,
+		},
+	}
+
+	want := "non-active validator cannot exit"
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
+	assert.ErrorContains(t, want, err)
+
+	// Check conformance of no verify method.
+	_, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessVoluntaryExits_InvalidExitEpoch(t *testing.T) {
+	exits := []*ethpb.SignedVoluntaryExit{
+		{
+			Exit: &ethpb.VoluntaryExit{
+				Epoch: 10,
+			},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+		},
+	}
+	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 := "expected current epoch >= exit epoch"
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b)
+	assert.ErrorContains(t, want, err)
+
+	// Check conformance of no verify method.
+	_, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessVoluntaryExits_NotActiveLongEnoughToExit(t *testing.T) {
+	exits := []*ethpb.SignedVoluntaryExit{
+		{
+			Exit: &ethpb.VoluntaryExit{
+				ValidatorIndex: 0,
+				Epoch:          0,
+			},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+		},
+	}
+	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Slot:       10,
+	})
+	require.NoError(t, err)
+	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, 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)
+}
+
+func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
+	exits := []*ethpb.SignedVoluntaryExit{
+		{
+			Exit: &ethpb.VoluntaryExit{
+				ValidatorIndex: 0,
+				Epoch:          0,
+			},
+		},
+	}
+	registry := []*ethpb.Validator{
+		{
+			ExitEpoch:       params.BeaconConfig().FarFutureEpoch,
+			ActivationEpoch: 0,
+		},
+	}
+	state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Fork: &pb.Fork{
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+		},
+		Slot: params.BeaconConfig().SlotsPerEpoch * 5,
+	})
+	require.NoError(t, err)
+	err = state.SetSlot(state.Slot() + (params.BeaconConfig().ShardCommitteePeriod * params.BeaconConfig().SlotsPerEpoch))
+	require.NoError(t, err)
+
+	priv := bls.RandKey()
+	val, err := state.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	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)
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			VoluntaryExits: exits,
+		},
+	}
+
+	stateCopy := state.Copy()
+	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) {
+		t.Errorf("Expected validator exit epoch to be %d, got %d",
+			helpers.ActivationExitEpoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch), newRegistry[0].ExitEpoch)
+	}
+
+	// Check conformance with NoVerify Exit Method.
+	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

@@ -0,0 +1,17 @@
+package blocks_test
+
+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 := bytesutil.PadTo([]byte{0}, 32)
+	b1 := blocks.NewGenesisBlock(stateHash)
+
+	assert.NotNil(t, b1.Block.ParentRoot, "Genesis block missing ParentHash field")
+	assert.DeepEqual(t, b1.Block.StateRoot, stateHash, "Genesis block StateRootHash32 isn't initialized correctly")
+}

beacon-chain/core/blocks/header.go

@@ -0,0 +1,136 @@
+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/shared/params"
+)
+
+// ProcessBlockHeader validates a block by its header.
+//
+// Spec pseudocode definition:
+//
+//  def process_block_header(state: BeaconState, block: BeaconBlock) -> None:
+//    # Verify that the slots match
+//    assert block.slot == state.slot
+//     # Verify that proposer index is the correct index
+//    assert block.proposer_index == get_beacon_proposer_index(state)
+//    # Verify that the parent matches
+//    assert block.parent_root == hash_tree_root(state.latest_block_header)
+//    # Save current block as the new latest block
+//    state.latest_block_header = BeaconBlockHeader(
+//        slot=block.slot,
+//        parent_root=block.parent_root,
+//        # state_root: zeroed, overwritten in the next `process_slot` call
+//        body_root=hash_tree_root(block.body),
+//		  # signature is always zeroed
+//    )
+//    # Verify proposer is not slashed
+//    proposer = state.validators[get_beacon_proposer_index(state)]
+//    assert not proposer.slashed
+//    # 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) {
+	beaconState, err := ProcessBlockHeaderNoVerify(beaconState, block.Block)
+	if err != nil {
+		return nil, err
+	}
+
+	// Verify proposer signature.
+	if err := VerifyBlockSignature(beaconState, block); err != nil {
+		return nil, err
+	}
+
+	return beaconState, nil
+}
+
+// ProcessBlockHeaderNoVerify validates a block by its header but skips proposer
+// signature verification.
+//
+// WARNING: This method does not verify proposer signature. This is used for proposer to compute state root
+// using a unsigned block.
+//
+// Spec pseudocode definition:
+//  def process_block_header(state: BeaconState, block: BeaconBlock) -> None:
+//    # Verify that the slots match
+//    assert block.slot == state.slot
+//     # Verify that proposer index is the correct index
+//    assert block.proposer_index == get_beacon_proposer_index(state)
+//    # Verify that the parent matches
+//    assert block.parent_root == hash_tree_root(state.latest_block_header)
+//    # Save current block as the new latest block
+//    state.latest_block_header = BeaconBlockHeader(
+//        slot=block.slot,
+//        parent_root=block.parent_root,
+//        # state_root: zeroed, overwritten in the next `process_slot` call
+//        body_root=hash_tree_root(block.body),
+//		  # signature is always zeroed
+//    )
+//    # Verify proposer is not slashed
+//    proposer = state.validators[get_beacon_proposer_index(state)]
+//    assert not proposer.slashed
+func ProcessBlockHeaderNoVerify(
+	beaconState *stateTrie.BeaconState,
+	block *ethpb.BeaconBlock,
+) (*stateTrie.BeaconState, error) {
+	if block == nil {
+		return nil, errors.New("nil block")
+	}
+	if beaconState.Slot() != block.Slot {
+		return nil, fmt.Errorf("state slot: %d is different than block slot: %d", beaconState.Slot(), block.Slot)
+	}
+	idx, err := helpers.BeaconProposerIndex(beaconState)
+	if err != nil {
+		return nil, err
+	}
+	if block.ProposerIndex != idx {
+		return nil, fmt.Errorf("proposer index: %d is different than calculated: %d", block.ProposerIndex, idx)
+	}
+	parentHeader := beaconState.LatestBlockHeader()
+	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 := parentHeader.HashTreeRoot()
+	if err != nil {
+		return nil, err
+	}
+
+	if !bytes.Equal(block.ParentRoot, parentRoot[:]) {
+		return nil, fmt.Errorf(
+			"parent root %#x does not match the latest block header signing root in state %#x",
+			block.ParentRoot, parentRoot)
+	}
+
+	proposer, err := beaconState.ValidatorAtIndexReadOnly(idx)
+	if err != nil {
+		return nil, err
+	}
+	if proposer.Slashed() {
+		return nil, fmt.Errorf("proposer at index %d was previously slashed", idx)
+	}
+
+	bodyRoot, err := block.Body.HashTreeRoot()
+	if err != nil {
+		return nil, err
+	}
+	if err := beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+		Slot:          block.Slot,
+		ProposerIndex: block.ProposerIndex,
+		ParentRoot:    block.ParentRoot,
+		StateRoot:     params.BeaconConfig().ZeroHash[:],
+		BodyRoot:      bodyRoot[:],
+	}); err != nil {
+		return nil, err
+	}
+	return beaconState, nil
+}

beacon-chain/core/blocks/header_test.go

@@ -0,0 +1,332 @@
+package blocks_test
+
+import (
+	"context"
+	"io/ioutil"
+	"testing"
+
+	"github.com/gogo/protobuf/proto"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/sirupsen/logrus"
+
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"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"
+)
+
+func init() {
+	logrus.SetOutput(ioutil.Discard) // Ignore "validator activated" logs
+}
+
+func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	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 := state.LatestBlockHeader().HashTreeRoot()
+	require.NoError(t, err)
+
+	currentEpoch := helpers.CurrentEpoch(state)
+	priv := bls.RandKey()
+	pID, err := helpers.BeaconProposerIndex(state)
+	require.NoError(t, err)
+	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)
+
+	proposerIdx, err := helpers.BeaconProposerIndex(state)
+	require.NoError(t, err)
+	validators[proposerIdx].Slashed = false
+	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
+	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
+	require.NoError(t, err)
+
+	_, 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,
+		ParentRoot: make([]byte, 32),
+		StateRoot:  make([]byte, 32),
+		BodyRoot:   make([]byte, 32),
+	}))
+	require.NoError(t, beaconState.SetSlot(10))
+
+	lbhdr, err := beaconState.LatestBlockHeader().HashTreeRoot()
+	require.NoError(t, err)
+
+	proposerIdx, err := helpers.BeaconProposerIndex(beaconState)
+	require.NoError(t, err)
+
+	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(context.Background(), beaconState, block)
+	want := "signature did not verify"
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	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 := state.LatestBlockHeader().HashTreeRoot()
+	require.NoError(t, err)
+	currentEpoch := helpers.CurrentEpoch(state)
+
+	priv := bls.RandKey()
+	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)
+	validators[5896].PublicKey = priv.PublicKey().Marshal()
+	block := &ethpb.SignedBeaconBlock{
+		Block: &ethpb.BeaconBlock{
+			Slot: 1,
+			Body: &ethpb.BeaconBlockBody{
+				RandaoReveal: []byte{'A', 'B', 'C'},
+			},
+			ParentRoot: lbhsr[:],
+		},
+		Signature: blockSig,
+	}
+
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, block)
+	want := "is different than block slot"
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 48),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	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()
+	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 := 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(context.Background(), state, block)
+	want := "does not match"
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 48),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	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()
+	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 := 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(context.Background(), state, block)
+	want := "was previously slashed"
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessBlockHeader_OK(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	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 := state.LatestBlockHeader().HashTreeRoot()
+	require.NoError(t, err)
+
+	currentEpoch := helpers.CurrentEpoch(state)
+	priv := bls.RandKey()
+	pID, err := helpers.BeaconProposerIndex(state)
+	require.NoError(t, err)
+	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 := block.Block.Body.HashTreeRoot()
+	require.NoError(t, err, "Failed to hash block bytes got")
+
+	proposerIdx, err := helpers.BeaconProposerIndex(state)
+	require.NoError(t, err)
+	validators[proposerIdx].Slashed = false
+	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
+	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
+	require.NoError(t, err)
+
+	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()
+	expected := &ethpb.BeaconBlockHeader{
+		ProposerIndex: pID,
+		Slot:          block.Block.Slot,
+		ParentRoot:    latestBlockSignedRoot[:],
+		BodyRoot:      bodyRoot[:],
+		StateRoot:     zeroHash[:],
+	}
+	assert.Equal(t, true, proto.Equal(nsh, expected), "Expected %v, received %v", expected, nsh)
+}
+
+func TestBlockSignatureSet_OK(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	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 := state.LatestBlockHeader().HashTreeRoot()
+	require.NoError(t, err)
+
+	currentEpoch := helpers.CurrentEpoch(state)
+	priv := bls.RandKey()
+	pID, err := helpers.BeaconProposerIndex(state)
+	require.NoError(t, err)
+	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)
+	require.NoError(t, err)
+	validators[proposerIdx].Slashed = false
+	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
+	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
+	require.NoError(t, err)
+	set, err := blocks.BlockSignatureSet(state, block)
+	require.NoError(t, err)
+
+	verified, err := set.Verify()
+	require.NoError(t, err)
+	assert.Equal(t, true, verified, "Block signature set returned a set which was unable to be verified")
+}

beacon-chain/core/blocks/log.go

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

beacon-chain/core/blocks/proposer_slashing.go

@@ -0,0 +1,101 @@
+package blocks
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// ProcessProposerSlashings is one of the operations performed
+// on each processed beacon block to slash proposers based on
+// slashing conditions if any slashable events occurred.
+//
+// Spec pseudocode definition:
+//   def process_proposer_slashing(state: BeaconState, proposer_slashing: ProposerSlashing) -> None:
+//    """
+//    Process ``ProposerSlashing`` operation.
+//    """
+//    proposer = state.validator_registry[proposer_slashing.proposer_index]
+//    # Verify slots match
+//    assert proposer_slashing.header_1.slot == proposer_slashing.header_2.slot
+//    # But the headers are different
+//    assert proposer_slashing.header_1 != proposer_slashing.header_2
+//    # Check proposer is slashable
+//    assert is_slashable_validator(proposer, get_current_epoch(state))
+//    # Signatures are valid
+//    for header in (proposer_slashing.header_1, proposer_slashing.header_2):
+//        domain = get_domain(state, DOMAIN_BEACON_PROPOSER, slot_to_epoch(header.slot))
+//        assert bls_verify(proposer.pubkey, signing_root(header), header.signature, domain)
+//
+//    slash_validator(state, proposer_slashing.proposer_index)
+func ProcessProposerSlashings(
+	_ context.Context,
+	beaconState *stateTrie.BeaconState,
+	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 {
+			return nil, errors.New("nil proposer slashings in block body")
+		}
+		if err = VerifyProposerSlashing(beaconState, slashing); err != nil {
+			return nil, errors.Wrapf(err, "could not verify proposer slashing %d", idx)
+		}
+		beaconState, err = v.SlashValidator(
+			beaconState, slashing.Header_1.Header.ProposerIndex,
+		)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not slash proposer index %d", slashing.Header_1.Header.ProposerIndex)
+		}
+	}
+	return beaconState, nil
+}
+
+// VerifyProposerSlashing verifies that the data provided from slashing is valid.
+func VerifyProposerSlashing(
+	beaconState *stateTrie.BeaconState,
+	slashing *ethpb.ProposerSlashing,
+) error {
+	if slashing.Header_1 == nil || slashing.Header_1.Header == nil || slashing.Header_2 == nil || slashing.Header_2.Header == nil {
+		return errors.New("nil header cannot be verified")
+	}
+	hSlot := slashing.Header_1.Header.Slot
+	if hSlot != slashing.Header_2.Header.Slot {
+		return fmt.Errorf("mismatched header slots, received %d == %d", slashing.Header_1.Header.Slot, slashing.Header_2.Header.Slot)
+	}
+	pIdx := slashing.Header_1.Header.ProposerIndex
+	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.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(hSlot)) {
+		return fmt.Errorf("validator with key %#x is not slashable", proposer.PublicKey())
+	}
+	headers := []*ethpb.SignedBeaconBlockHeader{slashing.Header_1, slashing.Header_2}
+	for _, header := range headers {
+		if err := helpers.ComputeDomainVerifySigningRoot(beaconState, pIdx, helpers.SlotToEpoch(hSlot),
+			header.Header, params.BeaconConfig().DomainBeaconProposer, header.Signature); err != nil {
+			return errors.Wrap(err, "could not verify beacon block header")
+		}
+	}
+
+	return nil
+}

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -0,0 +1,308 @@
+package blocks_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"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"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestProcessProposerSlashings_UnmatchedHeaderSlots(t *testing.T) {
+	testutil.ResetCache()
+	beaconState, _ := testutil.DeterministicGenesisState(t, 20)
+	currentSlot := uint64(0)
+	slashings := []*ethpb.ProposerSlashing{
+		{
+			Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header: &ethpb.BeaconBlockHeader{
+					ProposerIndex: 1,
+					Slot:          params.BeaconConfig().SlotsPerEpoch + 1,
+				},
+			},
+			Header_2: &ethpb.SignedBeaconBlockHeader{
+				Header: &ethpb.BeaconBlockHeader{
+					ProposerIndex: 1,
+					Slot:          0,
+				},
+			},
+		},
+	}
+	require.NoError(t, beaconState.SetSlot(currentSlot))
+
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			ProposerSlashings: slashings,
+		},
+	}
+	want := "mismatched header slots"
+	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessProposerSlashings_SameHeaders(t *testing.T) {
+	testutil.ResetCache()
+	beaconState, _ := testutil.DeterministicGenesisState(t, 2)
+	currentSlot := uint64(0)
+	slashings := []*ethpb.ProposerSlashing{
+		{
+			Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header: &ethpb.BeaconBlockHeader{
+					ProposerIndex: 1,
+					Slot:          0,
+				},
+			},
+			Header_2: &ethpb.SignedBeaconBlockHeader{
+				Header: &ethpb.BeaconBlockHeader{
+					ProposerIndex: 1,
+					Slot:          0,
+				},
+			},
+		},
+	}
+
+	require.NoError(t, beaconState.SetSlot(currentSlot))
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			ProposerSlashings: slashings,
+		},
+	}
+	want := "expected slashing headers to differ"
+	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
+	registry := []*ethpb.Validator{
+		{
+			PublicKey:         []byte("key"),
+			Slashed:           true,
+			ActivationEpoch:   0,
+			WithdrawableEpoch: 0,
+		},
+	}
+	currentSlot := uint64(0)
+	slashings := []*ethpb.ProposerSlashing{
+		{
+			Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header: &ethpb.BeaconBlockHeader{
+					ProposerIndex: 0,
+					Slot:          0,
+					BodyRoot:      []byte("foo"),
+				},
+				Signature: bytesutil.PadTo([]byte("A"), 96),
+			},
+			Header_2: &ethpb.SignedBeaconBlockHeader{
+				Header: &ethpb.BeaconBlockHeader{
+					ProposerIndex: 0,
+					Slot:          0,
+					BodyRoot:      []byte("bar"),
+				},
+				Signature: bytesutil.PadTo([]byte("B"), 96),
+			},
+		},
+	}
+
+	beaconState, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Validators: registry,
+		Slot:       currentSlot,
+	})
+	require.NoError(t, err)
+	b := testutil.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			ProposerSlashings: slashings,
+		},
+	}
+	want := fmt.Sprintf(
+		"validator with key %#x is not slashable",
+		bytesutil.ToBytes48(beaconState.Validators()[0].PublicKey),
+	)
+	_, err = blocks.ProcessProposerSlashings(context.Background(), beaconState, b)
+	assert.ErrorContains(t, want, err)
+}
+
+func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
+	// We test the case when data is correct and verify the validator
+	// registry has been updated.
+	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
+	proposerIdx := uint64(1)
+
+	header1 := &ethpb.SignedBeaconBlockHeader{
+		Header: &ethpb.BeaconBlockHeader{
+			ProposerIndex: proposerIdx,
+			Slot:          0,
+			ParentRoot:    make([]byte, 32),
+			BodyRoot:      make([]byte, 32),
+			StateRoot:     bytesutil.PadTo([]byte("A"), 32),
+		},
+	}
+	var err error
+	header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)
+
+	header2 := &ethpb.SignedBeaconBlockHeader{
+		Header: &ethpb.BeaconBlockHeader{
+			ProposerIndex: proposerIdx,
+			Slot:          0,
+			ParentRoot:    make([]byte, 32),
+			BodyRoot:      make([]byte, 32),
+			StateRoot:     bytesutil.PadTo([]byte("B"), 32),
+		},
+	}
+	header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)
+
+	slashings := []*ethpb.ProposerSlashing{
+		{
+			Header_1: header1,
+			Header_2: header2,
+		},
+	}
+
+	block := testutil.NewBeaconBlock()
+	block.Block.Body.ProposerSlashings = slashings
+
+	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block)
+	require.NoError(t, err)
+
+	newStateVals := newState.Validators()
+	if newStateVals[1].ExitEpoch != beaconState.Validators()[1].ExitEpoch {
+		t.Errorf("Proposer with index 1 did not correctly exit,"+"wanted slot:%d, got:%d",
+			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))
+
+	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: bls.RandKey().Sign([]byte("foo")).Marshal(),
+					},
+					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: bls.RandKey().Sign([]byte("bar")).Marshal(),
+					},
+				},
+				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

@@ -0,0 +1,85 @@
+package blocks
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/hashutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// ProcessRandao checks the block proposer's
+// randao commitment and generates a new randao mix to update
+// in the beacon state's latest randao mixes slice.
+//
+// Spec pseudocode definition:
+//   def process_randao(state: BeaconState, body: BeaconBlockBody) -> None:
+//    epoch = get_current_epoch(state)
+//    # Verify RANDAO reveal
+//    proposer = state.validators[get_beacon_proposer_index(state)]
+//    signing_root = compute_signing_root(epoch, get_domain(state, DOMAIN_RANDAO))
+//    assert bls.Verify(proposer.pubkey, signing_root, body.randao_reveal)
+//    # Mix in RANDAO reveal
+//    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,
+	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 {
+		return nil, errors.Wrap(err, "could not verify block randao")
+	}
+
+	beaconState, err = ProcessRandaoNoVerify(beaconState, body)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process randao")
+	}
+	return beaconState, nil
+}
+
+// ProcessRandaoNoVerify generates a new randao mix to update
+// in the beacon state's latest randao mixes slice.
+//
+// Spec pseudocode definition:
+//     # Mix it in
+//     state.latest_randao_mixes[get_current_epoch(state) % LATEST_RANDAO_MIXES_LENGTH] = (
+//         xor(get_randao_mix(state, get_current_epoch(state)),
+//             hash(body.randao_reveal))
+//     )
+func ProcessRandaoNoVerify(
+	beaconState *stateTrie.BeaconState,
+	body *ethpb.BeaconBlockBody,
+) (*stateTrie.BeaconState, error) {
+	currentEpoch := helpers.SlotToEpoch(beaconState.Slot())
+	// If block randao passed verification, we XOR the state's latest randao mix with the block's
+	// randao and update the state's corresponding latest randao mix value.
+	latestMixesLength := params.BeaconConfig().EpochsPerHistoricalVector
+	latestMixSlice, err := beaconState.RandaoMixAtIndex(currentEpoch % latestMixesLength)
+	if err != nil {
+		return nil, err
+	}
+	blockRandaoReveal := hashutil.Hash(body.RandaoReveal)
+	if len(blockRandaoReveal) != len(latestMixSlice) {
+		return nil, errors.New("blockRandaoReveal length doesnt match latestMixSlice length")
+	}
+	for i, x := range blockRandaoReveal {
+		latestMixSlice[i] ^= x
+	}
+	if err := beaconState.UpdateRandaoMixesAtIndex(currentEpoch%latestMixesLength, latestMixSlice); err != nil {
+		return nil, err
+	}
+	return beaconState, nil
+}