added flag to enable roughtime syncing, with it disabled by default (#6898)

* added flag to enable roughtime syncing, with it disabled by defaults

* gofmt

* switched to feature flag

* enable-roughtime works correctly

* enable-roughtime works correctly

* Gaz

* Remove conflict

* fix roughtime enable

Co-authored-by: Ivan Martinez <ivanthegreatdev@gmail.com>
Co-authored-by: rauljordan <raul@prysmaticlabs.com>

.bazelrc

@@ -5,6 +5,9 @@ test --test_verbose_timeout_warnings
 test --build_tests_only
 test --test_output=errors
 
+# Clearly indicate that coverage is enabled to disable certain nogo checks.
+coverage --define=coverage_enabled=1
+
 # Fix for rules_docker. See: https://github.com/bazelbuild/rules_docker/issues/842
 build --host_force_python=PY2
 test --host_force_python=PY2
@@ -15,7 +18,7 @@ run --host_force_python=PY2
 # Network sandboxing only works on linux.
 --experimental_sandbox_default_allow_network=false
 
-# Use minimal protobufs at runtime
+# Use mainnet protobufs at runtime
 run --define ssz=mainnet
 test --define ssz=mainnet
 build --define ssz=mainnet
@@ -24,3 +27,207 @@ build --define ssz=mainnet
 build --incompatible_strict_action_env
 test --incompatible_strict_action_env
 run --incompatible_strict_action_env
+
+# Disable kafka by default, it takes a long time to build...
+build --define kafka_enabled=false
+test --define kafka_enabled=false
+run --define kafka_enabled=false
+
+build:kafka_enabled --define kafka_enabled=true
+build:kafka_enabled --define gotags=kafka_enabled
+
+# Release flags
+build:release --workspace_status_command=./scripts/workspace_status.sh
+build:release --stamp
+build:release --compilation_mode=opt
+build:release --config=llvm
+
+# LLVM compiler for building C/C++ dependencies.
+build:llvm --crosstool_top=@llvm_toolchain//:toolchain
+build:llvm --define compiler=llvm
+build:llvm --copt -fno-sanitize=vptr,function
+build:llvm --linkopt -fno-sanitize=vptr,function
+
+build:asan --copt -fsanitize=address,undefined
+build:asan --copt -fno-omit-frame-pointer
+build:asan --linkopt -fsanitize=address,undefined
+build:asan --copt -fno-sanitize=vptr,function
+build:asan --linkopt -fno-sanitize=vptr,function
+build:asan --copt -DADDRESS_SANITIZER=1
+build:asan --copt -D__SANITIZE_ADDRESS__
+build:asan --linkopt -ldl
+
+build:llvm-asan --config=llvm
+build:llvm-asan --config=asan
+build:llvm-asan --linkopt -fuse-ld=ld.lld
+
+build:fuzz --define=gotags=libfuzzer
+build:fuzz --config=llvm-asan
+build:fuzz --copt=-fsanitize=fuzzer-no-link
+build:fuzz --linkopt=-fsanitize=fuzzer
+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 --run_under=//tools:fuzz_wrapper
+build:fuzz --compilation_mode=opt
+
+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
+build:cgo_symbolizer --define=USE_CGO_SYMBOLIZER=true
+build:cgo_symbolizer -c dbg
+build:cgo_symbolizer --define=gotags=cgosymbolizer_enabled
+
+# multi-arch cross-compiling toolchain configs:
+-----------------------------------------------
+build:cross --crosstool_top=@prysm_toolchains//:multiarch_toolchain
+build:cross --host_platform=@io_bazel_rules_go//go/toolchain:linux_amd64
+build:cross --host_crosstool_top=@prysm_toolchains//:hostonly_toolchain
+
+# linux_amd64 config for cross compiler toolchain, not strictly necessary since host/exec env is amd64
+build:linux_amd64 --platforms=@io_bazel_rules_go//go/toolchain:linux_amd64_cgo
+
+# osx_amd64 config for cross compiler toolchain
+build:osx_amd64 --config=cross
+build:osx_amd64 --platforms=@io_bazel_rules_go//go/toolchain:darwin_amd64_cgo
+build:osx_amd64 --compiler=osxcross
+
+# windows
+build:windows_amd64 --config=cross
+build:windows_amd64  --platforms=@io_bazel_rules_go//go/toolchain:windows_amd64_cgo
+build:windows_amd64 --compiler=mingw-w64
+
+# linux_arm64 conifg for cross compiler toolchain
+build:linux_arm64 --config=cross
+build:linux_arm64 --platforms=@io_bazel_rules_go//go/toolchain:linux_arm64_cgo
+build:linux_arm64 --copt=-funsafe-math-optimizations
+build:linux_arm64 --copt=-ftree-vectorize
+build:linux_arm64 --copt=-fomit-frame-pointer
+build:linux_arm64 --cpu=aarch64
+build:linux_arm64 --compiler=clang
+build:linux_arm64 --copt=-march=armv8-a
+
+
+# toolchain build debug configs
+#------------------------------
+build:debug --sandbox_debug
+build:debug --toolchain_resolution_debug
+build:debug --verbose_failures
+build:debug -s
+
+# windows debug
+build:windows_amd64_debug --config=windows_amd64
+build:windows_amd64_debug --config=debug
+
+# osx_amd64 debug config
+build:osx_amd64_debug --config=debug
+build:osx_amd64_debug --config=osx_amd64
+
+# linux_arm64_debug
+build:linux_arm64_debug --config=linux_arm64
+build:linux_arm64_debug --config=debug
+
+# linux_amd64_debug
+build:linux_amd64_debug --config=linux_amd64
+build:linux_amd64_debug --config=debug
+
+
+# Docker Sandbox Configs
+#-----------------------
+# Note all docker sandbox configs must run from a linux x86_64 host
+# build:docker-sandbox --experimental_docker_image=gcr.io/prysmaticlabs/rbe-worker:latest
+build:docker-sandbox --spawn_strategy=docker --strategy=Javac=docker --genrule_strategy=docker
+build:docker-sandbox --define=EXECUTOR=remote
+build:docker-sandbox --experimental_docker_verbose
+build:docker-sandbox --experimental_enable_docker_sandbox
+build:docker-sandbox --crosstool_top=@rbe_ubuntu_clang//cc:toolchain 
+build:docker-sandbox --host_javabase=@rbe_ubuntu_clang//java:jdk 
+build:docker-sandbox --javabase=@rbe_ubuntu_clang//java:jdk 
+build:docker-sandbox --host_java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8 
+build:docker-sandbox --java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8 
+build:docker-sandbox --extra_execution_platforms=@rbe_ubuntu_clang//config:platform 
+build:docker-sandbox --host_platform=@rbe_ubuntu_clang//config:platform 
+build:docker-sandbox --platforms=@rbe_ubuntu_clang//config:platform
+build:docker-sandbox --extra_toolchains=@prysm_toolchains//:cc-toolchain-multiarch
+
+# windows_amd64 docker sandbox build config
+build:windows_amd64_docker --config=docker-sandbox --config=windows_amd64
+build:windows_amd64_docker_debug --config=windows_amd64_docker --config=debug
+
+# osx_amd64 docker sandbox build config
+build:osx_amd64_docker --config=docker-sandbox --config=osx_amd64
+build:osx_amd64_docker_debug --config=osx_amd64_docker --config=debug
+
+# linux_arm64 docker sandbox build config
+build:linux_arm64_docker --config=docker-sandbox --config=linux_arm64
+build:linux_arm64_docker_debug --config=linux_arm64_docker --config=debug
+
+# linux_amd64 docker sandbox build config
+build:linux_amd64_docker --config=docker-sandbox --config=linux_amd64
+build:linux_amd64_docker_debug --config=linux_amd64_docker --config=debug
+
+
+# Remote Build Execution
+#-----------------------
+# Originally from https://github.com/bazelbuild/bazel-toolchains/blob/master/bazelrc/bazel-2.0.0.bazelrc
+#
+# Depending on how many machines are in the remote execution instance, setting
+# this higher can make builds faster by allowing more jobs to run in parallel.
+# Setting it too high can result in jobs that timeout, however, while waiting
+# for a remote machine to execute them.
+build:remote --jobs=50
+
+# Set several flags related to specifying the platform, toolchain and java
+# properties.
+# These flags should only be used as is for the rbe-ubuntu16-04 container
+# and need to be adapted to work with other toolchain containers.
+build:remote --host_javabase=@rbe_ubuntu_clang//java:jdk
+build:remote --javabase=@rbe_ubuntu_clang//java:jdk
+build:remote --host_java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8
+build:remote --java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8
+build:remote --crosstool_top=@rbe_ubuntu_clang//cc:toolchain
+build:remote --action_env=BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1
+# Platform flags:
+# The toolchain container used for execution is defined in the target indicated
+# by "extra_execution_platforms", "host_platform" and "platforms".
+# More about platforms: https://docs.bazel.build/versions/master/platforms.html
+build:remote --extra_toolchains=@rbe_ubuntu_clang//config:cc-toolchain
+build:remote --extra_execution_platforms=@rbe_ubuntu_clang//config:platform
+build:remote --host_platform=@rbe_ubuntu_clang//config:platform
+build:remote --platforms=@rbe_ubuntu_clang//config:platform
+
+# Starting with Bazel 0.27.0 strategies do not need to be explicitly
+# defined. See https://github.com/bazelbuild/bazel/issues/7480
+build:remote --define=EXECUTOR=remote
+
+# Enable remote execution so actions are performed on the remote systems.
+# build:remote --remote_executor=grpcs://remotebuildexecution.googleapis.com
+
+# Enforce stricter environment rules, which eliminates some non-hermetic
+# behavior and therefore improves both the remote cache hit rate and the
+# correctness and repeatability of the build.
+build:remote --incompatible_strict_action_env=true
+
+# Set a higher timeout value, just in case.
+build:remote --remote_timeout=3600
+
+# Enable authentication. This will pick up application default credentials by
+# default. You can use --google_credentials=some_file.json to use a service
+# account credential instead.
+# build:remote --google_default_credentials=true
+
+# Enable build without the bytes
+# See: https://github.com/bazelbuild/bazel/issues/6862
+build:remote --experimental_remote_download_outputs=toplevel --experimental_inmemory_jdeps_files --experimental_inmemory_dotd_files
+
+build:remote --remote_local_fallback

.bazelversion

@@ -0,0 +1 @@
+3.2.0

.buildkite-bazelrc

@@ -2,33 +2,24 @@
 # 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
-
 # 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 --experimental_remote_download_outputs=minimal
-build:remote-cache --experimental_inmemory_jdeps_files
-build:remote-cache --experimental_inmemory_dotd_files
+#build:remote-cache --disk_cache=
+build:remote-cache --remote_download_minimal
 
 # Import workspace options.
 import %workspace%/.bazelrc
 
 startup --host_jvm_args=-Xmx1000m --host_jvm_args=-Xms1000m
+query --repository_cache=/tmp/repositorycache
+query --experimental_repository_cache_hardlinks
+build --repository_cache=/tmp/repositorycache
+build --experimental_repository_cache_hardlinks
 build --experimental_strict_action_env
 build --disk_cache=/tmp/bazelbuilds
 build --experimental_multi_threaded_digest
@@ -36,12 +27,23 @@ build --sandbox_tmpfs_path=/tmp
 build --verbose_failures
 build --announce_rc
 build --show_progress_rate_limit=5
-build --curses=yes --color=yes
+build --curses=yes --color=no
 build --keep_going
 build --test_output=errors
 build --flaky_test_attempts=5
-build --jobs=50
-build --stamp
-test --local_test_jobs=2
 # 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

.github/CODEOWNERS

@@ -0,0 +1,8 @@
+# Automatically require code review from core-team.
+* @prysmaticlabs/core-team
+
+# Starlark code owners
+*.bzl @prestonvanloon
+
+# Anyone on prylabs team can approve dependency updates.
+deps.bzl @prysmaticlabs/core-team

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,59 @@
+---
+name: "\U0001F41EBug report"
+about: Report a bug or problem with running Prysm
+---
+<!--💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎
+
+Hellooo! 😄 
+
+To help us tend to your issue faster, please search our currently open issues before submitting a new one.
+Existing issues often contain information about workarounds, resolution, or progress updates.
+
+💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎-->
+
+# 🐞 Bug Report
+
+### Description
+
+<!-- ✍️--> A clear and concise description of the problem...
+
+### Has this worked before in a previous version?
+
+<!-- Did this behavior use to work in the previous version? -->
+<!-- ✍️--> Yes, the previous version in which this bug was not present was: ....
+
+## 🔬 Minimal Reproduction
+
+<!--
+Please let us know how we can reproduce this issue. Include the exact method you used to run Prysm along with any flags used in your beacon chain and/or validator. Make sure you don't upload any confidential files or private keys.
+-->
+
+## 🔥 Error
+
+<pre><code>
+<!-- If the issue is accompanied by an error, please share the error logs with us below. If you have a lot of logs, place make a paste bin with your logs and share the link with us here: -->
+<!-- ✍️-->
+
+</code></pre>
+
+
+## 🌍  Your Environment
+
+**Operating System:**
+
+<pre>
+  <code>
+
+  </code>
+</pre>
+
+**What version of Prysm are you running? (Which release)**
+
+<pre>
+  <code>
+
+  </code>
+</pre>
+
+**Anything else relevant (validator index / public key)?**
+

.github/ISSUE_TEMPLATE/discussion.md

@@ -0,0 +1,21 @@
+---
+name: "\U0001F48EGeneral issue / discussion"
+about: Any other type of general issue or discussion
+
+---
+<!--💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎
+
+Hellooo! 😄 
+
+To help us tend to your issue faster, please search our currently open issues before submitting a new one.
+Existing issues often contain information about workarounds, resolution, or progress updates.
+
+💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎-->
+
+# 💎 Issue
+
+### Background
+
+<!-- ✍️--> Context and background information on the discussion...
+
+### Description

.github/ISSUE_TEMPLATE/feature_flag.md

@@ -0,0 +1,38 @@
+---
+name: "\U0001F984Feature Flag Tracking"
+about: Track a new feature, in development, in Prysm. This issue template should only be used by developers or contributors!
+labels: Tracking
+---
+<!--💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎
+
+Hellooo! 😄 
+
+Thanks for taking the time to file a tracking issue for your new feature. These issues really help
+us track progress of features as they work their way through development. Be sure to review 
+shared/featureconfig/README.md for the latest documentation around feature flags.
+
+💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎-->
+
+# 🦄 Feature Tracking
+
+**Current status** (opt-in or opt-out): 
+
+**Opt-in feature flag name**:
+
+**Opt-out feature flag name**: 
+
+### Feature Description
+
+<!-- ✍️--> A clear and concise description of the new feature. Provide links to your technical
+design document or other supporting information.
+
+### Tasks
+
+- [ ] Feature flag created as opt-in
+- [ ] Feature implemented / code complete
+- [ ] Feature tested in production for adequate amount of time
+- [ ] Feature flag is inverted to be opt-out and the opt-in flag is deprecated
+- [ ] Feature has made it to a tagged production release as an opt-out flag
+- [ ] Opt-out feature flag is deprecated and old code paths are cleaned up
+
+This issue should be closed after all of the above tasks are complete.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,27 @@
+---
+name: "\U0001F680Feature request"
+about: Suggest a feature for Prysm
+
+---
+<!--💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎
+
+Hellooo! 😄 
+
+To help us tend to your issue faster, please search our currently open issues before submitting a new one.
+Existing issues often contain information about workarounds, resolution, or progress updates.
+
+💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎💎-->
+
+# 🚀 Feature Request
+
+### Description
+
+<!-- ✍️--> A clear and concise description of the problem or missing capability...
+
+### Describe the solution you'd like
+
+<!-- ✍️--> If you have a solution in mind, please describe it.
+
+### Describe alternatives you've considered
+
+<!-- ✍️--> Have you considered any alternative solutions or workarounds?

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,30 @@
+<!-- Thanks for sending a PR! Before submitting:
+
+1. If this is your first PR, please read CONTRIBUTING.md and sign the CLA
+   first. We cannot review code without a signed CLA.
+2. Please file an issue *first*. All features and most bug fixes should have
+   an associated issue with a design discussed and decided upon. Small bug
+   fixes and documentation improvements don't need issues.
+3. New features and bug fixes must have tests. Documentation may need to
+   be updated. If you're unsure what to update, send the PR, and we'll discuss
+   in review.
+4. Note that PRs updating dependencies and new Go versions are not accepted.
+   Please file an issue instead.
+-->
+
+**What type of PR is this?**
+
+> Uncomment one line below and remove others.
+>
+> Bug fix
+> Feature
+> Documentation
+> Other
+
+**What does this PR do? Why is it needed?**
+
+**Which issues(s) does this PR fix?**
+
+Fixes #
+
+**Other notes for review**

.github/actions/gofmt/Dockerfile

@@ -0,0 +1,5 @@
+FROM cytopia/gofmt
+
+COPY entrypoint.sh /entrypoint.sh
+
+ENTRYPOINT ["/entrypoint.sh"]

.github/actions/gofmt/action.yml

@@ -0,0 +1,12 @@
+name: 'Gofmt checker'
+description: 'Checks that all project files have been properly formatted.'
+inputs:
+  path:
+    description: 'Path to check'
+    required: true
+    default: './'
+runs:
+  using: 'docker'
+  image: 'Dockerfile'
+  args:
+    - ${{ inputs.path }}

.github/actions/gofmt/entrypoint.sh

@@ -0,0 +1,15 @@
+#!/bin/sh -l
+set -e
+
+cd $GITHUB_WORKSPACE
+
+# Check if any files are not formatted.
+nonformatted="$(gofmt -l $1 2>&1)"
+
+# Return if `go fmt` passes.
+[ -z "$nonformatted" ] && exit 0
+
+# Notify of issues with formatting.
+echo "Following files need to be properly formatted:"
+echo "$nonformatted"
+exit 1

.github/actions/gomodtidy/Dockerfile

@@ -0,0 +1,5 @@
+FROM golang:alpine
+
+COPY entrypoint.sh /entrypoint.sh
+
+ENTRYPOINT ["/entrypoint.sh"]

.github/actions/gomodtidy/action.yml

@@ -0,0 +1,5 @@
+name: 'Go mod tidy checker'
+description: 'Checks that `go mod tidy` has been applied.'
+runs:
+  using: 'docker'
+  image: 'Dockerfile'

.github/actions/gomodtidy/entrypoint.sh

@@ -0,0 +1,34 @@
+#!/bin/sh -l
+set -e
+export PATH=$PATH:/usr/local/go/bin
+
+cd $GITHUB_WORKSPACE
+
+cp go.mod go.mod.orig
+cp go.sum go.sum.orig
+
+go mod tidy
+
+echo "Checking go.mod and go.sum:"
+checks=0
+if [ "$(diff -s go.mod.orig go.mod | grep -c 'Files go.mod.orig and go.mod are identical')" = 1 ]; then
+  echo "- go.mod is up to date."
+  checks=$((checks + 1))
+else
+  echo "- go.mod is NOT up to date."
+fi
+
+if [ "$(diff -s go.sum.orig go.sum | grep -c 'Files go.sum.orig and go.sum are identical')" = 1 ]; then
+  echo "- go.sum is up to date."
+  checks=$((checks + 1))
+else
+  echo "- go.sum is NOT up to date."
+fi
+
+if [ $checks -eq 2 ]; then
+  exit 0
+fi
+
+# Notify of any issues.
+echo "Run 'go mod tidy' to update."
+exit 1

.github/no-response.yml

@@ -0,0 +1,13 @@
+# Configuration for probot-no-response - https://github.com/probot/no-response
+
+# Number of days of inactivity before an Issue is closed for lack of response
+daysUntilClose: 14
+# Label requiring a response
+responseRequiredLabel: Need-Info
+# Comment to post when closing an Issue for lack of response. Set to `false` to disable
+closeComment: >
+  This issue has been automatically closed because there has been no response
+  to our request for more information from the original author. With only the
+  information that is currently in the issue, we don't have enough information
+  to take action. Please reach out if you have or find the answers we need so
+  that we can investigate further.

.github/workflows/dappnode-release-trigger.yml

@@ -0,0 +1,41 @@
+name: Update DAppNodePackages
+
+on:
+  push:
+    tags:
+    - '*'
+
+jobs:
+  dappnode-update-beacon-chain:
+    name: Trigger a beacon-chain release
+    runs-on: ubuntu-latest
+    steps:
+    - name: Get latest tag
+      id: get_tag
+      run: echo ::set-output name=TAG::${GITHUB_REF/refs\/tags\//}
+    - name: Send dispatch event to DAppNodePackage-prysm-beacon-chain
+      env: 
+        DISPATCH_REPO: dappnode/DAppNodePackage-prysm-beacon-chain
+      run: |
+        curl -v -X POST -u "${{ secrets.PAT_GITHUB }}" \
+        -H "Accept: application/vnd.github.everest-preview+json" \
+        -H "Content-Type: application/json" \
+        --data '{"event_type":"new_release", "client_payload": { "tag":"${{ steps.get_tag.outputs.TAG }}"}}' \
+        https://api.github.com/repos/$DISPATCH_REPO/dispatches
+        
+  dappnode-update-validator:
+    name: Trigger a validator release
+    runs-on: ubuntu-latest
+    steps:
+    - name: Get latest tag
+      id: get_tag
+      run: echo ::set-output name=TAG::${GITHUB_REF/refs\/tags\//}
+    - name: Send dispatch event to DAppNodePackage validator repository
+      env: 
+        DISPATCH_REPO: dappnode/DAppNodePackage-prysm-validator
+      run: |
+        curl -v -X POST -u "${{ secrets.PAT_GITHUB }}" \
+        -H "Accept: application/vnd.github.everest-preview+json" \
+        -H "Content-Type: application/json" \
+        --data '{"event_type":"new_release", "client_payload": { "tag":"${{ steps.get_tag.outputs.TAG }}"}}' \
+        https://api.github.com/repos/$DISPATCH_REPO/dispatches

.github/workflows/go.yml

@@ -0,0 +1,50 @@
+name: Go
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ '*' ]
+
+jobs:
+
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Go mod tidy checker
+        id: gomodtidy
+        uses: ./.github/actions/gomodtidy
+
+      - name: Gofmt checker
+        id: gofmt
+        uses: ./.github/actions/gofmt
+        with:
+          path: ./
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Go 1.x
+        uses: actions/setup-go@v2
+        with:
+          go-version: ^1.14
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Get dependencies
+        run: |
+          go get -v -t -d ./...
+
+      - name: Build
+        run: go build -v ./...
+
+# Tests run via Bazel for now...
+#      - name: Test
+#        run: go test -v ./...

.gitignore

@@ -4,6 +4,9 @@ bazel-*
 .DS_Store
 .swp
 
+# Ignore VI/Vim swapfiles
+.*.sw?
+
 # IntelliJ
 .idea
 .ijwb
@@ -14,6 +17,7 @@ bazel-*
 # Coverage outputs
 coverage.txt
 profile.out
+profile.grind
 
 # Nodejs
 node_modules
@@ -23,6 +27,5 @@ yarn-error.log
 # Ignore password file
 password.txt
 
-# go dependancy
-/go.mod
-/go.sum
+# Dist files
+dist

.well-known/security.txt

@@ -4,23 +4,23 @@ Hash: SHA512
 Contact: mailto:security@prysmaticlabs.com
 Encryption: openpgp4fpr:0AE0051D647BA3C1A917AF4072E33E4DF1A5036E
 Encryption: openpgp4fpr:341396BAFACC28C5082327F889725027FC8EC0D4
-Encryption: openpgp4fpr:8B7814F1B221A8E8AA465FC7BDBF744ADE1A0033
+Encryption: openpgp4fpr:FEE44615A19049DF0CA0C2735E2B7E5734DFADCB
 Preferred-Languages: en
 Canonical: https://github.com/prysmaticlabs/prysm/tree/master/.well-known/security.txt
 
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEECuAFHWR7o8GpF69AcuM+TfGlA24FAlzi0WgACgkQcuM+TfGl
-A241pw/+Ks3Hxx8eGbjRIeuncuK811FkCiofNJS+MY2p4W2/tIrk48DtLRx8/k5L
-Dh1QyypZsqUgofrK7PbGVdEin6oEb2jYbTWUarAVTbhlsUdM4YcxwpgmGVslW7+C
-Hm8wMasQZhCkFfakzhfKX5hIQoFaFI/OvtVKIQsodP8dAieCDaGmtfq1Bs1LgFqi
-KrpeEdC2XbBQs33ADheC5SdGT1mnatP3VX8cOhLsfoPksYgTSpwK0clkoWs1eZOQ
-l1ImfW/FJCpSndBWgBR503ZgaU3Ic+5qxmAIuUP4chl0DFRMlPFEM5OWC6JkkCOd
-5kKrXGRmrhgtQg+pA3zqJnFItRj7gxPBA/ypxCkKPrLEkRvbdpdZEl5vAlYkeBL6
-iKSLHnMswGKldiYxy7ofam5bM3myhYYNFb25boV5pRptrnoUmWOACHioBGQHwWNt
-B0XktD0j7+pCCiJyyYxmOnElsk/Y/u4Tv5pYWvfFuxTF2XOg+P/EH64AIFLWgB1U
-VnITxhakxqejCBxZkuVCFNSzt+TXG0NS9EIj/UOYBY+wxrBZ62ITjdA16RS/3n3z
-DuIDtxOOwUumbOO32+a5zIb+ARmnocYJviI7FuENb01/U6qb+nm9hQI6oIpSCNsv
-Pb4O/ZlOx70U/7mt4Xn/dTKH9bnKOOVhOw00KJWFfAce73AVnLA=
-=Uhqg
+iQIzBAEBCgAdFiEECuAFHWR7o8GpF69AcuM+TfGlA24FAl6HrcwACgkQcuM+TfGl
+A26voQ/8DFB5wUHP0uyY8k7FGbxhLzSeImxomnUHJaUGfdczbCdYPMEHc9zI1iZP
+6LRiy9wS6qhqj/GSKVwvDPr+ZymXuV3L22GOP2lRhl7Z9Mm21ZJNOcoQBFOZnyHu
+DAy9HeTmeuJxYkf8weqZYXyzEoKJBDmfuWmEFjrtMcFXUfT3aJn1E2A/AQdcVQIC
+9L+iGWwFwjsPhcfaMuwcB7QMheDO6KSB7XPPCbrZ036Np8UTZ4qbZ5y73tlfkcOc
+tYTrMSPtS4eNutiDOP5Np36cLzRtNpm/BziAK+7ZKiYY0HI5h9IkCTLO4x2UmAMX
+sPoeaAB5z2QLIwmU9J2NhJrwiNMGTpJ+0bowy8U4cgzAX20CXVjRqGhy+cir8Ewg
+DjEGjWINUw6W0yzJp0mKSKzuOhdTTmzIYBeMBsyce+pgN1KGFCxeIwxGxyJzADdw
+mYQdljRXn4yEYP/KEpu/F2o8L4ptRO2jZWKvTvdzSSGGSyKyF4HsIRJ7m98DaB6S
+0oGq1KpbKKTbQi5g8UShGV2gPeMCs5ZIIqK2b/cRzUet18aUuofLmR4lkKZa9yEG
+rbzuJq/gB2vgQwExUEgVQ3/DfVc+y80e3YZ5s+rzV0vbLxl4Gh4yExpLo7hRf9iY
+EFvMzH+BEEb5VfCwByZyV1BmesZVIosr7K6UmVtPe0bZGvv3uIg=
+=5qpD
 -----END PGP SIGNATURE-----

BUILD.bazel

@@ -4,7 +4,7 @@ load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
 load("@graknlabs_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
-load("//tools:binary_targets.bzl", "binary_targets", "determine_targets")
+load("@bazel_skylib//rules:common_settings.bzl", "string_setting")
 
 prefix = "github.com/prysmaticlabs/prysm"
 
@@ -13,6 +13,8 @@ exports_files([
 ])
 
 # gazelle:prefix github.com/prysmaticlabs/prysm
+# gazelle:map_kind go_library go_library @prysm//tools/go:def.bzl
+# gazelle:map_kind go_repository go_repository @prysm//tools/go:def.bzl
 gazelle(
     name = "gazelle",
     prefix = prefix,
@@ -44,7 +46,7 @@ alias(
 # Protobuf gRPC gateway compiler
 alias(
     name = "grpc_gateway_proto_compiler",
-    actual = "@grpc_ecosystem_grpc_gateway//protoc-gen-grpc-gateway:go_gen_grpc_gateway",
+    actual = "@com_github_grpc_ecosystem_grpc_gateway//protoc-gen-grpc-gateway:go_gen_grpc_gateway",
     visibility = ["//visibility:public"],
 )
 
@@ -86,15 +88,12 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/pkgfact:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/nilness:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/nilfunc:go_tool_library",
-        # lost cancel ignore doesn't seem to work when running with coverage
-        #"@org_golang_x_tools//go/analysis/passes/lostcancel:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/loopclosure:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/httpresponse:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/findcall:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/copylock:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/composite:go_tool_library",
         #  "@org_golang_x_tools//go/analysis/passes/cgocall:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/buildtag:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/buildssa:go_tool_library",
@@ -104,20 +103,24 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/assign:go_tool_library",
         "@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",
+    ] + select({
+        # nogo checks that fail with coverage enabled.
+        ":coverage_enabled": [],
+        "//conditions:default": [
+            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_tool_library",
+            "@org_golang_x_tools//go/analysis/passes/composite:go_tool_library",
+        ],
+    }),
 )
 
-assemble_versioned(
-    name = "assemble-versioned-all",
-    tags = ["manual"],
-    targets = [
-        ":assemble-{}-{}-targz".format(
-            pair[0],
-            pair[1],
-        )
-        for pair in binary_targets
-    ],
-    version_file = "//:VERSION",
+config_setting(
+    name = "coverage_enabled",
+    values = {"define": "coverage_enabled=1"},
 )
 
 common_files = {
@@ -125,21 +128,17 @@ common_files = {
     "//:README.md": "README.md",
 }
 
-[assemble_targz(
-    name = "assemble-{}-{}-targz".format(
-        pair[0],
-        pair[1],
-    ),
-    additional_files = determine_targets(pair, common_files),
-    output_filename = "prysm-{}-{}".format(
-        pair[0],
-        pair[1],
-    ),
-    tags = ["manual"],
-) for pair in binary_targets]
-
 toolchain(
     name = "built_cmake_toolchain",
     toolchain = "@rules_foreign_cc//tools/build_defs/native_tools:built_cmake",
     toolchain_type = "@rules_foreign_cc//tools/build_defs:cmake_toolchain",
 )
+
+string_setting(
+    name = "gotags",
+    build_setting_default = "",
+    values = [
+        "",
+        "libfuzzer",
+    ],
+)

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!
 

DEPENDENCIES.md

@@ -0,0 +1,69 @@
+# Dependency Managagement in Prysm
+
+Prysm is go project with many complicated dependencies, including some c++ based libraries. There
+are two parts to Prysm's dependency management. Go modules and bazel managed dependencies. Be sure 
+to read [Why Bazel?](https://github.com/prysmaticlabs/documentation/issues/138) to fully
+understand the reasoning behind an additional layer of build tooling via Bazel rather than a pure
+"go build" project.
+
+## Go Module support
+
+The Prysm project officially supports go modules with some caveats. 
+
+### Caveat 1: Some c++ libraries are precompiled archives
+
+Given some of Prysm's c++ dependencies have very complicated project structures which make building
+difficult or impossible with "go build" alone. Additionally, building c++ dependencies with certain
+compilers, like clang / LLVM, offer a significant performance improvement. To get around this 
+issue, c++ dependencies have been precompiled as linkable archives. While there isn't necessarily
+anything bad about precompiled archives, these files are a "blackbox" which a 3rd party author
+could have compiled anything for this archive and detecting undesired behavior would be nearly
+impossible. If your risk tolerance is low, always compile everything from source yourself, 
+including complicated c++ dependencies.
+
+*Recommendation: Use go build only for local development and use bazel build for production.*
+
+### Caveat 2: Generated gRPC protobuf libraries
+
+One key advantage of Bazel over vanilla `go build` is that Bazel automatically (re)builds generated
+pb.go files at build time when file changes are present in any protobuf definition file or after
+any updates to the protobuf compiler or other relevant dependencies. Vanilla go users should run
+the following scripts often to ensure their generated files are up to date. Further more, Prysm
+generates SSZ marshal related code based on defined data structures. These generated files must
+also be updated and checked in as frequently.
+
+```bash
+./scripts/update-go-pbs.sh
+./scripts/update-go-ssz.sh
+```
+
+*Recommendation: Use go build only for local development and use bazel build for production.*
+
+### Caveat 3: Compile-time optimizations 
+
+When Prysmatic Labs builds production binaries, they use the "release" configuration of bazel to
+compile with several compiler optimizations and recommended production build configurations.
+Additionally, the release build properly stamps the built binaries to include helpful metadata
+about how and when the binary was built. 
+
+*Recommendation: Use go build only for local development and use bazel build for production.*
+
+```bash
+bazel build //beacon-chain --config=release
+```
+ 
+## Adding / updating dependencies
+
+1. Add your dependency as you would with go modules. I.e. `go get ...`
+1. Run `gazelle update-repos -from_file=go.mod` to update the bazel managed dependencies.
+
+Example:
+
+```bash
+go get github.com/prysmaticlabs/example@v1.2.3
+bazel run //:gazelle -- update-repos -from_file=go.mod -to_macro=deps.bzl%prysm_deps
+```
+
+The deps.bzl file should have been updated with the dependency and any transitive dependencies. 
+
+Do NOT add new `go_repository` to the WORKSPACE file. All dependencies should live in deps.bzl.

INTEROP.md

@@ -57,7 +57,7 @@ the system with 64 validators and the genesis time set to the current unix times
 Wait a bit until your beacon chain starts, and in the other window:
 
 ```
-bazel run //validator -- --interop-num-validators 64
+bazel run //validator -- --keymanager=interop --keymanageropts='{"keys":64}'
 ```
 
 This will launch and kickstart the system with your 64 validators performing their duties accordingly.
@@ -78,13 +78,7 @@ Assuming you generated a `genesis.ssz` file with 64 validators, open up two term
 Wait a bit until your beacon chain starts, and in the other window:
 
 ```
-bazel run //validator -- --interop-num-validators 64
+bazel run //validator -- --keymanager=interop --keymanageropts='{"keys":64}'
 ```
 
 This will launch and kickstart the system with your 64 validators performing their duties accordingly.
-
-
-
-
-
-

PULL_REQUEST_TEMPLATE.md

@@ -1,13 +0,0 @@
-TODO(you): choose "part of" or "resolves" and the associated github issue #.
-
-[Part of|Resolves] #531 
-
----
-
-# Description
-
-**Write why you are making the changes in this pull request**
-
-**Write a summary of the changes you are making**
-
-**Link anything that would be helpful or relevant to the reviewers**

README.md

@@ -1,236 +1,20 @@
 # Prysm: An Ethereum 2.0 Client Written in Go
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
-[![ETH2.0_Spec_Version 0.9.3](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v0.9.3-blue.svg)](https://github.com/ethereum/eth2.0-specs/tree/v0.9.3)
+[![ETH2.0_Spec_Version 0.12.2](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v0.12.2-blue.svg)](https://github.com/ethereum/eth2.0-specs/tree/v0.12.2)
 [![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)
 
 This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the Ethereum 2.0 client specifications developed by [Prysmatic Labs](https://prysmaticlabs.com).
 
-### Need assistance?
-A more detailed set of installation and usage instructions as well as breakdowns of each individual component are available in the [official documentation portal](https://prysmaticlabs.gitbook.io/prysm/). If you still have questions, feel free to stop by either our [Discord](https://discord.gg/KSA7rPr) or [Gitter](https://gitter.im/prysmaticlabs/geth-sharding?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) and a member of the team or our community will be happy to assist you.
+### Getting Started
+A detailed set of installation and usage instructions as well as breakdowns of each individual component are available in the [official documentation portal](https://docs.prylabs.network). If you still have questions, feel free to stop by either our [Discord](https://discord.gg/KSA7rPr) or [Gitter](https://gitter.im/prysmaticlabs/geth-sharding?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) and a member of the team or our community will be happy to assist you.
 
 ### Come join the testnet!
-Participation is now open to the public for our Ethereum 2.0 phase 0 testnet release. Visit [prylabs.net](https://prylabs.net) for more information on the project or to sign up as a validator on the network.
-
-# Table of Contents
-
-- [Dependencies](#dependencies)
-- [Installation](#installing-prysm)
-    - [Build via Docker](#build-via-docker)
-    - [Build via Bazel](#build-via-bazel)
-- [Connecting to the public testnet: running a beacon node](#connecting-to-the-testnet-running-a-beacon-node)
-    - [Running via Docker](#running-via-docker)
-    - [Running via Bazel](#running-via-bazel)
-- [Staking ETH: running a validator client](#staking-eth-running-a-validator-client)
-    - [Activating your validator: depositing 3.2 Goerli ETH](#activating-your-validator-depositing-32-göerli-eth)
-    - [Starting the validator with Bazel](#starting-the-validator-with-bazel)
-- [Setting up a local ETH2 development chain](#setting-up-a-local-eth2-development-chain)
-    - [Installation and dependencies](#installation-and-dependencies) 
-    - [Running a local beacon node and validator client](#running-a-local-beacon-node-and-validator-client)   
--   [Testing Prysm](#testing-prysm)
--   [Contributing](#contributing)
--   [License](#license)
-
-## Dependencies
-
-Prysm can be installed either with Docker **\(recommended\)** or using our build tool, Bazel. The below instructions include sections for performing both.
-
-#### **For Docker installations:**
-
-* The latest release of [Docker](https://docs.docker.com/install/)
-
-#### **For Bazel installations:**
-
-* The latest release of [Bazel](https://docs.bazel.build/versions/master/install.html)
-* The latest release of `cmake`
-* The latest release of `git`
-* A modern UNIX operating system \(macOS included\)
-
-## Installing Prysm
-
-### Build via Docker
-
-1. Ensure you are running the most recent version of Docker by issuing the command:
-
-```text
-docker -v
-```
-
-2. To pull the Prysm images, issue the following commands:
-
-```text
-docker pull gcr.io/prysmaticlabs/prysm/validator:latest
-docker pull gcr.io/prysmaticlabs/prysm/beacon-chain:latest
-```
-
-This process will also install any related dependencies.
-
-### Build via Bazel
-
-1. Open a terminal window. Ensure you are running the most recent version of Bazel by issuing the command:
-
-```text
-bazel version
-```
-
-2. Clone Prysm's [main repository](https://github.com/prysmaticlabs/prysm) and enter the directory:
-
-```text
-git clone https://github.com/prysmaticlabs/prysm
-cd prysm
-```
-
-3. Build both the beacon chain node and the validator client:
-
-```text
-bazel build //beacon-chain:beacon-chain
-bazel build //validator:validator
-```
-
-Bazel will automatically pull and install any dependencies as well, including Go and necessary compilers.
-
-## Connecting to the testnet: running a beacon node
-
-Below are instructions for initialising a beacon node and connecting to the public testnet. To further understand the role that the beacon node plays in Prysm, see [this section of the documentation.](https://prysmaticlabs.gitbook.io/prysm/how-prysm-works/overview-technical)
-
-
-**NOTE:** It is recommended to open up port 13000 on your local router to improve connectivity and receive more peers from the network. To do so, navigate to `192.168.0.1` in your browser and login if required. Follow along with the interface to modify your routers firewall settings. When this task is completed, append the parameter`--p2p-host-ip=$(curl -s ident.me)` to your selected beacon startup command presented in this section to use the newly opened port.
-
-### Running via Docker
-
-#### **Docker on Linux/macOS:**
-
-To start your beacon node, issue the following command:
-
-```text
-docker run -it -v $HOME/prysm:/data -p 4000:4000 --name beacon-node \
-  gcr.io/prysmaticlabs/prysm/beacon-chain:latest \
-  --datadir=/data \
-  --init-sync-no-verify
-```
-
-The beacon node can be halted by either using `Ctrl+c` or with the command:
-
-```text
-docker stop beacon-node
-```
-
-To restart the beacon node, issue the following command:
-
-```text
-docker start -ai beacon-node
-```
-
-To delete a corrupted container, issue the following command:
-
-```text
-docker rm beacon-node
-```
-
-To recreate a deleted container and refresh the chain database, issue the start command with an additional `--clear-db` parameter:
-
-```text
-docker run -it -v $HOME/prysm:/data -p 4000:4000 --name beacon-node \
-  gcr.io/prysmaticlabs/prysm/beacon-chain:latest \
-  --datadir=/data \
-  --clear-db
-```
-
-#### **Docker on Windows:**
-
-1. You will need to 'share' the local drive you wish to mount to \(e.g. C:\).
-   1. Enter Docker settings \(right click the tray icon\)
-   2. Click 'Shared Drives'
-   3. Select a drive to share
-   4. Click 'Apply'
-   
-2. You will next need to create a directory named `/prysm/` within your selected shared Drive. This folder will be used as a local data directory for Beacon Node chain data as well as account and keystore information required by the validator. Docker will **not** create this directory if it does not exist already. For the purposes of these instructions, it is assumed that `C:` is your prior-selected shared Drive.
-3. To run the beacon node, issue the following command:
-
-```text
-docker run -it -v c:/prysm/:/data -p 4000:4000 gcr.io/prysmaticlabs/prysm/beacon-chain:latest --datadir=/data --init-sync-no-verify --clear-db
-```
-
-### Running via Bazel
-
-To start your Beacon Node with Bazel, issue the following command:
-
-```text
-bazel run //beacon-chain -- --clear-db --datadir=$HOME/prysm
-```
-
-This will sync up the beacon node with the latest head block in the network.
-
-
-**NOTE:** The beacon node must be **completely synced** before attempting to initialise a validator client, otherwise the validator will not be able to complete the deposit and **funds will lost**.
-
-
-## Staking ETH: Running a validator client
-
-Once your beacon node is up, the chain will be waiting for you to deposit 3.2 Goerli ETH into a [validator deposit contract](how-prysm-works/validator-deposit-contract.md) in order to activate your validator \(discussed in the section below\). First though, you will need to create this validator and connect to this node to participate in consensus.
-
-Each validator represents 3.2 Goerli ETH being staked in the system, and it is possible to spin up as many as you desire in order to have more stake in the network.
-
-### Activating your validator: depositing 3.2 Göerli ETH
-
-To begin setting up a validator, follow the instructions found on [prylabs.net](https://prylabs.net) to use the Göerli ETH faucet and make a deposit. For step-by-step assistance with the deposit page, see the [Activating a Validator ](activating-a-validator.md)section of this documentation.
-
-It will take a while for the nodes in the network to process a deposit. Once the node is active, the validator will immediately begin performing its responsibilities.
-
-In your validator client, you will be able to frequently see your validator balance as it goes up over time. Note that, should your node ever go offline for a long period, a validator will start gradually losing its deposit until it is removed from the network entirely.
-
-**Congratulations, you are now running Ethereum 2.0 Phase 0!**
-
-## Setting up a local ETH2 development chain
-
-This section outlines the process of setting up Prysm for local testing with other Ethereum 2.0 client implementations. See the [INTEROP.md](https://github.com/prysmaticlabs/prysm/blob/master/INTEROP.md) file for advanced configuration options. For more background information on interoperability development, see [this blog post](https://blog.ethereum.org/2019/09/19/eth2-interop-in-review/).
-
-### Installation and dependencies
-
-To begin setting up a local ETH2 development chain, follow the **Bazel** instructions found in the [dependencies](https://github.com/prysmaticlabs/prysm#dependencies) and [installation](https://github.com/prysmaticlabs/prysm#installation) sections respectively.
-
-### Running a local beacon node and validator client
-
-The example below will generate a beacon genesis state and initiate Prysm with 64 validators with the genesis time set to your machines UNIX time.
-
-Open up two terminal windows. In the first, issue the command:
-
-```text
-bazel run //beacon-chain -- \
---no-genesis-delay \
---bootstrap-node= \
---deposit-contract $(curl https://prylabs.net/contract) \
---clear-db \
---interop-num-validators 64 \
---interop-eth1data-votes
-```
-
-Wait a moment for the beacon chain to start. In the other terminal, issue the command:
-
-```text
-bazel run //validator -- --interop-num-validators 64
-```
-
-This command will kickstart the system with your 64 validators performing their duties accordingly.
-
-## Testing Prysm
-
-To run the unit tests of our system, issue the command:
-
-```text
-bazel test //...
-```
-
-To run our linter, make sure you have [golangci-lint](https://github.com/golangci/golangci-lint) installed and then issue the command:
-
-```text
-golangci-lint run
-```
-
+Participation is now open to the public for our Ethereum 2.0 phase 0 testnet release. Visit [prylabs.net](https://prylabs.net) for more information on the project or to sign up as a validator on the network. You can visualize the nodes in the network on [eth2stats.io](https://eth2stats.io), explore validator rewards/penalties via Bitfly's block explorer: [beaconcha.in](https://beaconcha.in), and follow the latest blocks added to the chain on [Etherscan](https://beacon.etherscan.io).
 
 ## Contributing
-Want to get involved? Check out our [Contribution Guide](https://prysmaticlabs.gitbook.io/prysm/getting-involved/contribution-guidelines) to learn more!
+Want to get involved? Check out our [Contribution Guide](https://docs.prylabs.network/docs/contribute/contribution-guidelines/) to learn more!
 
 ## License
 [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html)

bazel.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+# This script serves as a wrapper around bazel to limit the scope of environment variables that
+# may change the action output. Using this script should result in a higher cache hit ratio for
+# cached actions with a more heremtic build.
+
+env -i \
+ PATH=/usr/bin:/bin \
+ HOME=$HOME \
+ GOOGLE_APPLICATION_CREDENTIALS=$GOOGLE_APPLICATION_CREDENTIALS \
+ bazel "$@"

beacon-chain/BUILD.bazel

@@ -1,7 +1,8 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library", "go_test")
+load("@prysm//tools/go:def.bzl", "go_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_test")
 load("@io_bazel_rules_docker//go:image.bzl", "go_image")
 load("@io_bazel_rules_docker//container:container.bzl", "container_bundle")
-load("//tools:binary_targets.bzl", "binary_targets")
+load("//tools:go_image.bzl", "go_image_alpine", "go_image_debug")
 load("@io_bazel_rules_docker//contrib:push-all.bzl", "docker_push")
 
 go_library(
@@ -19,14 +20,15 @@ go_library(
         "//shared/debug:go_default_library",
         "//shared/featureconfig:go_default_library",
         "//shared/logutil:go_default_library",
+        "//shared/maxprocs:go_default_library",
         "//shared/version:go_default_library",
-        "@com_github_ipfs_go_log//: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//:go_default_library",
-        "@com_github_whyrusleeping_go_logging//: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",
     ],
 )
 
@@ -36,7 +38,11 @@ go_image(
         "main.go",
         "usage.go",
     ],
-    base = "//tools:cc_image",
+    base = select({
+        "//tools:base_image_alpine": "//tools:alpine_cc_image",
+        "//tools:base_image_cc": "//tools:cc_image",
+        "//conditions:default": "//tools:cc_image",
+    }),
     goarch = "amd64",
     goos = "linux",
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain",
@@ -52,13 +58,14 @@ go_image(
         "//shared/featureconfig:go_default_library",
         "//shared/logutil:go_default_library",
         "//shared/version:go_default_library",
-        "@com_github_ipfs_go_log//: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//:go_default_library",
-        "@com_github_whyrusleeping_go_logging//: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",
+        "//shared/maxprocs:go_default_library",
     ],
 )
 
@@ -67,6 +74,42 @@ container_bundle(
     images = {
         "gcr.io/prysmaticlabs/prysm/beacon-chain:latest": ":image",
         "gcr.io/prysmaticlabs/prysm/beacon-chain:{DOCKER_TAG}": ":image",
+        "index.docker.io/prysmaticlabs/prysm-beacon-chain:latest": ":image",
+        "index.docker.io/prysmaticlabs/prysm-beacon-chain:{DOCKER_TAG}": ":image",
+    },
+    tags = ["manual"],
+)
+
+go_image_debug(
+    name = "image_debug",
+    image = ":image",
+    tags = ["manual"],
+)
+
+container_bundle(
+    name = "image_bundle_debug",
+    images = {
+        "gcr.io/prysmaticlabs/prysm/beacon-chain:latest-debug": ":image_debug",
+        "gcr.io/prysmaticlabs/prysm/beacon-chain:{DOCKER_TAG}-debug": ":image_debug",
+        "index.docker.io/prysmaticlabs/prysm-beacon-chain:latest-debug": ":image_debug",
+        "index.docker.io/prysmaticlabs/prysm-beacon-chain:{DOCKER_TAG}-debug": ":image_debug",
+    },
+    tags = ["manual"],
+)
+
+go_image_alpine(
+    name = "image_alpine",
+    image = ":image",
+    tags = ["manual"],
+)
+
+container_bundle(
+    name = "image_bundle_alpine",
+    images = {
+        "gcr.io/prysmaticlabs/prysm/beacon-chain:latest-alpine": ":image_alpine",
+        "gcr.io/prysmaticlabs/prysm/beacon-chain:{DOCKER_TAG}-alpine": ":image_alpine",
+        "index.docker.io/prysmaticlabs/prysm-beacon-chain:latest-alpine": ":image_alpine",
+        "index.docker.io/prysmaticlabs/prysm-beacon-chain:{DOCKER_TAG}-alpine": ":image_alpine",
     },
     tags = ["manual"],
 )
@@ -77,6 +120,18 @@ docker_push(
     tags = ["manual"],
 )
 
+docker_push(
+    name = "push_images_debug",
+    bundle = ":image_bundle_debug",
+    tags = ["manual"],
+)
+
+docker_push(
+    name = "push_images_alpine",
+    bundle = ":image_bundle_alpine",
+    tags = ["manual"],
+)
+
 go_binary(
     name = "beacon-chain",
     embed = [":go_default_library"],
@@ -91,17 +146,8 @@ go_test(
     size = "small",
     srcs = ["usage_test.go"],
     embed = [":go_default_library"],
-    deps = ["@com_github_urfave_cli//:go_default_library"],
+    deps = [
+        "//shared/featureconfig:go_default_library",
+        "@com_github_urfave_cli_v2//:go_default_library",
+    ],
 )
-
-[go_binary(
-    name = "beacon-chain-{}-{}".format(
-        pair[0],
-        pair[1],
-    ),
-    embed = [":go_default_library"],
-    goarch = pair[1],
-    goos = pair[0],
-    tags = ["manual"],
-    visibility = ["//visibility:public"],
-) for pair in binary_targets]

beacon-chain/README.md

@@ -5,6 +5,6 @@ This is the main project folder for the beacon chain implementation of Ethereum
 [![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/prysm?badge&utm_medium=badge&utm_campaign=pr-badge)
 
-Also, read the latest beacon chain [design spec](https://github.com/ethereum/eth2.0-specs/blob/dev/specs/core/0_beacon-chain.md), this design spec serves as a source of truth for the beacon chain implementation we follow at prysmatic labs.
+Also, read the latest beacon chain [design spec](https://github.com/ethereum/eth2.0-specs/blob/dev/specs/phase0/beacon-chain.md), this design spec serves as a source of truth for the beacon chain implementation we follow at prysmatic labs.
 Check out the [FAQs](https://notes.ethereum.org/9MMuzWeFTTSg-3Tz_YeiBA?view). Refer this page on [why](http://email.mg2.substack.com/c/eJwlj9GOhCAMRb9G3jRQQPGBh5mM8xsbhKrsDGIAM9m_X9xN2qZtbpt7rCm4xvSjj5gLOTOmL-809CMbKXFaOKakIl4DZYr2AGyQIGjHOnWH22OiYnoIxmDijaBhhS6fcy7GvjobA9m0mSXOcnZq5GBqLkilXBZhBsus5ZK89VbKkRt-a-BZI6DzZ7iur1lQ953KJ9bemnxgahuQU9XJu6pFPdu8meT8vragzEjpMCwMGLlgLo6h5z1JumQTu4IJd4v15xqMf_8ZLP_Y1bSLdbnrD-LL71i2Kj7DLxaWWF4)
 we are combining sharding and casper together.

beacon-chain/archiver/BUILD.bazel

@@ -1,44 +0,0 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "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",
-        "//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",
-        "//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_prysmaticlabs_go_bitfield//: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,194 +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"
-	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.Database
-	headFetcher          blockchain.HeadFetcher
-	participationFetcher blockchain.ParticipationFetcher
-	stateNotifier        statefeed.Notifier
-	lastArchivedEpoch    uint64
-}
-
-// Config options for the archiver service.
-type Config struct {
-	BeaconDB             db.Database
-	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 *pb.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 *pb.BeaconState, epoch uint64) error {
-	prevEpoch := epoch - 1
-	activations := validators.ActivatedValidatorIndices(prevEpoch, headState.Validators)
-	slashings := validators.SlashedValidatorIndices(prevEpoch, headState.Validators)
-	activeValidatorCount, err := helpers.ActiveValidatorCount(headState, prevEpoch)
-	if err != nil {
-		return errors.Wrap(err, "could not get active validator count")
-	}
-	exited, err := validators.ExitedValidatorIndices(prevEpoch, headState.Validators, 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 {
-	p := s.participationFetcher.Participation(epoch)
-	participation := &ethpb.ValidatorParticipation{}
-	if p != nil {
-		participation = &ethpb.ValidatorParticipation{
-			EligibleEther:           p.PrevEpoch,
-			VotedEther:              p.PrevEpochTargetAttesters,
-			GlobalParticipationRate: float32(p.PrevEpochTargetAttesters) / float32(p.PrevEpoch),
-		}
-	}
-	return s.beaconDB.SaveArchivedValidatorParticipation(ctx, epoch, participation)
-}
-
-// We archive validator balances and active indices.
-func (s *Service) archiveBalances(ctx context.Context, headState *pb.BeaconState, epoch uint64) error {
-	balances := headState.Balances
-	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 := event.Data.(*statefeed.BlockProcessedData)
-				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
-				}
-				currentEpoch := helpers.CurrentEpoch(headState)
-				if !helpers.IsEpochEnd(headState.Slot) && currentEpoch <= s.lastArchivedEpoch {
-					continue
-				}
-				epochToArchive := currentEpoch
-				if !helpers.IsEpochEnd(headState.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, 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,416 +0,0 @@
-package archiver
-
-import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"reflect"
-	"testing"
-
-	"github.com/gogo/protobuf/proto"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-bitfield"
-	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"
-	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)
-	params.OverrideBeaconConfig(params.MinimalSpecConfig())
-}
-
-func TestArchiverService_ReceivesBlockProcessedEvent(t *testing.T) {
-	hook := logTest.NewGlobal()
-	svc, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	svc.headFetcher = &mock.ChainService{
-		State: &pb.BeaconState{Slot: 1},
-	}
-
-	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, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	// The head state is NOT an epoch end.
-	svc.headFetcher = &mock.ChainService{
-		State: &pb.BeaconState{Slot: params.BeaconConfig().SlotsPerEpoch - 2},
-	}
-	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, beaconDB := setupService(t)
-	validatorCount := uint64(100)
-	headState := setupState(t, validatorCount)
-	defer dbutil.TeardownDB(t, beaconDB)
-	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++ {
-		headState.Slot = i
-		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 := setupState(t, validatorCount)
-	svc, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	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 := setupState(t, validatorCount)
-	svc, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	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 := setupState(t, validatorCount)
-	svc, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	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 := setupState(t, validatorCount)
-	svc, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	prevEpoch := helpers.PrevEpoch(headState)
-	delayedActEpoch := helpers.DelayedActivationExitEpoch(prevEpoch)
-	headState.Validators[4].ActivationEpoch = delayedActEpoch
-	headState.Validators[5].ActivationEpoch = delayedActEpoch
-	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.Activated, []uint64{4, 5}) {
-		t.Errorf("Wanted indices 4 5 activated, received %v", retrieved.Activated)
-	}
-	testutil.AssertLogsContain(t, hook, "Successfully archived")
-}
-
-func TestArchiverService_SavesSlashedValidatorChanges(t *testing.T) {
-	hook := logTest.NewGlobal()
-	validatorCount := uint64(100)
-	headState := setupState(t, validatorCount)
-	svc, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	prevEpoch := helpers.PrevEpoch(headState)
-	headState.Validators[95].Slashed = true
-	headState.Validators[96].Slashed = true
-	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 := setupState(t, validatorCount)
-	svc, beaconDB := setupService(t)
-	defer dbutil.TeardownDB(t, beaconDB)
-	svc.headFetcher = &mock.ChainService{
-		State: headState,
-	}
-	prevEpoch := helpers.PrevEpoch(headState)
-	headState.Validators[95].ExitEpoch = prevEpoch
-	headState.Validators[95].WithdrawableEpoch = prevEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
-	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(t *testing.T, validatorCount uint64) *pb.BeaconState {
-	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.
-	return &pb.BeaconState{
-		Slot:                       (2 * params.BeaconConfig().SlotsPerEpoch) - 1,
-		Validators:                 validators,
-		Balances:                   balances,
-		BlockRoots:                 make([][]byte, 128),
-		Slashings:                  []uint64{0, 1e9, 1e9},
-		RandaoMixes:                make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		CurrentEpochAttestations:   atts,
-		FinalizedCheckpoint:        &ethpb.Checkpoint{},
-		JustificationBits:          bitfield.Bitvector4{0x00},
-		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{},
-	}
-}
-
-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{PrevEpoch: totalBalance, PrevEpochTargetAttesters: 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

@@ -1,12 +1,19 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+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 = [
         "chain_info.go",
+        "head.go",
         "info.go",
+        "init_sync_process_block.go",
         "log.go",
         "metrics.go",
+        "process_attestation.go",
+        "process_attestation_helpers.go",
+        "process_block.go",
+        "process_block_helpers.go",
         "receive_attestation.go",
         "receive_block.go",
         "service.go",
@@ -14,7 +21,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//beacon-chain/blockchain/forkchoice:go_default_library",
+        "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
@@ -23,21 +30,31 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/state:go_default_library",
         "//beacon-chain/db:go_default_library",
+        "//beacon-chain/flags:go_default_library",
+        "//beacon-chain/forkchoice:go_default_library",
+        "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
+        "//beacon-chain/operations/slashings:go_default_library",
+        "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stategen:go_default_library",
+        "//beacon-chain/state/stateutil:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/attestationutil:go_default_library",
+        "//shared/bls:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/featureconfig:go_default_library",
         "//shared/params:go_default_library",
+        "//shared/roughtime:go_default_library",
         "//shared/slotutil:go_default_library",
         "//shared/traceutil:go_default_library",
-        "@com_github_gogo_protobuf//proto:go_default_library",
+        "@com_github_emicklei_dot//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -56,12 +73,17 @@ go_test(
     size = "medium",
     srcs = [
         "chain_info_test.go",
+        "head_test.go",
+        "info_test.go",
+        "process_attestation_test.go",
+        "process_block_test.go",
         "receive_attestation_test.go",
         "receive_block_test.go",
         "service_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",
@@ -70,12 +92,15 @@ go_test(
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/state/stateutil:go_default_library",
+        "//proto/beacon/db: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",
-        "//shared/stateutil: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",
@@ -84,6 +109,7 @@ go_test(
         "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
         "@org_golang_x_net//context:go_default_library",
     ],
 )
@@ -92,12 +118,21 @@ go_test(
     name = "go_raceon_test",
     srcs = [
         "chain_info_norace_test.go",
+        "receive_block_test.go",
         "service_norace_test.go",
     ],
     embed = [":go_default_library"],
+    gc_goopts = [
+        # Go 1.14 enables checkptr by default when building with -race or -msan. There is a pointer
+        # issue in boltdb, so must disable checkptr at compile time. This flag can be removed once
+        # the project is migrated to etcd's version of boltdb and the issue has been fixed.
+        # See: https://github.com/etcd-io/bbolt/issues/187.
+        "-d=checkptr=0",
+    ],
     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",
@@ -111,6 +146,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

@@ -1,46 +1,52 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
 // directly retrieves chain info related data.
 type ChainInfoFetcher interface {
 	HeadFetcher
-	CanonicalRootFetcher
 	FinalizationFetcher
+	GenesisFetcher
+	CanonicalFetcher
 }
 
-// GenesisTimeFetcher retrieves the Eth2 genesis timestamp.
-type GenesisTimeFetcher interface {
+// TimeFetcher retrieves the Eth2 data that's related to time.
+type TimeFetcher interface {
 	GenesisTime() time.Time
+	CurrentSlot() uint64
+}
+
+// GenesisFetcher retrieves the eth2 data related to its genesis.
+type GenesisFetcher interface {
+	GenesisValidatorRoot() [32]byte
 }
 
 // HeadFetcher defines a common interface for methods in blockchain service which
 // directly retrieves head related data.
 type HeadFetcher interface {
 	HeadSlot() uint64
-	HeadRoot() []byte
-	HeadBlock() *ethpb.SignedBeaconBlock
-	HeadState(ctx context.Context) (*pb.BeaconState, error)
-	HeadValidatorsIndices(epoch uint64) ([]uint64, error)
-	HeadSeed(epoch uint64) ([32]byte, error)
-}
-
-// CanonicalRootFetcher defines a common interface for methods in blockchain service which
-// directly retrieves canonical roots related data.
-type CanonicalRootFetcher interface {
-	CanonicalRoot(slot uint64) []byte
+	HeadRoot(ctx context.Context) ([]byte, error)
+	HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, error)
+	HeadState(ctx context.Context) (*state.BeaconState, 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
 }
 
 // ForkFetcher retrieves the current fork information of the Ethereum beacon chain.
@@ -48,6 +54,12 @@ type ForkFetcher interface {
 	CurrentFork() *pb.Fork
 }
 
+// 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
 // directly retrieves finalization and justification related data.
 type FinalizationFetcher interface {
@@ -56,123 +68,130 @@ 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.headState == nil || s.headState.FinalizedCheckpoint == nil {
+	if s.finalizedCheckpt == nil {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	// If head state exists but there hasn't been a finalized check point,
-	// the check point's root should refer to genesis block root.
-	if bytes.Equal(s.headState.FinalizedCheckpoint.Root, params.BeaconConfig().ZeroHash[:]) {
-		return &ethpb.Checkpoint{Root: s.genesisRoot[:]}
-	}
-
-	return s.headState.FinalizedCheckpoint
+	return state.CopyCheckpoint(s.finalizedCheckpt)
 }
 
 // CurrentJustifiedCheckpt returns the current justified checkpoint from head state.
 func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
-	if s.headState == nil || s.headState.CurrentJustifiedCheckpoint == nil {
+	if s.justifiedCheckpt == nil {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	// If head state exists but there hasn't been a justified check point,
-	// the check point root should refer to genesis block root.
-	if bytes.Equal(s.headState.CurrentJustifiedCheckpoint.Root, params.BeaconConfig().ZeroHash[:]) {
-		return &ethpb.Checkpoint{Root: s.genesisRoot[:]}
-	}
-
-	return s.headState.CurrentJustifiedCheckpoint
+	return state.CopyCheckpoint(s.justifiedCheckpt)
 }
 
 // PreviousJustifiedCheckpt returns the previous justified checkpoint from head state.
 func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
-	if s.headState == nil || s.headState.PreviousJustifiedCheckpoint == nil {
+	if s.prevJustifiedCheckpt == nil {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	// If head state exists but there hasn't been a justified check point,
-	// the check point root should refer to genesis block root.
-	if bytes.Equal(s.headState.PreviousJustifiedCheckpoint.Root, params.BeaconConfig().ZeroHash[:]) {
-		return &ethpb.Checkpoint{Root: s.genesisRoot[:]}
-	}
-
-	return s.headState.PreviousJustifiedCheckpoint
+	return state.CopyCheckpoint(s.prevJustifiedCheckpt)
 }
 
 // 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
+	}
 
-	return s.headSlot
+	return s.headSlot()
 }
 
 // HeadRoot returns the root of the head of the chain.
-func (s *Service) HeadRoot() []byte {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	root := s.canonicalRoots[s.headSlot]
-	if len(root) != 0 {
-		return root
+func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
+	if s.headRoot() != params.BeaconConfig().ZeroHash {
+		r := s.headRoot()
+		return r[:], nil
 	}
 
-	return params.BeaconConfig().ZeroHash[:]
+	b, err := s.beaconDB.HeadBlock(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if b == nil {
+		return params.BeaconConfig().ZeroHash[:], nil
+	}
+
+	r, err := stateutil.BlockRoot(b.Block)
+	if err != nil {
+		return nil, err
+	}
+
+	return r[:], nil
 }
 
 // HeadBlock returns the head block of the chain.
-func (s *Service) HeadBlock() *ethpb.SignedBeaconBlock {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
+// 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) {
+	if s.hasHeadState() {
+		return s.headBlock(), nil
+	}
 
-	return proto.Clone(s.headBlock).(*ethpb.SignedBeaconBlock)
+	return s.beaconDB.HeadBlock(ctx)
 }
 
 // HeadState returns the head state of the chain.
-// If the head state is nil from service struct,
-// it will attempt to get from DB and error if nil again.
-func (s *Service) HeadState(ctx context.Context) (*pb.BeaconState, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
+// 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) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.HeadState")
+	defer span.End()
 
-	if s.headState == nil {
-		return s.beaconDB.HeadState(ctx)
+	ok := s.hasHeadState()
+	span.AddAttributes(trace.BoolAttribute("cache_hit", ok))
+
+	if ok {
+		return s.headState(ctx), nil
 	}
 
-	return proto.Clone(s.headState).(*pb.BeaconState), 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) {
-	if s.headState == nil {
+func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch uint64) ([]uint64, error) {
+	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) {
-	if s.headState == nil {
+func (s *Service) HeadSeed(ctx context.Context, epoch uint64) ([32]byte, error) {
+	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)
 }
 
-// CanonicalRoot returns the canonical root of a given slot.
-func (s *Service) CanonicalRoot(slot uint64) []byte {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
+// HeadGenesisValidatorRoot returns genesis validator root of the head state.
+func (s *Service) HeadGenesisValidatorRoot() [32]byte {
+	if !s.hasHeadState() {
+		return [32]byte{}
+	}
 
-	return s.canonicalRoots[slot]
+	return s.headGenesisValidatorRoot()
+}
+
+// HeadETH1Data returns the eth1data of the current head state.
+func (s *Service) HeadETH1Data() *ethpb.Eth1Data {
+	if !s.hasHeadState() {
+		return &ethpb.Eth1Data{}
+	}
+	return s.head.state.Eth1Data()
+}
+
+// ProtoArrayStore returns the proto array store object.
+func (s *Service) ProtoArrayStore() *protoarray.Store {
+	return s.forkChoiceStore.Store()
 }
 
 // GenesisTime returns the genesis time of beacon chain.
@@ -180,21 +199,36 @@ func (s *Service) GenesisTime() time.Time {
 	return s.genesisTime
 }
 
+// GenesisValidatorRoot returns the genesis validator
+// root of the chain.
+func (s *Service) GenesisValidatorRoot() [32]byte {
+	if !s.hasHeadState() {
+		return [32]byte{}
+	}
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
+}
+
 // CurrentFork retrieves the latest fork information of the beacon chain.
 func (s *Service) CurrentFork() *pb.Fork {
-	if s.headState == nil {
+	if !s.hasHeadState() {
 		return &pb.Fork{
 			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
 		}
 	}
-	return proto.Clone(s.headState.Fork).(*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()
+// 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.
+	if s.beaconDB.IsFinalizedBlock(ctx, blockRoot) {
+		return true, nil
+	}
 
-	return s.epochParticipation[epoch]
+	// 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
 }

beacon-chain/blockchain/chain_info_norace_test.go

@@ -6,72 +6,58 @@ import (
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	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)
-	defer testDB.TeardownDB(t, db)
+	db, _ := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB:       db,
-		canonicalRoots: make(map[uint64][]byte),
+		beaconDB: db,
 	}
 	go func() {
-		s.saveHead(
-			context.Background(),
-			&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 777}},
-			[32]byte{},
-		)
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
 	s.HeadSlot()
 }
 
 func TestHeadRoot_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB:       db,
-		canonicalRoots: make(map[uint64][]byte),
+		beaconDB: db,
+		head:     &head{root: [32]byte{'A'}},
+		stateGen: stategen.New(db, sc),
 	}
 	go func() {
-		s.saveHead(
-			context.Background(),
-			&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 777}},
-			[32]byte{},
-		)
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	s.HeadRoot()
+	_, err := s.HeadRoot(context.Background())
+	require.NoError(t, err)
 }
 
 func TestHeadBlock_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB:       db,
-		canonicalRoots: make(map[uint64][]byte),
+		beaconDB: db,
+		head:     &head{block: &ethpb.SignedBeaconBlock{}},
+		stateGen: stategen.New(db, sc),
 	}
 	go func() {
-		s.saveHead(
-			context.Background(),
-			&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 777}},
-			[32]byte{},
-		)
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	s.HeadBlock()
+	_, err := s.HeadBlock(context.Background())
+	require.NoError(t, err)
 }
 
 func TestHeadState_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB:       db,
-		canonicalRoots: make(map[uint64][]byte),
+		beaconDB: db,
+		stateGen: stategen.New(db, sc),
 	}
 	go func() {
-		s.saveHead(
-			context.Background(),
-			&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 777}},
-			[32]byte{},
-		)
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	s.HeadState(context.Background())
+	_, err := s.HeadState(context.Background())
+	require.NoError(t, err)
 }

beacon-chain/blockchain/chain_info_test.go

@@ -3,62 +3,60 @@ package blockchain
 import (
 	"bytes"
 	"context"
-	"reflect"
 	"testing"
 	"time"
 
+	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	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/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 _ = GenesisTimeFetcher(&Service{})
+var _ = TimeFetcher(&Service{})
 var _ = ForkFetcher(&Service{})
 
 func TestFinalizedCheckpt_Nil(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	c := setupBeaconChain(t, db)
-	c.headState, _ = testutil.DeterministicGenesisState(t, 1)
+	db, sc := testDB.SetupDB(t)
+	c := setupBeaconChain(t, db, sc)
 	if !bytes.Equal(c.FinalizedCheckpt().Root, params.BeaconConfig().ZeroHash[:]) {
 		t.Error("Incorrect pre chain start value")
 	}
 }
 
 func TestHeadRoot_Nil(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	c := setupBeaconChain(t, db)
-	if !bytes.Equal(c.HeadRoot(), params.BeaconConfig().ZeroHash[:]) {
+	db, sc := testDB.SetupDB(t)
+	c := setupBeaconChain(t, db, sc)
+	headRoot, err := c.HeadRoot(context.Background())
+	require.NoError(t, err)
+	if !bytes.Equal(headRoot, params.BeaconConfig().ZeroHash[:]) {
 		t.Error("Incorrect pre chain start value")
 	}
 }
 
 func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 5}
-	c := setupBeaconChain(t, db)
-	c.headState = &pb.BeaconState{FinalizedCheckpoint: cp}
+	cp := &ethpb.Checkpoint{Epoch: 5, Root: []byte("foo")}
+	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)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	c := setupBeaconChain(t, db)
-	c.headState = &pb.BeaconState{FinalizedCheckpoint: cp}
-	c.genesisRoot = [32]byte{'A'}
+	genesisRoot := [32]byte{'A'}
+	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
+	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[:])
@@ -66,26 +64,23 @@ func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
 }
 
 func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 6}
-	c := setupBeaconChain(t, db)
-	c.headState = &pb.BeaconState{CurrentJustifiedCheckpoint: cp}
+	cp := &ethpb.Checkpoint{Epoch: 6, Root: []byte("foo")}
+	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)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	c := setupBeaconChain(t, db)
-	c.headState = &pb.BeaconState{CurrentJustifiedCheckpoint: cp}
-	c.genesisRoot = [32]byte{'B'}
+	genesisRoot := [32]byte{'B'}
+	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
+	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[:])
@@ -93,26 +88,23 @@ func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 }
 
 func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 7}
-	c := setupBeaconChain(t, db)
-	c.headState = &pb.BeaconState{PreviousJustifiedCheckpoint: cp}
+	cp := &ethpb.Checkpoint{Epoch: 7, Root: []byte("foo")}
+	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)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	c := setupBeaconChain(t, db)
-	c.headState = &pb.BeaconState{PreviousJustifiedCheckpoint: cp}
-	c.genesisRoot = [32]byte{'C'}
+	genesisRoot := [32]byte{'C'}
+	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
+	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[:])
@@ -121,37 +113,40 @@ func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 
 func TestHeadSlot_CanRetrieve(t *testing.T) {
 	c := &Service{}
-	c.headSlot = 100
-	if c.HeadSlot() != 100 {
-		t.Errorf("Wanted head slot: %d, got: %d", 100, c.HeadSlot())
+	s, err := state.InitializeFromProto(&pb.BeaconState{})
+	if err != nil {
+		t.Fatal(err)
 	}
+	c.head = &head{slot: 100, state: s}
+	assert.Equal(t, uint64(100), c.headSlot())
 }
 
 func TestHeadRoot_CanRetrieve(t *testing.T) {
-	c := &Service{canonicalRoots: make(map[uint64][]byte)}
-	c.headSlot = 100
-	c.canonicalRoots[c.headSlot] = []byte{'A'}
-	if !bytes.Equal([]byte{'A'}, c.HeadRoot()) {
-		t.Errorf("Wanted head root: %v, got: %d", []byte{'A'}, c.HeadRoot())
-	}
+	c := &Service{}
+	c.head = &head{root: [32]byte{'A'}}
+	assert.Equal(t, [32]byte{'A'}, c.headRoot())
 }
 
 func TestHeadBlock_CanRetrieve(t *testing.T) {
 	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
-	c := &Service{headBlock: b}
-	if !reflect.DeepEqual(b, c.HeadBlock()) {
-		t.Error("incorrect head block received")
-	}
+	s, err := state.InitializeFromProto(&pb.BeaconState{})
+	require.NoError(t, err)
+	c := &Service{}
+	c.head = &head{block: b, state: s}
+
+	recevied, err := c.HeadBlock(context.Background())
+	require.NoError(t, err)
+	assert.DeepEqual(t, b, recevied, "Incorrect head block received")
 }
 
 func TestHeadState_CanRetrieve(t *testing.T) {
-	s := &pb.BeaconState{Slot: 2}
-	c := &Service{headState: s}
+	s, err := state.InitializeFromProto(&pb.BeaconState{Slot: 2, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
+	require.NoError(t, err)
+	c := &Service{}
+	c.head = &head{state: s}
 	headState, err := c.HeadState(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(s, headState) {
+	require.NoError(t, err)
+	if !proto.Equal(s.InnerStateUnsafe(), headState.InnerStateUnsafe()) {
 		t.Error("incorrect head state received")
 	}
 }
@@ -159,26 +154,44 @@ func TestHeadState_CanRetrieve(t *testing.T) {
 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 := &pb.BeaconState{Fork: f}
-	c := &Service{headState: s}
-	if !reflect.DeepEqual(c.CurrentFork(), f) {
-		t.Error("Recieved incorrect fork version")
+	s, err := state.InitializeFromProto(&pb.BeaconState{Fork: f})
+	require.NoError(t, err)
+	c := &Service{}
+	c.head = &head{state: s}
+	if !proto.Equal(c.CurrentFork(), f) {
+		t.Error("Received incorrect fork version")
 	}
 }
 
-func TestCanonicalRoot_CanRetrieve(t *testing.T) {
-	c := &Service{canonicalRoots: make(map[uint64][]byte)}
-	slot := uint64(123)
-	r := []byte{'B'}
-	c.canonicalRoots[slot] = r
-	if !bytes.Equal(r, c.CanonicalRoot(slot)) {
-		t.Errorf("Wanted head root: %v, got: %d", []byte{'A'}, c.CanonicalRoot(slot))
+func TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
+	// Should not panic if head state is nil.
+	c := &Service{}
+	assert.Equal(t, [32]byte{}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+
+	s, err := state.InitializeFromProto(&pb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
+	require.NoError(t, err)
+	c.head = &head{state: s}
+	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+}
+
+func TestHeadETH1Data_Nil(t *testing.T) {
+	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})
+	require.NoError(t, err)
+	c := &Service{}
+	c.head = &head{state: s}
+	if !proto.Equal(c.HeadETH1Data(), d) {
+		t.Error("Received incorrect eth1 data")
 	}
 }

beacon-chain/blockchain/forkchoice/benchmark_test.go

@@ -1,168 +0,0 @@
-package forkchoice
-
-import (
-	"context"
-	"testing"
-
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-)
-
-func BenchmarkForkChoiceTree1(b *testing.B) {
-	ctx := context.Background()
-	db := testDB.SetupDB(b)
-	defer testDB.TeardownDB(b, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// Benchmark fork choice with 1024 validators
-	validators := make([]*ethpb.Validator, 1024)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{ExitEpoch: 2, EffectiveBalance: 1e9}
-	}
-	s := &pb.BeaconState{Validators: validators}
-
-	if err := store.GenesisStore(ctx, &ethpb.Checkpoint{}, &ethpb.Checkpoint{}); err != nil {
-		b.Fatal(err)
-	}
-
-	store.justifiedCheckpt.Root = roots[0]
-	if err := store.db.SaveState(ctx, s, bytesutil.ToBytes32(roots[0])); err != nil {
-		b.Fatal(err)
-	}
-
-	if err := store.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: store.justifiedCheckpt,
-		State:      s,
-	}); err != nil {
-		b.Fatal(err)
-	}
-
-	// Spread out the votes evenly for all 3 leaf nodes
-	for i := 0; i < len(validators); i++ {
-		switch {
-		case i < 256:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[1]}
-		case i > 768:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[7]}
-		default:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[8]}
-		}
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, err := store.Head(ctx)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkForkChoiceTree2(b *testing.B) {
-	ctx := context.Background()
-	db := testDB.SetupDB(b)
-	defer testDB.TeardownDB(b, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree2(db)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// Benchmark fork choice with 1024 validators
-	validators := make([]*ethpb.Validator, 1024)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{ExitEpoch: 2, EffectiveBalance: 1e9}
-	}
-	s := &pb.BeaconState{Validators: validators}
-	if err := store.GenesisStore(ctx, &ethpb.Checkpoint{}, &ethpb.Checkpoint{}); err != nil {
-		b.Fatal(err)
-	}
-
-	store.justifiedCheckpt.Root = roots[0]
-	if err := store.db.SaveState(ctx, s, bytesutil.ToBytes32(roots[0])); err != nil {
-		b.Fatal(err)
-	}
-
-	if err := store.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: store.justifiedCheckpt,
-		State:      s,
-	}); err != nil {
-		b.Fatal(err)
-	}
-
-	// Spread out the votes evenly for all the leaf nodes. 8 to 15
-	nodeIndex := 8
-	for i := 0; i < len(validators); i++ {
-		store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[nodeIndex]}
-		if i%155 == 0 {
-			nodeIndex++
-		}
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, err := store.Head(ctx)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkForkChoiceTree3(b *testing.B) {
-	ctx := context.Background()
-	db := testDB.SetupDB(b)
-	defer testDB.TeardownDB(b, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree3(db)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// Benchmark fork choice with 1024 validators
-	validators := make([]*ethpb.Validator, 1024)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{ExitEpoch: 2, EffectiveBalance: 1e9}
-	}
-	s := &pb.BeaconState{Validators: validators}
-	if err := store.GenesisStore(ctx, &ethpb.Checkpoint{}, &ethpb.Checkpoint{}); err != nil {
-		b.Fatal(err)
-	}
-
-	store.justifiedCheckpt.Root = roots[0]
-	if err := store.db.SaveState(ctx, s, bytesutil.ToBytes32(roots[0])); err != nil {
-		b.Fatal(err)
-	}
-
-	if err := store.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: store.justifiedCheckpt,
-		State:      s,
-	}); err != nil {
-		b.Fatal(err)
-	}
-
-	// All validators vote on the same head
-	for i := 0; i < len(validators); i++ {
-		store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[len(roots)-1]}
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, err := store.Head(ctx)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}

beacon-chain/blockchain/forkchoice/doc.go

@@ -1,9 +0,0 @@
-/*
-Package forkchoice implements the Latest Message Driven GHOST (Greediest Heaviest Observed
-Sub-Tree) algorithm as the Ethereum Serenity beacon chain fork choice rule. This algorithm is designed to
-properly detect the canonical chain based on validator votes even in the presence of high network
-latency, network partitions, and many conflicting blocks. To read more about fork choice, read the
-official accompanying document:
-https://github.com/ethereum/eth2.0-specs/blob/v0.9.0/specs/core/0_fork-choice.md
-*/
-package forkchoice

beacon-chain/blockchain/forkchoice/lmd_ghost_test.yaml

@@ -1,59 +0,0 @@
-test_cases:
-  # GHOST chooses b3 with the heaviest weight
-  - blocks:
-      - id: 'b0'
-        parent: 'b0'
-      - id: 'b1'
-        parent: 'b0'
-      - id: 'b2'
-        parent: 'b1'
-      - id: 'b3'
-        parent: 'b1'
-    weights:
-      b0: 0
-      b1: 0
-      b2: 5
-      b3: 10
-    head: 'b3'
-  # GHOST chooses b1 with the heaviest weight
-  - blocks:
-      - id: 'b0'
-        parent: 'b0'
-      - id: 'b1'
-        parent: 'b0'
-      - id: 'b2'
-        parent: 'b0'
-      - id: 'b3'
-        parent: 'b0'
-    weights:
-      b1: 5
-      b2: 4
-      b3: 3
-    head: 'b1'
-  # Equal weights children, GHOST chooses b2 because it is higher lexicographically than b3
-  - blocks:
-      - id: 'b0'
-        parent: 'b0'
-      - id: 'b1'
-        parent: 'b0'
-      - id: 'b2'
-        parent: 'b0'
-      - id: 'b3'
-        parent: 'b0'
-    weights:
-      b1: 5
-      b2: 6
-      b3: 6
-    head: 'b3'
-  # Equal weights children, GHOST chooses b2 because it is higher lexicographically than b1
-  - blocks:
-      - id: 'b0'
-        parent: 'b0'
-      - id: 'b1'
-        parent: 'b0'
-      - id: 'b2'
-        parent: 'b0'
-    weights:
-      b1: 0
-      b2: 0
-    head: 'b2'

beacon-chain/blockchain/forkchoice/lmd_ghost_yaml_test.go

@@ -1,140 +0,0 @@
-package forkchoice
-
-import (
-	"bytes"
-	"context"
-	"io/ioutil"
-	"path/filepath"
-	"strconv"
-	"testing"
-
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"gopkg.in/yaml.v2"
-)
-
-type Config struct {
-	TestCases []struct {
-		Blocks []struct {
-			ID     string `yaml:"id"`
-			Parent string `yaml:"parent"`
-		} `yaml:"blocks"`
-		Weights map[string]int `yaml:"weights"`
-		Head    string         `yaml:"head"`
-	} `yaml:"test_cases"`
-}
-
-func TestGetHeadFromYaml(t *testing.T) {
-	ctx := context.Background()
-	filename, _ := filepath.Abs("./lmd_ghost_test.yaml")
-	yamlFile, err := ioutil.ReadFile(filename)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var c *Config
-	err = yaml.Unmarshal(yamlFile, &c)
-
-	params.UseMainnetConfig()
-
-	for _, test := range c.TestCases {
-		db := testDB.SetupDB(t)
-		defer testDB.TeardownDB(t, db)
-
-		blksRoot := make(map[int][]byte)
-		// Construct block tree from yaml.
-		for _, blk := range test.Blocks {
-			// genesis block condition
-			if blk.ID == blk.Parent {
-				b := &ethpb.BeaconBlock{Slot: 0, ParentRoot: []byte{'g'}}
-				if err := db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: b}); err != nil {
-					t.Fatal(err)
-				}
-				root, err := ssz.HashTreeRoot(b)
-				if err != nil {
-					t.Fatal(err)
-				}
-				blksRoot[0] = root[:]
-			} else {
-				slot, err := strconv.Atoi(blk.ID[1:])
-				if err != nil {
-					t.Fatal(err)
-				}
-				parentSlot, err := strconv.Atoi(blk.Parent[1:])
-				if err != nil {
-					t.Fatal(err)
-				}
-				b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: uint64(slot), ParentRoot: blksRoot[parentSlot]}}
-				if err := db.SaveBlock(ctx, b); err != nil {
-					t.Fatal(err)
-				}
-				root, err := ssz.HashTreeRoot(b.Block)
-				if err != nil {
-					t.Fatal(err)
-				}
-				blksRoot[slot] = root[:]
-				if err := db.SaveState(ctx, &pb.BeaconState{}, root); err != nil {
-					t.Fatal(err)
-				}
-			}
-		}
-
-		store := NewForkChoiceService(ctx, db)
-
-		// Assign validator votes to the blocks as weights.
-		count := 0
-		for blk, votes := range test.Weights {
-			slot, err := strconv.Atoi(blk[1:])
-			if err != nil {
-				t.Fatal(err)
-			}
-			max := count + votes
-			for i := count; i < max; i++ {
-				store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: blksRoot[slot]}
-				count++
-			}
-		}
-
-		validators := make([]*ethpb.Validator, count)
-		for i := 0; i < len(validators); i++ {
-			validators[i] = &ethpb.Validator{ExitEpoch: 2, EffectiveBalance: 1e9}
-		}
-
-		s := &pb.BeaconState{Validators: validators}
-
-		if err := store.db.SaveState(ctx, s, bytesutil.ToBytes32(blksRoot[0])); err != nil {
-			t.Fatal(err)
-		}
-		if err := store.GenesisStore(ctx, &ethpb.Checkpoint{Root: blksRoot[0]}, &ethpb.Checkpoint{Root: blksRoot[0]}); err != nil {
-			t.Fatal(err)
-		}
-
-		if err := store.checkpointState.AddCheckpointState(&cache.CheckpointState{
-			Checkpoint: store.justifiedCheckpt,
-			State:      s,
-		}); err != nil {
-			t.Fatal(err)
-		}
-
-		head, err := store.Head(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		headSlot, err := strconv.Atoi(test.Head[1:])
-		if err != nil {
-			t.Fatal(err)
-		}
-		wantedHead := blksRoot[headSlot]
-
-		if !bytes.Equal(head, wantedHead) {
-			t.Errorf("wanted root %#x, got root %#x", wantedHead, head)
-		}
-
-		testDB.TeardownDB(t, db)
-	}
-}

beacon-chain/blockchain/forkchoice/log.go

@@ -1,40 +0,0 @@
-package forkchoice
-
-import (
-	"fmt"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/sirupsen/logrus"
-)
-
-var log = logrus.WithField("prefix", "forkchoice")
-
-// logs epoch related data during epoch boundary.
-func logEpochData(beaconState *pb.BeaconState) {
-	log.WithFields(logrus.Fields{
-		"epoch":                  helpers.CurrentEpoch(beaconState),
-		"finalizedEpoch":         beaconState.FinalizedCheckpoint.Epoch,
-		"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/forkchoice/metrics.go

@@ -1,161 +0,0 @@
-package forkchoice
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-)
-
-var (
-	beaconFinalizedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_finalized_epoch",
-		Help: "Last finalized epoch of the processed state",
-	})
-	beaconFinalizedRoot = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_finalized_root",
-		Help: "Last finalized root of the processed state",
-	})
-	cacheFinalizedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "cache_finalized_epoch",
-		Help: "Last cached finalized epoch",
-	})
-	cacheFinalizedRoot = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "cache_finalized_root",
-		Help: "Last cached finalized root",
-	})
-	beaconCurrentJustifiedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_current_justified_epoch",
-		Help: "Current justified epoch of the processed state",
-	})
-	beaconCurrentJustifiedRoot = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_current_justified_root",
-		Help: "Current justified root of the processed state",
-	})
-	beaconPrevJustifiedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_previous_justified_epoch",
-		Help: "Previous justified epoch of the processed state",
-	})
-	beaconPrevJustifiedRoot = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_previous_justified_root",
-		Help: "Previous justified root of the processed state",
-	})
-	sigFailsToVerify = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "att_signature_failed_to_verify_with_cache",
-		Help: "Number of attestation signatures that failed to verify with cache on, but succeeded without cache",
-	})
-	validatorsCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
-		Name: "validator_count",
-		Help: "The total number of validators, in GWei",
-	}, []string{"state"})
-	validatorsBalance = promauto.NewGaugeVec(prometheus.GaugeOpts{
-		Name: "validators_total_balance",
-		Help: "The total balance of validators, in GWei",
-	}, []string{"state"})
-	validatorsEffectiveBalance = promauto.NewGaugeVec(prometheus.GaugeOpts{
-		Name: "validators_total_effective_balance",
-		Help: "The total effective balance of validators, in GWei",
-	}, []string{"state"})
-	currentEth1DataDepositCount = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "current_eth1_data_deposit_count",
-		Help: "The current eth1 deposit count in the last processed state eth1data field.",
-	})
-	totalEligibleBalances = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "total_eligible_balances",
-		Help: "The total amount of ether, in gwei, that 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",
-	})
-)
-
-func reportEpochMetrics(state *pb.BeaconState) {
-	currentEpoch := state.Slot / params.BeaconConfig().SlotsPerEpoch
-
-	// Validator instances
-	pendingInstances := 0
-	activeInstances := 0
-	slashingInstances := 0
-	slashedInstances := 0
-	exitingInstances := 0
-	exitedInstances := 0
-	// Validator balances
-	pendingBalance := uint64(0)
-	activeBalance := uint64(0)
-	activeEffectiveBalance := uint64(0)
-	exitingBalance := uint64(0)
-	exitingEffectiveBalance := uint64(0)
-	slashingBalance := uint64(0)
-	slashingEffectiveBalance := uint64(0)
-
-	for i, validator := range state.Validators {
-		if validator.Slashed {
-			if currentEpoch < validator.ExitEpoch {
-				slashingInstances++
-				slashingBalance += state.Balances[i]
-				slashingEffectiveBalance += validator.EffectiveBalance
-			} else {
-				slashedInstances++
-			}
-			continue
-		}
-		if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
-			if currentEpoch < validator.ExitEpoch {
-				exitingInstances++
-				exitingBalance += state.Balances[i]
-				exitingEffectiveBalance += validator.EffectiveBalance
-			} else {
-				exitedInstances++
-			}
-			continue
-		}
-		if currentEpoch < validator.ActivationEpoch {
-			pendingInstances++
-			pendingBalance += state.Balances[i]
-			continue
-		}
-		activeInstances++
-		activeBalance += state.Balances[i]
-		activeEffectiveBalance += validator.EffectiveBalance
-	}
-	validatorsCount.WithLabelValues("Pending").Set(float64(pendingInstances))
-	validatorsCount.WithLabelValues("Active").Set(float64(activeInstances))
-	validatorsCount.WithLabelValues("Exiting").Set(float64(exitingInstances))
-	validatorsCount.WithLabelValues("Exited").Set(float64(exitedInstances))
-	validatorsCount.WithLabelValues("Slashing").Set(float64(slashingInstances))
-	validatorsCount.WithLabelValues("Slashed").Set(float64(slashedInstances))
-	validatorsBalance.WithLabelValues("Pending").Set(float64(pendingBalance))
-	validatorsBalance.WithLabelValues("Active").Set(float64(activeBalance))
-	validatorsBalance.WithLabelValues("Exiting").Set(float64(exitingBalance))
-	validatorsBalance.WithLabelValues("Slashing").Set(float64(slashingBalance))
-	validatorsEffectiveBalance.WithLabelValues("Active").Set(float64(activeEffectiveBalance))
-	validatorsEffectiveBalance.WithLabelValues("Exiting").Set(float64(exitingEffectiveBalance))
-	validatorsEffectiveBalance.WithLabelValues("Slashing").Set(float64(slashingEffectiveBalance))
-
-	// Last justified slot
-	if state.CurrentJustifiedCheckpoint != nil {
-		beaconCurrentJustifiedEpoch.Set(float64(state.CurrentJustifiedCheckpoint.Epoch))
-		beaconCurrentJustifiedRoot.Set(float64(bytesutil.ToLowInt64(state.CurrentJustifiedCheckpoint.Root)))
-	}
-	// Last previous justified slot
-	if state.PreviousJustifiedCheckpoint != nil {
-		beaconPrevJustifiedEpoch.Set(float64(state.PreviousJustifiedCheckpoint.Epoch))
-		beaconPrevJustifiedRoot.Set(float64(bytesutil.ToLowInt64(state.PreviousJustifiedCheckpoint.Root)))
-	}
-	// Last finalized slot
-	if state.FinalizedCheckpoint != nil {
-		beaconFinalizedEpoch.Set(float64(state.FinalizedCheckpoint.Epoch))
-		beaconFinalizedRoot.Set(float64(bytesutil.ToLowInt64(state.FinalizedCheckpoint.Root)))
-	}
-	if state.Eth1Data != nil {
-		currentEth1DataDepositCount.Set(float64(state.Eth1Data.DepositCount))
-	}
-
-	if precompute.Balances != nil {
-		totalEligibleBalances.Set(float64(precompute.Balances.PrevEpoch))
-		totalVotedTargetBalances.Set(float64(precompute.Balances.PrevEpochTargetAttesters))
-	}
-}

beacon-chain/blockchain/forkchoice/process_attestation.go

@@ -1,309 +0,0 @@
-package forkchoice
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/gogo/protobuf/proto"
-	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-)
-
-// ErrTargetRootNotInDB returns when the target block root of an attestation cannot be found in the
-// beacon database.
-var ErrTargetRootNotInDB = errors.New("target root does not exist in db")
-
-// OnAttestation is called whenever an attestation is received, it updates validators latest vote,
-// as well as the fork choice store struct.
-//
-// Spec pseudocode definition:
-//   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
-//
-//    # 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
-//    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 cannot be from future epochs. If they are, delay consideration until the epoch arrives
-//    base_state = store.block_states[target.root].copy()
-//    assert store.time >= base_state.genesis_time + compute_start_slot_at_epoch(target.epoch) * SECONDS_PER_SLOT
-//
-//    # 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
-//
-//    # Store 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
-//    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)
-func (s *Store) OnAttestation(ctx context.Context, a *ethpb.Attestation) error {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.onAttestation")
-	defer span.End()
-
-	tgt := proto.Clone(a.Data.Target).(*ethpb.Checkpoint)
-	tgtSlot := helpers.StartSlot(tgt.Epoch)
-
-	if helpers.SlotToEpoch(a.Data.Slot) != a.Data.Target.Epoch {
-		return fmt.Errorf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(a.Data.Slot), a.Data.Target.Epoch)
-	}
-
-	// Verify beacon node has seen the target block before.
-	if !s.db.HasBlock(ctx, bytesutil.ToBytes32(tgt.Root)) {
-		return ErrTargetRootNotInDB
-	}
-
-	// Verify attestation target has had a valid pre state produced by the target block.
-	baseState, err := s.verifyAttPreState(ctx, tgt)
-	if err != nil {
-		return err
-	}
-
-	// Verify attestation target is from current epoch or previous epoch.
-	if err := s.verifyAttTargetEpoch(ctx, baseState.GenesisTime, uint64(time.Now().Unix()), tgt); err != nil {
-		return err
-	}
-
-	// Verify Attestations cannot be from future epochs.
-	if err := helpers.VerifySlotTime(baseState.GenesisTime, tgtSlot); err != nil {
-		return errors.Wrap(err, "could not verify attestation target slot")
-	}
-
-	// Verify attestation beacon block is known and not from the future.
-	if err := s.verifyBeaconBlock(ctx, a.Data); err != nil {
-		return errors.Wrap(err, "could not verify attestation beacon block")
-	}
-
-	// Store target checkpoint state if not yet seen.
-	baseState, err = s.saveCheckpointState(ctx, baseState, tgt)
-	if err != nil {
-		return err
-	}
-
-	// Verify attestations can only affect the fork choice of subsequent slots.
-	if err := helpers.VerifySlotTime(baseState.GenesisTime, a.Data.Slot+1); err != nil {
-		return err
-	}
-
-	// Use the target state to to validate attestation and calculate the committees.
-	indexedAtt, err := s.verifyAttestation(ctx, baseState, a)
-	if err != nil {
-		return err
-	}
-
-	// Update every validator's latest vote.
-	if err := s.updateAttVotes(ctx, indexedAtt, tgt.Root, tgt.Epoch); err != nil {
-		return err
-	}
-
-	if err := s.db.SaveAttestation(ctx, a); err != nil {
-		return err
-	}
-
-	log := log.WithFields(logrus.Fields{
-		"Slot":               a.Data.Slot,
-		"Index":              a.Data.CommitteeIndex,
-		"AggregatedBitfield": fmt.Sprintf("%08b", a.AggregationBits),
-		"BeaconBlockRoot":    fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.BeaconBlockRoot)),
-	})
-	log.Debug("Updated latest votes")
-
-	return nil
-}
-
-// verifyAttPreState validates input attested check point has a valid pre-state.
-func (s *Store) verifyAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*pb.BeaconState, error) {
-	baseState, err := s.db.State(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))
-	}
-	if baseState == nil {
-		return nil, fmt.Errorf("pre state of target block %d does not exist", helpers.StartSlot(c.Epoch))
-	}
-	return baseState, nil
-}
-
-// verifyAttTargetEpoch validates attestation is from the current or previous epoch.
-func (s *Store) verifyAttTargetEpoch(ctx context.Context, genesisTime uint64, nowTime uint64, c *ethpb.Checkpoint) error {
-	currentSlot := (nowTime - genesisTime) / params.BeaconConfig().SecondsPerSlot
-	currentEpoch := helpers.SlotToEpoch(currentSlot)
-	var prevEpoch uint64
-	// Prevents previous epoch under flow
-	if currentEpoch > 1 {
-		prevEpoch = currentEpoch - 1
-	}
-	if c.Epoch != prevEpoch && c.Epoch != currentEpoch {
-		return fmt.Errorf("target epoch %d does not match current epoch %d or prev epoch %d", c.Epoch, currentEpoch, prevEpoch)
-	}
-	return nil
-}
-
-// verifyBeaconBlock verifies beacon head block is known and not from the future.
-func (s *Store) verifyBeaconBlock(ctx context.Context, data *ethpb.AttestationData) error {
-	b, err := s.db.Block(ctx, bytesutil.ToBytes32(data.BeaconBlockRoot))
-	if err != nil {
-		return err
-	}
-	if b == nil || b.Block == nil {
-		return fmt.Errorf("beacon block %#x does not exist", bytesutil.Trunc(data.BeaconBlockRoot))
-	}
-	if b.Block.Slot > data.Slot {
-		return fmt.Errorf("could not process attestation for future block, %d > %d", b.Block.Slot, data.Slot)
-	}
-	return nil
-}
-
-// saveCheckpointState saves and returns the processed state with the associated check point.
-func (s *Store) saveCheckpointState(ctx context.Context, baseState *pb.BeaconState, c *ethpb.Checkpoint) (*pb.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.saveCheckpointState")
-	defer span.End()
-
-	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")
-	}
-	if cachedState != nil {
-		return cachedState, nil
-	}
-
-	// Advance slots only when it's higher than current state slot.
-	if helpers.StartSlot(c.Epoch) > baseState.Slot {
-		stateCopy := proto.Clone(baseState).(*pb.BeaconState)
-		stateCopy, err = state.ProcessSlots(ctx, stateCopy, 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:      stateCopy,
-		}); err != nil {
-			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
-		}
-
-		return stateCopy, nil
-	}
-
-	return baseState, nil
-}
-
-// verifyAttestation validates input attestation is valid.
-func (s *Store) verifyAttestation(ctx context.Context, baseState *pb.BeaconState, a *ethpb.Attestation) (*ethpb.IndexedAttestation, error) {
-	committee, err := helpers.BeaconCommitteeFromState(baseState, a.Data.Slot, a.Data.CommitteeIndex)
-	if err != nil {
-		return nil, err
-	}
-	indexedAtt, err := blocks.ConvertToIndexed(ctx, a, committee)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert attestation to indexed attestation")
-	}
-
-	if err := blocks.VerifyIndexedAttestation(ctx, baseState, indexedAtt); err != nil {
-
-		// TODO(3603): Delete the following signature verify fallback when issue 3603 closes.
-		// When signature fails to verify with committee cache enabled at run time,
-		// the following re-runs the same signature verify routine without cache in play.
-		// This provides extra assurance that committee cache can't break run time.
-		if err == blocks.ErrSigFailedToVerify {
-			committee, err = helpers.BeaconCommitteeWithoutCache(baseState, a.Data.Slot, a.Data.CommitteeIndex)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not convert attestation to indexed attestation without cache")
-			}
-			indexedAtt, err = blocks.ConvertToIndexed(ctx, a, committee)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not convert attestation to indexed attestation")
-			}
-			if err := blocks.VerifyIndexedAttestation(ctx, baseState, indexedAtt); err != nil {
-				return nil, errors.Wrap(err, "could not verify indexed attestation without cache")
-			}
-			sigFailsToVerify.Inc()
-			return indexedAtt, nil
-		}
-
-		return nil, errors.Wrap(err, "could not verify indexed attestation")
-	}
-	return indexedAtt, nil
-}
-
-// updateAttVotes updates validator's latest votes based on the incoming attestation.
-func (s *Store) updateAttVotes(
-	ctx context.Context,
-	indexedAtt *ethpb.IndexedAttestation,
-	tgtRoot []byte,
-	tgtEpoch uint64) error {
-
-	indices := indexedAtt.AttestingIndices
-	s.voteLock.Lock()
-	defer s.voteLock.Unlock()
-	for _, i := range indices {
-		vote, ok := s.latestVoteMap[i]
-		if !ok || tgtEpoch > vote.Epoch {
-			s.latestVoteMap[i] = &pb.ValidatorLatestVote{
-				Epoch: tgtEpoch,
-				Root:  tgtRoot,
-			}
-		}
-	}
-	return nil
-}
-
-// aggregatedAttestation returns the aggregated attestation after checking saved one in db.
-func (s *Store) aggregatedAttestations(ctx context.Context, att *ethpb.Attestation) ([]*ethpb.Attestation, error) {
-	r, err := ssz.HashTreeRoot(att.Data)
-	if err != nil {
-		return nil, err
-	}
-	saved, err := s.db.AttestationsByDataRoot(ctx, r)
-	if err != nil {
-		return nil, err
-	}
-
-	if saved == nil {
-		return []*ethpb.Attestation{att}, nil
-	}
-
-	aggregated, err := helpers.AggregateAttestations(append(saved, att))
-	if err != nil {
-		return nil, err
-	}
-
-	return aggregated, nil
-}

beacon-chain/blockchain/forkchoice/process_attestation_test.go

@@ -1,369 +0,0 @@
-package forkchoice
-
-import (
-	"context"
-	"reflect"
-	"strings"
-	"testing"
-
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/go-ssz"
-	"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"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-)
-
-func TestStore_OnAttestation(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	_, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	BlkWithOutState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 0}}
-	if err := db.SaveBlock(ctx, BlkWithOutState); err != nil {
-		t.Fatal(err)
-	}
-	BlkWithOutStateRoot, _ := ssz.HashTreeRoot(BlkWithOutState.Block)
-
-	BlkWithStateBadAtt := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
-	if err := db.SaveBlock(ctx, BlkWithStateBadAtt); err != nil {
-		t.Fatal(err)
-	}
-	BlkWithStateBadAttRoot, _ := ssz.HashTreeRoot(BlkWithStateBadAtt.Block)
-	if err := store.db.SaveState(ctx, &pb.BeaconState{}, BlkWithStateBadAttRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	BlkWithValidState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
-	if err := db.SaveBlock(ctx, BlkWithValidState); err != nil {
-		t.Fatal(err)
-	}
-	BlkWithValidStateRoot, _ := ssz.HashTreeRoot(BlkWithValidState.Block)
-	if err := store.db.SaveState(ctx, &pb.BeaconState{
-		Fork: &pb.Fork{
-			Epoch:           0,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	}, BlkWithValidStateRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	tests := []struct {
-		name          string
-		a             *ethpb.Attestation
-		s             *pb.BeaconState
-		wantErr       bool
-		wantErrString 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 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:          "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: "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{},
-			wantErr:       true,
-			wantErrString: "does not match current epoch",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := store.GenesisStore(
-				ctx,
-				&ethpb.Checkpoint{Root: BlkWithValidStateRoot[:]},
-				&ethpb.Checkpoint{Root: BlkWithValidStateRoot[:]}); err != nil {
-				t.Fatal(err)
-			}
-
-			err := store.OnAttestation(ctx, tt.a)
-			if tt.wantErr {
-				if !strings.Contains(err.Error(), tt.wantErrString) {
-					t.Errorf("Store.OnAttestation() error = %v, wantErr = %v", err, tt.wantErrString)
-				}
-			} else {
-				t.Error(err)
-			}
-		})
-	}
-}
-
-func TestStore_SaveCheckpointState(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	params.UseDemoBeaconConfig()
-
-	store := NewForkChoiceService(ctx, db)
-
-	s := &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().EpochsPerHistoricalVector),
-		BlockRoots:          make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot),
-		LatestBlockHeader:   &ethpb.BeaconBlockHeader{},
-		JustificationBits:   []byte{0},
-		Slashings:           make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
-		FinalizedCheckpoint: &ethpb.Checkpoint{},
-	}
-	r := [32]byte{'g'}
-	if err := store.db.SaveState(ctx, s, r); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.GenesisStore(ctx, &ethpb.Checkpoint{Root: r[:]}, &ethpb.Checkpoint{Root: r[:]}); err != nil {
-		t.Fatal(err)
-	}
-
-	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: []byte{'A'}}
-	s1, err := store.saveCheckpointState(ctx, s, 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)
-	}
-
-	cp2 := &ethpb.Checkpoint{Epoch: 2, Root: []byte{'B'}}
-	s2, err := store.saveCheckpointState(ctx, s, 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)
-	}
-
-	s1, err = store.saveCheckpointState(ctx, nil, 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)
-	}
-
-	s1, err = store.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)
-	}
-
-	s2, err = store.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)
-	}
-
-	s.Slot = params.BeaconConfig().SlotsPerEpoch + 1
-	if err := store.GenesisStore(ctx, &ethpb.Checkpoint{Root: r[:]}, &ethpb.Checkpoint{Root: r[:]}); err != nil {
-		t.Fatal(err)
-	}
-	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: []byte{'C'}}
-	s3, err := store.saveCheckpointState(ctx, s, cp3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if s3.Slot != s.Slot {
-		t.Errorf("Wanted state slot: %d, got: %d", s.Slot, s3.Slot)
-	}
-}
-
-func TestStore_ReturnAggregatedAttestation(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	a1 := &ethpb.Attestation{Data: &ethpb.AttestationData{}, AggregationBits: bitfield.Bitlist{0x02}}
-	err := store.db.SaveAttestation(ctx, a1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2 := &ethpb.Attestation{Data: &ethpb.AttestationData{}, AggregationBits: bitfield.Bitlist{0x03}}
-	saved, err := store.aggregatedAttestations(ctx, a2)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual([]*ethpb.Attestation{a2}, saved) {
-		t.Error("did not retrieve saved attestation")
-	}
-}
-
-func TestStore_UpdateCheckpointState(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	epoch := uint64(1)
-	baseState, _ := testutil.DeterministicGenesisState(t, 1)
-	baseState.Slot = epoch * params.BeaconConfig().SlotsPerEpoch
-	checkpoint := &ethpb.Checkpoint{Epoch: epoch}
-	returned, err := store.saveCheckpointState(ctx, baseState, checkpoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(baseState, returned) {
-		t.Error("Incorrectly returned base state")
-	}
-
-	cached, err := store.checkpointState.StateByCheckpoint(checkpoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if cached != nil {
-		t.Error("State shouldn't have been cached")
-	}
-
-	epoch = uint64(2)
-	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch}
-	returned, err = store.saveCheckpointState(ctx, baseState, newCheckpoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	baseState, err = state.ProcessSlots(ctx, baseState, helpers.StartSlot(newCheckpoint.Epoch))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(baseState, returned) {
-		t.Error("Incorrectly returned base state")
-	}
-
-	cached, err = store.checkpointState.StateByCheckpoint(newCheckpoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(returned, cached) {
-		t.Error("Incorrectly cached base state")
-	}
-}
-
-func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	if err := store.verifyAttTargetEpoch(
-		ctx,
-		0,
-		params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
-		&ethpb.Checkpoint{}); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	if err := store.verifyAttTargetEpoch(
-		ctx,
-		0,
-		params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
-		&ethpb.Checkpoint{Epoch: 1}); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestAttEpoch_NotMatch(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	if err := store.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")
-	}
-}
-
-func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	s := NewForkChoiceService(ctx, db)
-	d := &ethpb.AttestationData{}
-	if err := s.verifyBeaconBlock(ctx, d); !strings.Contains(err.Error(), "beacon block  does not exist") {
-		t.Error("Did not receive the wanted error")
-	}
-}
-
-func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	s := NewForkChoiceService(ctx, db)
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
-	s.db.SaveBlock(ctx, b)
-	r, _ := ssz.HashTreeRoot(b.Block)
-	d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
-
-	if err := s.verifyBeaconBlock(ctx, d); !strings.Contains(err.Error(), "could not process attestation for future block") {
-		t.Error("Did not receive the wanted error")
-	}
-}
-
-func TestVerifyBeaconBlock_OK(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	s := NewForkChoiceService(ctx, db)
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
-	s.db.SaveBlock(ctx, b)
-	r, _ := ssz.HashTreeRoot(b.Block)
-	d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
-
-	if err := s.verifyBeaconBlock(ctx, d); err != nil {
-		t.Error("Did not receive the wanted error")
-	}
-}

beacon-chain/blockchain/forkchoice/process_block.go

@@ -1,572 +0,0 @@
-package forkchoice
-
-import (
-	"bytes"
-	"context"
-	"encoding/hex"
-	"fmt"
-	"time"
-
-	"github.com/gogo/protobuf/proto"
-	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
-	"github.com/prysmaticlabs/prysm/beacon-chain/flags"
-	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/traceutil"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-)
-
-// OnBlock is called when a gossip block is received. It runs regular state transition on the block and
-// update fork choice store.
-//
-// Spec pseudocode definition:
-//   def on_block(store: Store, block: BeaconBlock) -> None:
-//    # Make a copy of the state to avoid mutability issues
-//    assert block.parent_root in store.block_states
-//    pre_state = store.block_states[block.parent_root].copy()
-//    # 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)
-//    # Check the block is valid and compute the post-state
-//    state = state_transition(pre_state, block)
-//    # Add new state for this block to the store
-//    store.block_states[signing_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
-//
-//    # Update finalized checkpoint
-//    if state.finalized_checkpoint.epoch > store.finalized_checkpoint.epoch:
-//        store.finalized_checkpoint = state.finalized_checkpoint
-func (s *Store) OnBlock(ctx context.Context, signed *ethpb.SignedBeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.onBlock")
-	defer span.End()
-
-	if signed == nil || signed.Block == nil {
-		return errors.New("nil block")
-	}
-
-	b := signed.Block
-
-	// Retrieve incoming block's pre state.
-	preState, err := s.getBlockPreState(ctx, b)
-	if err != nil {
-		return err
-	}
-	preStateValidatorCount := len(preState.Validators)
-
-	root, err := ssz.HashTreeRoot(b)
-	if err != nil {
-		return errors.Wrapf(err, "could not get signing root of block %d", b.Slot)
-	}
-	log.WithFields(logrus.Fields{
-		"slot": b.Slot,
-		"root": fmt.Sprintf("0x%s...", hex.EncodeToString(root[:])[:8]),
-	}).Info("Executing state transition on block")
-	postState, err := state.ExecuteStateTransition(ctx, preState, signed)
-	if err != nil {
-		return errors.Wrap(err, "could not execute state transition")
-	}
-
-	if err := s.db.SaveBlock(ctx, signed); err != nil {
-		return errors.Wrapf(err, "could not save block from slot %d", b.Slot)
-	}
-	if err := s.db.SaveState(ctx, postState, root); err != nil {
-		return errors.Wrap(err, "could not save state")
-	}
-
-	// Update justified check point.
-	if postState.CurrentJustifiedCheckpoint.Epoch > s.justifiedCheckpt.Epoch {
-		if err := s.updateJustified(ctx, postState); err != nil {
-			return err
-		}
-	}
-
-	// Update finalized check point.
-	// Prune the block cache and helper caches on every new finalized epoch.
-	if postState.FinalizedCheckpoint.Epoch > s.finalizedCheckpt.Epoch {
-		if err := s.db.SaveFinalizedCheckpoint(ctx, postState.FinalizedCheckpoint); err != nil {
-			return errors.Wrap(err, "could not save finalized checkpoint")
-		}
-
-		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)
-			}
-		}
-
-		s.prevFinalizedCheckpt = s.finalizedCheckpt
-		s.finalizedCheckpt = postState.FinalizedCheckpoint
-	}
-
-	// Update validator indices in database as needed.
-	if err := s.saveNewValidators(ctx, preStateValidatorCount, postState); err != nil {
-		return errors.Wrap(err, "could not save finalized checkpoint")
-	}
-	// Save the unseen attestations from block to db.
-	if err := s.saveNewBlockAttestations(ctx, b.Body.Attestations); err != nil {
-		return errors.Wrap(err, "could not save attestations")
-	}
-
-	// 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 featureconfig.Get().EnableNewCache {
-			if err := helpers.UpdateCommitteeCache(postState, helpers.CurrentEpoch(postState)); err != nil {
-				return err
-			}
-		}
-
-		s.nextEpochBoundarySlot = helpers.StartSlot(helpers.NextEpoch(postState))
-	}
-
-	return nil
-}
-
-// OnBlockInitialSyncStateTransition is called when an initial sync block is received.
-// It runs state transition on the block and without any BLS verification. The BLS verification
-// includes proposer signature, randao and attestation's aggregated signature. It also does not save
-// attestations.
-func (s *Store) OnBlockInitialSyncStateTransition(ctx context.Context, signed *ethpb.SignedBeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.onBlock")
-	defer span.End()
-
-	if signed == nil || signed.Block == nil {
-		return errors.New("nil block")
-	}
-
-	b := signed.Block
-
-	s.initSyncStateLock.Lock()
-	defer s.initSyncStateLock.Unlock()
-
-	// Retrieve incoming block's pre state.
-	preState, err := s.cachedPreState(ctx, b)
-	if err != nil {
-		return err
-	}
-	preStateValidatorCount := len(preState.Validators)
-
-	log.WithField("slot", b.Slot).Debug("Executing state transition on block")
-
-	postState, err := state.ExecuteStateTransitionNoVerify(ctx, preState, signed)
-	if err != nil {
-		return errors.Wrap(err, "could not execute state transition")
-	}
-
-	if err := s.db.SaveBlock(ctx, signed); err != nil {
-		return errors.Wrapf(err, "could not save block from slot %d", b.Slot)
-	}
-	root, err := ssz.HashTreeRoot(b)
-	if err != nil {
-		return errors.Wrapf(err, "could not get signing root of block %d", b.Slot)
-	}
-
-	if featureconfig.Get().InitSyncCacheState {
-		s.initSyncState[root] = postState
-	} else {
-		if err := s.db.SaveState(ctx, postState, root); err != nil {
-			return errors.Wrap(err, "could not save state")
-		}
-	}
-
-	// Update justified check point.
-	if postState.CurrentJustifiedCheckpoint.Epoch > s.justifiedCheckpt.Epoch {
-		if err := s.updateJustified(ctx, postState); err != nil {
-			return err
-		}
-	}
-
-	// Update finalized check point.
-	// Prune the block cache and helper caches on every new finalized epoch.
-	if postState.FinalizedCheckpoint.Epoch > s.finalizedCheckpt.Epoch {
-		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 err := s.db.SaveFinalizedCheckpoint(ctx, postState.FinalizedCheckpoint); err != nil {
-			return errors.Wrap(err, "could not save finalized checkpoint")
-		}
-
-		s.prevFinalizedCheckpt = s.finalizedCheckpt
-		s.finalizedCheckpt = postState.FinalizedCheckpoint
-	}
-
-	// Update validator indices in database as needed.
-	if err := s.saveNewValidators(ctx, preStateValidatorCount, postState); err != nil {
-		return errors.Wrap(err, "could not save finalized checkpoint")
-	}
-
-	if flags.Get().EnableArchive {
-		// Save the unseen attestations from block to db.
-		if err := s.saveNewBlockAttestations(ctx, b.Body.Attestations); err != nil {
-			return errors.Wrap(err, "could not save attestations")
-		}
-	}
-
-	// Epoch boundary bookkeeping such as logging epoch summaries.
-	if postState.Slot >= s.nextEpochBoundarySlot {
-		reportEpochMetrics(postState)
-
-		s.nextEpochBoundarySlot = helpers.StartSlot(helpers.NextEpoch(postState))
-	}
-
-	return nil
-}
-
-// 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 *Store) getBlockPreState(ctx context.Context, b *ethpb.BeaconBlock) (*pb.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.getBlockPreState")
-	defer span.End()
-
-	// Verify incoming block has a valid pre state.
-	preState, err := s.verifyBlkPreState(ctx, b)
-	if err != nil {
-		return nil, err
-	}
-
-	// Verify block slot time is not from the feature.
-	if err := helpers.VerifySlotTime(preState.GenesisTime, b.Slot); 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
-	}
-
-	return preState, nil
-}
-
-// verifyBlkPreState validates input block has a valid pre-state.
-func (s *Store) verifyBlkPreState(ctx context.Context, b *ethpb.BeaconBlock) (*pb.BeaconState, error) {
-	preState, err := s.db.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 {
-		return nil, fmt.Errorf("pre state of slot %d does not exist", b.Slot)
-	}
-	return preState, nil
-}
-
-// verifyBlkDescendant validates input block root is a descendant of the
-// current finalized block root.
-func (s *Store) verifyBlkDescendant(ctx context.Context, root [32]byte, slot uint64) error {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.verifyBlkDescendant")
-	defer span.End()
-
-	finalizedBlkSigned, err := s.db.Block(ctx, bytesutil.ToBytes32(s.finalizedCheckpt.Root))
-	if err != nil || finalizedBlkSigned == nil || finalizedBlkSigned.Block == nil {
-		return errors.Wrap(err, "could not get 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 !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))
-		traceutil.AnnotateError(span, err)
-		return err
-	}
-	return nil
-}
-
-// verifyBlkFinalizedSlot validates input block is not less than or equal
-// to current finalized slot.
-func (s *Store) verifyBlkFinalizedSlot(b *ethpb.BeaconBlock) error {
-	finalizedSlot := helpers.StartSlot(s.finalizedCheckpt.Epoch)
-	if finalizedSlot >= b.Slot {
-		return fmt.Errorf("block is equal or earlier than finalized block, slot %d < slot %d", b.Slot, finalizedSlot)
-	}
-	return nil
-}
-
-// saveNewValidators saves newly added validator index from state to db. Does nothing if validator count has not
-// changed.
-func (s *Store) saveNewValidators(ctx context.Context, preStateValidatorCount int, postState *pb.BeaconState) error {
-	postStateValidatorCount := len(postState.Validators)
-	if preStateValidatorCount != postStateValidatorCount {
-		for i := preStateValidatorCount; i < postStateValidatorCount; i++ {
-			pubKey := postState.Validators[i].PublicKey
-			if err := s.db.SaveValidatorIndex(ctx, bytesutil.ToBytes48(pubKey), uint64(i)); err != nil {
-				return errors.Wrapf(err, "could not save activated validator: %d", i)
-			}
-			log.WithFields(logrus.Fields{
-				"index":               i,
-				"pubKey":              hex.EncodeToString(bytesutil.Trunc(pubKey)),
-				"totalValidatorCount": i + 1,
-			}).Info("New validator index saved in DB")
-		}
-	}
-	return nil
-}
-
-// saveNewBlockAttestations saves the new attestations in block to DB.
-func (s *Store) saveNewBlockAttestations(ctx context.Context, atts []*ethpb.Attestation) error {
-	attestations := make([]*ethpb.Attestation, 0, len(atts))
-	for _, att := range atts {
-		aggregated, err := s.aggregatedAttestations(ctx, att)
-		if err != nil {
-			continue
-		}
-		attestations = append(attestations, aggregated...)
-	}
-	if err := s.db.SaveAttestations(ctx, atts); err != nil {
-		return err
-	}
-	return nil
-}
-
-// rmStatesOlderThanLastFinalized deletes the states in db since last finalized check point.
-func (s *Store) 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.db.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.db.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.db.BlockRoots(ctx, filter)
-	if err != nil {
-		return err
-	}
-
-	roots, err = s.filterBlockRoots(ctx, roots)
-	if err != nil {
-		return err
-	}
-
-	if err := s.db.DeleteStates(ctx, roots); err != nil {
-		return 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.
-// See https://ethresear.ch/t/prevention-of-bouncing-attack-on-ffg/6114 for more detailed analysis and discussion.
-func (s *Store) shouldUpdateCurrentJustified(ctx context.Context, newJustifiedCheckpt *ethpb.Checkpoint) (bool, error) {
-	if helpers.SlotsSinceEpochStarts(s.currentSlot()) < params.BeaconConfig().SafeSlotsToUpdateJustified {
-		return true, nil
-	}
-	newJustifiedBlockSigned, err := s.db.Block(ctx, bytesutil.ToBytes32(newJustifiedCheckpt.Root))
-	if err != nil {
-		return false, err
-	}
-	if newJustifiedBlockSigned == nil || newJustifiedBlockSigned.Block == nil {
-		return false, errors.New("nil new justified block")
-	}
-	newJustifiedBlock := newJustifiedBlockSigned.Block
-	if newJustifiedBlock.Slot <= helpers.StartSlot(s.justifiedCheckpt.Epoch) {
-		return false, nil
-	}
-	justifiedBlockSigned, err := s.db.Block(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
-	if err != nil {
-		return false, err
-	}
-	if justifiedBlockSigned == nil || justifiedBlockSigned.Block == nil {
-		return false, errors.New("nil justified block")
-	}
-	justifiedBlock := justifiedBlockSigned.Block
-	b, err := s.ancestor(ctx, newJustifiedCheckpt.Root, justifiedBlock.Slot)
-	if err != nil {
-		return false, err
-	}
-	if !bytes.Equal(b, s.justifiedCheckpt.Root) {
-		return false, nil
-	}
-	return true, nil
-}
-
-func (s *Store) updateJustified(ctx context.Context, state *pb.BeaconState) error {
-	if state.CurrentJustifiedCheckpoint.Epoch > s.bestJustifiedCheckpt.Epoch {
-		s.bestJustifiedCheckpt = state.CurrentJustifiedCheckpoint
-	}
-	canUpdate, err := s.shouldUpdateCurrentJustified(ctx, state.CurrentJustifiedCheckpoint)
-	if err != nil {
-		return err
-	}
-	if canUpdate {
-		s.justifiedCheckpt = state.CurrentJustifiedCheckpoint
-	}
-
-	if featureconfig.Get().InitSyncCacheState {
-		justifiedRoot := bytesutil.ToBytes32(state.CurrentJustifiedCheckpoint.Root)
-		justifiedState := s.initSyncState[justifiedRoot]
-		if err := s.db.SaveState(ctx, justifiedState, justifiedRoot); err != nil {
-			return errors.Wrap(err, "could not save justified state")
-		}
-	}
-
-	return s.db.SaveJustifiedCheckpoint(ctx, state.CurrentJustifiedCheckpoint)
-}
-
-// currentSlot returns the current slot based on time.
-func (s *Store) currentSlot() uint64 {
-	return (uint64(time.Now().Unix()) - s.genesisTime) / params.BeaconConfig().SecondsPerSlot
-}
-
-// updates justified check point in store if a better check point is known
-func (s *Store) updateJustifiedCheckpoint() {
-	// Update at epoch boundary slot only
-	if !helpers.IsEpochStart(s.currentSlot()) {
-		return
-	}
-	if s.bestJustifiedCheckpt.Epoch > s.justifiedCheckpt.Epoch {
-		s.justifiedCheckpt = s.bestJustifiedCheckpt
-	}
-}
-
-// This receives cached state in memory for initial sync only during initial sync.
-func (s *Store) cachedPreState(ctx context.Context, b *ethpb.BeaconBlock) (*pb.BeaconState, error) {
-	if featureconfig.Get().InitSyncCacheState {
-		preState := s.initSyncState[bytesutil.ToBytes32(b.ParentRoot)]
-		var err error
-		if preState == nil {
-			preState, err = s.db.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 {
-				return nil, fmt.Errorf("pre state of slot %d does not exist", b.Slot)
-			}
-		}
-		return proto.Clone(preState).(*pb.BeaconState), nil
-	}
-
-	preState, err := s.db.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 {
-		return nil, fmt.Errorf("pre state of slot %d does not exist", b.Slot)
-	}
-
-	return preState, nil
-}
-
-// 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 *Store) saveInitState(ctx context.Context, state *pb.BeaconState) error {
-	if !featureconfig.Get().InitSyncCacheState {
-		return nil
-	}
-	finalizedRoot := bytesutil.ToBytes32(state.FinalizedCheckpoint.Root)
-	fs := s.initSyncState[finalizedRoot]
-
-	if err := s.db.SaveState(ctx, fs, finalizedRoot); err != nil {
-		return errors.Wrap(err, "could not save state")
-	}
-	for r, oldState := range s.initSyncState {
-		if oldState.Slot < state.FinalizedCheckpoint.Epoch*params.BeaconConfig().SlotsPerEpoch {
-			delete(s.initSyncState, r)
-		}
-	}
-	return nil
-}
-
-// 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 *Store) filterBlockRoots(ctx context.Context, roots [][32]byte) ([][32]byte, error) {
-	f, err := s.db.FinalizedCheckpoint(ctx)
-	if err != nil {
-		return nil, err
-	}
-	fRoot := f.Root
-	h, err := s.db.HeadBlock(ctx)
-	if err != nil {
-		return nil, err
-	}
-	hRoot, err := ssz.SigningRoot(h)
-	if err != nil {
-		return nil, 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)
-	}
-
-	return filtered, nil
-}

beacon-chain/blockchain/forkchoice/process_block_test.go

@@ -1,610 +0,0 @@
-package forkchoice
-
-import (
-	"bytes"
-	"context"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	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/stateutil"
-)
-
-func TestStore_OnBlock(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	genesisStateRoot, err := stateutil.HashTreeRootState(&pb.BeaconState{})
-	if err != nil {
-		t.Error(err)
-	}
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	if err := db.SaveBlock(ctx, genesis); err != nil {
-		t.Error(err)
-	}
-	validGenesisRoot, err := ssz.HashTreeRoot(genesis.Block)
-	if err != nil {
-		t.Error(err)
-	}
-	if err := store.db.SaveState(ctx, &pb.BeaconState{}, validGenesisRoot); err != nil {
-		t.Fatal(err)
-	}
-	roots, err := blockTree1(db, validGenesisRoot[:])
-	if err != nil {
-		t.Fatal(err)
-	}
-	random := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1, ParentRoot: validGenesisRoot[:]}}
-	if err := db.SaveBlock(ctx, random); err != nil {
-		t.Error(err)
-	}
-	randomParentRoot, err := ssz.HashTreeRoot(random.Block)
-	if err != nil {
-		t.Error(err)
-	}
-	if err := store.db.SaveState(ctx, &pb.BeaconState{}, randomParentRoot); err != nil {
-		t.Fatal(err)
-	}
-	randomParentRoot2 := roots[1]
-	if err := store.db.SaveState(ctx, &pb.BeaconState{}, bytesutil.ToBytes32(randomParentRoot2)); err != nil {
-		t.Fatal(err)
-	}
-
-	tests := []struct {
-		name          string
-		blk           *ethpb.BeaconBlock
-		s             *pb.BeaconState
-		time          uint64
-		wantErrString string
-	}{
-		{
-			name:          "parent block root does not have a state",
-			blk:           &ethpb.BeaconBlock{},
-			s:             &pb.BeaconState{},
-			wantErrString: "pre state of slot 0 does not exist",
-		},
-		{
-			name:          "block is from the feature",
-			blk:           &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:], Slot: params.BeaconConfig().FarFutureEpoch},
-			s:             &pb.BeaconState{},
-			wantErrString: "could not process slot from the future",
-		},
-		{
-			name:          "could not get finalized block",
-			blk:           &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:]},
-			s:             &pb.BeaconState{},
-			wantErrString: "block from slot 0 is not a descendent of the current finalized block",
-		},
-		{
-			name:          "same slot as finalized block",
-			blk:           &ethpb.BeaconBlock{Slot: 0, ParentRoot: randomParentRoot2},
-			s:             &pb.BeaconState{},
-			wantErrString: "block is equal or earlier than finalized block, slot 0 < slot 0",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := store.GenesisStore(ctx, &ethpb.Checkpoint{Root: validGenesisRoot[:]}, &ethpb.Checkpoint{Root: validGenesisRoot[:]}); err != nil {
-				t.Fatal(err)
-			}
-			store.finalizedCheckpt.Root = roots[0]
-
-			err := store.OnBlock(ctx, &ethpb.SignedBeaconBlock{Block: tt.blk})
-			if !strings.Contains(err.Error(), tt.wantErrString) {
-				t.Errorf("Store.OnBlock() error = %v, wantErr = %v", err, tt.wantErrString)
-			}
-		})
-	}
-}
-
-func TestStore_SaveNewValidators(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	preCount := 2 // validators 0 and validators 1
-	s := &pb.BeaconState{Validators: []*ethpb.Validator{
-		{PublicKey: []byte{0}}, {PublicKey: []byte{1}},
-		{PublicKey: []byte{2}}, {PublicKey: []byte{3}},
-	}}
-	if err := store.saveNewValidators(ctx, preCount, s); err != nil {
-		t.Fatal(err)
-	}
-
-	if !db.HasValidatorIndex(ctx, bytesutil.ToBytes48([]byte{2})) {
-		t.Error("Wanted validator saved in db")
-	}
-	if !db.HasValidatorIndex(ctx, bytesutil.ToBytes48([]byte{3})) {
-		t.Error("Wanted validator saved in db")
-	}
-	if db.HasValidatorIndex(ctx, bytesutil.ToBytes48([]byte{1})) {
-		t.Error("validator not suppose to be saved in db")
-	}
-}
-
-func TestStore_SavesNewBlockAttestations(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	a1 := &ethpb.Attestation{Data: &ethpb.AttestationData{}, AggregationBits: bitfield.Bitlist{0b101}}
-	a2 := &ethpb.Attestation{Data: &ethpb.AttestationData{BeaconBlockRoot: []byte{'A'}}, AggregationBits: bitfield.Bitlist{0b110}}
-	r1, _ := ssz.HashTreeRoot(a1.Data)
-	r2, _ := ssz.HashTreeRoot(a2.Data)
-
-	if err := store.saveNewBlockAttestations(ctx, []*ethpb.Attestation{a1, a2}); err != nil {
-		t.Fatal(err)
-	}
-
-	saved, err := store.db.AttestationsByDataRoot(ctx, r1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual([]*ethpb.Attestation{a1}, saved) {
-		t.Error("did not retrieve saved attestation")
-	}
-
-	saved, err = store.db.AttestationsByDataRoot(ctx, r2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual([]*ethpb.Attestation{a2}, saved) {
-		t.Error("did not retrieve saved attestation")
-	}
-
-	a1 = &ethpb.Attestation{Data: &ethpb.AttestationData{}, AggregationBits: bitfield.Bitlist{0b111}}
-	a2 = &ethpb.Attestation{Data: &ethpb.AttestationData{BeaconBlockRoot: []byte{'A'}}, AggregationBits: bitfield.Bitlist{0b111}}
-
-	if err := store.saveNewBlockAttestations(ctx, []*ethpb.Attestation{a1, a2}); err != nil {
-		t.Fatal(err)
-	}
-
-	saved, err = store.db.AttestationsByDataRoot(ctx, r1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual([]*ethpb.Attestation{a1}, saved) {
-		t.Error("did not retrieve saved attestation")
-	}
-
-	saved, err = store.db.AttestationsByDataRoot(ctx, r2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual([]*ethpb.Attestation{a2}, saved) {
-		t.Error("did not retrieve saved attestation")
-	}
-}
-
-func TestRemoveStateSinceLastFinalized(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	params.UseMinimalConfig()
-	defer params.UseMainnetConfig()
-
-	store := NewForkChoiceService(ctx, db)
-
-	// Save 100 blocks in DB, each has a state.
-	numBlocks := 100
-	totalBlocks := make([]*ethpb.SignedBeaconBlock, numBlocks)
-	blockRoots := make([][32]byte, 0)
-	for i := 0; i < len(totalBlocks); i++ {
-		totalBlocks[i] = &ethpb.SignedBeaconBlock{
-			Block: &ethpb.BeaconBlock{
-				Slot: uint64(i),
-			},
-		}
-		r, err := ssz.HashTreeRoot(totalBlocks[i].Block)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := store.db.SaveState(ctx, &pb.BeaconState{Slot: uint64(i)}, r); err != nil {
-			t.Fatal(err)
-		}
-		if err := store.db.SaveBlock(ctx, totalBlocks[i]); err != nil {
-			t.Fatal(err)
-		}
-		blockRoots = append(blockRoots, r)
-		if err := store.db.SaveHeadBlockRoot(ctx, r); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	// New finalized epoch: 1
-	finalizedEpoch := uint64(1)
-	finalizedSlot := finalizedEpoch * params.BeaconConfig().SlotsPerEpoch
-	endSlot := helpers.StartSlot(finalizedEpoch+1) - 1 // Inclusive
-	if err := store.rmStatesOlderThanLastFinalized(ctx, 0, endSlot); err != nil {
-		t.Fatal(err)
-	}
-	for _, r := range blockRoots {
-		s, err := store.db.State(ctx, r)
-		if err != nil {
-			t.Fatal(err)
-		}
-		// Also verifies genesis state didnt get deleted
-		if s != nil && s.Slot != finalizedSlot && s.Slot != 0 && s.Slot < endSlot {
-			t.Errorf("State with slot %d should not be in DB", s.Slot)
-		}
-	}
-
-	// New finalized epoch: 5
-	newFinalizedEpoch := uint64(5)
-	newFinalizedSlot := newFinalizedEpoch * params.BeaconConfig().SlotsPerEpoch
-	endSlot = helpers.StartSlot(newFinalizedEpoch+1) - 1 // Inclusive
-	if err := store.rmStatesOlderThanLastFinalized(ctx, helpers.StartSlot(finalizedEpoch+1)-1, endSlot); err != nil {
-		t.Fatal(err)
-	}
-	for _, r := range blockRoots {
-		s, err := store.db.State(ctx, r)
-		if err != nil {
-			t.Fatal(err)
-		}
-		// Also verifies genesis state didnt get deleted
-		if s != nil && s.Slot != newFinalizedSlot && s.Slot != finalizedSlot && s.Slot != 0 && s.Slot < endSlot {
-			t.Errorf("State with slot %d should not be in DB", s.Slot)
-		}
-	}
-}
-
-func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	params.UseMinimalConfig()
-	defer params.UseMainnetConfig()
-
-	store := NewForkChoiceService(ctx, db)
-	store.genesisTime = uint64(time.Now().Unix())
-
-	update, err := store.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !update {
-		t.Error("Should be able to update justified, received false")
-	}
-
-	lastJustifiedBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{ParentRoot: []byte{'G'}}}
-	lastJustifiedRoot, _ := ssz.HashTreeRoot(lastJustifiedBlk.Block)
-	newJustifiedBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1, ParentRoot: lastJustifiedRoot[:]}}
-	newJustifiedRoot, _ := ssz.HashTreeRoot(newJustifiedBlk.Block)
-	if err := store.db.SaveBlock(ctx, newJustifiedBlk); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveBlock(ctx, lastJustifiedBlk); err != nil {
-		t.Fatal(err)
-	}
-
-	diff := (params.BeaconConfig().SlotsPerEpoch - 1) * params.BeaconConfig().SecondsPerSlot
-	store.genesisTime = uint64(time.Now().Unix()) - diff
-	store.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
-	update, err = store.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !update {
-		t.Error("Should be able to update justified, received false")
-	}
-}
-
-func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	params.UseMinimalConfig()
-	defer params.UseMainnetConfig()
-
-	store := NewForkChoiceService(ctx, db)
-
-	lastJustifiedBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{ParentRoot: []byte{'G'}}}
-	lastJustifiedRoot, _ := ssz.HashTreeRoot(lastJustifiedBlk.Block)
-	newJustifiedBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{ParentRoot: lastJustifiedRoot[:]}}
-	newJustifiedRoot, _ := ssz.HashTreeRoot(newJustifiedBlk.Block)
-	if err := store.db.SaveBlock(ctx, newJustifiedBlk); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveBlock(ctx, lastJustifiedBlk); err != nil {
-		t.Fatal(err)
-	}
-
-	diff := (params.BeaconConfig().SlotsPerEpoch - 1) * params.BeaconConfig().SecondsPerSlot
-	store.genesisTime = uint64(time.Now().Unix()) - diff
-	store.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
-
-	update, err := store.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if update {
-		t.Error("Should not be able to update justified, received true")
-	}
-}
-
-func TestUpdateJustifiedCheckpoint_Update(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	params.UseMinimalConfig()
-	defer params.UseMainnetConfig()
-
-	store := NewForkChoiceService(ctx, db)
-	store.genesisTime = uint64(time.Now().Unix())
-
-	store.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
-	store.bestJustifiedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'B'}}
-	store.updateJustifiedCheckpoint()
-
-	if !bytes.Equal(store.justifiedCheckpt.Root, []byte{'B'}) {
-		t.Error("Justified check point root did not update")
-	}
-}
-
-func TestUpdateJustifiedCheckpoint_NoUpdate(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	params.UseMinimalConfig()
-	defer params.UseMainnetConfig()
-
-	store := NewForkChoiceService(ctx, db)
-	store.genesisTime = uint64(time.Now().Unix()) - params.BeaconConfig().SecondsPerSlot
-
-	store.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
-	store.bestJustifiedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'B'}}
-	store.updateJustifiedCheckpoint()
-
-	if bytes.Equal(store.justifiedCheckpt.Root, []byte{'B'}) {
-		t.Error("Justified check point root was not suppose to update")
-
-		store := NewForkChoiceService(ctx, db)
-
-		// Save 5 blocks in DB, each has a state.
-		numBlocks := 5
-		totalBlocks := make([]*ethpb.SignedBeaconBlock, numBlocks)
-		blockRoots := make([][32]byte, 0)
-		for i := 0; i < len(totalBlocks); i++ {
-			totalBlocks[i] = &ethpb.SignedBeaconBlock{
-				Block: &ethpb.BeaconBlock{
-					Slot: uint64(i),
-				},
-			}
-			r, err := ssz.HashTreeRoot(totalBlocks[i].Block)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if err := store.db.SaveState(ctx, &pb.BeaconState{Slot: uint64(i)}, r); err != nil {
-				t.Fatal(err)
-			}
-			if err := store.db.SaveBlock(ctx, totalBlocks[i]); err != nil {
-				t.Fatal(err)
-			}
-			blockRoots = append(blockRoots, r)
-		}
-		if err := store.db.SaveHeadBlockRoot(ctx, blockRoots[0]); err != nil {
-			t.Fatal(err)
-		}
-		if err := store.rmStatesOlderThanLastFinalized(ctx, 10, 11); err != nil {
-			t.Fatal(err)
-		}
-		// Since 5-10 are skip slots, block with slot 4 should be deleted
-		s, err := store.db.State(ctx, blockRoots[4])
-		if err != nil {
-			t.Fatal(err)
-		}
-		if s != nil {
-			t.Error("Did not delete state for start slot")
-		}
-	}
-}
-
-func TestCachedPreState_CanGetFromCache(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	s := &pb.BeaconState{Slot: 1}
-	r := [32]byte{'A'}
-	b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
-	store.initSyncState[r] = s
-
-	wanted := "pre state of slot 1 does not exist"
-	if _, err := store.cachedPreState(ctx, b); !strings.Contains(err.Error(), wanted) {
-		t.Fatal("Not expected error")
-	}
-}
-
-func TestCachedPreState_CanGetFromCacheWithFeature(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	config := &featureconfig.Flags{
-		InitSyncCacheState: true,
-	}
-	featureconfig.Init(config)
-
-	store := NewForkChoiceService(ctx, db)
-	s := &pb.BeaconState{Slot: 1}
-	r := [32]byte{'A'}
-	b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
-	store.initSyncState[r] = s
-
-	received, err := store.cachedPreState(ctx, b)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(s, received) {
-		t.Error("cached state not the same")
-	}
-}
-
-func TestCachedPreState_CanGetFromDB(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	r := [32]byte{'A'}
-	b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
-
-	_, err := store.cachedPreState(ctx, b)
-	wanted := "pre state of slot 1 does not exist"
-	if err.Error() != wanted {
-		t.Error("Did not get wanted error")
-	}
-
-	s := &pb.BeaconState{Slot: 1}
-	store.db.SaveState(ctx, s, r)
-
-	received, err := store.cachedPreState(ctx, b)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(s, received) {
-		t.Error("cached state not the same")
-	}
-}
-
-func TestSaveInitState_CanSaveDelete(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	config := &featureconfig.Flags{
-		InitSyncCacheState: true,
-	}
-	featureconfig.Init(config)
-
-	for i := uint64(0); i < 64; i++ {
-		b := &ethpb.BeaconBlock{Slot: i}
-		s := &pb.BeaconState{Slot: i}
-		r, _ := ssz.HashTreeRoot(b)
-		store.initSyncState[r] = s
-	}
-
-	// Set finalized root as slot 32
-	finalizedRoot, _ := ssz.HashTreeRoot(&ethpb.BeaconBlock{Slot: 32})
-
-	if err := store.saveInitState(ctx, &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{
-		Epoch: 1, Root: finalizedRoot[:]}}); err != nil {
-		t.Fatal(err)
-	}
-
-	// Verify finalized state is saved in DB
-	finalizedState, err := store.db.State(ctx, finalizedRoot)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if finalizedState == nil {
-		t.Error("finalized state can't be nil")
-	}
-
-	// Verify cached state is properly pruned
-	if len(store.initSyncState) != int(params.BeaconConfig().SlotsPerEpoch) {
-		t.Errorf("wanted: %d, got: %d", len(store.initSyncState), params.BeaconConfig().SlotsPerEpoch)
-	}
-}
-
-func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	signedBlock := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
-	if err := db.SaveBlock(ctx, signedBlock); err != nil {
-		t.Fatal(err)
-	}
-	r, err := ssz.HashTreeRoot(signedBlock.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	store.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
-	store.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
-	store.initSyncState[r] = &pb.BeaconState{}
-	if err := db.SaveState(ctx, &pb.BeaconState{}, r); err != nil {
-		t.Fatal(err)
-	}
-
-	// Could update
-	s := &pb.BeaconState{CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: r[:]}}
-	if err := store.updateJustified(context.Background(), s); err != nil {
-		t.Fatal(err)
-	}
-
-	if store.bestJustifiedCheckpt.Epoch != s.CurrentJustifiedCheckpoint.Epoch {
-		t.Error("Incorrect justified epoch in store")
-	}
-
-	// Could not update
-	store.bestJustifiedCheckpt.Epoch = 2
-	if err := store.updateJustified(context.Background(), s); err != nil {
-		t.Fatal(err)
-	}
-
-	if store.bestJustifiedCheckpt.Epoch != 2 {
-		t.Error("Incorrect justified epoch in store")
-	}
-}
-
-func TestFilterBlockRoots_CanFilter(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	fBlock := &ethpb.BeaconBlock{}
-	fRoot, _ := ssz.HashTreeRoot(fBlock)
-	hBlock := &ethpb.BeaconBlock{Slot: 1}
-	headRoot, _ := ssz.HashTreeRoot(hBlock)
-	if err := store.db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: fBlock}); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, &pb.BeaconState{}, fRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: fRoot[:]}); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: hBlock}); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, &pb.BeaconState{}, headRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveHeadBlockRoot(ctx, headRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	roots := [][32]byte{{'C'}, {'D'}, headRoot, {'E'}, fRoot, {'F'}}
-	wanted := [][32]byte{{'C'}, {'D'}, {'E'}, {'F'}}
-
-	received, err := store.filterBlockRoots(ctx, roots)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(wanted, received) {
-		t.Error("Did not filter correctly")
-	}
-}

beacon-chain/blockchain/forkchoice/service.go

@@ -1,433 +0,0 @@
-package forkchoice
-
-import (
-	"bytes"
-	"context"
-	"encoding/hex"
-	"fmt"
-	"sync"
-
-	"github.com/gogo/protobuf/proto"
-	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
-	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/stateutil"
-	"go.opencensus.io/trace"
-)
-
-// ForkChoicer defines a common interface for methods useful for directly applying fork choice
-// to beacon blocks to compute head.
-type ForkChoicer interface {
-	Head(ctx context.Context) ([]byte, error)
-	OnBlock(ctx context.Context, b *ethpb.SignedBeaconBlock) error
-	OnBlockInitialSyncStateTransition(ctx context.Context, b *ethpb.SignedBeaconBlock) error
-	OnAttestation(ctx context.Context, a *ethpb.Attestation) error
-	GenesisStore(ctx context.Context, justifiedCheckpoint *ethpb.Checkpoint, finalizedCheckpoint *ethpb.Checkpoint) error
-	FinalizedCheckpt() *ethpb.Checkpoint
-}
-
-// Store represents a service struct that handles the forkchoice
-// logic of managing the full PoS beacon chain.
-type Store struct {
-	ctx                   context.Context
-	cancel                context.CancelFunc
-	db                    db.Database
-	justifiedCheckpt      *ethpb.Checkpoint
-	finalizedCheckpt      *ethpb.Checkpoint
-	prevFinalizedCheckpt  *ethpb.Checkpoint
-	checkpointState       *cache.CheckpointStateCache
-	checkpointStateLock   sync.Mutex
-	genesisTime           uint64
-	bestJustifiedCheckpt  *ethpb.Checkpoint
-	latestVoteMap         map[uint64]*pb.ValidatorLatestVote
-	voteLock              sync.RWMutex
-	initSyncState         map[[32]byte]*pb.BeaconState
-	initSyncStateLock     sync.RWMutex
-	nextEpochBoundarySlot uint64
-}
-
-// NewForkChoiceService instantiates a new service instance that will
-// be registered into a running beacon node.
-func NewForkChoiceService(ctx context.Context, db db.Database) *Store {
-	ctx, cancel := context.WithCancel(ctx)
-	return &Store{
-		ctx:             ctx,
-		cancel:          cancel,
-		db:              db,
-		checkpointState: cache.NewCheckpointStateCache(),
-		latestVoteMap:   make(map[uint64]*pb.ValidatorLatestVote),
-		initSyncState:   make(map[[32]byte]*pb.BeaconState),
-	}
-}
-
-// GenesisStore initializes the store struct before beacon chain
-// starts to advance.
-//
-// Spec pseudocode definition:
-//   def get_genesis_store(genesis_state: BeaconState) -> Store:
-//    genesis_block = BeaconBlock(state_root=hash_tree_root(genesis_state))
-//    root = signing_root(genesis_block)
-//    justified_checkpoint = Checkpoint(epoch=GENESIS_EPOCH, root=root)
-//    finalized_checkpoint = Checkpoint(epoch=GENESIS_EPOCH, root=root)
-//    return Store(
-//        time=genesis_state.genesis_time,
-//        justified_checkpoint=justified_checkpoint,
-//        finalized_checkpoint=finalized_checkpoint,
-//        blocks={root: genesis_block},
-//        block_states={root: genesis_state.copy()},
-//        checkpoint_states={justified_checkpoint: genesis_state.copy()},
-//    )
-func (s *Store) GenesisStore(
-	ctx context.Context,
-	justifiedCheckpoint *ethpb.Checkpoint,
-	finalizedCheckpoint *ethpb.Checkpoint) error {
-
-	s.justifiedCheckpt = proto.Clone(justifiedCheckpoint).(*ethpb.Checkpoint)
-	s.bestJustifiedCheckpt = proto.Clone(justifiedCheckpoint).(*ethpb.Checkpoint)
-	s.finalizedCheckpt = proto.Clone(finalizedCheckpoint).(*ethpb.Checkpoint)
-	s.prevFinalizedCheckpt = proto.Clone(finalizedCheckpoint).(*ethpb.Checkpoint)
-
-	justifiedState, err := s.db.State(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
-	if err != nil {
-		return errors.Wrap(err, "could not retrieve last justified state")
-	}
-
-	if err := s.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: s.justifiedCheckpt,
-		State:      justifiedState,
-	}); err != nil {
-		return errors.Wrap(err, "could not save genesis state in check point cache")
-	}
-
-	s.genesisTime = justifiedState.GenesisTime
-	if err := s.cacheGenesisState(ctx); err != nil {
-		return errors.Wrap(err, "could not cache initial sync state")
-	}
-
-	return nil
-}
-
-// This sets up gensis for initial sync state cache.
-func (s *Store) cacheGenesisState(ctx context.Context) error {
-	if !featureconfig.Get().InitSyncCacheState {
-		return nil
-	}
-
-	genesisState, err := s.db.GenesisState(ctx)
-	if err != nil {
-		return err
-	}
-	stateRoot, err := stateutil.HashTreeRootState(genesisState)
-	if err != nil {
-		return errors.Wrap(err, "could not tree hash genesis state")
-	}
-	genesisBlk := blocks.NewGenesisBlock(stateRoot[:])
-	genesisBlkRoot, err := ssz.HashTreeRoot(genesisBlk.Block)
-	if err != nil {
-		return errors.Wrap(err, "could not get genesis block root")
-	}
-	s.initSyncState[genesisBlkRoot] = genesisState
-
-	return nil
-}
-
-// ancestor returns the block root of an ancestry block from the input block root.
-//
-// Spec pseudocode definition:
-//   def get_ancestor(store: Store, root: Hash, slot: Slot) -> Hash:
-//    block = store.blocks[root]
-//    if block.slot > slot:
-//      return get_ancestor(store, block.parent_root, slot)
-//    elif block.slot == slot:
-//      return root
-//    else:
-//      return Bytes32()  # root is older than queried slot: no results.
-func (s *Store) ancestor(ctx context.Context, root []byte, slot uint64) ([]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.ancestor")
-	defer span.End()
-
-	// Stop recursive ancestry lookup if context is cancelled.
-	if ctx.Err() != nil {
-		return nil, ctx.Err()
-	}
-
-	signed, err := s.db.Block(ctx, bytesutil.ToBytes32(root))
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get ancestor block")
-	}
-	if signed == nil || signed.Block == nil {
-		return nil, errors.New("nil block")
-	}
-	b := signed.Block
-
-	// If we dont have the ancestor in the DB, simply return nil so rest of fork choice
-	// operation can proceed. This is not an error condition.
-	if b == nil || b.Slot < slot {
-		return nil, nil
-	}
-
-	if b.Slot == slot {
-		return root, nil
-	}
-
-	return s.ancestor(ctx, b.ParentRoot, slot)
-}
-
-// latestAttestingBalance returns the staked balance of a block from the input block root.
-//
-// Spec pseudocode definition:
-//   def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
-//    state = store.checkpoint_states[store.justified_checkpoint]
-//    active_indices = get_active_validator_indices(state, get_current_epoch(state))
-//    return Gwei(sum(
-//        state.validators[i].effective_balance for i in active_indices
-//        if (i in store.latest_messages
-//            and get_ancestor(store, store.latest_messages[i].root, store.blocks[root].slot) == root)
-//    ))
-func (s *Store) latestAttestingBalance(ctx context.Context, root []byte) (uint64, error) {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.latestAttestingBalance")
-	defer span.End()
-
-	lastJustifiedState, err := s.checkpointState.StateByCheckpoint(s.JustifiedCheckpt())
-	if err != nil {
-		return 0, errors.Wrap(err, "could not retrieve cached state via last justified check point")
-	}
-	if lastJustifiedState == nil {
-		return 0, errors.Wrapf(err, "could not get justified state at epoch %d", s.JustifiedCheckpt().Epoch)
-	}
-
-	lastJustifiedEpoch := helpers.CurrentEpoch(lastJustifiedState)
-	activeIndices, err := helpers.ActiveValidatorIndices(lastJustifiedState, lastJustifiedEpoch)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get active indices for last justified checkpoint")
-	}
-
-	wantedBlkSigned, err := s.db.Block(ctx, bytesutil.ToBytes32(root))
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get target block")
-	}
-	if wantedBlkSigned == nil || wantedBlkSigned.Block == nil {
-		return 0, errors.New("nil wanted block")
-	}
-	wantedBlk := wantedBlkSigned.Block
-
-	balances := uint64(0)
-	s.voteLock.RLock()
-	defer s.voteLock.RUnlock()
-	for _, i := range activeIndices {
-		vote, ok := s.latestVoteMap[i]
-		if !ok {
-			continue
-		}
-
-		wantedRoot, err := s.ancestor(ctx, vote.Root, wantedBlk.Slot)
-		if err != nil {
-			return 0, errors.Wrapf(err, "could not get ancestor root for slot %d", wantedBlk.Slot)
-		}
-		if bytes.Equal(wantedRoot, root) {
-			balances += lastJustifiedState.Validators[i].EffectiveBalance
-		}
-	}
-	return balances, nil
-}
-
-// Head returns the head of the beacon chain.
-//
-// Spec pseudocode definition:
-//   def get_head(store: Store) -> Root:
-//    # Get filtered block tree that only includes viable branches
-//    blocks = get_filtered_block_tree(store)
-//    # Execute the LMD-GHOST fork choice
-//    head = store.justified_checkpoint.root
-//    justified_slot = compute_start_slot_at_epoch(store.justified_checkpoint.epoch)
-//    while True:
-//        children = [
-//            root for root in blocks.keys()
-//            if blocks[root].parent_root == head and blocks[root].slot > justified_slot
-//        ]
-//        if len(children) == 0:
-//            return head
-//        # Sort by latest attesting balance with ties broken lexicographically
-//        head = max(children, key=lambda root: (get_latest_attesting_balance(store, root), root))
-func (s *Store) Head(ctx context.Context) ([]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.head")
-	defer span.End()
-
-	head := s.JustifiedCheckpt().Root
-	filteredBlocks, err := s.getFilterBlockTree(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	justifiedSlot := helpers.StartSlot(s.justifiedCheckpt.Epoch)
-	for {
-		children := make([][32]byte, 0, len(filteredBlocks))
-		for root, block := range filteredBlocks {
-			if bytes.Equal(block.ParentRoot, head) && block.Slot > justifiedSlot {
-				children = append(children, root)
-			}
-		}
-
-		if len(children) == 0 {
-			return head, nil
-		}
-
-		// if a block has one child, then we don't have to lookup anything to
-		// know that this child will be the best child.
-		head = children[0][:]
-		if len(children) > 1 {
-			highest, err := s.latestAttestingBalance(ctx, head)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get latest balance")
-			}
-			for _, child := range children[1:] {
-				balance, err := s.latestAttestingBalance(ctx, child[:])
-				if err != nil {
-					return nil, errors.Wrap(err, "could not get latest balance")
-				}
-				// When there's a tie, it's broken lexicographically to favor the higher one.
-				if balance > highest ||
-					balance == highest && bytes.Compare(child[:], head) > 0 {
-					highest = balance
-					head = child[:]
-				}
-			}
-		}
-	}
-}
-
-// getFilterBlockTree retrieves a filtered block tree from store, it only returns branches
-// whose leaf state's justified and finalized info agrees with what's in the store.
-// Rationale: https://notes.ethereum.org/Fj-gVkOSTpOyUx-zkWjuwg?view
-//
-// Spec pseudocode definition:
-//   def get_filtered_block_tree(store: Store) -> Dict[Root, BeaconBlock]:
-//    """
-//    Retrieve a filtered block true from ``store``, only returning branches
-//    whose leaf state's justified/finalized info agrees with that in ``store``.
-//    """
-//    base = store.justified_checkpoint.root
-//    blocks: Dict[Root, BeaconBlock] = {}
-//    filter_block_tree(store, base, blocks)
-//    return blocks
-func (s *Store) getFilterBlockTree(ctx context.Context) (map[[32]byte]*ethpb.BeaconBlock, error) {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.getFilterBlockTree")
-	defer span.End()
-
-	baseRoot := bytesutil.ToBytes32(s.justifiedCheckpt.Root)
-	filteredBlocks := make(map[[32]byte]*ethpb.BeaconBlock)
-	if _, err := s.filterBlockTree(ctx, baseRoot, filteredBlocks); err != nil {
-		return nil, err
-	}
-
-	return filteredBlocks, nil
-}
-
-// filterBlockTree filters for branches that see latest finalized and justified info as correct on-chain
-// before running Head.
-//
-// Spec pseudocode definition:
-//   def filter_block_tree(store: Store, block_root: Root, blocks: Dict[Root, BeaconBlock]) -> bool:
-//    block = store.blocks[block_root]
-//    children = [
-//        root for root in store.blocks.keys()
-//        if store.blocks[root].parent_root == block_root
-//    ]
-//    # If any children branches contain expected finalized/justified checkpoints,
-//    # add to filtered block-tree and signal viability to parent.
-//    if any(children):
-//        filter_block_tree_result = [filter_block_tree(store, child, blocks) for child in children]
-//        if any(filter_block_tree_result):
-//            blocks[block_root] = block
-//            return True
-//        return False
-//    # If leaf block, check finalized/justified checkpoints as matching latest.
-//    head_state = store.block_states[block_root]
-//    correct_justified = (
-//        store.justified_checkpoint.epoch == GENESIS_EPOCH
-//        or head_state.current_justified_checkpoint == store.justified_checkpoint
-//    )
-//    correct_finalized = (
-//        store.finalized_checkpoint.epoch == GENESIS_EPOCH
-//        or head_state.finalized_checkpoint == store.finalized_checkpoint
-//    )
-//    # If expected finalized/justified, add to viable block-tree and signal viability to parent.
-//    if correct_justified and correct_finalized:
-//        blocks[block_root] = block
-//        return True
-//    # Otherwise, branch not viable
-//    return False
-func (s *Store) filterBlockTree(ctx context.Context, blockRoot [32]byte, filteredBlocks map[[32]byte]*ethpb.BeaconBlock) (bool, error) {
-	ctx, span := trace.StartSpan(ctx, "forkchoice.filterBlockTree")
-	defer span.End()
-	signed, err := s.db.Block(ctx, blockRoot)
-	if err != nil {
-		return false, err
-	}
-	if signed == nil || signed.Block == nil {
-		return false, errors.New("nil block")
-	}
-	block := signed.Block
-
-	filter := filters.NewFilter().SetParentRoot(blockRoot[:])
-	childrenRoots, err := s.db.BlockRoots(ctx, filter)
-	if err != nil {
-		return false, err
-	}
-
-	if len(childrenRoots) != 0 {
-		var filtered bool
-		for _, childRoot := range childrenRoots {
-			didFilter, err := s.filterBlockTree(ctx, childRoot, filteredBlocks)
-			if err != nil {
-				return false, err
-			}
-			if didFilter {
-				filtered = true
-			}
-		}
-		if filtered {
-			filteredBlocks[blockRoot] = block
-			return true, nil
-		}
-		return false, nil
-	}
-
-	headState, err := s.db.State(ctx, blockRoot)
-	if err != nil {
-		return false, err
-	}
-
-	if headState == nil {
-		return false, fmt.Errorf("no state matching block root %v", hex.EncodeToString(blockRoot[:]))
-	}
-
-	correctJustified := s.justifiedCheckpt.Epoch == 0 ||
-		proto.Equal(s.justifiedCheckpt, headState.CurrentJustifiedCheckpoint)
-	correctFinalized := s.finalizedCheckpt.Epoch == 0 ||
-		proto.Equal(s.finalizedCheckpt, headState.FinalizedCheckpoint)
-	if correctJustified && correctFinalized {
-		filteredBlocks[blockRoot] = block
-		return true, nil
-	}
-
-	return false, nil
-}
-
-// JustifiedCheckpt returns the latest justified check point from fork choice store.
-func (s *Store) JustifiedCheckpt() *ethpb.Checkpoint {
-	return proto.Clone(s.justifiedCheckpt).(*ethpb.Checkpoint)
-}
-
-// FinalizedCheckpt returns the latest finalized check point from fork choice store.
-func (s *Store) FinalizedCheckpt() *ethpb.Checkpoint {
-	return proto.Clone(s.finalizedCheckpt).(*ethpb.Checkpoint)
-}

beacon-chain/blockchain/forkchoice/service_test.go

@@ -1,517 +0,0 @@
-package forkchoice
-
-import (
-	"bytes"
-	"context"
-	"reflect"
-	"testing"
-	"time"
-
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	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/stateutil"
-)
-
-func TestStore_GenesisStoreOk(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	genesisTime := time.Unix(9999, 0)
-	genesisState := &pb.BeaconState{GenesisTime: uint64(genesisTime.Unix())}
-	genesisStateRoot, err := stateutil.HashTreeRootState(genesisState)
-	if err != nil {
-		t.Fatal(err)
-	}
-	genesisBlk := blocks.NewGenesisBlock(genesisStateRoot[:])
-	genesisBlkRoot, err := ssz.HashTreeRoot(genesisBlk.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, genesisState, genesisBlkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveGenesisBlockRoot(ctx, genesisBlkRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	checkPoint := &ethpb.Checkpoint{Root: genesisBlkRoot[:]}
-	if err := store.GenesisStore(ctx, checkPoint, checkPoint); err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(store.justifiedCheckpt, checkPoint) {
-		t.Error("Justified check point from genesis store did not match")
-	}
-	if !reflect.DeepEqual(store.finalizedCheckpt, checkPoint) {
-		t.Error("Finalized check point from genesis store did not match")
-	}
-
-	cachedState, err := store.checkpointState.StateByCheckpoint(checkPoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(cachedState, genesisState) {
-		t.Error("Incorrect genesis state cached")
-	}
-}
-
-func TestStore_AncestorOk(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-	type args struct {
-		root []byte
-		slot uint64
-	}
-
-	//    /- B1
-	// B0           /- B5 - B7
-	//    \- B3 - B4 - B6 - B8
-	tests := []struct {
-		args *args
-		want []byte
-	}{
-		{args: &args{roots[1], 0}, want: roots[0]},
-		{args: &args{roots[8], 0}, want: roots[0]},
-		{args: &args{roots[8], 4}, want: roots[4]},
-		{args: &args{roots[7], 4}, want: roots[4]},
-		{args: &args{roots[7], 0}, want: roots[0]},
-	}
-	for _, tt := range tests {
-		got, err := store.ancestor(ctx, tt.args.root, tt.args.slot)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !reflect.DeepEqual(got, tt.want) {
-			t.Errorf("Store.ancestor(ctx, ) = %v, want %v", got, tt.want)
-		}
-	}
-}
-
-func TestStore_AncestorNotPartOfTheChain(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	//    /- B1
-	// B0           /- B5 - B7
-	//    \- B3 - B4 - B6 - B8
-	root, err := store.ancestor(ctx, roots[8], 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if root != nil {
-		t.Error("block at slot 1 is not part of the chain")
-	}
-	root, err = store.ancestor(ctx, roots[8], 2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if root != nil {
-		t.Error("block at slot 2 is not part of the chain")
-	}
-}
-
-func TestStore_LatestAttestingBalance(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	validators := make([]*ethpb.Validator, 100)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{ExitEpoch: 2, EffectiveBalance: 1e9}
-	}
-
-	s := &pb.BeaconState{Validators: validators}
-	stateRoot, err := stateutil.HashTreeRootState(s)
-	if err != nil {
-		t.Fatal(err)
-	}
-	b := blocks.NewGenesisBlock(stateRoot[:])
-	blkRoot, err := ssz.HashTreeRoot(b.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, s, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveGenesisBlockRoot(ctx, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	checkPoint := &ethpb.Checkpoint{Root: blkRoot[:]}
-	if err := store.GenesisStore(ctx, checkPoint, checkPoint); err != nil {
-		t.Fatal(err)
-	}
-
-	//    /- B1 (33 votes)
-	// B0           /- B5 - B7 (33 votes)
-	//    \- B3 - B4 - B6 - B8 (34 votes)
-	for i := 0; i < len(validators); i++ {
-		switch {
-		case i < 33:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[1]}
-		case i > 66:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[7]}
-		default:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[8]}
-		}
-	}
-
-	tests := []struct {
-		root []byte
-		want uint64
-	}{
-		{root: roots[0], want: 100 * 1e9},
-		{root: roots[1], want: 33 * 1e9},
-		{root: roots[3], want: 67 * 1e9},
-		{root: roots[4], want: 67 * 1e9},
-		{root: roots[7], want: 33 * 1e9},
-		{root: roots[8], want: 34 * 1e9},
-	}
-	for _, tt := range tests {
-		got, err := store.latestAttestingBalance(ctx, tt.root)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if got != tt.want {
-			t.Errorf("Store.latestAttestingBalance(ctx, ) = %v, want %v", got, tt.want)
-		}
-	}
-}
-
-func TestStore_ChildrenBlocksFromParentRoot(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	filter := filters.NewFilter().SetParentRoot(roots[0]).SetStartSlot(0)
-	children, err := store.db.BlockRoots(ctx, filter)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(children, [][32]byte{bytesutil.ToBytes32(roots[1]), bytesutil.ToBytes32(roots[3])}) {
-		t.Error("Did not receive correct children roots")
-	}
-
-	filter = filters.NewFilter().SetParentRoot(roots[0]).SetStartSlot(2)
-	children, err = store.db.BlockRoots(ctx, filter)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(children, [][32]byte{bytesutil.ToBytes32(roots[3])}) {
-		t.Error("Did not receive correct children roots")
-	}
-}
-
-func TestStore_GetHead(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	validators := make([]*ethpb.Validator, 100)
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{ExitEpoch: 2, EffectiveBalance: 1e9}
-	}
-
-	s := &pb.BeaconState{Validators: validators}
-	stateRoot, err := stateutil.HashTreeRootState(s)
-	if err != nil {
-		t.Fatal(err)
-	}
-	b := blocks.NewGenesisBlock(stateRoot[:])
-	blkRoot, err := ssz.HashTreeRoot(b.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, s, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveGenesisBlockRoot(ctx, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	checkPoint := &ethpb.Checkpoint{Root: blkRoot[:]}
-
-	if err := store.GenesisStore(ctx, checkPoint, checkPoint); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, s, bytesutil.ToBytes32(roots[0])); err != nil {
-		t.Fatal(err)
-	}
-	store.justifiedCheckpt.Root = roots[0]
-	if err := store.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: store.justifiedCheckpt,
-		State:      s,
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	//    /- B1 (33 votes)
-	// B0           /- B5 - B7 (33 votes)
-	//    \- B3 - B4 - B6 - B8 (34 votes)
-	for i := 0; i < len(validators); i++ {
-		switch {
-		case i < 33:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[1]}
-		case i > 66:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[7]}
-		default:
-			store.latestVoteMap[uint64(i)] = &pb.ValidatorLatestVote{Root: roots[8]}
-		}
-	}
-
-	// Default head is B8
-	head, err := store.Head(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(head, roots[8]) {
-		t.Error("Incorrect head")
-	}
-
-	// 1 validator switches vote to B7 to gain 34%, enough to switch head
-	store.latestVoteMap[uint64(50)] = &pb.ValidatorLatestVote{Root: roots[7]}
-
-	head, err = store.Head(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(head, roots[7]) {
-		t.Error("Incorrect head")
-	}
-
-	// 18 validators switches vote to B1 to gain 51%, enough to switch head
-	for i := 0; i < 18; i++ {
-		idx := 50 + uint64(i)
-		store.latestVoteMap[uint64(idx)] = &pb.ValidatorLatestVote{Root: roots[1]}
-	}
-	head, err = store.Head(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(head, roots[1]) {
-		t.Log(head)
-		t.Error("Incorrect head")
-	}
-}
-
-func TestCacheGenesisState_Correct(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-	config := &featureconfig.Flags{
-		InitSyncCacheState: true,
-	}
-	featureconfig.Init(config)
-
-	b := &ethpb.BeaconBlock{Slot: 1}
-	r, _ := ssz.HashTreeRoot(b)
-	s := &pb.BeaconState{GenesisTime: 99}
-
-	store.db.SaveState(ctx, s, r)
-	store.db.SaveGenesisBlockRoot(ctx, r)
-
-	if err := store.cacheGenesisState(ctx); err != nil {
-		t.Fatal(err)
-	}
-
-	for _, state := range store.initSyncState {
-		if !reflect.DeepEqual(s, state) {
-			t.Error("Did not get wanted state")
-		}
-	}
-}
-
-func TestStore_GetFilterBlockTree_CorrectLeaf(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	s := &pb.BeaconState{}
-	stateRoot, err := stateutil.HashTreeRootState(s)
-	if err != nil {
-		t.Fatal(err)
-	}
-	b := blocks.NewGenesisBlock(stateRoot[:])
-	blkRoot, err := ssz.HashTreeRoot(b.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, s, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveGenesisBlockRoot(ctx, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	checkPoint := &ethpb.Checkpoint{Root: blkRoot[:]}
-
-	if err := store.GenesisStore(ctx, checkPoint, checkPoint); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, s, bytesutil.ToBytes32(roots[0])); err != nil {
-		t.Fatal(err)
-	}
-	store.justifiedCheckpt.Root = roots[0]
-	if err := store.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: store.justifiedCheckpt,
-		State:      s,
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	tree, err := store.getFilterBlockTree(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	wanted := make(map[[32]byte]*ethpb.BeaconBlock)
-	for _, root := range roots {
-		root32 := bytesutil.ToBytes32(root)
-		b, _ := store.db.Block(ctx, root32)
-		if b != nil {
-			wanted[root32] = b.Block
-		}
-	}
-	if !reflect.DeepEqual(tree, wanted) {
-		t.Error("Did not filter tree correctly")
-	}
-}
-
-func TestStore_GetFilterBlockTree_IncorrectLeaf(t *testing.T) {
-	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-
-	store := NewForkChoiceService(ctx, db)
-
-	roots, err := blockTree1(db, []byte{'g'})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	s := &pb.BeaconState{}
-	stateRoot, err := stateutil.HashTreeRootState(s)
-	if err != nil {
-		t.Fatal(err)
-	}
-	b := blocks.NewGenesisBlock(stateRoot[:])
-	blkRoot, err := ssz.HashTreeRoot(b.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, s, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveGenesisBlockRoot(ctx, blkRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	checkPoint := &ethpb.Checkpoint{Root: blkRoot[:]}
-
-	if err := store.GenesisStore(ctx, checkPoint, checkPoint); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.db.SaveState(ctx, s, bytesutil.ToBytes32(roots[0])); err != nil {
-		t.Fatal(err)
-	}
-	store.justifiedCheckpt.Root = roots[0]
-	if err := store.checkpointState.AddCheckpointState(&cache.CheckpointState{
-		Checkpoint: store.justifiedCheckpt,
-		State:      s,
-	}); err != nil {
-		t.Fatal(err)
-	}
-	// Filter for incorrect leaves for 1, 7 and 8
-	store.db.SaveState(ctx, &pb.BeaconState{CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}, bytesutil.ToBytes32(roots[1]))
-	store.db.SaveState(ctx, &pb.BeaconState{CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}, bytesutil.ToBytes32(roots[7]))
-	store.db.SaveState(ctx, &pb.BeaconState{CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}, bytesutil.ToBytes32(roots[8]))
-	store.justifiedCheckpt.Epoch = 1
-	tree, err := store.getFilterBlockTree(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(tree) != 0 {
-		t.Error("filtered tree should be 0 length")
-	}
-
-	// Set leave 1 as correct
-	store.db.SaveState(ctx, &pb.BeaconState{CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: store.justifiedCheckpt.Root}}, bytesutil.ToBytes32(roots[1]))
-	tree, err = store.getFilterBlockTree(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	wanted := make(map[[32]byte]*ethpb.BeaconBlock)
-	root32 := bytesutil.ToBytes32(roots[0])
-	b, err = store.db.Block(ctx, root32)
-	if err != nil {
-		t.Fatal(err)
-	}
-	wanted[root32] = b.Block
-	root32 = bytesutil.ToBytes32(roots[1])
-	b, err = store.db.Block(ctx, root32)
-	if err != nil {
-		t.Fatal(err)
-	}
-	wanted[root32] = b.Block
-
-	if !reflect.DeepEqual(tree, wanted) {
-		t.Error("Did not filter tree correctly")
-	}
-}

beacon-chain/blockchain/forkchoice/tree_test.go

@@ -1,153 +0,0 @@
-package forkchoice
-
-import (
-	"context"
-
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-)
-
-// blockTree1 constructs the following tree:
-//    /- B1
-// B0           /- B5 - B7
-//    \- B3 - B4 - B6 - B8
-// (B1, and B3 are all from the same slots)
-func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
-	b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
-	r0, _ := ssz.HashTreeRoot(b0)
-	b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
-	r1, _ := ssz.HashTreeRoot(b1)
-	b3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: r0[:]}
-	r3, _ := ssz.HashTreeRoot(b3)
-	b4 := &ethpb.BeaconBlock{Slot: 4, ParentRoot: r3[:]}
-	r4, _ := ssz.HashTreeRoot(b4)
-	b5 := &ethpb.BeaconBlock{Slot: 5, ParentRoot: r4[:]}
-	r5, _ := ssz.HashTreeRoot(b5)
-	b6 := &ethpb.BeaconBlock{Slot: 6, ParentRoot: r4[:]}
-	r6, _ := ssz.HashTreeRoot(b6)
-	b7 := &ethpb.BeaconBlock{Slot: 7, ParentRoot: r5[:]}
-	r7, _ := ssz.HashTreeRoot(b7)
-	b8 := &ethpb.BeaconBlock{Slot: 8, ParentRoot: r6[:]}
-	r8, _ := ssz.HashTreeRoot(b8)
-	for _, b := range []*ethpb.BeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
-		if err := db.SaveBlock(context.Background(), &ethpb.SignedBeaconBlock{Block: b}); err != nil {
-			return nil, err
-		}
-		if err := db.SaveState(context.Background(), &pb.BeaconState{}, bytesutil.ToBytes32(b.ParentRoot)); err != nil {
-			return nil, err
-		}
-	}
-	if err := db.SaveState(context.Background(), &pb.BeaconState{}, r1); err != nil {
-		return nil, err
-	}
-	if err := db.SaveState(context.Background(), &pb.BeaconState{}, r7); err != nil {
-		return nil, err
-	}
-	if err := db.SaveState(context.Background(), &pb.BeaconState{}, r8); err != nil {
-		return nil, err
-	}
-	return [][]byte{r0[:], r1[:], nil, r3[:], r4[:], r5[:], r6[:], r7[:], r8[:]}, nil
-}
-
-// blockTree2 constructs the following tree:
-// Scenario graph: shorturl.at/loyP6
-//
-//digraph G {
-//    rankdir=LR;
-//    node [shape="none"];
-//
-//    subgraph blocks {
-//        rankdir=LR;
-//        node [shape="box"];
-//        a->b;
-//        a->c;
-//        b->d;
-//        b->e;
-//        c->f;
-//        c->g;
-//        d->h
-//        d->i
-//        d->j
-//        d->k
-//        h->l
-//        h->m
-//        g->n
-//        g->o
-//        e->p
-//    }
-//}
-func blockTree2(db db.Database) ([][]byte, error) {
-	b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: []byte{'g'}}
-	r0, _ := ssz.HashTreeRoot(b0)
-	b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
-	r1, _ := ssz.HashTreeRoot(b1)
-	b2 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r0[:]}
-	r2, _ := ssz.HashTreeRoot(b2)
-	b3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: r1[:]}
-	r3, _ := ssz.HashTreeRoot(b3)
-	b4 := &ethpb.BeaconBlock{Slot: 4, ParentRoot: r1[:]}
-	r4, _ := ssz.HashTreeRoot(b4)
-	b5 := &ethpb.BeaconBlock{Slot: 5, ParentRoot: r2[:]}
-	r5, _ := ssz.HashTreeRoot(b5)
-	b6 := &ethpb.BeaconBlock{Slot: 6, ParentRoot: r2[:]}
-	r6, _ := ssz.HashTreeRoot(b6)
-	b7 := &ethpb.BeaconBlock{Slot: 7, ParentRoot: r3[:]}
-	r7, _ := ssz.HashTreeRoot(b7)
-	b8 := &ethpb.BeaconBlock{Slot: 8, ParentRoot: r3[:]}
-	r8, _ := ssz.HashTreeRoot(b8)
-	b9 := &ethpb.BeaconBlock{Slot: 9, ParentRoot: r3[:]}
-	r9, _ := ssz.HashTreeRoot(b9)
-	b10 := &ethpb.BeaconBlock{Slot: 10, ParentRoot: r3[:]}
-	r10, _ := ssz.HashTreeRoot(b10)
-	b11 := &ethpb.BeaconBlock{Slot: 11, ParentRoot: r4[:]}
-	r11, _ := ssz.HashTreeRoot(b11)
-	b12 := &ethpb.BeaconBlock{Slot: 12, ParentRoot: r6[:]}
-	r12, _ := ssz.HashTreeRoot(b12)
-	b13 := &ethpb.BeaconBlock{Slot: 13, ParentRoot: r6[:]}
-	r13, _ := ssz.HashTreeRoot(b13)
-	b14 := &ethpb.BeaconBlock{Slot: 14, ParentRoot: r7[:]}
-	r14, _ := ssz.HashTreeRoot(b14)
-	b15 := &ethpb.BeaconBlock{Slot: 15, ParentRoot: r7[:]}
-	r15, _ := ssz.HashTreeRoot(b15)
-	for _, b := range []*ethpb.BeaconBlock{b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15} {
-		if err := db.SaveBlock(context.Background(), &ethpb.SignedBeaconBlock{Block: b}); err != nil {
-			return nil, err
-		}
-		if err := db.SaveState(context.Background(), &pb.BeaconState{}, bytesutil.ToBytes32(b.ParentRoot)); err != nil {
-			return nil, err
-		}
-	}
-	return [][]byte{r0[:], r1[:], r2[:], r3[:], r4[:], r5[:], r6[:], r7[:], r8[:], r9[:], r10[:], r11[:], r12[:], r13[:], r14[:], r15[:]}, nil
-}
-
-// blockTree3 constructs a tree that is 512 blocks in a row.
-// B0 - B1 - B2 - B3 - .... - B512
-func blockTree3(db db.Database) ([][]byte, error) {
-	blkCount := 512
-	roots := make([][]byte, 0, blkCount)
-	blks := make([]*ethpb.BeaconBlock, 0, blkCount)
-	b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: []byte{'g'}}
-	r0, _ := ssz.HashTreeRoot(b0)
-	roots = append(roots, r0[:])
-	blks = append(blks, b0)
-
-	for i := 1; i < blkCount; i++ {
-		b := &ethpb.BeaconBlock{Slot: uint64(i), ParentRoot: roots[len(roots)-1]}
-		r, _ := ssz.HashTreeRoot(b)
-		roots = append(roots, r[:])
-		blks = append(blks, b)
-	}
-
-	for _, b := range blks {
-		if err := db.SaveBlock(context.Background(), &ethpb.SignedBeaconBlock{Block: b}); err != nil {
-			return nil, err
-		}
-		if err := db.SaveState(context.Background(), &pb.BeaconState{}, bytesutil.ToBytes32(b.ParentRoot)); err != nil {
-			return nil, err
-		}
-	}
-	return roots, nil
-}

beacon-chain/blockchain/head.go

@@ -0,0 +1,316 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+)
+
+// This defines the current chain service's view of head.
+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.
+}
+
+// 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")
+	defer span.End()
+
+	// To get the proper head update, a node first checks its best justified
+	// can become justified. This is designed to prevent bounce attack and
+	// ensure head gets its best justified info.
+	if s.bestJustifiedCheckpt.Epoch > s.justifiedCheckpt.Epoch {
+		s.justifiedCheckpt = s.bestJustifiedCheckpt
+		if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+			return err
+		}
+	}
+
+	// Get head from the fork choice service.
+	f := s.finalizedCheckpt
+	j := s.justifiedCheckpt
+	// To get head before the first justified epoch, the fork choice will start with genesis root
+	// instead of zero hashes.
+	headStartRoot := bytesutil.ToBytes32(j.Root)
+	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
+	}
+
+	if err := s.updateRecentCanonicalBlocks(ctx, headRoot); err != nil {
+		return err
+	}
+
+	// Save head to the local service cache.
+	return s.saveHead(ctx, headRoot)
+}
+
+// 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")
+	defer span.End()
+
+	// Do nothing if head hasn't changed.
+	if headRoot == s.headRoot() {
+		return nil
+	}
+
+	// If the head state is not available, just return nil.
+	// There's nothing to cache
+	if !s.stateGen.StateSummaryExists(ctx, headRoot) {
+		return nil
+	}
+
+	// Get the new head block from DB.
+	newHeadBlock, err := s.beaconDB.Block(ctx, headRoot)
+	if err != nil {
+		return err
+	}
+	if newHeadBlock == nil || newHeadBlock.Block == nil {
+		return errors.New("cannot save nil head block")
+	}
+
+	// Get the new head state from cached state or 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() {
+		log.WithFields(logrus.Fields{
+			"newSlot": fmt.Sprintf("%d", newHeadBlock.Block.Slot),
+			"oldSlot": fmt.Sprintf("%d", s.headSlot()),
+		}).Debug("Chain reorg occurred")
+		s.stateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.Reorg,
+			Data: &statefeed.ReorgData{
+				NewSlot: newHeadBlock.Block.Slot,
+				OldSlot: s.headSlot(),
+			},
+		})
+
+		reorgCount.Inc()
+	}
+
+	// Cache the new head info.
+	s.setHead(headRoot, newHeadBlock, newHeadState)
+
+	// Save the new head root to DB.
+	if err := s.beaconDB.SaveHeadBlockRoot(ctx, headRoot); err != nil {
+		return errors.Wrap(err, "could not save head root in DB")
+	}
+
+	return nil
+}
+
+// This gets called to update canonical root mapping. It does not save head block
+// root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
+// check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
+func (s *Service) saveHeadNoDB(ctx context.Context, b *ethpb.SignedBeaconBlock, r [32]byte, hs *state.BeaconState) error {
+	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")
+	}
+
+	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) {
+	s.headLock.Lock()
+	defer s.headLock.Unlock()
+
+	// This does a full copy of the block and state.
+	s.head = &head{
+		slot:  block.Block.Slot,
+		root:  root,
+		block: stateTrie.CopySignedBeaconBlock(block),
+		state: state.Copy(),
+	}
+}
+
+// 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) {
+	s.headLock.Lock()
+	defer s.headLock.Unlock()
+
+	// This does a full copy of the block only.
+	s.head = &head{
+		slot:  block.Block.Slot,
+		root:  root,
+		block: stateTrie.CopySignedBeaconBlock(block),
+		state: state,
+	}
+}
+
+// This returns the head slot.
+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.
+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.
+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(ctx context.Context) *stateTrie.BeaconState {
+	ctx, span := trace.StartSpan(ctx, "blockChain.headState")
+	defer span.End()
+
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
+	return s.head.state.Copy()
+}
+
+// This returns the genesis validator root of the head state.
+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 {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
+	return s.head != nil && s.head.state != nil
+}
+
+// This updates recent canonical block mapping. It uses input head root and retrieves
+// all the canonical block roots that are ancestor of the input head block root.
+func (s *Service) updateRecentCanonicalBlocks(ctx context.Context, headRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.updateRecentCanonicalBlocks")
+	defer span.End()
+
+	s.recentCanonicalBlocksLock.Lock()
+	defer s.recentCanonicalBlocksLock.Unlock()
+
+	s.recentCanonicalBlocks = make(map[[32]byte]bool)
+	s.recentCanonicalBlocks[headRoot] = true
+	nodes := s.forkChoiceStore.Nodes()
+	node := s.forkChoiceStore.Node(headRoot)
+	if node == nil {
+		return nil
+	}
+
+	for node.Parent() != protoarray.NonExistentNode {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		node = nodes[node.Parent()]
+		s.recentCanonicalBlocks[node.Root()] = true
+	}
+
+	return nil
+}
+
+// This caches justified state balances to be used for fork choice.
+func (s *Service) cacheJustifiedStateBalances(ctx context.Context, justifiedRoot [32]byte) error {
+	if err := s.beaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+		return err
+	}
+
+	s.clearInitSyncBlocks()
+
+	var justifiedState *stateTrie.BeaconState
+	var err error
+	if justifiedRoot == s.genesisRoot {
+		justifiedState, err = s.beaconDB.GenesisState(ctx)
+		if err != nil {
+			return err
+		}
+	} else {
+		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)
+
+	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[idx] = 0
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	s.justifiedBalancesLock.Lock()
+	defer s.justifiedBalancesLock.Unlock()
+	s.justifiedBalances = justifiedBalances
+	return nil
+}
+
+func (s *Service) getJustifiedBalances() []uint64 {
+	s.justifiedBalancesLock.RLock()
+	defer s.justifiedBalancesLock.RUnlock()
+	return s.justifiedBalances
+}

beacon-chain/blockchain/head_test.go

@@ -0,0 +1,141 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+	"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, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
+
+	r := [32]byte{'A'}
+	service.head = &head{slot: 0, root: r}
+
+	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) {
+	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}
+
+	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
+	newRoot, err := stateutil.BlockRoot(newHeadBlock)
+	require.NoError(t, err)
+	headState := testutil.NewBeaconState()
+	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))
+
+	assert.Equal(t, uint64(1), service.HeadSlot(), "Head did not change")
+
+	cachedRoot, err := service.HeadRoot(context.Background())
+	require.NoError(t, err)
+	if !bytes.Equal(cachedRoot, newRoot[:]) {
+		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, 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}
+
+	require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
+	newRoot, err := stateutil.BlockRoot(newHeadBlock)
+	require.NoError(t, err)
+	headState := testutil.NewBeaconState()
+	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))
+
+	assert.Equal(t, uint64(1), service.HeadSlot(), "Head did not change")
+
+	cachedRoot, err := service.HeadRoot(context.Background())
+	require.NoError(t, err)
+	if !bytes.Equal(cachedRoot, newRoot[:]) {
+		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")
+	require.LogsContain(t, hook, "Chain reorg occurred")
+}
+
+func TestUpdateRecentCanonicalBlocks_CanUpdateWithoutParent(t *testing.T) {
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
+
+	r := [32]byte{'a'}
+	require.NoError(t, service.updateRecentCanonicalBlocks(context.Background(), r))
+	canonical, err := service.IsCanonical(context.Background(), r)
+	require.NoError(t, err)
+	assert.Equal(t, true, canonical, "Block should be canonical")
+}
+
+func TestUpdateRecentCanonicalBlocks_CanUpdateWithParent(t *testing.T) {
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
+	oldHead := [32]byte{'a'}
+	require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), 1, oldHead, [32]byte{'g'}, [32]byte{}, 0, 0))
+	currentHead := [32]byte{'b'}
+	require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), 3, currentHead, oldHead, [32]byte{}, 0, 0))
+	forkedRoot := [32]byte{'c'}
+	require.NoError(t, service.forkChoiceStore.ProcessBlock(context.Background(), 2, forkedRoot, oldHead, [32]byte{}, 0, 0))
+
+	require.NoError(t, service.updateRecentCanonicalBlocks(context.Background(), currentHead))
+	canonical, err := service.IsCanonical(context.Background(), currentHead)
+	require.NoError(t, err)
+	assert.Equal(t, true, canonical, "Block should be canonical")
+	canonical, err = service.IsCanonical(context.Background(), oldHead)
+	require.NoError(t, err)
+	assert.Equal(t, true, canonical, "Block should be canonical")
+	canonical, err = service.IsCanonical(context.Background(), forkedRoot)
+	require.NoError(t, err)
+	assert.Equal(t, false, canonical, "Block should not be canonical")
+}
+
+func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
+	db, sc := testDB.SetupDB(t)
+	service := setupBeaconChain(t, db, sc)
+
+	state, _ := testutil.DeterministicGenesisState(t, 100)
+	r := [32]byte{'a'}
+	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")
+}

beacon-chain/blockchain/info.go

@@ -1,57 +1,94 @@
 package blockchain
 
 import (
-	"bytes"
 	"encoding/hex"
 	"fmt"
 	"net/http"
-	"sort"
 
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/sirupsen/logrus"
+	"github.com/emicklei/dot"
+	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
-const latestSlotCount = 10
+const template = `<html>
+<head>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/viz.js/2.1.2/viz.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/viz.js/2.1.2/full.render.js"></script>
+<body>
+    <script type="application/javascript">
+        var graph = ` + "`%s`;" + `
+        var viz = new Viz();
+        viz.renderSVGElement(graph) // reading the graph.
+            .then(function(element) {
+                document.body.appendChild(element); // appends to document.
+            })
+            .catch(error => {
+                // Create a new Viz instance (@see Caveats page for more info)
+                viz = new Viz();
+                // Possibly display the error
+                console.error(error);
+            });
+    </script>
+</head>
+</body>
+</html>`
 
-// HeadsHandler is a handler to serve /heads page in metrics.
-func (s *Service) HeadsHandler(w http.ResponseWriter, _ *http.Request) {
-	buf := new(bytes.Buffer)
-
-	if _, err := fmt.Fprintf(w, "\n %s\t%s\t", "Head slot", "Head root"); err != nil {
-		logrus.WithError(err).Error("Failed to render chain heads page")
-		return
+// TreeHandler is a handler to serve /tree page in metrics.
+func (s *Service) TreeHandler(w http.ResponseWriter, r *http.Request) {
+	if s.headState(r.Context()) == nil {
+		if _, err := w.Write([]byte("Unavailable during initial syncing")); err != nil {
+			log.WithError(err).Error("Failed to render p2p info page")
+		}
 	}
 
-	if _, err := fmt.Fprintf(w, "\n %s\t%s\t", "---------", "---------"); err != nil {
-		logrus.WithError(err).Error("Failed to render chain heads page")
-		return
+	nodes := s.forkChoiceStore.Nodes()
+
+	graph := dot.NewGraph(dot.Directed)
+	graph.Attr("rankdir", "RL")
+	graph.Attr("labeljust", "l")
+
+	dotNodes := make([]*dot.Node, len(nodes))
+	avgBalance := uint64(averageBalance(s.headState(r.Context()).Balances()))
+
+	for i := len(nodes) - 1; i >= 0; i-- {
+		// Construct label for each node.
+		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) {
+			dotN = graph.Node(index).Box().Attr("label", label)
+		}
+
+		if nodes[i].Slot() == s.headSlot() &&
+			nodes[i].BestDescendant() == ^uint64(0) &&
+			nodes[i].Parent() != ^uint64(0) {
+			dotN = dotN.Attr("color", "green")
+		}
+
+		dotNodes[i] = &dotN
 	}
 
-	slots := s.latestHeadSlots()
-	for _, slot := range slots {
-		r := hex.EncodeToString(bytesutil.Trunc(s.canonicalRoots[uint64(slot)]))
-		if _, err := fmt.Fprintf(w, "\n %d\t\t%s\t", slot, r); err != nil {
-			logrus.WithError(err).Error("Failed to render chain heads page")
-			return
+	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()])
 		}
 	}
 
 	w.WriteHeader(http.StatusOK)
-	if _, err := w.Write(buf.Bytes()); err != nil {
-		log.WithError(err).Error("Failed to render chain heads page")
+	w.Header().Set("Content-Type", "text/html")
+	if _, err := fmt.Fprintf(w, template, graph.String()); err != nil {
+		log.WithError(err).Error("Failed to render p2p info page")
 	}
-
 }
 
-// This returns the latest head slots in a slice and up to latestSlotCount
-func (s *Service) latestHeadSlots() []int {
-	slots := make([]int, 0, len(s.canonicalRoots))
-	for k := range s.canonicalRoots {
-		slots = append(slots, int(k))
+func averageBalance(balances []uint64) float64 {
+	total := uint64(0)
+	for i := 0; i < len(balances); i++ {
+		total += balances[i]
 	}
-	sort.Ints(slots)
-	if (len(slots)) > latestSlotCount {
-		return slots[len(slots)-latestSlotCount:]
-	}
-	return slots
+	return float64(total) / float64(len(balances)) / float64(params.BeaconConfig().GweiPerEth)
 }

beacon-chain/blockchain/info_test.go

@@ -0,0 +1,46 @@
+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, 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

@@ -0,0 +1,50 @@
+package blockchain
+
+import (
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+)
+
+// This saves a beacon block to the initial sync blocks cache.
+func (s *Service) saveInitSyncBlock(r [32]byte, b *ethpb.SignedBeaconBlock) {
+	s.initSyncBlocksLock.Lock()
+	defer s.initSyncBlocksLock.Unlock()
+	s.initSyncBlocks[r] = b
+}
+
+// This checks if a beacon block exists in the initial sync blocks cache using the root
+// of the block.
+func (s *Service) hasInitSyncBlock(r [32]byte) bool {
+	s.initSyncBlocksLock.RLock()
+	defer s.initSyncBlocksLock.RUnlock()
+	_, ok := s.initSyncBlocks[r]
+	return ok
+}
+
+// This retrieves a beacon block from the initial sync blocks cache using the root of
+// the block.
+func (s *Service) getInitSyncBlock(r [32]byte) *ethpb.SignedBeaconBlock {
+	s.initSyncBlocksLock.RLock()
+	defer s.initSyncBlocksLock.RUnlock()
+	b := s.initSyncBlocks[r]
+	return b
+}
+
+// This retrieves all the beacon blocks from the initial sync blocks cache, the returned
+// blocks are unordered.
+func (s *Service) getInitSyncBlocks() []*ethpb.SignedBeaconBlock {
+	s.initSyncBlocksLock.RLock()
+	defer s.initSyncBlocksLock.RUnlock()
+
+	blks := make([]*ethpb.SignedBeaconBlock, 0, len(s.initSyncBlocks))
+	for _, b := range s.initSyncBlocks {
+		blks = append(blks, b)
+	}
+	return blks
+}
+
+// This clears out the initial sync blocks cache.
+func (s *Service) clearInitSyncBlocks() {
+	s.initSyncBlocksLock.Lock()
+	defer s.initSyncBlocksLock.Unlock()
+	s.initSyncBlocks = make(map[[32]byte]*ethpb.SignedBeaconBlock)
+}

beacon-chain/blockchain/log.go

@@ -1,17 +1,33 @@
 package blockchain
 
 import (
+	"encoding/hex"
+	"fmt"
+
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/sirupsen/logrus"
 )
 
 var log = logrus.WithField("prefix", "blockchain")
 
 // logs state transition related data every slot.
-func logStateTransitionData(b *ethpb.BeaconBlock, r []byte) {
+func logStateTransitionData(b *ethpb.BeaconBlock) {
 	log.WithFields(logrus.Fields{
-		"slot":         b.Slot,
-		"attestations": len(b.Body.Attestations),
-		"deposits":     len(b.Body.Deposits),
+		"attestations":      len(b.Body.Attestations),
+		"deposits":          len(b.Body.Deposits),
+		"attesterSlashings": len(b.Body.AttesterSlashings),
+		"proposerSlashings": len(b.Body.ProposerSlashings),
+		"voluntaryExits":    len(b.Body.VoluntaryExits),
 	}).Info("Finished applying state transition")
 }
+
+func logBlockSyncStatus(block *ethpb.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint) {
+	log.WithFields(logrus.Fields{
+		"slot":           block.Slot,
+		"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]),
+	}).Info("Synced new block")
+}

beacon-chain/blockchain/metrics.go

@@ -1,9 +1,17 @@
 package blockchain
 
 import (
+	"time"
+
 	"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 (
@@ -15,38 +23,11 @@ var (
 		Name: "beacon_head_slot",
 		Help: "Slot of the head block of the beacon chain",
 	})
-	beaconHeadRoot = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_head_root",
-		Help: "Root of the head block of the beacon chain, it returns the lowest 8 bytes interpreted as little endian",
-	})
-	competingAtts = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "competing_attestations",
-		Help: "The # of attestations received and processed from a competing chain",
-	})
-	competingBlks = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "competing_blocks",
-		Help: "The # of blocks received and processed from a competing chain",
-	})
-	processedBlkNoPubsub = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "processed_no_pubsub_block_counter",
-		Help: "The # of processed block without pubsub, this usually means the blocks from sync",
-	})
-	processedBlkNoPubsubForkchoice = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "processed_no_pubsub_forkchoice_block_counter",
-		Help: "The # of processed block without pubsub and forkchoice, this means indicate blocks from initial sync",
-	})
-	processedBlk = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "processed_block_counter",
-		Help: "The # of total processed in block chain service, with fork choice and pubsub",
-	})
-	processedAttNoPubsub = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "processed_no_pubsub_attestation_counter",
-		Help: "The # of processed attestation without pubsub, this usually means the attestations from sync",
-	})
-	processedAtt = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "processed_attestation_counter",
-		Help: "The # of processed attestation with pubsub and fork choice, this ususally means attestations from rpc",
+	clockTimeSlot = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_clock_time_slot",
+		Help: "The current slot based on the genesis time and current clock",
 	})
+
 	headFinalizedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
 		Name: "head_finalized_epoch",
 		Help: "Last finalized epoch of the head state",
@@ -55,14 +36,188 @@ var (
 		Name: "head_finalized_root",
 		Help: "Last finalized root of the head state",
 	})
+	beaconFinalizedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_finalized_epoch",
+		Help: "Last finalized epoch of the processed state",
+	})
+	beaconFinalizedRoot = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_finalized_root",
+		Help: "Last finalized root of the processed state",
+	})
+	beaconCurrentJustifiedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_current_justified_epoch",
+		Help: "Current justified epoch of the processed state",
+	})
+	beaconCurrentJustifiedRoot = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_current_justified_root",
+		Help: "Current justified root of the processed state",
+	})
+	beaconPrevJustifiedEpoch = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_previous_justified_epoch",
+		Help: "Previous justified epoch of the processed state",
+	})
+	beaconPrevJustifiedRoot = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "beacon_previous_justified_root",
+		Help: "Previous justified root of the processed state",
+	})
+	validatorsCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "validator_count",
+		Help: "The total number of validators",
+	}, []string{"state"})
+	validatorsBalance = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "validators_total_balance",
+		Help: "The total balance of validators, in GWei",
+	}, []string{"state"})
+	validatorsEffectiveBalance = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "validators_total_effective_balance",
+		Help: "The total effective balance of validators, in GWei",
+	}, []string{"state"})
+	currentEth1DataDepositCount = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "current_eth1_data_deposit_count",
+		Help: "The current eth1 deposit count in the last processed state eth1data field.",
+	})
+	totalEligibleBalances = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "total_eligible_balances",
+		Help: "The total amount of ether, in gwei, that is eligible for voting of previous epoch",
+	})
+	totalVotedTargetBalances = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "total_voted_target_balances",
+		Help: "The total amount of ether, in gwei, that has been used in voting attestation target 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",
+			Help:    "The number of slots between att.Slot and block.Slot",
+			Buckets: []float64{1, 2, 3, 4, 6, 32, 64},
+		},
+	)
 )
 
-func (s *Service) reportSlotMetrics(currentSlot uint64) {
-	beaconSlot.Set(float64(currentSlot))
-	beaconHeadSlot.Set(float64(s.HeadSlot()))
-	beaconHeadRoot.Set(float64(bytesutil.ToLowInt64(s.HeadRoot())))
-	if s.headState != nil {
-		headFinalizedEpoch.Set(float64(s.headState.FinalizedCheckpoint.Epoch))
-		headFinalizedRoot.Set(float64(bytesutil.ToLowInt64(s.headState.FinalizedCheckpoint.Root)))
+// reportSlotMetrics reports slot related metrics.
+func reportSlotMetrics(stateSlot uint64, headSlot uint64, clockSlot uint64, finalizedCheckpoint *ethpb.Checkpoint) {
+	clockTimeSlot.Set(float64(clockSlot))
+	beaconSlot.Set(float64(stateSlot))
+	beaconHeadSlot.Set(float64(headSlot))
+	if finalizedCheckpoint != nil {
+		headFinalizedEpoch.Set(float64(finalizedCheckpoint.Epoch))
+		headFinalizedRoot.Set(float64(bytesutil.ToLowInt64(finalizedCheckpoint.Root)))
+	}
+}
+
+// reportEpochMetrics reports epoch related metrics.
+func reportEpochMetrics(state *stateTrie.BeaconState) {
+	currentEpoch := state.Slot() / params.BeaconConfig().SlotsPerEpoch
+
+	// Validator instances
+	pendingInstances := 0
+	activeInstances := 0
+	slashingInstances := 0
+	slashedInstances := 0
+	exitingInstances := 0
+	exitedInstances := 0
+	// Validator balances
+	pendingBalance := uint64(0)
+	activeBalance := uint64(0)
+	activeEffectiveBalance := uint64(0)
+	exitingBalance := uint64(0)
+	exitingEffectiveBalance := uint64(0)
+	slashingBalance := uint64(0)
+	slashingEffectiveBalance := uint64(0)
+
+	for i, validator := range state.Validators() {
+		bal, err := state.BalanceAtIndex(uint64(i))
+		if err != nil {
+			log.Errorf("Could not load validator balance: %v", err)
+			continue
+		}
+		if validator.Slashed {
+			if currentEpoch < validator.ExitEpoch {
+				slashingInstances++
+				slashingBalance += bal
+				slashingEffectiveBalance += validator.EffectiveBalance
+			} else {
+				slashedInstances++
+			}
+			continue
+		}
+		if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+			if currentEpoch < validator.ExitEpoch {
+				exitingInstances++
+				exitingBalance += bal
+				exitingEffectiveBalance += validator.EffectiveBalance
+			} else {
+				exitedInstances++
+			}
+			continue
+		}
+		if currentEpoch < validator.ActivationEpoch {
+			pendingInstances++
+			pendingBalance += bal
+			continue
+		}
+		activeInstances++
+		activeBalance += bal
+		activeEffectiveBalance += validator.EffectiveBalance
+	}
+	validatorsCount.WithLabelValues("Pending").Set(float64(pendingInstances))
+	validatorsCount.WithLabelValues("Active").Set(float64(activeInstances))
+	validatorsCount.WithLabelValues("Exiting").Set(float64(exitingInstances))
+	validatorsCount.WithLabelValues("Exited").Set(float64(exitedInstances))
+	validatorsCount.WithLabelValues("Slashing").Set(float64(slashingInstances))
+	validatorsCount.WithLabelValues("Slashed").Set(float64(slashedInstances))
+	validatorsBalance.WithLabelValues("Pending").Set(float64(pendingBalance))
+	validatorsBalance.WithLabelValues("Active").Set(float64(activeBalance))
+	validatorsBalance.WithLabelValues("Exiting").Set(float64(exitingBalance))
+	validatorsBalance.WithLabelValues("Slashing").Set(float64(slashingBalance))
+	validatorsEffectiveBalance.WithLabelValues("Active").Set(float64(activeEffectiveBalance))
+	validatorsEffectiveBalance.WithLabelValues("Exiting").Set(float64(exitingEffectiveBalance))
+	validatorsEffectiveBalance.WithLabelValues("Slashing").Set(float64(slashingEffectiveBalance))
+
+	// Last justified slot
+	beaconCurrentJustifiedEpoch.Set(float64(state.CurrentJustifiedCheckpoint().Epoch))
+	beaconCurrentJustifiedRoot.Set(float64(bytesutil.ToLowInt64(state.CurrentJustifiedCheckpoint().Root)))
+
+	// Last previous justified slot
+	beaconPrevJustifiedEpoch.Set(float64(state.PreviousJustifiedCheckpoint().Epoch))
+	beaconPrevJustifiedRoot.Set(float64(bytesutil.ToLowInt64(state.PreviousJustifiedCheckpoint().Root)))
+
+	// Last finalized slot
+	beaconFinalizedEpoch.Set(float64(state.FinalizedCheckpointEpoch()))
+	beaconFinalizedRoot.Set(float64(bytesutil.ToLowInt64(state.FinalizedCheckpoint().Root)))
+
+	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)
+	if err != nil {
+		return err
+	}
+	diffMs := roughtime.Now().Sub(startTime) / time.Millisecond
+	sentBlockPropagationHistogram.Observe(float64(diffMs))
+
+	return nil
+}
+
+func reportAttestationInclusion(blk *ethpb.BeaconBlock) {
+	for _, att := range blk.Body.Attestations {
+		attestationInclusionDelay.Observe(float64(blk.Slot - att.Data.Slot))
 	}
 }

beacon-chain/blockchain/process_attestation.go

@@ -0,0 +1,112 @@
+package blockchain
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/roughtime"
+	"go.opencensus.io/trace"
+)
+
+// ErrTargetRootNotInDB returns when the target block root of an attestation cannot be found in the
+// beacon database.
+var ErrTargetRootNotInDB = errors.New("target root does not exist in db")
+
+// onAttestation is called whenever an attestation is received, verifies the attestation is valid and saves
+// it to the DB. As a stateless function, this does not hold nor delay attestation based on the spec descriptions.
+// The delay is handled by the caller in `processAttestation`.
+//
+// Spec pseudocode definition:
+//   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.
+//    """
+//    validate_on_attestation(store, attestation)
+//    store_target_checkpoint_state(store, attestation.data.target)
+//
+//    # 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 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")
+	defer span.End()
+
+	if a == nil {
+		return nil, errors.New("nil attestation")
+	}
+	if a.Data == nil {
+		return nil, errors.New("nil attestation.Data field")
+	}
+	if a.Data.Target == nil {
+		return nil, errors.New("nil attestation.Data.Target field")
+	}
+
+	tgt := stateTrie.CopyCheckpoint(a.Data.Target)
+
+	if helpers.SlotToEpoch(a.Data.Slot) != a.Data.Target.Epoch {
+		return nil, fmt.Errorf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(a.Data.Slot), a.Data.Target.Epoch)
+	}
+
+	// Verify beacon node has seen the target block before.
+	if !s.hasBlock(ctx, bytesutil.ToBytes32(tgt.Root)) {
+		return nil, ErrTargetRootNotInDB
+	}
+
+	// Retrieve attestation's data beacon block pre state. Advance pre state to latest epoch if necessary and
+	// save it to the cache.
+	baseState, err := s.getAttPreState(ctx, tgt)
+	if err != nil {
+		return nil, err
+	}
+
+	genesisTime := helpers.GenesisTime(baseState)
+
+	// Verify attestation target is from current epoch or previous epoch.
+	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(roughtime.Now().Unix()), tgt); err != nil {
+		return nil, err
+	}
+
+	// Verify attestation beacon block is known and not from the future.
+	if err := s.verifyBeaconBlock(ctx, a.Data); err != nil {
+		return nil, errors.Wrap(err, "could not verify attestation beacon block")
+	}
+
+	// Verify LMG GHOST and FFG votes are consistent with each other.
+	if err := s.verifyLMDFFGConsistent(ctx, a.Data.Target.Epoch, a.Data.Target.Root, a.Data.BeaconBlockRoot); err != nil {
+		return nil, errors.Wrap(err, "could not verify attestation beacon block")
+	}
+
+	// Verify attestations can only affect the fork choice of subsequent slots.
+	if err := helpers.VerifySlotTime(genesisTime, a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+		return nil, err
+	}
+
+	// Use the target state to validate attestation and calculate the committees.
+	indexedAtt, err := s.verifyAttestation(ctx, baseState, a)
+	if err != nil {
+		return nil, err
+	}
+
+	if indexedAtt.AttestingIndices == nil {
+		return nil, errors.New("nil attesting indices")
+	}
+
+	// Update forkchoice store with the new attestation for updating weight.
+	s.forkChoiceStore.ProcessAttestation(ctx, indexedAtt.AttestingIndices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
+
+	return indexedAtt.AttestingIndices, nil
+}

beacon-chain/blockchain/process_attestation_helpers.go

@@ -0,0 +1,117 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+	"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"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// getAttPreState retrieves the att pre state by either from the cache or the DB.
+func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (*stateTrie.BeaconState, error) {
+	s.checkpointStateLock.Lock()
+	defer s.checkpointStateLock.Unlock()
+	cachedState, err := s.checkpointState.StateByCheckpoint(c)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get cached checkpoint state")
+	}
+	if cachedState != nil {
+		return cachedState, nil
+	}
+
+	baseState, err := s.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(c.Root))
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not get pre state for slot %d", helpers.StartSlot(c.Epoch))
+	}
+
+	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 {
+		return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
+	}
+
+	return baseState, nil
+
+}
+
+// verifyAttTargetEpoch validates attestation is from the current or previous epoch.
+func (s *Service) verifyAttTargetEpoch(ctx context.Context, genesisTime uint64, nowTime uint64, c *ethpb.Checkpoint) error {
+	currentSlot := (nowTime - genesisTime) / params.BeaconConfig().SecondsPerSlot
+	currentEpoch := helpers.SlotToEpoch(currentSlot)
+	var prevEpoch uint64
+	// Prevents previous epoch under flow
+	if currentEpoch > 1 {
+		prevEpoch = currentEpoch - 1
+	}
+	if c.Epoch != prevEpoch && c.Epoch != currentEpoch {
+		return fmt.Errorf("target epoch %d does not match current epoch %d or prev epoch %d", c.Epoch, currentEpoch, prevEpoch)
+	}
+	return nil
+}
+
+// verifyBeaconBlock verifies beacon head block is known and not from the future.
+func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.AttestationData) error {
+	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))
+	}
+	if b.Block.Slot > data.Slot {
+		return fmt.Errorf("could not process attestation for future block, block.Slot=%d > attestation.Data.Slot=%d", b.Block.Slot, data.Slot)
+	}
+	return nil
+}
+
+// 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)
+	r, err := s.ancestor(ctx, lmdRoot, ffgSlot)
+	if err != nil {
+		return err
+	}
+	if !bytes.Equal(ffgRoot, r) {
+		return errors.New("FFG and LMD votes are not consistent")
+	}
+
+	return nil
+}
+
+// verifyAttestation validates input attestation is valid.
+func (s *Service) verifyAttestation(ctx context.Context, baseState *stateTrie.BeaconState, a *ethpb.Attestation) (*ethpb.IndexedAttestation, error) {
+	committee, err := helpers.BeaconCommitteeFromState(baseState, a.Data.Slot, a.Data.CommitteeIndex)
+	if err != nil {
+		return nil, err
+	}
+	indexedAtt := attestationutil.ConvertToIndexed(ctx, a, committee)
+	if err := blocks.VerifyIndexedAttestation(ctx, baseState, indexedAtt); err != nil {
+		return nil, errors.Wrap(err, "could not verify indexed attestation")
+	}
+	return indexedAtt, nil
+}

beacon-chain/blockchain/process_attestation_test.go

@@ -0,0 +1,397 @@
+package blockchain
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/gogo/protobuf/proto"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	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"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestStore_OnAttestation(t *testing.T) {
+	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 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 0}}
+	require.NoError(t, db.SaveBlock(ctx, BlkWithOutState))
+	BlkWithOutStateRoot, err := stateutil.BlockRoot(BlkWithOutState.Block)
+	require.NoError(t, err)
+
+	BlkWithStateBadAtt := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
+	require.NoError(t, db.SaveBlock(ctx, BlkWithStateBadAtt))
+	BlkWithStateBadAttRoot, err := stateutil.BlockRoot(BlkWithStateBadAtt.Block)
+	require.NoError(t, err)
+
+	s := testutil.NewBeaconState()
+	require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
+	require.NoError(t, service.beaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
+
+	BlkWithValidState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
+	require.NoError(t, db.SaveBlock(ctx, BlkWithValidState))
+
+	BlkWithValidStateRoot, err := stateutil.BlockRoot(BlkWithValidState.Block)
+	require.NoError(t, err)
+	s = testutil.NewBeaconState()
+	if err := s.SetFork(&pb.Fork{
+		Epoch:           0,
+		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+	}); err != nil {
+		t.Fatal(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:          "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 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:          "no pre state for attestations's target block",
+			a:             &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}},
+			s:             &pb.BeaconState{},
+			wantErr:       true,
+			wantErrString: "could not get pre state for slot 0",
+		},
+		{
+			name: "process attestation doesn't match current epoch",
+			a: &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
+				Root: BlkWithStateBadAttRoot[:]}}},
+			s:             &pb.BeaconState{Slot: 100 * params.BeaconConfig().SlotsPerEpoch},
+			wantErr:       true,
+			wantErrString: "target epoch 100 does not match current epoch",
+		},
+		{
+			name:          "process nil field (a.Target) in attestation",
+			a:             nil,
+			s:             &pb.BeaconState{},
+			wantErr:       true,
+			wantErrString: "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.Target) in attestation",
+			a:             &ethpb.Attestation{Data: &ethpb.AttestationData{}},
+			s:             &pb.BeaconState{},
+			wantErr:       true,
+			wantErrString: "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)
+				}
+			} else {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestStore_SaveCheckpointState(t *testing.T) {
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB: db,
+		StateGen: stategen.New(db, sc),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	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},
+	})
+	require.NoError(t, err)
+	r := [32]byte{'g'}
+	require.NoError(t, service.beaconDB.SaveState(ctx, s, r))
+
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+
+	r = bytesutil.ToBytes32([]byte{'A'})
+	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
+	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)
+	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)}
+	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)
+	require.NoError(t, err)
+	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
+
+	s1, err = service.getAttPreState(ctx, cp1)
+	require.NoError(t, err)
+	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
+
+	s1, err = service.checkpointState.StateByCheckpoint(cp1)
+	require.NoError(t, err)
+	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
+
+	s2, err = service.checkpointState.StateByCheckpoint(cp2)
+	require.NoError(t, err)
+	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
+
+	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)}
+	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)
+	require.NoError(t, err)
+	assert.Equal(t, s.Slot(), s3.Slot(), "Unexpected state slot")
+}
+
+func TestStore_UpdateCheckpointState(t *testing.T) {
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB: db,
+		StateGen: stategen.New(db, sc),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	epoch := uint64(1)
+	baseState, _ := testutil.DeterministicGenesisState(t, 1)
+	require.NoError(t, baseState.SetSlot(epoch*params.BeaconConfig().SlotsPerEpoch))
+	checkpoint := &ethpb.Checkpoint{Epoch: epoch}
+	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
+	returned, err := service.getAttPreState(ctx, checkpoint)
+	require.NoError(t, err)
+	assert.Equal(t, returned.Slot(), baseState.Slot(), "Incorrectly returned base state")
+
+	cached, err := service.checkpointState.StateByCheckpoint(checkpoint)
+	require.NoError(t, err)
+	assert.NotNil(t, cached, "State should have been cached")
+
+	epoch = uint64(2)
+	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch}
+	require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
+	returned, err = service.getAttPreState(ctx, newCheckpoint)
+	require.NoError(t, err)
+	baseState, err = state.ProcessSlots(ctx, baseState, helpers.StartSlot(newCheckpoint.Epoch))
+	require.NoError(t, err)
+	assert.Equal(t, returned.Slot(), baseState.Slot(), "Incorrectly returned base state")
+
+	cached, err = service.checkpointState.StateByCheckpoint(newCheckpoint)
+	require.NoError(t, err)
+	if !proto.Equal(returned.InnerStateUnsafe(), cached.InnerStateUnsafe()) {
+		t.Error("Incorrectly cached base state")
+	}
+}
+
+func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	if err := service.verifyAttTargetEpoch(
+		ctx,
+		0,
+		params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
+		&ethpb.Checkpoint{}); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	if err := service.verifyAttTargetEpoch(
+		ctx,
+		0,
+		params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
+		&ethpb.Checkpoint{Epoch: 1}); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestAttEpoch_NotMatch(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	if err := service.verifyAttTargetEpoch(
+		ctx,
+		0,
+		2*params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
+		&ethpb.Checkpoint{}); !strings.Contains(err.Error(),
+		"target epoch 0 does not match current epoch 2 or prev epoch 1") {
+		t.Error("Did not receive wanted error")
+	}
+}
+
+func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	d := &ethpb.AttestationData{}
+	assert.ErrorContains(t, "beacon block  does not exist", service.verifyBeaconBlock(ctx, d))
+}
+
+func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
+	r, err := stateutil.BlockRoot(b.Block)
+	require.NoError(t, err)
+	d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
+
+	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)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
+	r, err := stateutil.BlockRoot(b.Block)
+	require.NoError(t, err)
+	d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
+
+	assert.NoError(t, service.verifyBeaconBlock(ctx, d), "Did not receive the wanted error")
+}
+
+func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
+	r32, err := stateutil.BlockRoot(b32.Block)
+	require.NoError(t, err)
+	b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
+	r33, err := stateutil.BlockRoot(b33.Block)
+	require.NoError(t, err)
+
+	wanted := "FFG and LMD votes are not consistent"
+	assert.ErrorContains(t, wanted, service.verifyLMDFFGConsistent(context.Background(), 1, []byte{'a'}, r33[:]))
+}
+
+func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
+	r32, err := stateutil.BlockRoot(b32.Block)
+	require.NoError(t, err)
+	b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
+	r33, err := stateutil.BlockRoot(b33.Block)
+	require.NoError(t, err)
+
+	err = service.verifyLMDFFGConsistent(context.Background(), 1, r32[:], r33[:])
+	assert.NoError(t, err, "Could not verify LMD and FFG votes to be consistent")
+}

beacon-chain/blockchain/process_block.go

@@ -0,0 +1,385 @@
+package blockchain
+
+import (
+	"context"
+	"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"
+	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"
+	"go.opencensus.io/trace"
+)
+
+// This defines size of the upper bound for initial sync block cache.
+var initialSyncBlockCacheSize = 2 * params.BeaconConfig().SlotsPerEpoch
+
+// onBlock is called when a gossip block is received. It runs regular state transition on the block.
+// The block's signing root should be computed before calling this method to avoid redundant
+// computation in this method and methods it calls into.
+//
+// Spec pseudocode definition:
+//   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
+//    # 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 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, 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[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
+//
+//        # 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 errors.New("nil block")
+	}
+	b := signed.Block
+
+	preState, err := s.getBlockPreState(ctx, b)
+	if err != nil {
+		return err
+	}
+
+	postState, err := state.ExecuteStateTransition(ctx, preState, signed)
+	if err != nil {
+		return errors.Wrap(err, "could not execute state transition")
+	}
+
+	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 err
+		}
+	}
+
+	// Update finalized check point.
+	if postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch {
+		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
+		}
+
+		fRoot := bytesutil.ToBytes32(postState.FinalizedCheckpoint().Root)
+		if err := s.forkChoiceStore.Prune(ctx, fRoot); err != nil {
+			return errors.Wrap(err, "could not prune proto array fork choice nodes")
+		}
+
+		if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
+			return errors.Wrap(err, "could not save new justified")
+		}
+
+		// Update deposit cache.
+		s.depositCache.InsertFinalizedDeposits(ctx, int64(postState.Eth1DepositIndex()))
+	}
+
+	defer reportAttestationInclusion(b)
+
+	return s.handleEpochBoundary(postState)
+}
+
+// onBlockInitialSyncStateTransition is called when an initial sync block is received.
+// 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.onBlockInitialSyncStateTransition")
+	defer span.End()
+
+	if signed == nil || signed.Block == nil {
+		return errors.New("nil block")
+	}
+
+	b := signed.Block
+
+	// Retrieve incoming block's pre state.
+	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
+	}
+	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)
+	}
+	if err != nil {
+		return errors.Wrap(err, "could not execute state transition")
+	}
+
+	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, true /* init sync */); err != nil {
+		return err
+	}
+	// 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 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 err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
+			return err
+		}
+	}
+
+	return s.handleEpochBoundary(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: []bls.Signature{},
+		PublicKeys: []bls.PublicKey{},
+		Messages:   [][32]byte{},
+	}
+	set := new(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(preState); err != nil {
+				return nil, nil, fmt.Errorf("could not handle epoch boundary state")
+			}
+		}
+		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
+		fCheckpoints[i] = preState.FinalizedCheckpoint()
+		sigSet.Join(set)
+	}
+	verify, err := bls.VerifyMultipleSignatures(sigSet.Signatures, sigSet.Messages, sigSet.PublicKeys)
+	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 *ethpb.Checkpoint, 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
+		}
+	}
+
+	// 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(postState *stateTrie.BeaconState) error {
+	if postState.Slot() >= s.nextEpochBoundarySlot {
+		reportEpochMetrics(postState)
+		s.nextEpochBoundarySlot = helpers.StartSlot(helpers.NextEpoch(postState))
+
+		// Update committees cache at epoch boundary slot.
+		if err := helpers.UpdateCommitteeCache(postState, helpers.CurrentEpoch(postState)); err != nil {
+			return err
+		}
+		if err := helpers.UpdateProposerIndicesInCache(postState, helpers.CurrentEpoch(postState)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// This feeds in the block and block's attestations to fork choice store. It's allows fork choice store
+// to gain information on the most current chain.
+func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Context, blk *ethpb.BeaconBlock, root [32]byte,
+	state *stateTrie.BeaconState) error {
+	fCheckpoint := state.FinalizedCheckpoint()
+	jCheckpoint := state.CurrentJustifiedCheckpoint()
+	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint); err != nil {
+		return err
+	}
+	// Feed in block's attestations to fork choice store.
+	for _, a := range blk.Body.Attestations {
+		committee, err := helpers.BeaconCommitteeFromState(state, a.Data.Slot, a.Data.CommitteeIndex)
+		if err != nil {
+			return err
+		}
+		indices := attestationutil.AttestingIndices(a.AggregationBits, committee)
+		s.forkChoiceStore.ProcessAttestation(ctx, indices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
+	}
+	return nil
+}
+
+func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk *ethpb.BeaconBlock,
+	root [32]byte, fCheckpoint *ethpb.Checkpoint, 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

@@ -0,0 +1,397 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/roughtime"
+	"github.com/prysmaticlabs/prysm/shared/traceutil"
+	"go.opencensus.io/trace"
+)
+
+// CurrentSlot returns the current slot based on time.
+func (s *Service) CurrentSlot() uint64 {
+	now := roughtime.Now().Unix()
+	genesis := s.genesisTime.Unix()
+	if now < genesis {
+		return 0
+	}
+	return uint64(now-genesis) / params.BeaconConfig().SecondsPerSlot
+}
+
+// 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")
+	defer span.End()
+
+	// Verify incoming block has a valid pre state.
+	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, 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 future.
+	if err := helpers.VerifySlotTime(helpers.GenesisTime(preState), b.Slot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+		return nil, err
+	}
+
+	// Verify block is a descendent of a finalized block.
+	if err := s.VerifyBlkDescendant(ctx, bytesutil.ToBytes32(b.ParentRoot)); err != nil {
+		return nil, err
+	}
+
+	// Verify block is later than the finalized epoch slot.
+	if err := s.verifyBlkFinalizedSlot(b); err != nil {
+		return nil, err
+	}
+
+	return preState, nil
+}
+
+// verifyBlkPreState validates input block has a valid pre-state.
+func (s *Service) verifyBlkPreState(ctx context.Context, b *ethpb.BeaconBlock) error {
+	ctx, span := trace.StartSpan(ctx, "chainService.verifyBlkPreState")
+	defer span.End()
+
+	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")
+	}
+	if !s.stateGen.HasState(ctx, parentRoot) {
+		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
+// current finalized block root.
+func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "forkChoice.VerifyBlkDescendant")
+	defer span.End()
+	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 %#x", bytesutil.Trunc(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
+	}
+	return nil
+}
+
+// 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)
+	if finalizedSlot >= b.Slot {
+		return fmt.Errorf("block is equal or earlier than finalized block, slot %d < slot %d", b.Slot, finalizedSlot)
+	}
+	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.
+// See https://ethresear.ch/t/prevention-of-bouncing-attack-on-ffg/6114 for more detailed analysis and discussion.
+func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustifiedCheckpt *ethpb.Checkpoint) (bool, error) {
+	if helpers.SlotsSinceEpochStarts(s.CurrentSlot()) < params.BeaconConfig().SafeSlotsToUpdateJustified {
+		return true, nil
+	}
+	var newJustifiedBlockSigned *ethpb.SignedBeaconBlock
+	justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(newJustifiedCheckpt.Root))
+	var err error
+	if s.hasInitSyncBlock(justifiedRoot) {
+		newJustifiedBlockSigned = s.getInitSyncBlock(justifiedRoot)
+	} else {
+		newJustifiedBlockSigned, err = s.beaconDB.Block(ctx, justifiedRoot)
+		if err != nil {
+			return false, err
+		}
+	}
+	if newJustifiedBlockSigned == nil || newJustifiedBlockSigned.Block == nil {
+		return false, errors.New("nil new justified block")
+	}
+
+	newJustifiedBlock := newJustifiedBlockSigned.Block
+	if newJustifiedBlock.Slot <= helpers.StartSlot(s.justifiedCheckpt.Epoch) {
+		return false, nil
+	}
+	var justifiedBlockSigned *ethpb.SignedBeaconBlock
+	cachedJustifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+	if s.hasInitSyncBlock(cachedJustifiedRoot) {
+		justifiedBlockSigned = s.getInitSyncBlock(cachedJustifiedRoot)
+	} else {
+		justifiedBlockSigned, err = s.beaconDB.Block(ctx, cachedJustifiedRoot)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	if justifiedBlockSigned == nil || justifiedBlockSigned.Block == nil {
+		return false, errors.New("nil justified block")
+	}
+	justifiedBlock := justifiedBlockSigned.Block
+	b, err := s.ancestor(ctx, justifiedRoot[:], justifiedBlock.Slot)
+	if err != nil {
+		return false, err
+	}
+	if !bytes.Equal(b, s.justifiedCheckpt.Root) {
+		return false, nil
+	}
+	return true, nil
+}
+
+func (s *Service) updateJustified(ctx context.Context, state *stateTrie.BeaconState) error {
+	cpt := state.CurrentJustifiedCheckpoint()
+	if cpt.Epoch > s.bestJustifiedCheckpt.Epoch {
+		s.bestJustifiedCheckpt = cpt
+	}
+	canUpdate, err := s.shouldUpdateCurrentJustified(ctx, cpt)
+	if err != nil {
+		return err
+	}
+
+	if canUpdate {
+		s.prevJustifiedCheckpt = s.justifiedCheckpt
+		s.justifiedCheckpt = cpt
+		if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+			return err
+		}
+	}
+
+	return s.beaconDB.SaveJustifiedCheckpoint(ctx, cpt)
+}
+
+// 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
+	}
+
+	return s.beaconDB.SaveJustifiedCheckpoint(ctx, cp)
+}
+
+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
+	}
+	s.clearInitSyncBlocks()
+
+	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")
+	}
+
+	s.attPool.ClearSeenAtts()
+
+	return s.beaconDB.SaveFinalizedCheckpoint(ctx, cp)
+}
+
+// ancestor returns the block root of an ancestry block from the input block root.
+//
+// Spec pseudocode definition:
+//   def get_ancestor(store: Store, root: Root, slot: Slot) -> Root:
+//    block = store.blocks[root]
+//    if block.slot > slot:
+//        return get_ancestor(store, block.parent_root, slot)
+//    elif block.slot == slot:
+//        return root
+//    else:
+//        # 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")
+	defer span.End()
+
+	// Stop recursive ancestry lookup if context is cancelled.
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	}
+
+	r := bytesutil.ToBytes32(root)
+	// Get ancestor root from fork choice store instead of recursively looking up blocks in DB.
+	// This is most optimal outcome.
+	if s.forkChoiceStore.HasParent(r) {
+		return s.forkChoiceStore.AncestorRoot(ctx, r, slot)
+	}
+
+	signed, err := s.beaconDB.Block(ctx, r)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get ancestor block")
+	}
+
+	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 s.ancestor(ctx, b.ParentRoot, slot)
+}
+
+// This updates justified check point in store, if the new justified is later than stored justified or
+// the store's justified is not in chain with finalized check point.
+//
+// Spec definition:
+//   # 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) finalizedImpliesNewJustified(ctx context.Context, state *stateTrie.BeaconState) error {
+	// Update justified if it's different than the one cached in the store.
+	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
+		}
+
+		// Update justified if store justified is not in chain with finalized check point.
+		finalizedSlot := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+		justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+		anc, err := s.ancestor(ctx, justifiedRoot[:], finalizedSlot)
+		if err != nil {
+			return err
+		}
+		if !bytes.Equal(anc, s.finalizedCheckpt.Root) {
+			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
+			if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// This retrieves missing blocks from DB (ie. the blocks that couldn't be received over sync) and inserts them to fork choice store.
+// This is useful for block tree visualizer and additional vote accounting.
+func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk *ethpb.BeaconBlock,
+	fCheckpoint *ethpb.Checkpoint, jCheckpoint *ethpb.Checkpoint) error {
+	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)
+	// 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)
+		if err != nil {
+			return err
+		}
+
+		pendingNodes = append(pendingNodes, b.Block)
+		parentRoot = bytesutil.ToBytes32(b.Block.ParentRoot)
+		slot = b.Block.Slot
+		higherThanFinalized = slot > helpers.StartSlot(s.finalizedCheckpt.Epoch)
+	}
+
+	// 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)
+		if err != nil {
+			return err
+		}
+
+		if err := s.forkChoiceStore.ProcessBlock(ctx,
+			b.Slot, r, bytesutil.ToBytes32(b.ParentRoot), bytesutil.ToBytes32(b.Body.Graffiti),
+			jCheckpoint.Epoch,
+			fCheckpoint.Epoch); err != nil {
+			return errors.Wrap(err, "could not process block for proto array fork choice")
+		}
+	}
+
+	return nil
+}
+
+// The deletes input attestations from the attestation pool, so proposers don't include them in a block for the future.
+func (s *Service) deletePoolAtts(atts []*ethpb.Attestation) error {
+	for _, att := range atts {
+		if helpers.IsAggregated(att) {
+			if err := s.attPool.DeleteAggregatedAttestation(att); err != nil {
+				return err
+			}
+		} else {
+			if err := s.attPool.DeleteUnaggregatedAttestation(att); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// This ensures that the input root defaults to using genesis root instead of zero hashes. This is needed for handling
+// fork choice justification routine.
+func (s *Service) ensureRootNotZeros(root [32]byte) [32]byte {
+	if root == params.BeaconConfig().ZeroHash {
+		return s.genesisRoot
+	}
+	return root
+}

beacon-chain/blockchain/process_block_test.go

@@ -0,0 +1,690 @@
+package blockchain
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/go-ssz"
+	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db"
+	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/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/roughtime"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestStore_OnBlock(t *testing.T) {
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB:        db,
+		StateGen:        stategen.New(db, sc),
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+	genesisStateRoot := [32]byte{}
+	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
+	assert.NoError(t, db.SaveBlock(ctx, genesis))
+	validGenesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	require.NoError(t, err)
+	st := testutil.NewBeaconState()
+	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
+	roots, err := blockTree1(db, validGenesisRoot[:])
+	require.NoError(t, err)
+	random := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1, ParentRoot: validGenesisRoot[:]}}
+	assert.NoError(t, db.SaveBlock(ctx, random))
+	randomParentRoot, err := stateutil.BlockRoot(random.Block)
+	assert.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
+	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), randomParentRoot))
+	randomParentRoot2 := roots[1]
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot2[:]}))
+	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), bytesutil.ToBytes32(randomParentRoot2)))
+
+	tests := []struct {
+		name          string
+		blk           *ethpb.BeaconBlock
+		s             *stateTrie.BeaconState
+		time          uint64
+		wantErrString string
+	}{
+		{
+			name:          "parent block root does not have a state",
+			blk:           &ethpb.BeaconBlock{},
+			s:             st.Copy(),
+			wantErrString: "could not reconstruct parent state",
+		},
+		{
+			name:          "block is from the future",
+			blk:           &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:], Slot: params.BeaconConfig().FarFutureEpoch},
+			s:             st.Copy(),
+			wantErrString: "far distant future",
+		},
+		{
+			name:          "could not get finalized block",
+			blk:           &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:]},
+			s:             st.Copy(),
+			wantErrString: "is not a descendent of the current finalized block",
+		},
+		{
+			name:          "same slot as finalized block",
+			blk:           &ethpb.BeaconBlock{Slot: 0, ParentRoot: randomParentRoot2},
+			s:             st.Copy(),
+			wantErrString: "block is equal or earlier than finalized block, slot 0 < slot 0",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			service.justifiedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
+			service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
+			service.finalizedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
+			service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
+			service.finalizedCheckpt.Root = roots[0]
+
+			root, err := stateutil.BlockRoot(tt.blk)
+			assert.NoError(t, err)
+			err = service.onBlock(ctx, &ethpb.SignedBeaconBlock{Block: tt.blk}, root)
+			assert.ErrorContains(t, tt.wantErrString, err)
+		})
+	}
+}
+
+func TestStore_OnBlockBatch(t *testing.T) {
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB: db,
+		StateGen: stategen.New(db, sc),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	genesisStateRoot := [32]byte{}
+	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
+	assert.NoError(t, db.SaveBlock(ctx, genesis))
+
+	st, keys := testutil.DeterministicGenesisState(t, 64)
+
+	bState := st.Copy()
+
+	blks := []*ethpb.SignedBeaconBlock{}
+	blkRoots := [][32]byte{}
+	var firstState *stateTrie.BeaconState
+	for i := 1; i < 10; i++ {
+		b, err := testutil.GenerateFullBlock(bState, keys, testutil.DefaultBlockGenConfig(), uint64(i))
+		require.NoError(t, err)
+		bState, err = state.ExecuteStateTransition(ctx, bState, b)
+		require.NoError(t, err)
+		if i == 1 {
+			firstState = bState.Copy()
+		}
+		root, err := stateutil.BlockRoot(b.Block)
+		require.NoError(t, err)
+		blks = append(blks, b)
+		blkRoots = append(blkRoots, root)
+	}
+	require.NoError(t, db.SaveBlock(context.Background(), blks[0]))
+	require.NoError(t, service.stateGen.SaveState(ctx, blkRoots[0], firstState))
+	_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
+	require.NoError(t, err)
+}
+
+func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+	params.UseMinimalConfig()
+	defer params.UseMainnetConfig()
+
+	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+	service.genesisTime = time.Now()
+
+	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{})
+	require.NoError(t, err)
+	assert.Equal(t, true, update, "Should be able to update justified")
+	lastJustifiedBlk := testutil.NewBeaconBlock()
+	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
+	lastJustifiedRoot, err := stateutil.BlockRoot(lastJustifiedBlk.Block)
+	require.NoError(t, err)
+	newJustifiedBlk := testutil.NewBeaconBlock()
+	newJustifiedBlk.Block.Slot = 1
+	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
+	newJustifiedRoot, err := stateutil.BlockRoot(newJustifiedBlk.Block)
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, newJustifiedBlk))
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, lastJustifiedBlk))
+
+	diff := (params.BeaconConfig().SlotsPerEpoch - 1) * params.BeaconConfig().SecondsPerSlot
+	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
+	update, err = service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
+	require.NoError(t, err)
+	assert.Equal(t, true, update, "Should be able to update justified")
+}
+
+func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+	params.UseMinimalConfig()
+	defer params.UseMainnetConfig()
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+	lastJustifiedBlk := testutil.NewBeaconBlock()
+	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
+	lastJustifiedRoot, err := stateutil.BlockRoot(lastJustifiedBlk.Block)
+	require.NoError(t, err)
+	newJustifiedBlk := testutil.NewBeaconBlock()
+	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
+	newJustifiedRoot, err := stateutil.BlockRoot(newJustifiedBlk.Block)
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, newJustifiedBlk))
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, lastJustifiedBlk))
+
+	diff := (params.BeaconConfig().SlotsPerEpoch - 1) * params.BeaconConfig().SecondsPerSlot
+	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
+
+	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
+	require.NoError(t, err)
+	assert.Equal(t, false, update, "Should not be able to update justified, received true")
+}
+
+func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
+	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{NewStateMgmt: true})
+	defer resetCfg()
+
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB: db,
+		StateGen: stategen.New(db, sc),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	s, err := stateTrie.InitializeFromProto(&pb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
+	require.NoError(t, err)
+	r := [32]byte{'A'}
+	b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: r[:]}))
+	require.NoError(t, service.stateGen.SaveState(ctx, r, s))
+	require.NoError(t, service.verifyBlkPreState(ctx, b))
+}
+
+func TestCachedPreState_CanGetFromDB(t *testing.T) {
+	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{NewStateMgmt: true})
+	defer resetCfg()
+
+	ctx := context.Background()
+	db, sc := testDB.SetupDB(t)
+
+	cfg := &Config{
+		BeaconDB: db,
+		StateGen: stategen.New(db, sc),
+	}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	r := [32]byte{'A'}
+	b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
+
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	err = service.verifyBlkPreState(ctx, b)
+	wanted := "could not reconstruct parent state"
+	assert.ErrorContains(t, wanted, err)
+
+	s, err := stateTrie.InitializeFromProto(&pb.BeaconState{Slot: 1})
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: r[:]}))
+	require.NoError(t, service.stateGen.SaveState(ctx, r, s))
+	require.NoError(t, service.verifyBlkPreState(ctx, b))
+}
+
+func TestUpdateJustified_CouldUpdateBest(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)
+
+	signedBlock := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
+	require.NoError(t, db.SaveBlock(ctx, signedBlock))
+	r, err := stateutil.BlockRoot(signedBlock.Block)
+	require.NoError(t, err)
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
+	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
+	st := testutil.NewBeaconState()
+	service.initSyncState[r] = st.Copy()
+	require.NoError(t, db.SaveState(ctx, st.Copy(), r))
+
+	// Could update
+	s := testutil.NewBeaconState()
+	require.NoError(t, s.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: r[:]}))
+	require.NoError(t, service.updateJustified(context.Background(), s))
+
+	assert.Equal(t, s.CurrentJustifiedCheckpoint().Epoch, service.bestJustifiedCheckpt.Epoch, "Incorrect justified epoch in service")
+
+	// Could not update
+	service.bestJustifiedCheckpt.Epoch = 2
+	require.NoError(t, service.updateJustified(context.Background(), s))
+
+	assert.Equal(t, uint64(2), service.bestJustifiedCheckpt.Epoch, "Incorrect justified epoch in service")
+}
+
+func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
+	service.finalizedCheckpt = &ethpb.Checkpoint{}
+
+	genesisStateRoot := [32]byte{}
+	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
+	require.NoError(t, db.SaveBlock(ctx, genesis))
+	validGenesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	require.NoError(t, err)
+	st := testutil.NewBeaconState()
+
+	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
+	roots, err := blockTree1(db, validGenesisRoot[:])
+	require.NoError(t, err)
+
+	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
+	block := &ethpb.BeaconBlock{Slot: 9, ParentRoot: roots[8], Body: &ethpb.BeaconBlockBody{Graffiti: []byte{}}}
+
+	err = service.fillInForkChoiceMissingBlocks(
+		context.Background(), block, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+	require.NoError(t, err)
+
+	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
+	assert.Equal(t, 5, len(service.forkChoiceStore.Nodes()), "Miss match nodes")
+	assert.Equal(t, true, service.forkChoiceStore.HasNode(bytesutil.ToBytes32(roots[4])), "Didn't save node")
+	assert.Equal(t, true, service.forkChoiceStore.HasNode(bytesutil.ToBytes32(roots[6])), "Didn't save node")
+	assert.Equal(t, true, service.forkChoiceStore.HasNode(bytesutil.ToBytes32(roots[8])), "Didn't save node")
+}
+
+func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+	service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
+	// Set finalized epoch to 1.
+	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
+
+	genesisStateRoot := [32]byte{}
+	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
+	assert.NoError(t, db.SaveBlock(ctx, genesis))
+	validGenesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	assert.NoError(t, err)
+	st := testutil.NewBeaconState()
+
+	require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
+
+	// Define a tree branch, slot 63 <- 64 <- 65
+	b63 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 63, Body: &ethpb.BeaconBlockBody{}}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b63))
+	r63, err := stateutil.BlockRoot(b63.Block)
+	require.NoError(t, err)
+	b64 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 64, ParentRoot: r63[:], Body: &ethpb.BeaconBlockBody{}}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b64))
+	r64, err := stateutil.BlockRoot(b64.Block)
+	require.NoError(t, err)
+	b65 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 65, ParentRoot: r64[:], Body: &ethpb.BeaconBlockBody{}}}
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, b65))
+
+	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
+	err = service.fillInForkChoiceMissingBlocks(
+		context.Background(), b65.Block, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+	require.NoError(t, err)
+
+	// There should be 2 nodes, block 65 and block 64.
+	assert.Equal(t, 2, len(service.forkChoiceStore.Nodes()), "Miss match nodes")
+
+	// Block with slot 63 should be in fork choice because it's less than finalized epoch 1.
+	assert.Equal(t, true, service.forkChoiceStore.HasNode(r63), "Didn't save node")
+}
+
+// blockTree1 constructs the following tree:
+//    /- B1
+// B0           /- B5 - B7
+//    \- B3 - B4 - B6 - B8
+// (B1, and B3 are all from the same slots)
+func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
+	b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
+	r0, err := ssz.HashTreeRoot(b0)
+	if err != nil {
+		return nil, err
+	}
+	b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
+	r1, err := ssz.HashTreeRoot(b1)
+	if err != nil {
+		return nil, err
+	}
+	b3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: r0[:]}
+	r3, err := ssz.HashTreeRoot(b3)
+	if err != nil {
+		return nil, err
+	}
+	b4 := &ethpb.BeaconBlock{Slot: 4, ParentRoot: r3[:]}
+	r4, err := ssz.HashTreeRoot(b4)
+	if err != nil {
+		return nil, err
+	}
+	b5 := &ethpb.BeaconBlock{Slot: 5, ParentRoot: r4[:]}
+	r5, err := ssz.HashTreeRoot(b5)
+	if err != nil {
+		return nil, err
+	}
+	b6 := &ethpb.BeaconBlock{Slot: 6, ParentRoot: r4[:]}
+	r6, err := ssz.HashTreeRoot(b6)
+	if err != nil {
+		return nil, err
+	}
+	b7 := &ethpb.BeaconBlock{Slot: 7, ParentRoot: r5[:]}
+	r7, err := ssz.HashTreeRoot(b7)
+	if err != nil {
+		return nil, err
+	}
+	b8 := &ethpb.BeaconBlock{Slot: 8, ParentRoot: r6[:]}
+	r8, err := ssz.HashTreeRoot(b8)
+	if err != nil {
+		return nil, err
+	}
+	st := testutil.NewBeaconState()
+
+	for _, b := range []*ethpb.BeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
+		beaconBlock := testutil.NewBeaconBlock()
+		beaconBlock.Block.Slot = b.Slot
+		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
+		beaconBlock.Block.Body = &ethpb.BeaconBlockBody{}
+		if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
+			return nil, err
+		}
+		if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
+			return nil, err
+		}
+	}
+	if err := db.SaveState(context.Background(), st.Copy(), r1); err != nil {
+		return nil, err
+	}
+	if err := db.SaveState(context.Background(), st.Copy(), r7); err != nil {
+		return nil, err
+	}
+	if err := db.SaveState(context.Background(), st.Copy(), r8); err != nil {
+		return nil, err
+	}
+	return [][]byte{r0[:], r1[:], nil, r3[:], r4[:], r5[:], r6[:], r7[:], r8[:]}, nil
+}
+
+func TestCurrentSlot_HandlesOverflow(t *testing.T) {
+	svc := Service{genesisTime: roughtime.Now().Add(1 * time.Hour)}
+
+	slot := svc.CurrentSlot()
+	require.Equal(t, uint64(0), slot, "Unexpected slot")
+}
+
+func TestAncestor_HandleSkipSlot(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+
+	cfg := &Config{BeaconDB: db, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: []byte{'a'}}
+	r1, err := ssz.HashTreeRoot(b1)
+	require.NoError(t, err)
+	b100 := &ethpb.BeaconBlock{Slot: 100, ParentRoot: r1[:]}
+	r100, err := ssz.HashTreeRoot(b100)
+	require.NoError(t, err)
+	b200 := &ethpb.BeaconBlock{Slot: 200, ParentRoot: r100[:]}
+	r200, err := ssz.HashTreeRoot(b200)
+	require.NoError(t, err)
+	for _, b := range []*ethpb.BeaconBlock{b1, b100, b200} {
+		beaconBlock := testutil.NewBeaconBlock()
+		beaconBlock.Block.Slot = b.Slot
+		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
+		beaconBlock.Block.Body = &ethpb.BeaconBlockBody{}
+		require.NoError(t, db.SaveBlock(context.Background(), beaconBlock))
+	}
+
+	// Slots 100 to 200 are skip slots. Requesting root at 150 will yield root at 100. The last physical block.
+	r, err := service.ancestor(context.Background(), r200[:], 150)
+	require.NoError(t, err)
+	if bytesutil.ToBytes32(r) != r100 {
+		t.Error("Did not get correct root")
+	}
+
+	// Slots 1 to 100 are skip slots. Requesting root at 50 will yield root at 1. The last physical block.
+	r, err = service.ancestor(context.Background(), r200[:], 50)
+	require.NoError(t, err)
+	if bytesutil.ToBytes32(r) != r1 {
+		t.Error("Did not get correct root")
+	}
+}
+
+func TestEnsureRootNotZeroHashes(t *testing.T) {
+	ctx := context.Background()
+	cfg := &Config{}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+	service.genesisRoot = [32]byte{'a'}
+
+	r := service.ensureRootNotZeros(params.BeaconConfig().ZeroHash)
+	assert.Equal(t, service.genesisRoot, r, "Did not get wanted justified root")
+	root := [32]byte{'b'}
+	r = service.ensureRootNotZeros(root)
+	assert.Equal(t, root, r, "Did not get wanted justified root")
+}
+
+func TestFinalizedImpliesNewJustified(t *testing.T) {
+	db, sc := testDB.SetupDB(t)
+	ctx := context.Background()
+	type args struct {
+		cachedCheckPoint        *ethpb.Checkpoint
+		stateCheckPoint         *ethpb.Checkpoint
+		diffFinalizedCheckPoint bool
+	}
+	tests := []struct {
+		name string
+		args args
+		want *ethpb.Checkpoint
+	}{
+		{
+			name: "Same justified, do nothing",
+			args: args{
+				cachedCheckPoint: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
+				stateCheckPoint:  &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
+			},
+			want: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
+		},
+		{
+			name: "Different justified, higher epoch, cache new justified",
+			args: args{
+				cachedCheckPoint: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
+				stateCheckPoint:  &ethpb.Checkpoint{Epoch: 2, Root: []byte{'b'}},
+			},
+			want: &ethpb.Checkpoint{Epoch: 2, Root: []byte{'b'}},
+		},
+		{
+			name: "finalized has different justified, cache new justified",
+			args: args{
+				cachedCheckPoint:        &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
+				stateCheckPoint:         &ethpb.Checkpoint{Epoch: 1, Root: []byte{'b'}},
+				diffFinalizedCheckPoint: true,
+			},
+			want: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'b'}},
+		},
+	}
+	for _, test := range tests {
+		beaconState := testutil.NewBeaconState()
+		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(test.args.stateCheckPoint))
+		service, err := NewService(ctx, &Config{BeaconDB: db, StateGen: stategen.New(db, sc), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
+		require.NoError(t, err)
+		service.justifiedCheckpt = test.args.cachedCheckPoint
+		require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
+		genesisState := testutil.NewBeaconState()
+		require.NoError(t, service.beaconDB.SaveState(ctx, genesisState, bytesutil.ToBytes32(test.want.Root)))
+
+		if test.args.diffFinalizedCheckPoint {
+			b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: []byte{'a'}}
+			r1, err := ssz.HashTreeRoot(b1)
+			require.NoError(t, err)
+			b100 := &ethpb.BeaconBlock{Slot: 100, ParentRoot: r1[:]}
+			r100, err := ssz.HashTreeRoot(b100)
+			require.NoError(t, err)
+			for _, b := range []*ethpb.BeaconBlock{b1, b100} {
+				beaconBlock := testutil.NewBeaconBlock()
+				beaconBlock.Block.Slot = b.Slot
+				beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
+				require.NoError(t, service.beaconDB.SaveBlock(context.Background(), beaconBlock))
+			}
+			service.finalizedCheckpt = &ethpb.Checkpoint{Root: []byte{'c'}, Epoch: 1}
+			service.justifiedCheckpt.Root = r100[:]
+		}
+
+		require.NoError(t, service.finalizedImpliesNewJustified(ctx, beaconState))
+		assert.Equal(t, true, attestationutil.CheckPointIsEqual(test.want, service.justifiedCheckpt), "Did not get wanted check point")
+	}
+}
+
+func TestVerifyBlkDescendant(t *testing.T) {
+	db, sc := testDB.SetupDB(t)
+	ctx := context.Background()
+
+	b := testutil.NewBeaconBlock()
+	b.Block.Slot = 1
+	r, err := stateutil.BlockRoot(b.Block)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, b))
+
+	b1 := testutil.NewBeaconBlock()
+	b1.Block.Slot = 1
+	b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32)
+	r1, err := stateutil.BlockRoot(b1.Block)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, b1))
+
+	type args struct {
+		parentRoot    [32]byte
+		finalizedRoot [32]byte
+		finalizedSlot uint64
+	}
+	tests := []struct {
+		name        string
+		args        args
+		shouldError bool
+		err         string
+	}{
+		{
+			name: "could not get finalized block in block service cache",
+			args: args{
+				finalizedRoot: [32]byte{'a'},
+			},
+			shouldError: true,
+			err:         "nil finalized block",
+		},
+		{
+			name: "could not get finalized block root in DB",
+			args: args{
+				finalizedRoot: r,
+				parentRoot:    [32]byte{'a'},
+			},
+			shouldError: true,
+			err:         "could not get finalized block root",
+		},
+		{
+			name: "is not descendant",
+			args: args{
+				finalizedRoot: r1,
+				parentRoot:    r,
+			},
+			shouldError: true,
+			err:         "is not a descendent of the current finalized block slot",
+		},
+		{
+			name: "is descendant",
+			args: args{
+				finalizedRoot: r,
+				parentRoot:    r,
+			},
+			shouldError: false,
+		},
+	}
+	for _, test := range tests {
+		service, err := NewService(ctx, &Config{BeaconDB: db, StateGen: stategen.New(db, sc), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
+		require.NoError(t, err)
+		service.finalizedCheckpt = &ethpb.Checkpoint{
+			Root: test.args.finalizedRoot[:],
+		}
+		err = service.VerifyBlkDescendant(ctx, test.args.parentRoot)
+		if test.shouldError {
+			if err == nil || !strings.Contains(err.Error(), test.err) {
+				t.Error("Did not get wanted error")
+			}
+		} else if err != nil {
+			t.Error(err)
+		}
+	}
+}
+
+func TestUpdateJustifiedInitSync(t *testing.T) {
+	db, _ := testDB.SetupDB(t)
+	ctx := context.Background()
+	cfg := &Config{BeaconDB: db}
+	service, err := NewService(ctx, cfg)
+	require.NoError(t, err)
+
+	gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
+	gRoot, err := stateutil.BlockRoot(gBlk.Block)
+	require.NoError(t, err)
+	require.NoError(t, service.beaconDB.SaveBlock(ctx, gBlk))
+	require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
+	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: gRoot[:]}))
+	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
+	require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, gRoot))
+	service.genesisRoot = gRoot
+	currentCp := &ethpb.Checkpoint{Epoch: 1}
+	service.justifiedCheckpt = currentCp
+	newCp := &ethpb.Checkpoint{Epoch: 2, Root: gRoot[:]}
+
+	require.NoError(t, service.updateJustifiedInitSync(ctx, newCp))
+
+	assert.DeepEqual(t, currentCp, service.prevJustifiedCheckpt, "Incorrect previous justified checkpoint")
+	assert.DeepEqual(t, newCp, service.CurrentJustifiedCheckpt(), "Incorrect current justified checkpoint in cache")
+	cp, err := service.beaconDB.JustifiedCheckpoint(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.DeepEqual(t, newCp, cp, "Incorrect current justified checkpoint in db")
+}

beacon-chain/blockchain/receive_attestation.go

@@ -1,15 +1,19 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/roughtime"
 	"github.com/prysmaticlabs/prysm/shared/slotutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -18,9 +22,11 @@ import (
 // AttestationReceiver interface defines the methods of chain service receive and processing new attestations.
 type AttestationReceiver interface {
 	ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation) error
+	IsValidAttestation(ctx context.Context, att *ethpb.Attestation) bool
+	AttestationPreState(ctx context.Context, att *ethpb.Attestation) (*state.BeaconState, error)
 }
 
-// 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
@@ -29,39 +35,51 @@ func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Att
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveAttestationNoPubsub")
 	defer span.End()
 
-	// Update forkchoice store for the new attestation
-	if err := s.forkChoiceStore.OnAttestation(ctx, att); err != nil {
-		return errors.Wrap(err, "could not process attestation from fork choice service")
-	}
-
-	// Run fork choice for head block after updating fork choice store.
-	headRoot, err := s.forkChoiceStore.Head(ctx)
+	_, err := s.onAttestation(ctx, att)
 	if err != nil {
-		return errors.Wrap(err, "could not get head from fork choice service")
+		return errors.Wrap(err, "could not process attestation")
 	}
-	// Only save head if it's different than the current head.
-	if !bytes.Equal(headRoot, s.HeadRoot()) {
-		signed, err := s.beaconDB.Block(ctx, bytesutil.ToBytes32(headRoot))
-		if err != nil {
-			return errors.Wrap(err, "could not compute state from block head")
-		}
-		if signed == nil || signed.Block == nil {
-			return errors.New("nil head block")
-		}
-		if err := s.saveHead(ctx, signed, bytesutil.ToBytes32(headRoot)); err != nil {
-			return errors.Wrap(err, "could not save head")
+
+	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
 		}
 	}
 
-	processedAttNoPubsub.Inc()
 	return nil
 }
 
+// IsValidAttestation returns true if the attestation can be verified against its pre-state.
+func (s *Service) IsValidAttestation(ctx context.Context, att *ethpb.Attestation) bool {
+	baseState, err := s.AttestationPreState(ctx, att)
+	if err != nil {
+		log.WithError(err).Error("Failed to get attestation pre state")
+		return false
+	}
+
+	if err := blocks.VerifyAttestation(ctx, baseState, att); err != nil {
+		log.WithError(err).Error("Failed to validate attestation")
+		return false
+	}
+
+	return true
+}
+
+// AttestationPreState returns the pre state of attestation.
+func (s *Service) AttestationPreState(ctx context.Context, att *ethpb.Attestation) (*state.BeaconState, error) {
+	return s.getAttPreState(ctx, att.Data.Target)
+}
+
 // This processes attestations from the attestation pool to account for validator votes and fork choice.
-func (s *Service) processAttestation() {
+func (s *Service) processAttestation(subscribedToStateEvents chan struct{}) {
 	// Wait for state to be initialized.
 	stateChannel := make(chan *feed.Event, 1)
 	stateSub := s.stateNotifier.StateFeed().Subscribe(stateChannel)
+	subscribedToStateEvents <- struct{}{}
 	<-stateChannel
 	stateSub.Unsubscribe()
 
@@ -74,16 +92,58 @@ func (s *Service) processAttestation() {
 			ctx := context.Background()
 			atts := s.attPool.ForkchoiceAttestations()
 			for _, a := range atts {
+				// Based on the spec, don't process the attestation until the subsequent slot.
+				// This delays consideration in the fork choice until their slot is in the past.
+				// https://github.com/ethereum/eth2.0-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
+				nextSlot := a.Data.Slot + 1
+				if err := helpers.VerifySlotTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+					continue
+				}
+
+				hasState := s.stateGen.StateSummaryExists(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
+				hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
+				if !(hasState && hasBlock) {
+					continue
+				}
+
 				if err := s.attPool.DeleteForkchoiceAttestation(a); err != nil {
 					log.WithError(err).Error("Could not delete fork choice attestation in pool")
 				}
 
+				if !s.verifyCheckpointEpoch(a.Data.Target) {
+					continue
+				}
+
 				if err := s.ReceiveAttestationNoPubsub(ctx, a); err != nil {
 					log.WithFields(logrus.Fields{
-						"targetRoot": fmt.Sprintf("%#x", a.Data.Target.Root),
-					}).WithError(err).Error("Could not receive attestation in chain service")
+						"slot":             a.Data.Slot,
+						"committeeIndex":   a.Data.CommitteeIndex,
+						"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.BeaconBlockRoot)),
+						"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.Target.Root)),
+						"aggregationCount": a.AggregationBits.Count(),
+					}).WithError(err).Warn("Could not receive attestation in chain service")
 				}
 			}
 		}
 	}
 }
+
+// This verifies the epoch of input checkpoint is within current epoch and previous epoch
+// with respect to current time. Returns true if it's within, false if it's not.
+func (s *Service) verifyCheckpointEpoch(c *ethpb.Checkpoint) bool {
+	now := uint64(roughtime.Now().Unix())
+	genesisTime := uint64(s.genesisTime.Unix())
+	currentSlot := (now - genesisTime) / params.BeaconConfig().SecondsPerSlot
+	currentEpoch := helpers.SlotToEpoch(currentSlot)
+
+	var prevEpoch uint64
+	if currentEpoch > 1 {
+		prevEpoch = currentEpoch - 1
+	}
+
+	if c.Epoch != prevEpoch && c.Epoch != currentEpoch {
+		return false
+	}
+
+	return true
+}

beacon-chain/blockchain/receive_attestation_test.go

@@ -2,45 +2,21 @@ package blockchain
 
 import (
 	"testing"
+	"time"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-	"golang.org/x/net/context"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 )
 
-func TestReceiveAttestationNoPubsub_ProcessCorrectly(t *testing.T) {
-	hook := logTest.NewGlobal()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	ctx := context.Background()
+func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
+	helpers.ClearCache()
+	db, sc := testDB.SetupDB(t)
 
-	chainService := setupBeaconChain(t, db)
-	r, _ := ssz.HashTreeRoot(&ethpb.BeaconBlock{})
-	chainService.forkChoiceStore = &store{headRoot: r[:]}
+	chainService := setupBeaconChain(t, db, sc)
+	chainService.genesisTime = time.Now()
 
-	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
-	if err := chainService.beaconDB.SaveBlock(ctx, b); err != nil {
-		t.Fatal(err)
-	}
-	root, err := ssz.HashTreeRoot(b.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := chainService.beaconDB.SaveState(ctx, &pb.BeaconState{}, root); err != nil {
-		t.Fatal(err)
-	}
-
-	a := &ethpb.Attestation{Data: &ethpb.AttestationData{
-		Target: &ethpb.Checkpoint{Root: root[:]},
-	}}
-	if err := chainService.ReceiveAttestationNoPubsub(ctx, a); err != nil {
-		t.Fatal(err)
-	}
-
-	testutil.AssertLogsContain(t, hook, "Saved new head info")
-	testutil.AssertLogsDoNotContain(t, hook, "Broadcasting attestation")
+	assert.Equal(t, true, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{}))
+	assert.Equal(t, false, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 1}))
 }

beacon-chain/blockchain/receive_block.go

@@ -1,20 +1,13 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
-	"encoding/hex"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"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/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/traceutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -22,212 +15,87 @@ import (
 
 // BlockReceiver interface defines the methods of chain service receive and processing new blocks.
 type BlockReceiver interface {
-	ReceiveBlock(ctx context.Context, block *ethpb.SignedBeaconBlock) error
-	ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.SignedBeaconBlock) error
-	ReceiveBlockNoPubsubForkchoice(ctx context.Context, block *ethpb.SignedBeaconBlock) error
-	ReceiveBlockNoVerify(ctx context.Context, block *ethpb.SignedBeaconBlock) error
+	ReceiveBlock(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) error {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlock")
-	defer span.End()
-
-	root, err := ssz.HashTreeRoot(block.Block)
-	if err != nil {
-		return errors.Wrap(err, "could not get signing root on received block")
-	}
-
-	// 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(root[:]),
-	}).Debug("Broadcasting block")
-
-	if err := s.ReceiveBlockNoPubsub(ctx, block); err != nil {
-		return err
-	}
-
-	processedBlk.Inc()
-	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) 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 := proto.Clone(block).(*ethpb.SignedBeaconBlock)
+	blockCopy := stateTrie.CopySignedBeaconBlock(block)
 
 	// Apply state transition on the new block.
-	if err := s.forkChoiceStore.OnBlock(ctx, blockCopy); err != nil {
-		err := errors.Wrap(err, "could not process block from fork choice service")
+	if err := s.onBlock(ctx, blockCopy, blockRoot); err != nil {
+		err := errors.Wrap(err, "could not process block")
 		traceutil.AnnotateError(span, err)
 		return err
 	}
-	root, err := ssz.HashTreeRoot(blockCopy.Block)
-	if err != nil {
-		return errors.Wrap(err, "could not get signing root on received block")
-	}
 
-	// Run fork choice after applying state transition on the new block.
-	headRoot, err := s.forkChoiceStore.Head(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get head from fork choice service")
-	}
-	signedHeadBlock, err := s.beaconDB.Block(ctx, bytesutil.ToBytes32(headRoot))
-	if err != nil {
-		return errors.Wrap(err, "could not compute state from block head")
-	}
-	if signedHeadBlock == nil || signedHeadBlock.Block == nil {
-		return errors.New("nil head block")
-	}
-
-	// Only save head if it's different than the current head.
-	if !bytes.Equal(headRoot, s.HeadRoot()) {
-		if err := s.saveHead(ctx, signedHeadBlock, bytesutil.ToBytes32(headRoot)); 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 {
+		return errors.Wrap(err, "could not update head")
 	}
 
 	// Send notification of the processed block to the state feed.
 	s.stateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
-			BlockRoot: root,
+			Slot:      blockCopy.Block.Slot,
+			BlockRoot: blockRoot,
 			Verified:  true,
 		},
 	})
 
-	// 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
+	// Handle post block operations such as attestations and exits.
+	if err := s.handlePostBlockOperations(blockCopy.Block); err != nil {
+		return err
 	}
 
 	// Reports on block and fork choice metrics.
-	s.reportSlotMetrics(blockCopy.Block.Slot)
+	reportSlotMetrics(blockCopy.Block.Slot, s.headSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 
-	// Log if block is a competing block.
-	isCompetingBlock(root[:], blockCopy.Block.Slot, headRoot, signedHeadBlock.Block.Slot)
+	// Log block sync status.
+	logBlockSyncStatus(blockCopy.Block, blockRoot, s.finalizedCheckpt)
 
 	// Log state transition data.
-	logStateTransitionData(blockCopy.Block, root[:])
-
-	s.epochParticipationLock.Lock()
-	defer s.epochParticipationLock.Unlock()
-	s.epochParticipation[helpers.SlotToEpoch(blockCopy.Block.Slot)] = precompute.Balances
-
-	processedBlkNoPubsub.Inc()
+	logStateTransitionData(blockCopy.Block)
 
 	return nil
 }
 
-// ReceiveBlockNoPubsubForkchoice is a function that defines the all operations (minus pubsub and forkchoice)
-// that are preformed blocks that is received from initial sync service. The operations consists of:
-//   1. Validate block, apply state transition and update check points
-//   2. Save latest head info
-func (s *Service) ReceiveBlockNoPubsubForkchoice(ctx context.Context, block *ethpb.SignedBeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlockNoForkchoice")
+// 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, "blockChain.ReceiveBlockNoVerify")
 	defer span.End()
-	blockCopy := proto.Clone(block).(*ethpb.SignedBeaconBlock)
+	blockCopy := stateTrie.CopySignedBeaconBlock(block)
 
-	// Apply state transition on the incoming newly received block.
-	if err := s.forkChoiceStore.OnBlock(ctx, blockCopy); err != nil {
-		err := errors.Wrap(err, "could not process block from fork choice service")
+	// 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
 	}
-	root, err := ssz.HashTreeRoot(blockCopy.Block)
-	if err != nil {
-		return errors.Wrap(err, "could not get signing root on received block")
-	}
-
-	if !bytes.Equal(root[:], s.HeadRoot()) {
-		if err := s.saveHead(ctx, blockCopy, root); err != nil {
-			return errors.Wrap(err, "could not save head")
-		}
-	}
 
 	// Send notification of the processed block to the state feed.
 	s.stateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
-			BlockRoot: root,
+			Slot:      blockCopy.Block.Slot,
+			BlockRoot: blockRoot,
 			Verified:  true,
 		},
 	})
 
-	// Reports on block and fork choice metrics.
-	s.reportSlotMetrics(blockCopy.Block.Slot)
-
-	// Log state transition data.
-	logStateTransitionData(blockCopy.Block, root[:])
-
-	s.epochParticipationLock.Lock()
-	defer s.epochParticipationLock.Unlock()
-	s.epochParticipation[helpers.SlotToEpoch(blockCopy.Block.Slot)] = precompute.Balances
-
-	processedBlkNoPubsubForkchoice.Inc()
-	return nil
-}
-
-// ReceiveBlockNoVerify runs state transition on a input block without verifying the block's BLS contents.
-// Depends on the security model, this is the "minimal" work a node can do to sync the chain.
-// It simulates light client behavior and assumes 100% trust with the syncing peer.
-func (s *Service) ReceiveBlockNoVerify(ctx context.Context, block *ethpb.SignedBeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlockNoVerify")
-	defer span.End()
-	blockCopy := proto.Clone(block).(*ethpb.SignedBeaconBlock)
-
-	// Apply state transition on the incoming newly received blockCopy without verifying its BLS contents.
-	if err := s.forkChoiceStore.OnBlockInitialSyncStateTransition(ctx, blockCopy); err != nil {
-		return errors.Wrap(err, "could not process blockCopy from fork choice service")
-	}
-	root, err := ssz.HashTreeRoot(blockCopy.Block)
-	if err != nil {
-		return errors.Wrap(err, "could not get signing root on received blockCopy")
-	}
-
-	if featureconfig.Get().InitSyncCacheState {
-		if !bytes.Equal(root[:], s.HeadRoot()) {
-			if err := s.saveHeadNoDB(ctx, blockCopy, root); err != nil {
-				err := errors.Wrap(err, "could not save head")
-				traceutil.AnnotateError(span, err)
-				return err
-			}
-		}
-	} else {
-		if !bytes.Equal(root[:], s.HeadRoot()) {
-			if err := s.saveHead(ctx, blockCopy, root); 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{
-			BlockRoot: root,
-			Verified:  false,
-		},
-	})
-
 	// Reports on blockCopy and fork choice metrics.
-	s.reportSlotMetrics(blockCopy.Block.Slot)
+	reportSlotMetrics(blockCopy.Block.Slot, s.headSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 
 	// Log state transition data.
 	log.WithFields(logrus.Fields{
@@ -236,22 +104,71 @@ func (s *Service) ReceiveBlockNoVerify(ctx context.Context, block *ethpb.SignedB
 		"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)
+	}
 
 	return nil
 }
 
-// This checks if the block is from a competing chain, emits warning and updates metrics.
-func isCompetingBlock(root []byte, slot uint64, headRoot []byte, headSlot uint64) {
-	if !bytes.Equal(root[:], headRoot) {
-		log.WithFields(logrus.Fields{
-			"blkSlot":  slot,
-			"blkRoot":  hex.EncodeToString(root[:]),
-			"headSlot": headSlot,
-			"headRoot": hex.EncodeToString(headRoot),
-		}).Warn("Calculated head diffs from new block")
-		competingBlks.Inc()
-	}
+// HasInitSyncBlock returns true if the block of the input root exists in initial sync blocks cache.
+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
 }

beacon-chain/blockchain/receive_block_test.go

@@ -1,195 +1,370 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
-	"reflect"
+	"sync"
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	blockchainTesting "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"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/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/stateutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
-	logTest "github.com/sirupsen/logrus/hooks/test"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
-func TestReceiveBlock_ProcessCorrectly(t *testing.T) {
-	hook := logTest.NewGlobal()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+func TestService_ReceiveBlock(t *testing.T) {
 	ctx := context.Background()
 
-	chainService := setupBeaconChain(t, db)
+	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)
 
-	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	genesis, _ := testutil.GenerateFullBlock(beaconState, privKeys, nil, beaconState.Slot+1)
-	beaconState, err := state.ExecuteStateTransition(ctx, beaconState, genesis)
-	if err != nil {
-		t.Fatal(err)
+	type args struct {
+		block *ethpb.SignedBeaconBlock
 	}
-	genesisBlkRoot, err := ssz.HashTreeRoot(genesis.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, beaconState, genesisBlkRoot); err != nil {
-		t.Fatal(err)
-	}
-	cp := &ethpb.Checkpoint{Root: genesisBlkRoot[:]}
-	if err := chainService.forkChoiceStore.GenesisStore(ctx, cp, cp); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := chainService.beaconDB.SaveBlock(ctx, genesis); err != nil {
-		t.Fatalf("Could not save block to db: %v", err)
-	}
-
-	if err := db.SaveState(ctx, beaconState, genesisBlkRoot); err != nil {
-		t.Fatal(err)
-	}
-
-	slot := beaconState.Slot + 1
-	block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, slot)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := chainService.beaconDB.SaveBlock(ctx, block); err != nil {
-		t.Fatal(err)
-	}
-	if err := chainService.ReceiveBlock(context.Background(), block); err != nil {
-		t.Errorf("Block failed processing: %v", err)
-	}
-	testutil.AssertLogsContain(t, hook, "Finished applying state transition")
-}
-
-func TestReceiveReceiveBlockNoPubsub_CanSaveHeadInfo(t *testing.T) {
-	hook := logTest.NewGlobal()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	ctx := context.Background()
-
-	chainService := setupBeaconChain(t, db)
-
-	headBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 100}}
-	if err := db.SaveBlock(ctx, headBlk); err != nil {
-		t.Fatal(err)
-	}
-	r, err := ssz.HashTreeRoot(headBlk.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	head := &pb.BeaconState{Slot: 100, FinalizedCheckpoint: &ethpb.Checkpoint{Root: r[:]}}
-	if err := db.SaveState(ctx, head, r); err != nil {
-		t.Fatal(err)
-	}
-	chainService.forkChoiceStore = &store{headRoot: r[:]}
-
-	if err := chainService.ReceiveBlockNoPubsub(ctx, &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			Slot: 1,
-			Body: &ethpb.BeaconBlockBody{},
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+		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)
+				}
+			},
 		},
-	}); err != nil {
-		t.Fatal(err)
-	}
 
-	if !bytes.Equal(r[:], chainService.HeadRoot()) {
-		t.Error("Incorrect head root saved")
-	}
-
-	if !reflect.DeepEqual(headBlk, chainService.HeadBlock()) {
-		t.Error("Incorrect head block saved")
-	}
-
-	testutil.AssertLogsContain(t, hook, "Saved new head info")
-}
-
-func TestReceiveReceiveBlockNoPubsub_SameHead(t *testing.T) {
-	hook := logTest.NewGlobal()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	ctx := context.Background()
-
-	chainService := setupBeaconChain(t, db)
-
-	headBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
-	if err := db.SaveBlock(ctx, headBlk); err != nil {
-		t.Fatal(err)
-	}
-	newBlk := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			Slot: 1,
-			Body: &ethpb.BeaconBlockBody{},
+		{
+			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)
+				}
+			},
 		},
 	}
-	newRoot, _ := ssz.HashTreeRoot(newBlk.Block)
-	if err := db.SaveBlock(ctx, newBlk); err != nil {
-		t.Fatal(err)
+
+	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 := stateutil.BlockRoot(gBlk.Block)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			root, err := stateutil.BlockRoot(tt.args.block.Block)
+			require.NoError(t, err)
+			if err := s.ReceiveBlock(ctx, tt.args.block, root); (err != nil) != tt.wantErr {
+				t.Errorf("ReceiveBlock() error = %v, wantErr %v", err, tt.wantErr)
+			} else {
+				tt.check(t, s)
+			}
+		})
 	}
-
-	chainService.forkChoiceStore = &store{headRoot: newRoot[:]}
-	chainService.canonicalRoots[0] = newRoot[:]
-
-	if err := chainService.ReceiveBlockNoPubsub(ctx, newBlk); err != nil {
-		t.Fatal(err)
-	}
-
-	testutil.AssertLogsDoNotContain(t, hook, "Saved new head info")
 }
 
-func TestReceiveBlockNoPubsubForkchoice_ProcessCorrectly(t *testing.T) {
-	hook := logTest.NewGlobal()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+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 := stateutil.BlockRoot(gBlk.Block)
+	s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	root, err := stateutil.BlockRoot(b.Block)
+	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()
 
-	chainService := setupBeaconChain(t, db)
-	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-
-	block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, beaconState.Slot)
-	if err != nil {
-		t.Fatal(err)
+	genesis, keys := testutil.DeterministicGenesisState(t, 64)
+	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot uint64) *ethpb.SignedBeaconBlock {
+		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
+		if err != nil {
+			t.Error(err)
+		}
+		return blk
 	}
 
-	stateRoot, err := stateutil.HashTreeRootState(beaconState)
-	if err != nil {
-		t.Fatal(err)
+	type args struct {
+		block *ethpb.SignedBeaconBlock
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+		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)
+				}
+			},
+		},
 	}
 
-	genesis := b.NewGenesisBlock(stateRoot[:])
-	parentRoot, err := ssz.HashTreeRoot(genesis.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, beaconState, parentRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := chainService.forkChoiceStore.GenesisStore(ctx, &ethpb.Checkpoint{Root: parentRoot[:]}, &ethpb.Checkpoint{Root: parentRoot[:]}); err != nil {
-		t.Fatal(err)
-	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db, stateSummaryCache := testDB.SetupDB(t)
+			genesisBlockRoot := bytesutil.ToBytes32(nil)
 
-	if err := chainService.beaconDB.SaveBlock(ctx, block); err != nil {
-		t.Fatalf("Could not save block to db: %v", 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)
 
-	block, err = testutil.GenerateFullBlock(beaconState, privKeys, nil, beaconState.Slot)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, beaconState, bytesutil.ToBytes32(block.Block.ParentRoot)); err != nil {
-		t.Fatal(err)
-	}
+			gRoot, err := stateutil.BlockRoot(gBlk.Block)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			root, err := stateutil.BlockRoot(tt.args.block.Block)
+			require.NoError(t, err)
 
-	if err := chainService.beaconDB.SaveBlock(ctx, block); err != nil {
-		t.Fatal(err)
+			if err := s.ReceiveBlockInitialSync(ctx, tt.args.block, root); (err != nil) != tt.wantErr {
+				t.Errorf("ReceiveBlockInitialSync() error = %v, wantErr %v", err, tt.wantErr)
+			} else {
+				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)
+		if err != nil {
+			t.Error(err)
+		}
+		return blk
+	}
+
+	type args struct {
+		block *ethpb.SignedBeaconBlock
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+		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 := stateutil.BlockRoot(gBlk.Block)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			root, err := stateutil.BlockRoot(tt.args.block.Block)
+			require.NoError(t, err)
+			blks := []*ethpb.SignedBeaconBlock{tt.args.block}
+			roots := [][32]byte{root}
+			if err := s.ReceiveBlockBatch(ctx, blks, roots); (err != nil) != tt.wantErr {
+				t.Errorf("ReceiveBlockBatch() error = %v, wantErr %v", err, tt.wantErr)
+			} else {
+				tt.check(t, s)
+			}
+		})
+	}
+}
+
+func TestService_HasInitSyncBlock(t *testing.T) {
+	s, err := NewService(context.Background(), &Config{})
+	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")
 	}
-	if err := chainService.ReceiveBlockNoPubsubForkchoice(context.Background(), block); err != nil {
-		t.Errorf("Block failed processing: %v", err)
-	}
-	testutil.AssertLogsContain(t, hook, "Finished applying state transition")
-	testutil.AssertLogsDoNotContain(t, hook, "Finished fork choice")
 }

beacon-chain/blockchain/service.go

@@ -1,6 +1,6 @@
-// Package blockchain defines the life-cycle and status of the beacon chain
-// as well as the Ethereum Serenity beacon chain fork-choice rule based on
-// Casper Proof of Stake finality.
+// Package blockchain defines the life-cycle of the blockchain at the core of
+// eth2, including processing of new blocks and attestations using casper
+// proof of stake.
 package blockchain
 
 import (
@@ -12,87 +12,119 @@ import (
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain/forkchoice"
+	"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/flags"
+	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
+	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"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/sirupsen/logrus"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/slotutil"
 	"go.opencensus.io/trace"
 )
 
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	ctx                    context.Context
-	cancel                 context.CancelFunc
-	beaconDB               db.Database
-	depositCache           *depositcache.DepositCache
-	chainStartFetcher      powchain.ChainStartFetcher
-	attPool                attestations.Pool
-	forkChoiceStore        forkchoice.ForkChoicer
-	genesisTime            time.Time
-	p2p                    p2p.Broadcaster
-	maxRoutines            int64
-	headSlot               uint64
-	headBlock              *ethpb.SignedBeaconBlock
-	headState              *pb.BeaconState
-	canonicalRoots         map[uint64][]byte
-	headLock               sync.RWMutex
-	stateNotifier          statefeed.Notifier
-	genesisRoot            [32]byte
-	epochParticipation     map[uint64]*precompute.Balance
-	epochParticipationLock 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
+	recentCanonicalBlocks     map[[32]byte]bool
+	recentCanonicalBlocksLock sync.RWMutex
+	justifiedBalances         []uint64
+	justifiedBalancesLock     sync.RWMutex
 }
 
 // Config options for the service.
 type Config struct {
 	BeaconBlockBuf    int
 	ChainStartFetcher powchain.ChainStartFetcher
-	BeaconDB          db.Database
+	BeaconDB          db.HeadAccessDatabase
 	DepositCache      *depositcache.DepositCache
 	AttPool           attestations.Pool
+	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
 }
 
 // NewService instantiates a new block service instance that will
 // be registered into a running beacon node.
 func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
-	store := forkchoice.NewForkChoiceService(ctx, cfg.BeaconDB)
 	return &Service{
-		ctx:                ctx,
-		cancel:             cancel,
-		beaconDB:           cfg.BeaconDB,
-		depositCache:       cfg.DepositCache,
-		chainStartFetcher:  cfg.ChainStartFetcher,
-		attPool:            cfg.AttPool,
-		forkChoiceStore:    store,
-		p2p:                cfg.P2p,
-		canonicalRoots:     make(map[uint64][]byte),
-		maxRoutines:        cfg.MaxRoutines,
-		stateNotifier:      cfg.StateNotifier,
-		epochParticipation: make(map[uint64]*precompute.Balance),
+		ctx:                   ctx,
+		cancel:                cancel,
+		beaconDB:              cfg.BeaconDB,
+		depositCache:          cfg.DepositCache,
+		chainStartFetcher:     cfg.ChainStartFetcher,
+		attPool:               cfg.AttPool,
+		exitPool:              cfg.ExitPool,
+		slashingPool:          cfg.SlashingPool,
+		p2p:                   cfg.P2p,
+		maxRoutines:           cfg.MaxRoutines,
+		stateNotifier:         cfg.StateNotifier,
+		forkChoiceStore:       cfg.ForkChoiceStore,
+		initSyncState:         make(map[[32]byte]*stateTrie.BeaconState),
+		boundaryRoots:         [][32]byte{},
+		checkpointState:       cache.NewCheckpointStateCache(),
+		opsService:            cfg.OpsService,
+		stateGen:              cfg.StateGen,
+		initSyncBlocks:        make(map[[32]byte]*ethpb.SignedBeaconBlock),
+		recentCanonicalBlocks: make(map[[32]byte]bool),
+		justifiedBalances:     make([]uint64, 0),
 	}, 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)
 	}
@@ -100,41 +132,62 @@ 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.
-	if featureconfig.Get().InitSyncCacheState {
-		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 {
+		beaconState, err = s.stateGen.StateByRoot(s.ctx, bytesutil.ToBytes32(cp.Root))
 		if err != nil {
-			log.Fatalf("Could not fetch finalized cp: %v", err)
-		}
-		if beaconState == nil {
-			beaconState, err = s.beaconDB.State(ctx, bytesutil.ToBytes32(cp.Root))
-			if err != nil {
-				log.Fatalf("Could not fetch beacon state: %v", err)
-			}
+			log.Fatalf("Could not fetch beacon state by root: %v", err)
 		}
 	}
 
+	// Make sure that attestation processor is subscribed and ready for state initializing event.
+	attestationProcessorSubscribed := make(chan struct{}, 1)
+
 	// If the chain has already been initialized, simply start the block processing routine.
 	if beaconState != nil {
 		log.Info("Blockchain data already exists in DB, initializing...")
-		s.genesisTime = time.Unix(int64(beaconState.GenesisTime), 0)
-		if err := s.initializeChainInfo(ctx); err != nil {
+		s.genesisTime = time.Unix(int64(helpers.GenesisTime(beaconState)), 0)
+		s.opsService.SetGenesisTime(helpers.GenesisTime(beaconState))
+		if err := s.initializeChainInfo(s.ctx); err != nil {
 			log.Fatalf("Could not set up chain info: %v", err)
 		}
-		justifiedCheckpoint, err := s.beaconDB.JustifiedCheckpoint(ctx)
+
+		// We start a counter to genesis, if needed.
+		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(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)
 		}
-		if err := s.forkChoiceStore.GenesisStore(ctx, justifiedCheckpoint, finalizedCheckpoint); err != nil {
-			log.Fatalf("Could not start fork choice service: %v", err)
+
+		// Resume fork choice.
+		s.justifiedCheckpt = stateTrie.CopyCheckpoint(justifiedCheckpoint)
+		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)
+		s.bestJustifiedCheckpt = stateTrie.CopyCheckpoint(justifiedCheckpoint)
+		s.finalizedCheckpt = stateTrie.CopyCheckpoint(finalizedCheckpoint)
+		s.prevFinalizedCheckpt = stateTrie.CopyCheckpoint(finalizedCheckpoint)
+		s.resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint)
+
 		s.stateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Initialized,
 			Data: &statefeed.InitializedData{
-				StartTime: s.genesisTime,
+				StartTime:             s.genesisTime,
+				GenesisValidatorsRoot: beaconState.GenesisValidatorRoot(),
 			},
 		})
 	} else {
@@ -147,13 +200,18 @@ func (s *Service) Start() {
 			stateChannel := make(chan *feed.Event, 1)
 			stateSub := s.stateNotifier.StateFeed().Subscribe(stateChannel)
 			defer stateSub.Unsubscribe()
+			<-attestationProcessorSubscribed
 			for {
 				select {
 				case event := <-stateChannel:
 					if event.Type == statefeed.ChainStarted {
-						data := event.Data.(*statefeed.ChainStartedData)
+						data, ok := event.Data.(*statefeed.ChainStartedData)
+						if !ok {
+							log.Error("event data is not type *statefeed.ChainStartedData")
+							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():
@@ -167,20 +225,27 @@ func (s *Service) Start() {
 		}()
 	}
 
-	go s.processAttestation()
+	go s.processAttestation(attestationProcessorSubscribed)
 }
 
 // processChainStartTime initializes a series of deposits from the ChainStart deposits in the eth1
 // deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
 func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Time) {
 	preGenesisState := s.chainStartFetcher.PreGenesisState()
-	if err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.chainStartFetcher.ChainStartEth1Data()); err != nil {
+	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.chainStartFetcher.ChainStartEth1Data())
+	if err != nil {
 		log.Fatalf("Could not initialize beacon chain: %v", err)
 	}
+	// We start a counter to genesis, if needed.
+	go slotutil.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()))
+
+	// We send out a state initialized event to the rest of the services
+	// running in the beacon node.
 	s.stateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
-			StartTime: genesisTime,
+			StartTime:             genesisTime,
+			GenesisValidatorsRoot: initializedState.GenesisValidatorRoot(),
 		},
 	})
 }
@@ -191,129 +256,77 @@ func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Ti
 func (s *Service) initializeBeaconChain(
 	ctx context.Context,
 	genesisTime time.Time,
-	preGenesisState *pb.BeaconState,
-	eth1data *ethpb.Eth1Data) error {
+	preGenesisState *stateTrie.BeaconState,
+	eth1data *ethpb.Eth1Data) (*stateTrie.BeaconState, error) {
 	_, span := trace.StartSpan(context.Background(), "beacon-chain.Service.initializeBeaconChain")
 	defer span.End()
-	log.Info("Genesis time reached, starting the beacon chain")
 	s.genesisTime = genesisTime
 	unixTime := uint64(genesisTime.Unix())
 
 	genesisState, err := state.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
 	if err != nil {
-		return errors.Wrap(err, "could not initialize genesis state")
+		return nil, errors.Wrap(err, "could not initialize genesis state")
 	}
 
 	if err := s.saveGenesisData(ctx, genesisState); err != nil {
-		return errors.Wrap(err, "could not save genesis data")
+		return nil, errors.Wrap(err, "could not save genesis data")
 	}
 
+	log.Info("Initialized beacon chain genesis state")
+
+	// Clear out all pre-genesis data now that the state is initialized.
+	s.chainStartFetcher.ClearPreGenesisData()
+
 	// Update committee shuffled indices for genesis epoch.
-	if featureconfig.Get().EnableNewCache {
-		if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
-			return err
-		}
+	if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
+		return nil, err
+	}
+	if err := helpers.UpdateProposerIndicesInCache(genesisState, 0 /* genesis epoch */); err != nil {
+		return nil, err
 	}
 
-	return nil
+	s.opsService.SetGenesisTime(helpers.GenesisTime(genesisState))
+
+	return genesisState, nil
 }
 
 // Stop the blockchain service's main event loop and associated goroutines.
 func (s *Service) Stop() error {
 	defer s.cancel()
+
+	if s.stateGen != nil && s.head != nil && s.head.state != nil {
+		return s.stateGen.ForceCheckpoint(s.ctx, s.head.state.FinalizedCheckpoint().Root)
+	}
 	return nil
 }
 
 // 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
 }
 
-// This gets called to update canonical root mapping.
-func (s *Service) saveHead(ctx context.Context, signed *ethpb.SignedBeaconBlock, r [32]byte) error {
-	s.headLock.Lock()
-	defer s.headLock.Unlock()
-
-	if signed == nil || signed.Block == nil {
-		return errors.New("cannot save nil head block")
-	}
-
-	s.headSlot = signed.Block.Slot
-
-	s.canonicalRoots[signed.Block.Slot] = r[:]
-
-	if err := s.beaconDB.SaveHeadBlockRoot(ctx, r); err != nil {
-		return errors.Wrap(err, "could not save head root in DB")
-	}
-	s.headBlock = signed
-
-	headState, err := s.beaconDB.State(ctx, r)
-	if err != nil {
-		return errors.Wrap(err, "could not retrieve head state in DB")
-	}
-	s.headState = headState
-
-	log.WithFields(logrus.Fields{
-		"slot":     signed.Block.Slot,
-		"headRoot": fmt.Sprintf("%#x", r),
-	}).Debug("Saved new head info")
-	return nil
+// ClearCachedStates removes all stored caches states. This is done after the node
+// is synced.
+func (s *Service) ClearCachedStates() {
+	s.initSyncState = map[[32]byte]*stateTrie.BeaconState{}
 }
 
-// This gets called 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
-// 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 {
-	s.headLock.Lock()
-	defer s.headLock.Unlock()
-
-	s.headSlot = b.Block.Slot
-
-	s.canonicalRoots[b.Block.Slot] = r[:]
-
-	s.headBlock = b
-
-	headState, err := s.beaconDB.State(ctx, r)
+// This gets called when beacon chain is first initialized to save genesis data (state, block, and more) in db.
+func (s *Service) saveGenesisData(ctx context.Context, genesisState *stateTrie.BeaconState) error {
+	stateRoot, err := genesisState.HashTreeRoot(ctx)
 	if err != nil {
-		return errors.Wrap(err, "could not retrieve head state in DB")
-	}
-	s.headState = headState
-
-	log.WithFields(logrus.Fields{
-		"slot":     b.Block.Slot,
-		"headRoot": fmt.Sprintf("%#x", r),
-	}).Debug("Saved new head info")
-	return nil
-}
-
-// This gets called when beacon chain is first initialized to save validator indices and pubkeys in db
-func (s *Service) saveGenesisValidators(ctx context.Context, state *pb.BeaconState) error {
-	for i, v := range state.Validators {
-		if err := s.beaconDB.SaveValidatorIndex(ctx, bytesutil.ToBytes48(v.PublicKey), uint64(i)); err != nil {
-			return errors.Wrapf(err, "could not save validator index: %d", i)
-		}
-	}
-	return nil
-}
-
-// This gets called when beacon chain is first initialized to save genesis data (state, block, and more) in db
-func (s *Service) saveGenesisData(ctx context.Context, genesisState *pb.BeaconState) error {
-	s.headLock.Lock()
-	defer s.headLock.Unlock()
-
-	stateRoot, err := ssz.HashTreeRoot(genesisState)
-	if err != nil {
-		return errors.Wrap(err, "could not tree hash genesis state")
+		return err
 	}
 	genesisBlk := blocks.NewGenesisBlock(stateRoot[:])
-	genesisBlkRoot, err := ssz.HashTreeRoot(genesisBlk.Block)
+	genesisBlkRoot, err := stateutil.BlockRoot(genesisBlk.Block)
 	if err != nil {
 		return errors.Wrap(err, "could not get genesis block root")
 	}
+	s.genesisRoot = genesisBlkRoot
 
 	if err := s.beaconDB.SaveBlock(ctx, genesisBlk); err != nil {
 		return errors.Wrap(err, "could not save genesis block")
@@ -321,34 +334,51 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState *pb.BeaconSt
 	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")
-	}
-	if err := s.saveGenesisValidators(ctx, genesisState); err != nil {
-		return errors.Wrap(err, "could not save genesis validators")
+		return errors.Wrap(err, "could not save genesis block root")
 	}
 
-	genesisCheckpoint := &ethpb.Checkpoint{Root: genesisBlkRoot[:]}
-	if err := s.forkChoiceStore.GenesisStore(ctx, genesisCheckpoint, genesisCheckpoint); err != nil {
-		return errors.Wrap(err, "Could not start fork choice service: %v")
+	// Finalized checkpoint at genesis is a zero hash.
+	genesisCheckpoint := genesisState.FinalizedCheckpoint()
+
+	s.justifiedCheckpt = stateTrie.CopyCheckpoint(genesisCheckpoint)
+	if err := s.cacheJustifiedStateBalances(ctx, genesisBlkRoot); err != nil {
+		return err
+	}
+	s.prevJustifiedCheckpt = stateTrie.CopyCheckpoint(genesisCheckpoint)
+	s.bestJustifiedCheckpt = stateTrie.CopyCheckpoint(genesisCheckpoint)
+	s.finalizedCheckpt = stateTrie.CopyCheckpoint(genesisCheckpoint)
+	s.prevFinalizedCheckpt = stateTrie.CopyCheckpoint(genesisCheckpoint)
+
+	if err := s.forkChoiceStore.ProcessBlock(ctx,
+		genesisBlk.Block.Slot,
+		genesisBlkRoot,
+		params.BeaconConfig().ZeroHash,
+		[32]byte{},
+		genesisCheckpoint.Epoch,
+		genesisCheckpoint.Epoch); err != nil {
+		log.Fatalf("Could not process genesis block for fork choice: %v", err)
 	}
 
-	s.genesisRoot = genesisBlkRoot
-	s.headBlock = genesisBlk
-	s.headState = genesisState
-	s.canonicalRoots[genesisState.Slot] = genesisBlkRoot[:]
+	s.setHead(genesisBlkRoot, genesisBlk, genesisState)
 
 	return nil
 }
 
 // This gets called to initialize chain info variables using the finalized checkpoint stored in DB
 func (s *Service) initializeChainInfo(ctx context.Context) error {
-	s.headLock.Lock()
-	defer s.headLock.Unlock()
-
 	genesisBlock, err := s.beaconDB.GenesisBlock(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get genesis block from db")
@@ -356,12 +386,29 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 	if genesisBlock == nil {
 		return errors.New("no genesis block in db")
 	}
-	genesisBlkRoot, err := ssz.HashTreeRoot(genesisBlock.Block)
+	genesisBlkRoot, err := stateutil.BlockRoot(genesisBlock.Block)
 	if err != nil {
 		return errors.Wrap(err, "could not get signing root of genesis block")
 	}
 	s.genesisRoot = genesisBlkRoot
 
+	if flags.Get().UnsafeSync {
+		headBlock, err := s.beaconDB.HeadBlock(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not retrieve head block")
+		}
+		headRoot, err := stateutil.BlockRoot(headBlock.Block)
+		if err != nil {
+			return errors.Wrap(err, "could not hash head block")
+		}
+		headState, err := s.beaconDB.HeadState(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not retrieve head state")
+		}
+		s.setHead(headRoot, headBlock, headState)
+		return nil
+	}
+
 	finalized, err := s.beaconDB.FinalizedCheckpoint(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint from db")
@@ -371,19 +418,46 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 		// would be the genesis state and block.
 		return errors.New("no finalized epoch in the database")
 	}
-	s.headState, err = s.beaconDB.State(ctx, bytesutil.ToBytes32(finalized.Root))
+	finalizedRoot := bytesutil.ToBytes32(finalized.Root)
+	var finalizedState *stateTrie.BeaconState
+
+	finalizedState, err = s.stateGen.Resume(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized state from db")
 	}
-	s.headBlock, err = s.beaconDB.Block(ctx, bytesutil.ToBytes32(finalized.Root))
+	finalizedRoot = s.beaconDB.LastArchivedRoot(ctx)
+	if finalizedRoot == params.BeaconConfig().ZeroHash {
+		finalizedRoot = bytesutil.ToBytes32(finalized.Root)
+	}
+
+	finalizedBlock, err := s.beaconDB.Block(ctx, finalizedRoot)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized block from db")
 	}
 
-	if s.headBlock != nil && s.headBlock.Block != nil {
-		s.headSlot = s.headBlock.Block.Slot
+	if finalizedState == nil || finalizedBlock == nil {
+		return errors.New("finalized state and block can't be nil")
 	}
-	s.canonicalRoots[s.headSlot] = finalized.Root
+	s.setHead(finalizedRoot, finalizedBlock, finalizedState)
 
 	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) {
+	store := protoarray.New(justifiedCheckpoint.Epoch, finalizedCheckpoint.Epoch, bytesutil.ToBytes32(finalizedCheckpoint.Root))
+	s.forkChoiceStore = store
+}
+
+// This returns true if block has been processed before. Two ways to verify the block has been processed:
+// 1.) Check fork choice store.
+// 2.) Check DB.
+// Checking 1.) is ten times faster than checking 2.)
+func (s *Service) hasBlock(ctx context.Context, root [32]byte) bool {
+	if s.forkChoiceStore.HasNode(root) {
+		return true
+	}
+
+	return s.beaconDB.HasBlock(ctx, root)
+}

beacon-chain/blockchain/service_norace_test.go

@@ -5,8 +5,8 @@ import (
 	"io/ioutil"
 	"testing"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"github.com/sirupsen/logrus"
 )
 
@@ -16,22 +16,12 @@ func init() {
 }
 
 func TestChainService_SaveHead_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, _ := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB:       db,
-		canonicalRoots: make(map[uint64][]byte),
+		beaconDB: db,
 	}
 	go func() {
-		s.saveHead(
-			context.Background(),
-			&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 777}},
-			[32]byte{},
-		)
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	s.saveHead(
-		context.Background(),
-		&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 888}},
-		[32]byte{},
-	)
+	require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 }

beacon-chain/blockchain/service_test.go

@@ -3,7 +3,6 @@ package blockchain
 import (
 	"bytes"
 	"context"
-	"encoding/hex"
 	"io/ioutil"
 	"reflect"
 	"testing"
@@ -12,23 +11,29 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	ssz "github.com/prysmaticlabs/go-ssz"
+	"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"
 	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/p2p"
 	"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"
 )
@@ -38,34 +43,6 @@ func init() {
 	logrus.SetOutput(ioutil.Discard)
 }
 
-type store struct {
-	headRoot []byte
-}
-
-func (s *store) OnBlock(ctx context.Context, b *ethpb.SignedBeaconBlock) error {
-	return nil
-}
-
-func (s *store) OnBlockInitialSyncStateTransition(ctx context.Context, b *ethpb.SignedBeaconBlock) error {
-	return nil
-}
-
-func (s *store) OnAttestation(ctx context.Context, a *ethpb.Attestation) error {
-	return nil
-}
-
-func (s *store) GenesisStore(ctx context.Context, justifiedCheckpoint *ethpb.Checkpoint, finalizedCheckpoint *ethpb.Checkpoint) error {
-	return nil
-}
-
-func (s *store) FinalizedCheckpt() *ethpb.Checkpoint {
-	return nil
-}
-
-func (s *store) Head(ctx context.Context) ([]byte, error) {
-	return s.headRoot, nil
-}
-
 type mockBeaconNode struct {
 	stateFeed *event.Feed
 }
@@ -87,274 +64,286 @@ func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	return nil
 }
 
+func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ *ethpb.Attestation) error {
+	mb.broadcastCalled = true
+	return nil
+}
+
 var _ = p2p.Broadcaster(&mockBroadcaster{})
 
-func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
-	endpoint := "ws://127.0.0.1"
+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
 	var err error
+	bState, _ := testutil.DeterministicGenesisState(t, 10)
+	err = beaconDB.SavePowchainData(ctx, &protodb.ETH1ChainData{
+		BeaconState: bState.InnerStateUnsafe(),
+		Trie:        &protodb.SparseMerkleTrie{},
+		CurrentEth1Data: &protodb.LatestETH1Data{
+			BlockHash: make([]byte, 32),
+		},
+		ChainstartData: &protodb.ChainStartData{
+			Eth1Data: &ethpb.Eth1Data{
+				DepositRoot:  make([]byte, 32),
+				DepositCount: 0,
+				BlockHash:    make([]byte, 32),
+			},
+		},
+		DepositContainers: []*protodb.DepositContainer{},
+	})
+	require.NoError(t, err)
 	web3Service, err = powchain.NewService(ctx, &powchain.Web3ServiceConfig{
 		BeaconDB:        beaconDB,
-		ETH1Endpoint:    endpoint,
+		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()})
+	require.NoError(t, err)
+
+	depositCache, err := depositcache.NewDepositCache()
+	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, sc),
+		ForkChoiceStore:   protoarray.New(0, 0, params.BeaconConfig().ZeroHash),
+		OpsService:        opsService,
 	}
-	if err != nil {
-		t.Fatalf("could not register blockchain service: %v", err)
+
+	// Safe a state in stategen to purposes of testing a service stop / shutdown.
+	if err := cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState); err != nil {
+		t.Fatal(err)
 	}
+
 	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)
-	defer testDB.TeardownDB(t, db)
-	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, "Genesis time reached")
-}
-
 func TestChainStartStop_Initialized(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 
-	chainService := setupBeaconChain(t, db)
+	chainService := setupBeaconChain(t, db, sc)
 
-	genesisBlk := b.NewGenesisBlock([]byte{})
-	blkRoot, err := ssz.HashTreeRoot(genesisBlk.Block)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveBlock(ctx, genesisBlk); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveState(ctx, &pb.BeaconState{Slot: 1}, 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)
-	}
+	genesisBlk := testutil.NewBeaconBlock()
+	blkRoot, err := stateutil.BlockRoot(genesisBlk.Block)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, genesisBlk))
+	s := testutil.NewBeaconState()
+	require.NoError(t, s.SetSlot(1))
+	require.NoError(t, db.SaveState(ctx, s, blkRoot))
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot))
+	require.NoError(t, db.SaveGenesisBlockRoot(ctx, blkRoot))
+	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
 
 	// 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 TestChainService_InitializeBeaconChain(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	helpers.ClearCache()
+	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, _, _ := testutil.DeterministicDepositsAndKeys(count)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(count)
+	require.NoError(t, err)
 	trie, _, err := testutil.DepositTrieFromDeposits(deposits)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	hashTreeRoot := trie.HashTreeRoot()
-	genState := state.EmptyGenesisState()
-	genState.Eth1Data = &ethpb.Eth1Data{
+	genState, err := state.EmptyGenesisState()
+	require.NoError(t, err)
+	err = genState.SetEth1Data(&ethpb.Eth1Data{
 		DepositRoot:  hashTreeRoot[:],
 		DepositCount: uint64(len(deposits)),
-	}
-	genState, err = b.ProcessDeposits(ctx, genState, &ethpb.BeaconBlockBody{Deposits: deposits})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{
-		DepositRoot: hashTreeRoot[:],
-	}); err != nil {
-		t.Fatal(err)
-	}
+	})
+	genState, err = b.ProcessPreGenesisDeposits(ctx, genState, deposits)
+	require.NoError(t, err)
 
-	s, err := bc.beaconDB.State(ctx, bytesutil.ToBytes32(bc.canonicalRoots[0]))
-	if err != nil {
-		t.Fatal(err)
-	}
+	_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:]})
+	require.NoError(t, err)
 
-	for _, v := range s.Validators {
-		if !db.HasValidatorIndex(ctx, bytesutil.ToBytes48(v.PublicKey)) {
-			t.Errorf("Validator %s missing from db", hex.EncodeToString(v.PublicKey))
-		}
-	}
-
-	if _, err := bc.HeadState(ctx); err != nil {
-		t.Error(err)
-	}
-	if bc.HeadBlock() == nil {
+	_, err = bc.HeadState(ctx)
+	assert.NoError(t, err)
+	headBlk, err := bc.HeadBlock(ctx)
+	require.NoError(t, err)
+	if headBlk == nil {
 		t.Error("Head state can't be nil after initialize beacon chain")
 	}
-	if bc.CanonicalRoot(0) == nil {
-		t.Error("Canonical root for slot 0 can't be nil after initialize beacon chain")
+	if bc.headRoot() == 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 := stateutil.BlockRoot(genesisBlk.Block)
+	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))
+	// Test the start function.
+	chainService.Start()
+
+	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], 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)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	genesis := b.NewGenesisBlock([]byte{})
-	genesisRoot, err := ssz.HashTreeRoot(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)
-	}
+	genesis := testutil.NewBeaconBlock()
+	genesisRoot, err := stateutil.BlockRoot(genesis.Block)
+	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 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: finalizedSlot, ParentRoot: genesisRoot[:]}}
-	headState := &pb.BeaconState{Slot: finalizedSlot}
-	headRoot, _ := ssz.HashTreeRoot(headBlock.Block)
-	if err := db.SaveState(ctx, headState, headRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.SaveBlock(ctx, headBlock); err != nil {
-		t.Fatal(err)
-	}
+	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 := stateutil.BlockRoot(headBlock.Block)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveState(ctx, headState, headRoot))
+	require.NoError(t, db.SaveState(ctx, headState, genesisRoot))
+	require.NoError(t, db.SaveBlock(ctx, headBlock))
 	if err := db.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
 		Epoch: helpers.SlotToEpoch(finalizedSlot),
 		Root:  headRoot[:],
 	}); err != nil {
 		t.Fatal(err)
 	}
-	if err := db.SaveBlock(ctx, headBlock); err != nil {
-		t.Fatal(err)
-	}
-	c := &Service{beaconDB: db, canonicalRoots: make(map[uint64][]byte)}
-	if err := c.initializeChainInfo(ctx); err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(c.HeadBlock(), headBlock) {
-		t.Error("head block incorrect")
-	}
+	c := &Service{beaconDB: db, stateGen: stategen.New(db, sc)}
+	require.NoError(t, c.initializeChainInfo(ctx))
+	headBlk, err := c.HeadBlock(ctx)
+	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, headState) {
-		t.Error("head state incorrect")
-	}
-	if headBlock.Block.Slot != c.HeadSlot() {
+	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())
+	require.NoError(t, err)
+	if !bytes.Equal(headRoot[:], r) {
 		t.Error("head slot incorrect")
 	}
-	if !bytes.Equal(headRoot[:], c.HeadRoot()) {
-		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_SaveHeadNoDB(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	db, sc := testDB.SetupDB(t)
 	ctx := context.Background()
 	s := &Service{
-		beaconDB:       db,
-		canonicalRoots: make(map[uint64][]byte),
+		beaconDB: db,
+		stateGen: stategen.New(db, sc),
 	}
 	b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
-	r, _ := ssz.HashTreeRoot(b)
-	if err := s.saveHeadNoDB(ctx, b, r); err != nil {
-		t.Fatal(err)
-	}
+	r, err := ssz.HashTreeRoot(b)
+	require.NoError(t, err)
+	newState := testutil.NewBeaconState()
+	require.NoError(t, s.stateGen.SaveState(ctx, r, newState))
+	require.NoError(t, s.saveHeadNoDB(ctx, b, r, newState))
 
 	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 TestHasBlock_ForkChoiceAndDB(t *testing.T) {
+	ctx := context.Background()
+	db, _ := testDB.SetupDB(t)
+	s := &Service{
+		forkChoiceStore:  protoarray.New(0, 0, [32]byte{}),
+		finalizedCheckpt: &ethpb.Checkpoint{},
+		beaconDB:         db,
+	}
+	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
+	r, err := stateutil.BlockRoot(block.Block)
+	require.NoError(t, err)
+	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
+	state, err := beaconstate.InitializeFromProto(bs)
+	require.NoError(t, err)
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))
+
+	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
+	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
+}
+
+func BenchmarkHasBlockDB(b *testing.B) {
+	db, _ := testDB.SetupDB(b)
+	ctx := context.Background()
+	s := &Service{
+		beaconDB: db,
+	}
+	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
+	require.NoError(b, s.beaconDB.SaveBlock(ctx, block))
+	r, err := stateutil.BlockRoot(block.Block)
+	require.NoError(b, err)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		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)
+	s := &Service{
+		forkChoiceStore:  protoarray.New(0, 0, [32]byte{}),
+		finalizedCheckpt: &ethpb.Checkpoint{},
+		beaconDB:         db,
+	}
+	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
+	r, err := stateutil.BlockRoot(block.Block)
+	require.NoError(b, err)
+	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
+	state, err := beaconstate.InitializeFromProto(bs)
+	require.NoError(b, err)
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		require.Equal(b, true, s.forkChoiceStore.HasNode(r), "Block is not in fork choice store")
+	}
+}

beacon-chain/blockchain/testing/BUILD.bazel

@@ -1,23 +1,30 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("@prysm//tools/go:def.bzl", "go_library")
 
 go_library(
     name = "go_default_library",
     testonly = True,
     srcs = ["mock.go"],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing",
-    visibility = ["//beacon-chain:__subpackages__"],
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//fuzz:__pkg__",
+    ],
     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",
         "//beacon-chain/core/helpers:go_default_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/event: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_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/blockchain/testing/mock.go

@@ -1,18 +1,25 @@
+// Package testing includes useful mocks for writing unit
+// tests which depend on logic from the blockchain package.
 package testing
 
 import (
 	"bytes"
 	"context"
+	"sync"
 	"time"
 
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"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"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"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/event"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -21,7 +28,7 @@ import (
 
 // ChainService defines the mock interface for testing
 type ChainService struct {
-	State                       *pb.BeaconState
+	State                       *stateTrie.BeaconState
 	Root                        []byte
 	Block                       *ethpb.SignedBeaconBlock
 	FinalizedCheckPoint         *ethpb.Checkpoint
@@ -30,10 +37,16 @@ type ChainService struct {
 	BlocksReceived              []*ethpb.SignedBeaconBlock
 	Balance                     *precompute.Balance
 	Genesis                     time.Time
+	ValidatorsRoot              [32]byte
 	Fork                        *pb.Fork
+	ETH1Data                    *ethpb.Eth1Data
 	DB                          db.Database
 	stateNotifier               statefeed.Notifier
+	blockNotifier               blockfeed.Notifier
 	opNotifier                  opfeed.Notifier
+	ValidAttestation            bool
+	ForkChoiceStore             *protoarray.Store
+	VerifyBlkDescendantErr      error
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -44,15 +57,64 @@ func (ms *ChainService) StateNotifier() statefeed.Notifier {
 	return ms.stateNotifier
 }
 
+// BlockNotifier mocks the same method in the chain service.
+func (ms *ChainService) BlockNotifier() blockfeed.Notifier {
+	if ms.blockNotifier == nil {
+		ms.blockNotifier = &MockBlockNotifier{}
+	}
+	return ms.blockNotifier
+}
+
+// MockBlockNotifier mocks the block notifier.
+type MockBlockNotifier struct {
+	feed *event.Feed
+}
+
+// BlockFeed returns a block feed.
+func (msn *MockBlockNotifier) BlockFeed() *event.Feed {
+	if msn.feed == nil {
+		msn.feed = new(event.Feed)
+	}
+	return msn.feed
+}
+
 // MockStateNotifier mocks the state notifier.
 type MockStateNotifier struct {
 	feed *event.Feed
+
+	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 {
+	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
 }
@@ -78,32 +140,75 @@ 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) error {
-	return nil
-}
-
-// ReceiveBlockNoVerify mocks ReceiveBlockNoVerify method in chain service.
-func (ms *ChainService) ReceiveBlockNoVerify(ctx context.Context, block *ethpb.SignedBeaconBlock) error {
-	return nil
-}
-
-// ReceiveBlockNoPubsub mocks ReceiveBlockNoPubsub method in chain service.
-func (ms *ChainService) ReceiveBlockNoPubsub(ctx context.Context, block *ethpb.SignedBeaconBlock) error {
-	return nil
-}
-
-// ReceiveBlockNoPubsubForkchoice mocks ReceiveBlockNoPubsubForkchoice method in chain service.
-func (ms *ChainService) ReceiveBlockNoPubsubForkchoice(ctx context.Context, block *ethpb.SignedBeaconBlock) error {
+// ReceiveBlockInitialSync mocks ReceiveBlockInitialSync method in chain service.
+func (ms *ChainService) ReceiveBlockInitialSync(ctx context.Context, block *ethpb.SignedBeaconBlock, blockRoot [32]byte) error {
 	if ms.State == nil {
-		ms.State = &pb.BeaconState{}
+		ms.State = &stateTrie.BeaconState{}
 	}
 	if !bytes.Equal(ms.Root, block.Block.ParentRoot) {
 		return errors.Errorf("wanted %#x but got %#x", ms.Root, block.Block.ParentRoot)
 	}
-	ms.State.Slot = block.Block.Slot
+	if err := ms.State.SetSlot(block.Block.Slot); err != nil {
+		return err
+	}
 	ms.BlocksReceived = append(ms.BlocksReceived, block)
-	signingRoot, err := ssz.HashTreeRoot(block.Block)
+	signingRoot, err := stateutil.BlockRoot(block.Block)
+	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
+}
+
+// ReceiveBlockBatch processes blocks in batches from initial-sync.
+func (ms *ChainService) ReceiveBlockBatch(ctx context.Context, blks []*ethpb.SignedBeaconBlock, roots [][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 := stateutil.BlockRoot(block.Block)
+		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, blockRoot [32]byte) error {
+	if ms.State == nil {
+		ms.State = &stateTrie.BeaconState{}
+	}
+	if !bytes.Equal(ms.Root, block.Block.ParentRoot) {
+		return errors.Errorf("wanted %#x but got %#x", ms.Root, block.Block.ParentRoot)
+	}
+	if err := ms.State.SetSlot(block.Block.Slot); err != nil {
+		return err
+	}
+	ms.BlocksReceived = append(ms.BlocksReceived, block)
+	signingRoot, err := stateutil.BlockRoot(block.Block)
 	if err != nil {
 		return err
 	}
@@ -123,23 +228,22 @@ func (ms *ChainService) HeadSlot() uint64 {
 	if ms.State == nil {
 		return 0
 	}
-	return ms.State.Slot
-
+	return ms.State.Slot()
 }
 
 // HeadRoot mocks HeadRoot method in chain service.
-func (ms *ChainService) HeadRoot() []byte {
-	return ms.Root
+func (ms *ChainService) HeadRoot(ctx context.Context) ([]byte, error) {
+	return ms.Root, nil
 
 }
 
 // HeadBlock mocks HeadBlock method in chain service.
-func (ms *ChainService) HeadBlock() *ethpb.SignedBeaconBlock {
-	return ms.Block
+func (ms *ChainService) HeadBlock(context.Context) (*ethpb.SignedBeaconBlock, error) {
+	return ms.Block, nil
 }
 
 // HeadState mocks HeadState method in chain service.
-func (ms *ChainService) HeadState(context.Context) (*pb.BeaconState, error) {
+func (ms *ChainService) HeadState(context.Context) (*stateTrie.BeaconState, error) {
 	return ms.State, nil
 }
 
@@ -173,8 +277,13 @@ func (ms *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attes
 	return nil
 }
 
+// AttestationPreState mocks AttestationPreState method in chain service.
+func (ms *ChainService) AttestationPreState(ctx context.Context, att *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(ctx context.Context, epoch uint64) ([]uint64, error) {
 	if ms.State == nil {
 		return []uint64{}, nil
 	}
@@ -182,16 +291,65 @@ 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(ctx context.Context, epoch uint64) ([32]byte, error) {
 	return helpers.Seed(ms.State, epoch, params.BeaconConfig().DomainBeaconAttester)
 }
 
+// HeadETH1Data provides the current ETH1Data of the head state.
+func (ms *ChainService) HeadETH1Data() *ethpb.Eth1Data {
+	return ms.ETH1Data
+}
+
+// ProtoArrayStore mocks the same method in the chain service.
+func (ms *ChainService) ProtoArrayStore() *protoarray.Store {
+	return ms.ForkChoiceStore
+}
+
 // GenesisTime mocks the same method in the chain service.
 func (ms *ChainService) GenesisTime() time.Time {
 	return ms.Genesis
 }
 
+// GenesisValidatorRoot mocks the same method in the chain service.
+func (ms *ChainService) GenesisValidatorRoot() [32]byte {
+	return ms.ValidatorsRoot
+}
+
+// CurrentSlot mocks the same method in the chain service.
+func (ms *ChainService) CurrentSlot() uint64 {
+	return uint64(time.Now().Unix()-ms.Genesis.Unix()) / params.BeaconConfig().SecondsPerSlot
+}
+
 // Participation mocks the same method in the chain service.
 func (ms *ChainService) Participation(epoch uint64) *precompute.Balance {
 	return ms.Balance
 }
+
+// IsValidAttestation always returns true.
+func (ms *ChainService) IsValidAttestation(ctx context.Context, att *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) {
+	return true, nil
+}
+
+// ClearCachedStates does nothing.
+func (ms *ChainService) ClearCachedStates() {}
+
+// HasInitSyncBlock mocks the same method in the chain service.
+func (ms *ChainService) HasInitSyncBlock(root [32]byte) bool {
+	return false
+}
+
+// HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
+func (ms *ChainService) HeadGenesisValidatorRoot() [32]byte {
+	return [32]byte{}
+}
+
+// VerifyBlkDescendant mocks VerifyBlkDescendant and always returns nil.
+func (ms *ChainService) VerifyBlkDescendant(ctx context.Context, root [32]byte) error {
+	return ms.VerifyBlkDescendantErr
+}

beacon-chain/cache/BUILD.bazel

@@ -1,4 +1,5 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+load("@prysm//tools/go:def.bzl", "go_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_test")
 
 go_library(
     name = "go_default_library",
@@ -7,21 +8,32 @@ go_library(
         "checkpoint_state.go",
         "committee.go",
         "common.go",
-        "eth1_data.go",
+        "doc.go",
+        "hot_state_cache.go",
+        "skip_slot_cache.go",
+        "state_summary.go",
+        "subnet_ids.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache",
-    visibility = ["//beacon-chain:__subpackages__"],
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//fuzz:__pkg__",
+        "//tools:__subpackages__",
+    ],
     deps = [
+        "//beacon-chain/state:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/featureconfig:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/params:go_default_library",
         "//shared/sliceutil:go_default_library",
-        "@com_github_gogo_protobuf//proto:go_default_library",
+        "@com_github_hashicorp_golang_lru//:go_default_library",
+        "@com_github_patrickmn_go_cache//: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",
         "@io_k8s_client_go//tools/cache:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 
@@ -31,19 +43,25 @@ go_test(
     srcs = [
         "attestation_data_test.go",
         "checkpoint_state_test.go",
+        "committee_fuzz_test.go",
         "committee_test.go",
-        "eth1_data_test.go",
         "feature_flag_test.go",
+        "hot_state_cache_test.go",
+        "skip_slot_cache_test.go",
+        "subnet_ids_test.go",
     ],
     embed = [":go_default_library"],
-    race = "on",
     deps = [
+        "//beacon-chain/state:go_default_library",
         "//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

@@ -11,6 +11,7 @@ import (
 	"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/state"
 	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"k8s.io/client-go/tools/cache"
 )
@@ -59,12 +60,6 @@ func NewAttestationCache() *AttestationCache {
 // Get waits for any in progress calculation to complete before returning a
 // cached response, if any.
 func (c *AttestationCache) Get(ctx context.Context, req *ethpb.AttestationDataRequest) (*ethpb.AttestationData, error) {
-	if !featureconfig.Get().EnableAttestationCache {
-		// Return a miss result if cache is not enabled.
-		attestationCacheMiss.Inc()
-		return nil, nil
-	}
-
 	if req == nil {
 		return nil, errors.New("nil attestation data request")
 	}
@@ -104,6 +99,9 @@ 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
 	}
 	attestationCacheMiss.Inc()
@@ -113,10 +111,6 @@ func (c *AttestationCache) Get(ctx context.Context, req *ethpb.AttestationDataRe
 // MarkInProgress a request so that any other similar requests will block on
 // Get until MarkNotInProgress is called.
 func (c *AttestationCache) MarkInProgress(req *ethpb.AttestationDataRequest) error {
-	if !featureconfig.Get().EnableAttestationCache {
-		return nil
-	}
-
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	s, e := reqToKey(req)
@@ -126,19 +120,13 @@ func (c *AttestationCache) MarkInProgress(req *ethpb.AttestationDataRequest) err
 	if c.inProgress[s] {
 		return ErrAlreadyInProgress
 	}
-	if featureconfig.Get().EnableAttestationCache {
-		c.inProgress[s] = true
-	}
+	c.inProgress[s] = true
 	return nil
 }
 
 // MarkNotInProgress will release the lock on a given request. This should be
 // called after put.
 func (c *AttestationCache) MarkNotInProgress(req *ethpb.AttestationDataRequest) error {
-	if !featureconfig.Get().EnableAttestationCache {
-		return nil
-	}
-
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	s, e := reqToKey(req)
@@ -151,10 +139,6 @@ 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 {
-	if !featureconfig.Get().EnableAttestationCache {
-		return nil
-	}
-
 	data := &attestationReqResWrapper{
 		req,
 		res,
@@ -169,7 +153,10 @@ func (c *AttestationCache) Put(ctx context.Context, req *ethpb.AttestationDataRe
 }
 
 func wrapperToKey(i interface{}) (string, error) {
-	w := i.(*attestationReqResWrapper)
+	w, ok := i.(*attestationReqResWrapper)
+	if !ok {
+		return "", errors.New("key is not of type *attestationReqResWrapper")
+	}
 	if w == nil {
 		return "", errors.New("nil wrapper")
 	}
@@ -180,6 +167,9 @@ 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
 }
 

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

@@ -4,11 +4,10 @@ import (
 	"errors"
 	"sync"
 
-	"github.com/gogo/protobuf/proto"
 	"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"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/shared/hashutil"
 	"k8s.io/client-go/tools/cache"
 )
@@ -19,7 +18,9 @@ var (
 	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.
-	maxCheckpointStateSize = 4
+	// 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.
+	maxCheckpointStateSize = uint64(10)
 
 	// Metrics.
 	checkpointStateMiss = promauto.NewCounter(prometheus.CounterOpts{
@@ -35,7 +36,7 @@ var (
 // CheckpointState defines the active validator indices per epoch.
 type CheckpointState struct {
 	Checkpoint *ethpb.Checkpoint
-	State      *pb.BeaconState
+	State      *stateTrie.BeaconState
 }
 
 // CheckpointStateCache is a struct with 1 queue for looking up state by checkpoint.
@@ -67,7 +68,7 @@ func NewCheckpointStateCache() *CheckpointStateCache {
 
 // StateByCheckpoint fetches state by checkpoint. Returns true with a
 // reference to the CheckpointState info, if exists. Otherwise returns false, nil.
-func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (*pb.BeaconState, error) {
+func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (*stateTrie.BeaconState, error) {
 	c.lock.RLock()
 	defer c.lock.RUnlock()
 	h, err := hashutil.HashProto(cp)
@@ -92,7 +93,8 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (*pb.Beac
 		return nil, ErrNotCheckpointState
 	}
 
-	return proto.Clone(info.State).(*pb.BeaconState), nil
+	// Copy here is unnecessary since the return will only be used to verify attestation signature.
+	return info.State, nil
 }
 
 // AddCheckpointState adds CheckpointState object to the cache. This method also trims the least
@@ -100,7 +102,10 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (*pb.Beac
 func (c *CheckpointStateCache) AddCheckpointState(cp *CheckpointState) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
-	if err := c.cache.AddIfNotPresent(cp); err != nil {
+	if err := c.cache.AddIfNotPresent(&CheckpointState{
+		Checkpoint: stateTrie.CopyCheckpoint(cp.Checkpoint),
+		State:      cp.State.Copy(),
+	}); err != nil {
 		return err
 	}
 

beacon-chain/cache/checkpoint_state_test.go

@@ -1,110 +1,107 @@
 package cache
 
 import (
-	"reflect"
 	"testing"
 
+	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	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: []byte{'A'}}
+	cp := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
+	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Slot: 64,
+	})
+	require.NoError(t, err)
+
 	info := &CheckpointState{
 		Checkpoint: cp,
-		State:      &pb.BeaconState{Slot: 64},
+		State:      st,
 	}
 	key, err := checkpointState(info)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, 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[:]))
-	}
+	require.NoError(t, err)
+	assert.Equal(t, string(wantedKey[:]), key)
 }
 
 func TestCheckpointStateCacheKeyFn_InvalidObj(t *testing.T) {
 	_, err := checkpointState("bad")
-	if err != ErrNotCheckpointState {
-		t.Errorf("Expected error %v, got %v", ErrNotCheckpointState, err)
-	}
+	assert.Equal(t, ErrNotCheckpointState, err)
 }
 
 func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 	cache := NewCheckpointStateCache()
 
-	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: []byte{'A'}}
+	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
+	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:],
+		Slot:                  64,
+	})
+	require.NoError(t, err)
+
 	info1 := &CheckpointState{
 		Checkpoint: cp1,
-		State:      &pb.BeaconState{Slot: 64},
+		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)
+	assert.Equal(t, (*stateTrie.BeaconState)(nil), state, "Expected state not to exist in empty cache")
+
+	require.NoError(t, cache.AddCheckpointState(info1))
 
-	if err := cache.AddCheckpointState(info1); err != nil {
-		t.Fatal(err)
-	}
 	state, err = cache.StateByCheckpoint(cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(state, info1.State) {
+	require.NoError(t, err)
+
+	if !proto.Equal(state.InnerStateUnsafe(), info1.State.InnerStateUnsafe()) {
 		t.Error("incorrectly cached state")
 	}
 
-	cp2 := &ethpb.Checkpoint{Epoch: 2, Root: []byte{'B'}}
+	cp2 := &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'B'}, 32)}
+	st2, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Slot: 128,
+	})
+	require.NoError(t, err)
+
 	info2 := &CheckpointState{
 		Checkpoint: cp2,
-		State:      &pb.BeaconState{Slot: 128},
-	}
-	if err := cache.AddCheckpointState(info2); err != nil {
-		t.Fatal(err)
+		State:      st2,
 	}
+	require.NoError(t, cache.AddCheckpointState(info2))
+
 	state, err = cache.StateByCheckpoint(cp2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(state, info2.State) {
-		t.Error("incorrectly cached state")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, info2.State.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")
 
 	state, err = cache.StateByCheckpoint(cp1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(state, info1.State) {
-		t.Error("incorrectly cached state")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, info1.State.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")
 }
 
-func TestCheckpointStateCache__MaxSize(t *testing.T) {
+func TestCheckpointStateCache_MaxSize(t *testing.T) {
 	c := NewCheckpointStateCache()
+	st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
+		Slot: 0,
+	})
+	require.NoError(t, err)
+
+	for i := uint64(0); i < maxCheckpointStateSize+100; i++ {
+		require.NoError(t, st.SetSlot(i))
 
-	for i := 0; i < maxCheckpointStateSize+100; i++ {
 		info := &CheckpointState{
-			Checkpoint: &ethpb.Checkpoint{Epoch: uint64(i)},
-			State:      &pb.BeaconState{Slot: uint64(i)},
-		}
-		if err := c.AddCheckpointState(info); err != nil {
-			t.Fatal(err)
+			Checkpoint: &ethpb.Checkpoint{Epoch: i},
+			State:      st,
 		}
+		require.NoError(t, c.AddCheckpointState(info))
 	}
 
-	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, uint64(len(c.cache.ListKeys())))
 }

beacon-chain/cache/committee.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 	"k8s.io/client-go/tools/cache"
@@ -20,7 +19,7 @@ var (
 	// 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
+	maxCommitteesCacheSize = uint64(10)
 
 	// CommitteeCacheMiss tracks the number of committee requests that aren't present in the cache.
 	CommitteeCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
@@ -40,6 +39,7 @@ type Committees struct {
 	Seed            [32]byte
 	ShuffledIndices []uint64
 	SortedIndices   []uint64
+	ProposerIndices []uint64
 }
 
 // CommitteeCache is a struct with 1 queue for looking up shuffled indices list by seed.
@@ -68,9 +68,6 @@ func NewCommitteesCache() *CommitteeCache {
 // 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 *CommitteeCache) Committee(slot uint64, seed [32]byte, index uint64) ([]uint64, error) {
-	if !featureconfig.Get().EnableShuffledIndexCache && !featureconfig.Get().EnableNewCache {
-		return nil, nil
-	}
 	c.lock.RLock()
 	defer c.lock.RUnlock()
 
@@ -99,21 +96,50 @@ func (c *CommitteeCache) Committee(slot uint64, seed [32]byte, index uint64) ([]
 	indexOffSet := index + (slot%params.BeaconConfig().SlotsPerEpoch)*committeeCountPerSlot
 	start, end := startEndIndices(item, indexOffSet)
 
+	if end > uint64(len(item.ShuffledIndices)) || end < start {
+		return nil, errors.New("requested index out of bound")
+	}
+
 	return item.ShuffledIndices[start:end], 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 *CommitteeCache) AddCommitteeShuffledList(committees *Committees) error {
-	if !featureconfig.Get().EnableShuffledIndexCache && !featureconfig.Get().EnableNewCache {
-		return nil
-	}
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
 	if err := c.CommitteeCache.AddIfNotPresent(committees); err != nil {
 		return err
 	}
+	trim(c.CommitteeCache, maxCommitteesCacheSize)
+	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
@@ -121,10 +147,6 @@ func (c *CommitteeCache) AddCommitteeShuffledList(committees *Committees) error
 
 // ActiveIndices returns the active indices of a given seed stored in cache.
 func (c *CommitteeCache) ActiveIndices(seed [32]byte) ([]uint64, error) {
-	if !featureconfig.Get().EnableShuffledIndexCache && !featureconfig.Get().EnableNewCache {
-		return nil, nil
-	}
-
 	c.lock.RLock()
 	defer c.lock.RUnlock()
 	obj, exists, err := c.CommitteeCache.GetByKey(key(seed))
@@ -147,6 +169,54 @@ func (c *CommitteeCache) ActiveIndices(seed [32]byte) ([]uint64, error) {
 	return item.SortedIndices, nil
 }
 
+// ActiveIndicesCount returns the active indices count of a given seed stored in cache.
+func (c *CommitteeCache) ActiveIndicesCount(seed [32]byte) (int, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	obj, exists, err := c.CommitteeCache.GetByKey(key(seed))
+	if err != nil {
+		return 0, err
+	}
+
+	if exists {
+		CommitteeCacheHit.Inc()
+	} else {
+		CommitteeCacheMiss.Inc()
+		return 0, nil
+	}
+
+	item, ok := obj.(*Committees)
+	if !ok {
+		return 0, ErrNotCommittee
+	}
+
+	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
+}
+
 func startEndIndices(c *Committees, index uint64) (uint64, uint64) {
 	validatorCount := uint64(len(c.ShuffledIndices))
 	start := sliceutil.SplitOffset(validatorCount, c.CommitteeCount, index)
@@ -157,7 +227,7 @@ func startEndIndices(c *Committees, index uint64) (uint64, uint64) {
 // Using seed as source for key to handle reorgs in the same epoch.
 // The seed is derived from state's array of randao mixes and epoch value
 // hashed together. This avoids collisions on different validator set. Spec definition:
-// https://github.com/ethereum/eth2.0-specs/blob/v0.9.2/specs/core/0_beacon-chain.md#get_seed
+// https://github.com/ethereum/eth2.0-specs/blob/v0.9.3/specs/core/0_beacon-chain.md#get_seed
 func key(seed [32]byte) string {
 	return string(seed[:])
 }

beacon-chain/cache/committee_fuzz_test.go

@@ -0,0 +1,53 @@
+package cache
+
+import (
+	"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) {
+	fuzzer := fuzz.NewWithSeed(0)
+	c := &Committees{}
+
+	for i := 0; i < 100000; i++ {
+		fuzzer.Fuzz(c)
+		k, err := committeeKeyFn(c)
+		require.NoError(t, err)
+		assert.Equal(t, key(c.Seed), k)
+	}
+}
+
+func TestCommitteeCache_FuzzCommitteesByEpoch(t *testing.T) {
+	cache := NewCommitteesCache()
+	fuzzer := fuzz.NewWithSeed(0)
+	c := &Committees{}
+
+	for i := 0; i < 100000; i++ {
+		fuzzer.Fuzz(c)
+		require.NoError(t, cache.AddCommitteeShuffledList(c))
+		_, err := cache.Committee(0, c.Seed, 0)
+		require.NoError(t, err)
+	}
+
+	assert.Equal(t, maxCommitteesCacheSize, uint64(len(cache.CommitteeCache.ListKeys())), "Incorrect key size")
+}
+
+func TestCommitteeCache_FuzzActiveIndices(t *testing.T) {
+	cache := NewCommitteesCache()
+	fuzzer := fuzz.NewWithSeed(0)
+	c := &Committees{}
+
+	for i := 0; i < 100000; i++ {
+		fuzzer.Fuzz(c)
+		require.NoError(t, cache.AddCommitteeShuffledList(c))
+
+		indices, err := cache.ActiveIndices(c.Seed)
+		require.NoError(t, err)
+		assert.DeepEqual(t, c.SortedIndices, indices)
+	}
+
+	assert.Equal(t, maxCommitteesCacheSize, uint64(len(cache.CommitteeCache.ListKeys())), "Incorrect key size")
+}

beacon-chain/cache/committee_test.go

@@ -1,13 +1,15 @@
 package cache
 
 import (
-	"reflect"
+	"math"
 	"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) {
@@ -18,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) {
@@ -45,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) {
@@ -76,24 +60,62 @@ 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 not to exist in empty cache")
 	}
+
+	require.NoError(t, cache.AddCommitteeShuffledList(item))
+
+	indices, err = cache.ActiveIndices(item.Seed)
+	require.NoError(t, err)
+	assert.DeepEqual(t, item.SortedIndices, indices)
+}
+
+func TestCommitteeCache_ActiveCount(t *testing.T) {
+	cache := NewCommitteesCache()
+
+	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
+	count, err := cache.ActiveIndicesCount(item.Seed)
+	require.NoError(t, err)
+	assert.Equal(t, 0, count, "Expected active count not to exist in empty cache")
+
+	require.NoError(t, cache.AddCommitteeShuffledList(item))
+
+	count, err = cache.ActiveIndicesCount(item.Seed)
+	require.NoError(t, err)
+	assert.Equal(t, len(item.SortedIndices), count)
+}
+
+func TestCommitteeCache_AddProposerIndicesList(t *testing.T) {
+	cache := NewCommitteesCache()
+
+	seed := [32]byte{'A'}
+	indices := []uint64{1, 2, 3, 4, 5}
+	indices, err := cache.ProposerIndices(seed)
+	require.NoError(t, err)
 	if indices != nil {
 		t.Error("Expected committee count not to exist in empty cache")
 	}
+	require.NoError(t, cache.AddProposerIndicesList(seed, indices))
 
-	if err := cache.AddCommitteeShuffledList(item); err != nil {
-		t.Fatal(err)
-	}
+	received, err := cache.ProposerIndices(seed)
+	require.NoError(t, err)
+	assert.DeepEqual(t, received, indices)
 
-	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")
+	item := &Committees{Seed: [32]byte{'B'}, SortedIndices: []uint64{1, 2, 3, 4, 5, 6}}
+	require.NoError(t, cache.AddCommitteeShuffledList(item))
+
+	indices, err = cache.ProposerIndices(item.Seed)
+	require.NoError(t, err)
+	if indices != nil {
+		t.Error("Expected committee count not to exist in empty cache")
 	}
+	require.NoError(t, cache.AddProposerIndicesList(item.Seed, indices))
+
+	received, err = cache.ProposerIndices(item.Seed)
+	require.NoError(t, err)
+	assert.DeepEqual(t, received, indices)
 }
 
 func TestCommitteeCache_CanRotate(t *testing.T) {
@@ -103,25 +125,34 @@ func TestCommitteeCache_CanRotate(t *testing.T) {
 	for i := 100; i < 200; 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")
-	}
+	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) {
+	cache := NewCommitteesCache()
+	seed := bytesutil.ToBytes32([]byte("foo"))
+	err := cache.CommitteeCache.Add(&Committees{
+		CommitteeCount:  1,
+		Seed:            seed,
+		ShuffledIndices: []uint64{0},
+		SortedIndices:   []uint64{},
+		ProposerIndices: []uint64{},
+	})
+	require.NoError(t, err)
+
+	_, err = cache.Committee(0, seed, math.MaxUint64) // Overflow!
+	require.NotNil(t, err, "Did not fail as expected")
 }

beacon-chain/cache/common.go

@@ -8,14 +8,18 @@ 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-- {
-		// #nosec G104 popProcessNoopFunc never returns an error
-		_, _ = queue.Pop(popProcessNoopFunc)
+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
+			// happy.
+			return
+		}
 	}
 }
 

beacon-chain/cache/depositcache/BUILD.bazel

@@ -1,4 +1,5 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+load("@prysm//tools/go:def.bzl", "go_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_test")
 
 go_library(
     name = "go_default_library",
@@ -12,9 +13,12 @@ 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",
+        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -23,15 +27,20 @@ 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_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],
 )

beacon-chain/cache/depositcache/deposits_cache.go

@@ -1,3 +1,7 @@
+// Package depositcache is the source of validator deposits maintained
+// in-memory by the beacon node – deposits processed from the
+// eth1 powchain are then stored in this cache to be accessed by
+// any other service during a beacon node's runtime.
 package depositcache
 
 import (
@@ -11,8 +15,11 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/go-ssz"
 	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/trieutil"
 	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -26,31 +33,48 @@ 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
 // stores all the deposit related data that is required by the beacon-node.
 type DepositCache struct {
 	// Beacon chain deposits in memory.
-	pendingDeposits       []*dbpb.DepositContainer
-	deposits              []*dbpb.DepositContainer
-	depositsLock          sync.RWMutex
-	chainStartDeposits    []*ethpb.Deposit
-	chainstartPubkeys     map[string]bool
-	chainstartPubkeysLock sync.RWMutex
+	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 {
+func NewDepositCache() (*DepositCache, error) {
+	finalizedDepositsTrie, err := trieutil.NewTrie(int(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{},
-		chainstartPubkeys:  make(map[string]bool),
+		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
@@ -69,7 +93,7 @@ func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blo
 	}
 	dc.depositsLock.Lock()
 	defer dc.depositsLock.Unlock()
-	// keep the slice sorted on insertion in order to avoid costly sorting on retrival.
+	// Keep the slice sorted on insertion in order to avoid costly sorting on retrieval.
 	heightIdx := sort.Search(len(dc.deposits), func(i int) bool { return dc.deposits[i].Index >= index })
 	newDeposits := append([]*dbpb.DepositContainer{{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}}, dc.deposits[heightIdx:]...)
 	dc.deposits = append(dc.deposits[:heightIdx], newDeposits...)
@@ -88,9 +112,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 := dc.finalizedDeposits.MerkleTrieIndex + 1
+	for _, d := range dc.deposits {
+		if d.Index <= dc.finalizedDeposits.MerkleTrieIndex {
+			continue
+		}
+		if d.Index > eth1DepositIndex {
+			break
+		}
+		depHash, err := ssz.HashTreeRoot(d.Deposit.Data)
+		if err != nil {
+			log.WithError(err).Error("Could not hash deposit data. Finalized deposit cache not updated.")
+			return
+		}
+		depositTrie.Insert(depHash[:], int(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()
@@ -102,27 +157,23 @@ func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*dbpb.Deposi
 func (dc *DepositCache) MarkPubkeyForChainstart(ctx context.Context, pubkey string) {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.MarkPubkeyForChainstart")
 	defer span.End()
-	dc.chainstartPubkeysLock.Lock()
-	defer dc.chainstartPubkeysLock.Unlock()
-	dc.chainstartPubkeys[pubkey] = true
+	dc.chainStartPubkeys[pubkey] = true
 }
 
 // PubkeyInChainstart returns bool for whether the pubkey passed in has deposited.
 func (dc *DepositCache) PubkeyInChainstart(ctx context.Context, pubkey string) bool {
 	ctx, span := trace.StartSpan(ctx, "DepositsCache.PubkeyInChainstart")
 	defer span.End()
-	dc.chainstartPubkeysLock.Lock()
-	defer dc.chainstartPubkeysLock.Unlock()
-	if dc.chainstartPubkeys != nil {
-		return dc.chainstartPubkeys[pubkey]
+	if dc.chainStartPubkeys != nil {
+		return dc.chainStartPubkeys[pubkey]
 	}
-	dc.chainstartPubkeys = make(map[string]bool)
+	dc.chainStartPubkeys = make(map[string]bool)
 	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()
@@ -130,7 +181,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)
 		}
 	}
@@ -172,3 +223,39 @@ 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
+}

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -0,0 +1,483 @@
+package depositcache
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"math/big"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/go-ssz"
+	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"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{})
+
+func TestInsertDeposit_LogsOnNilDepositInsertion(t *testing.T) {
+	hook := logTest.NewGlobal()
+	dc, err := NewDepositCache()
+	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 := NewDepositCache()
+	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 := NewDepositCache()
+	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 := NewDepositCache()
+	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 := NewDepositCache()
+	require.NoError(t, err)
+
+	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))
+	assert.Equal(t, 5, int(n))
+	assert.Equal(t, bytesutil.ToBytes32([]byte("root")), root)
+}
+
+func TestDepositsNumberAndRootAtHeight_ReturnsEmptyTrieIfBlockHeightLessThanOldestDeposit(t *testing.T) {
+	dc, err := NewDepositCache()
+	require.NoError(t, err)
+
+	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))
+	assert.Equal(t, 0, int(n))
+	assert.Equal(t, [32]byte{}, root)
+}
+
+func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
+	dc, err := NewDepositCache()
+	require.NoError(t, err)
+
+	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")
+	}
+	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 := NewDepositCache()
+	require.NoError(t, err)
+
+	finalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{0},
+				},
+			},
+			Index: 0,
+		},
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{1},
+				},
+			},
+			Index: 1,
+		},
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{2},
+				},
+			},
+			Index: 2,
+		},
+	}
+	dc.deposits = append(finalizedDeposits, &dbpb.DepositContainer{
+		Deposit: &ethpb.Deposit{
+			Data: &ethpb.Deposit_Data{
+				PublicKey: []byte{3},
+			},
+		},
+		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 := ssz.HashTreeRoot(d.Deposit.Data)
+		require.NoError(t, err, "Could not hash deposit data")
+		deps = append(deps, hash[:])
+	}
+	trie, err := trieutil.GenerateTrieFromItems(deps, int(params.BeaconConfig().DepositContractTreeDepth))
+	require.NoError(t, err, "Could not generate deposit trie")
+	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
+}
+
+func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
+	dc, err := NewDepositCache()
+	require.NoError(t, err)
+
+	oldFinalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{0},
+				},
+			},
+			Index: 0,
+		},
+		{
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{1},
+				},
+			},
+			Index: 1,
+		},
+	}
+	newFinalizedDeposit := dbpb.DepositContainer{
+		Deposit: &ethpb.Deposit{
+			Data: &ethpb.Deposit_Data{
+				PublicKey: []byte{2},
+			},
+		},
+		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 := ssz.HashTreeRoot(d.Deposit.Data)
+		require.NoError(t, err, "Could not hash deposit data")
+		deps = append(deps, hash[:])
+	}
+	trie, err := trieutil.GenerateTrieFromItems(deps, int(params.BeaconConfig().DepositContractTreeDepth))
+	require.NoError(t, err, "Could not generate deposit trie")
+	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
+}
+
+func TestFinalizedDeposits_InitializedCorrectly(t *testing.T) {
+	dc, err := NewDepositCache()
+	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 := NewDepositCache()
+	require.NoError(t, err)
+
+	finalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{0},
+				},
+			},
+			Index: 0,
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{1},
+				},
+			},
+			Index: 1,
+		},
+	}
+	dc.deposits = append(finalizedDeposits,
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{2},
+				},
+			},
+			Index: 2,
+		},
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 11,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{3},
+				},
+			},
+			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 := NewDepositCache()
+	require.NoError(t, err)
+
+	finalizedDeposits := []*dbpb.DepositContainer{
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{0},
+				},
+			},
+			Index: 0,
+		},
+		{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{1},
+				},
+			},
+			Index: 1,
+		},
+	}
+	dc.deposits = append(finalizedDeposits,
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 10,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{2},
+				},
+			},
+			Index: 2,
+		},
+		&dbpb.DepositContainer{
+			Eth1BlockHeight: 11,
+			Deposit: &ethpb.Deposit{
+				Data: &ethpb.Deposit_Data{
+					PublicKey: []byte{3},
+				},
+			},
+			Index: 3,
+		})
+	dc.InsertFinalizedDeposits(context.Background(), 1)
+
+	deps := dc.NonFinalizedDeposits(context.Background(), big.NewInt(10))
+	assert.Equal(t, 1, len(deps))
+}

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,12 +3,14 @@ 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/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 )
 
 var _ = PendingDepositsFetcher(&DepositCache{})
@@ -17,24 +19,24 @@ 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{}
-	depToRemove := &ethpb.Deposit{Proof: [][]byte{[]byte("A")}}
-	otherDep := &ethpb.Deposit{Proof: [][]byte{[]byte("B")}}
+	proof1 := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
+	proof1[0] = bytesutil.PadTo([]byte{'A'}, 32)
+	proof2 := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
+	proof2[0] = bytesutil.PadTo([]byte{'A'}, 32)
+	depToRemove := &ethpb.Deposit{Proof: proof1}
+	otherDep := &ethpb.Deposit{Proof: proof2}
 	db.pendingDeposits = []*dbpb.DepositContainer{
 		{Deposit: depToRemove, Index: 1},
 		{Deposit: otherDep, Index: 5},
@@ -50,19 +52,17 @@ 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{}
-	dep := &ethpb.Deposit{Proof: [][]byte{[]byte("A")}}
+	proof := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
+	proof[0] = bytesutil.PadTo([]byte{'A'}, 32)
+	dep := &ethpb.Deposit{Proof: proof}
 	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) {
@@ -79,15 +79,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) {
@@ -111,9 +106,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) {
@@ -136,9 +129,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},
@@ -155,8 +146,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/doc.go

@@ -0,0 +1,5 @@
+// Package cache includes all important caches for the runtime
+// of an eth2 beacon node, ensuring the node does not spend
+// resources computing duplicate operations such as committee
+// calculations for validators during the same epoch, etc.
+package cache

beacon-chain/cache/eth1_data.go

@@ -1,136 +0,0 @@
-package cache
-
-import (
-	"errors"
-	"sync"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
-	"k8s.io/client-go/tools/cache"
-)
-
-var (
-	// ErrNotEth1DataVote will be returned when a cache object is not a pointer to
-	// a Eth1DataVote struct.
-	ErrNotEth1DataVote = errors.New("object is not a eth1 data vote obj")
-
-	// maxEth1DataVoteSize defines the max number of eth1 data votes can cache.
-	maxEth1DataVoteSize = 1000
-
-	// Metrics.
-	eth1DataVoteCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "eth1_data_vote_cache_miss",
-		Help: "The number of eth1 data vote count requests that aren't present in the cache.",
-	})
-	eth1DataVoteCacheHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "eth1_data_vote_cache_hit",
-		Help: "The number of eth1 data vote count requests that are present in the cache.",
-	})
-)
-
-// Eth1DataVote defines the struct which keeps track of the vote count of individual deposit root.
-type Eth1DataVote struct {
-	Eth1DataHash [32]byte
-	VoteCount    uint64
-}
-
-// Eth1DataVoteCache is a struct with 1 queue for looking up eth1 data vote count by deposit root.
-type Eth1DataVoteCache struct {
-	eth1DataVoteCache *cache.FIFO
-	lock              sync.RWMutex
-}
-
-// eth1DataVoteKeyFn takes the eth1data hash as the key for the eth1 data vote count of a given eth1data object.
-func eth1DataVoteKeyFn(obj interface{}) (string, error) {
-	eInfo, ok := obj.(*Eth1DataVote)
-	if !ok {
-		return "", ErrNotEth1DataVote
-	}
-
-	return string(eInfo.Eth1DataHash[:]), nil
-}
-
-// NewEth1DataVoteCache creates a new eth1 data vote count cache for storing/accessing Eth1DataVote.
-func NewEth1DataVoteCache() *Eth1DataVoteCache {
-	return &Eth1DataVoteCache{
-		eth1DataVoteCache: cache.NewFIFO(eth1DataVoteKeyFn),
-	}
-}
-
-// Eth1DataVote fetches eth1 data vote count by the eth1data hash. Returns vote count,
-// if exists. Otherwise returns false, nil.
-func (c *Eth1DataVoteCache) Eth1DataVote(eth1DataHash [32]byte) (uint64, error) {
-	if !featureconfig.Get().EnableEth1DataVoteCache {
-		// Return a miss result if cache is not enabled.
-		eth1DataVoteCacheMiss.Inc()
-		return 0, nil
-	}
-
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	obj, exists, err := c.eth1DataVoteCache.GetByKey(string(eth1DataHash[:]))
-	if err != nil {
-		return 0, err
-	}
-
-	if exists {
-		eth1DataVoteCacheHit.Inc()
-	} else {
-		eth1DataVoteCacheMiss.Inc()
-		return 0, nil
-	}
-
-	eInfo, ok := obj.(*Eth1DataVote)
-	if !ok {
-		return 0, ErrNotEth1DataVote
-	}
-
-	return eInfo.VoteCount, nil
-}
-
-// AddEth1DataVote adds eth1 data vote object to the cache. This method also trims the least
-// recently added Eth1DataVoteByEpoch object if the cache size has ready the max cache size limit.
-func (c *Eth1DataVoteCache) AddEth1DataVote(eth1DataVote *Eth1DataVote) error {
-	if !featureconfig.Get().EnableEth1DataVoteCache {
-		return nil
-	}
-
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if err := c.eth1DataVoteCache.Add(eth1DataVote); err != nil {
-		return err
-	}
-
-	trim(c.eth1DataVoteCache, maxEth1DataVoteSize)
-	return nil
-}
-
-// IncrementEth1DataVote increments the existing eth1 data object's vote count by 1,
-// and returns the vote count.
-func (c *Eth1DataVoteCache) IncrementEth1DataVote(eth1DataHash [32]byte) (uint64, error) {
-	if !featureconfig.Get().EnableEth1DataVoteCache {
-		return 0, nil
-	}
-
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	obj, exists, err := c.eth1DataVoteCache.GetByKey(string(eth1DataHash[:]))
-	if err != nil {
-		return 0, err
-	}
-	if !exists {
-		return 0, errors.New("eth1 data vote object does not exist")
-	}
-
-	eth1DataVoteCacheHit.Inc()
-
-	eInfo, _ := obj.(*Eth1DataVote)
-	eInfo.VoteCount++
-
-	if err := c.eth1DataVoteCache.Add(eInfo); err != nil {
-		return 0, err
-	}
-
-	return eInfo.VoteCount, nil
-}

beacon-chain/cache/eth1_data_test.go

@@ -1,110 +0,0 @@
-package cache
-
-import (
-	"strconv"
-	"testing"
-)
-
-func TestEth1DataVoteKeyFn_OK(t *testing.T) {
-	eInfo := &Eth1DataVote{
-		VoteCount:    44,
-		Eth1DataHash: [32]byte{'A'},
-	}
-
-	key, err := eth1DataVoteKeyFn(eInfo)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if key != string(eInfo.Eth1DataHash[:]) {
-		t.Errorf("Incorrect hash key: %s, expected %s", key, string(eInfo.Eth1DataHash[:]))
-	}
-}
-
-func TestEth1DataVoteKeyFn_InvalidObj(t *testing.T) {
-	_, err := eth1DataVoteKeyFn("bad")
-	if err != ErrNotEth1DataVote {
-		t.Errorf("Expected error %v, got %v", ErrNotEth1DataVote, err)
-	}
-}
-
-func TestEth1DataVoteCache_CanAdd(t *testing.T) {
-	cache := NewEth1DataVoteCache()
-
-	eInfo := &Eth1DataVote{
-		VoteCount:    55,
-		Eth1DataHash: [32]byte{'B'},
-	}
-	count, err := cache.Eth1DataVote(eInfo.Eth1DataHash)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count != 0 {
-		t.Error("Expected seed not to exist in empty cache")
-	}
-
-	if err := cache.AddEth1DataVote(eInfo); err != nil {
-		t.Fatal(err)
-	}
-	count, err = cache.Eth1DataVote(eInfo.Eth1DataHash)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count != eInfo.VoteCount {
-		t.Errorf(
-			"Expected vote count to be %d, got %d",
-			eInfo.VoteCount,
-			count,
-		)
-	}
-}
-
-func TestEth1DataVoteCache_CanIncrement(t *testing.T) {
-	cache := NewEth1DataVoteCache()
-
-	eInfo := &Eth1DataVote{
-		VoteCount:    55,
-		Eth1DataHash: [32]byte{'B'},
-	}
-
-	if err := cache.AddEth1DataVote(eInfo); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := cache.IncrementEth1DataVote(eInfo.Eth1DataHash)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, _ = cache.IncrementEth1DataVote(eInfo.Eth1DataHash)
-	count, _ := cache.IncrementEth1DataVote(eInfo.Eth1DataHash)
-
-	if count != 58 {
-		t.Errorf(
-			"Expected vote count to be %d, got %d",
-			58,
-			count,
-		)
-	}
-}
-
-func TestEth1Data_MaxSize(t *testing.T) {
-	cache := NewEth1DataVoteCache()
-
-	for i := 0; i < maxEth1DataVoteSize+1; i++ {
-		var hash [32]byte
-		copy(hash[:], []byte(strconv.Itoa(i)))
-		eInfo := &Eth1DataVote{
-			Eth1DataHash: hash,
-		}
-		if err := cache.AddEth1DataVote(eInfo); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	if len(cache.eth1DataVoteCache.ListKeys()) != maxEth1DataVoteSize {
-		t.Errorf(
-			"Expected hash cache key size to be %d, got %d",
-			maxEth1DataVoteSize,
-			len(cache.eth1DataVoteCache.ListKeys()),
-		)
-	}
-}

beacon-chain/cache/feature_flag_test.go

@@ -1,11 +1,14 @@
 package cache
 
-import "github.com/prysmaticlabs/prysm/shared/featureconfig"
+import (
+	"os"
+	"testing"
 
-func init() {
-	featureconfig.Init(&featureconfig.Flags{
-		EnableAttestationCache:   true,
-		EnableEth1DataVoteCache:  true,
-		EnableShuffledIndexCache: true,
-	})
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+)
+
+func TestMain(m *testing.M) {
+	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{EnableEth1DataVoteCache: true})
+	defer resetCfg()
+	os.Exit(m.Run())
 }

beacon-chain/cache/hot_state_cache.go

@@ -0,0 +1,90 @@
+package cache
+
+import (
+	"sync"
+
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+)
+
+var (
+	// hotStateCacheSize defines the max number of hot state this can cache.
+	hotStateCacheSize = 32
+	// Metrics
+	hotStateCacheHit = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "hot_state_cache_hit",
+		Help: "The total number of cache hits on the hot state cache.",
+	})
+	hotStateCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "hot_state_cache_miss",
+		Help: "The total number of cache misses on the hot state cache.",
+	})
+)
+
+// 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.
+func NewHotStateCache() *HotStateCache {
+	cache, err := lru.New(hotStateCacheSize)
+	if err != nil {
+		panic(err)
+	}
+	return &HotStateCache{
+		cache: cache,
+	}
+}
+
+// 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 {
+		hotStateCacheHit.Inc()
+		return item.(*stateTrie.BeaconState).Copy()
+	}
+	hotStateCacheMiss.Inc()
+	return nil
+}
+
+// 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()
+		return item.(*stateTrie.BeaconState)
+	}
+	hotStateCacheMiss.Inc()
+	return nil
+}
+
+// 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

@@ -0,0 +1,34 @@
+package cache_test
+
+import (
+	"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)
+	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,
+	})
+	require.NoError(t, err)
+
+	c.Put(root, state)
+	assert.Equal(t, true, c.Has(root), "Empty cache does not have an object")
+
+	res := c.Get(root)
+	assert.NotNil(t, state)
+	assert.DeepEqual(t, res.CloneInnerState(), state.CloneInnerState(), "Expected equal protos to return from cache")
+
+	c.Delete(root)
+	assert.Equal(t, false, c.Has(root), "Cache not supposed to have the object")
+}

beacon-chain/cache/skip_slot_cache.go

@@ -0,0 +1,148 @@
+package cache
+
+import (
+	"context"
+	"math"
+	"sync"
+	"time"
+
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"go.opencensus.io/trace"
+)
+
+var (
+	// Metrics
+	skipSlotCacheHit = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "skip_slot_cache_hit",
+		Help: "The total number of cache hits on the skip slot cache.",
+	})
+	skipSlotCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "skip_slot_cache_miss",
+		Help: "The total number of cache misses on the skip slot cache.",
+	})
+)
+
+// SkipSlotCache is used to store the cached results of processing skip slots in state.ProcessSlots.
+type SkipSlotCache struct {
+	cache      *lru.Cache
+	lock       sync.RWMutex
+	disabled   bool // Allow for programmatic toggling of the cache, useful during initial sync.
+	inProgress map[uint64]bool
+}
+
+// NewSkipSlotCache initializes the map and underlying cache.
+func NewSkipSlotCache() *SkipSlotCache {
+	cache, err := lru.New(8)
+	if err != nil {
+		panic(err)
+	}
+	return &SkipSlotCache{
+		cache:      cache,
+		inProgress: make(map[uint64]bool),
+	}
+}
+
+// Enable the skip slot cache.
+func (c *SkipSlotCache) Enable() {
+	c.disabled = false
+}
+
+// Disable the skip slot cache.
+func (c *SkipSlotCache) Disable() {
+	c.disabled = true
+}
+
+// Get waits for any in progress calculation to complete before returning a
+// cached response, if any.
+func (c *SkipSlotCache) Get(ctx context.Context, slot uint64) (*stateTrie.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "skipSlotCache.Get")
+	defer span.End()
+	if c.disabled {
+		// Return a miss result if cache is not enabled.
+		skipSlotCacheMiss.Inc()
+		return nil, nil
+	}
+
+	delay := minDelay
+
+	// Another identical request may be in progress already. Let's wait until
+	// any in progress request resolves or our timeout is exceeded.
+	inProgress := false
+	for {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
+
+		c.lock.RLock()
+		if !c.inProgress[slot] {
+			c.lock.RUnlock()
+			break
+		}
+		inProgress = true
+		c.lock.RUnlock()
+
+		// This increasing backoff is to decrease the CPU cycles while waiting
+		// for the in progress boolean to flip to false.
+		time.Sleep(time.Duration(delay) * time.Nanosecond)
+		delay *= delayFactor
+		delay = math.Min(delay, maxDelay)
+	}
+	span.AddAttributes(trace.BoolAttribute("inProgress", inProgress))
+
+	item, exists := c.cache.Get(slot)
+
+	if exists && item != nil {
+		skipSlotCacheHit.Inc()
+		span.AddAttributes(trace.BoolAttribute("hit", true))
+		return item.(*stateTrie.BeaconState).Copy(), nil
+	}
+	skipSlotCacheMiss.Inc()
+	span.AddAttributes(trace.BoolAttribute("hit", false))
+	return nil, nil
+}
+
+// MarkInProgress a request so that any other similar requests will block on
+// Get until MarkNotInProgress is called.
+func (c *SkipSlotCache) MarkInProgress(slot uint64) error {
+	if c.disabled {
+		return nil
+	}
+
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if c.inProgress[slot] {
+		return ErrAlreadyInProgress
+	}
+	c.inProgress[slot] = true
+	return nil
+}
+
+// MarkNotInProgress will release the lock on a given request. This should be
+// called after put.
+func (c *SkipSlotCache) MarkNotInProgress(slot uint64) error {
+	if c.disabled {
+		return nil
+	}
+
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	delete(c.inProgress, slot)
+	return nil
+}
+
+// Put the response in the cache.
+func (c *SkipSlotCache) Put(ctx context.Context, slot uint64, state *stateTrie.BeaconState) error {
+	if c.disabled {
+		return nil
+	}
+
+	// Copy state so cached value is not mutated.
+	c.cache.Add(slot, state.Copy())
+
+	return nil
+}

beacon-chain/cache/skip_slot_cache_test.go

@@ -0,0 +1,35 @@
+package cache_test
+
+import (
+	"context"
+	"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) {
+	ctx := context.Background()
+	c := cache.NewSkipSlotCache()
+
+	state, err := c.Get(ctx, 5)
+	require.NoError(t, err)
+	assert.Equal(t, (*stateTrie.BeaconState)(nil), state, "Empty cache returned an object")
+
+	require.NoError(t, c.MarkInProgress(5))
+
+	state, err = stateTrie.InitializeFromProto(&pb.BeaconState{
+		Slot: 10,
+	})
+	require.NoError(t, err)
+
+	require.NoError(t, c.Put(ctx, 5, state))
+	require.NoError(t, c.MarkNotInProgress(5))
+
+	res, err := c.Get(ctx, 5)
+	require.NoError(t, err)
+	assert.DeepEqual(t, res.CloneInnerState(), state.CloneInnerState(), "Expected equal protos to return from cache")
+}

beacon-chain/cache/state_summary.go

@@ -0,0 +1,65 @@
+package cache
+
+import (
+	"sync"
+
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+)
+
+// StateSummaryCache caches state summary object.
+type StateSummaryCache struct {
+	initSyncStateSummaries     map[[32]byte]*pb.StateSummary
+	initSyncStateSummariesLock sync.RWMutex
+}
+
+// NewStateSummaryCache creates a new state summary cache.
+func NewStateSummaryCache() *StateSummaryCache {
+	return &StateSummaryCache{
+		initSyncStateSummaries: make(map[[32]byte]*pb.StateSummary),
+	}
+}
+
+// Put saves a state summary to the initial sync state summaries cache.
+func (s *StateSummaryCache) Put(r [32]byte, b *pb.StateSummary) {
+	s.initSyncStateSummariesLock.Lock()
+	defer s.initSyncStateSummariesLock.Unlock()
+	s.initSyncStateSummaries[r] = b
+}
+
+// Has checks if a state summary exists in the initial sync state summaries cache using the root
+// of the block.
+func (s *StateSummaryCache) Has(r [32]byte) bool {
+	s.initSyncStateSummariesLock.RLock()
+	defer s.initSyncStateSummariesLock.RUnlock()
+	_, ok := s.initSyncStateSummaries[r]
+	return ok
+}
+
+// Get retrieves a state summary from the initial sync state summaries cache using the root of
+// the block.
+func (s *StateSummaryCache) Get(r [32]byte) *pb.StateSummary {
+	s.initSyncStateSummariesLock.RLock()
+	defer s.initSyncStateSummariesLock.RUnlock()
+	b := s.initSyncStateSummaries[r]
+	return b
+}
+
+// GetAll retrieves all the beacon state summaries from the initial sync state summaries cache, the returned
+// state summaries are unordered.
+func (s *StateSummaryCache) GetAll() []*pb.StateSummary {
+	s.initSyncStateSummariesLock.RLock()
+	defer s.initSyncStateSummariesLock.RUnlock()
+
+	blks := make([]*pb.StateSummary, 0, len(s.initSyncStateSummaries))
+	for _, b := range s.initSyncStateSummaries {
+		blks = append(blks, b)
+	}
+	return blks
+}
+
+// Clear clears out the initial sync state summaries cache.
+func (s *StateSummaryCache) Clear() {
+	s.initSyncStateSummariesLock.Lock()
+	defer s.initSyncStateSummariesLock.Unlock()
+	s.initSyncStateSummaries = make(map[[32]byte]*pb.StateSummary)
+}

beacon-chain/cache/subnet_ids.go

@@ -0,0 +1,134 @@
+package cache
+
+import (
+	"sync"
+	"time"
+
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/patrickmn/go-cache"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/sliceutil"
+)
+
+type subnetIDs struct {
+	attester          *lru.Cache
+	attesterLock      sync.RWMutex
+	aggregator        *lru.Cache
+	aggregatorLock    sync.RWMutex
+	persistentSubnets *cache.Cache
+	subnetsLock       sync.RWMutex
+}
+
+// SubnetIDs for attester and aggregator.
+var SubnetIDs = newSubnetIDs()
+
+func newSubnetIDs() *subnetIDs {
+	// Given a node can calculate committee assignments of current epoch and next epoch.
+	// Max size is set to 2 epoch length.
+	cacheSize := params.BeaconConfig().MaxCommitteesPerSlot * params.BeaconConfig().SlotsPerEpoch * 2
+	attesterCache, err := lru.New(int(cacheSize))
+	if err != nil {
+		panic(err)
+	}
+	aggregatorCache, err := lru.New(int(cacheSize))
+	if err != nil {
+		panic(err)
+	}
+	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch * params.BeaconConfig().SecondsPerSlot)
+	subLength := epochDuration * time.Duration(params.BeaconNetworkConfig().EpochsPerRandomSubnetSubscription)
+	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
+	return &subnetIDs{attester: attesterCache, aggregator: aggregatorCache, persistentSubnets: persistentCache}
+}
+
+// AddAttesterSubnetID adds the subnet index for subscribing subnet for the attester of a given slot.
+func (c *subnetIDs) AddAttesterSubnetID(slot uint64, subnetID uint64) {
+	c.attesterLock.Lock()
+	defer c.attesterLock.Unlock()
+
+	ids := []uint64{subnetID}
+	val, exists := c.attester.Get(slot)
+	if exists {
+		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
+	}
+	c.attester.Add(slot, ids)
+}
+
+// GetAttesterSubnetIDs gets the subnet IDs for subscribed subnets for attesters of the slot.
+func (c *subnetIDs) GetAttesterSubnetIDs(slot uint64) []uint64 {
+	c.attesterLock.RLock()
+	defer c.attesterLock.RUnlock()
+
+	val, exists := c.attester.Get(slot)
+	if !exists {
+		return nil
+	}
+	if v, ok := val.([]uint64); ok {
+		return v
+	}
+	return nil
+}
+
+// AddAggregatorSubnetID adds the subnet ID for subscribing subnet for the aggregator of a given slot.
+func (c *subnetIDs) AddAggregatorSubnetID(slot uint64, subnetID uint64) {
+	c.aggregatorLock.Lock()
+	defer c.aggregatorLock.Unlock()
+
+	ids := []uint64{subnetID}
+	val, exists := c.aggregator.Get(slot)
+	if exists {
+		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
+	}
+	c.aggregator.Add(slot, ids)
+}
+
+// GetAggregatorSubnetIDs gets the subnet IDs for subscribing subnet for aggregator of the slot.
+func (c *subnetIDs) GetAggregatorSubnetIDs(slot uint64) []uint64 {
+	c.aggregatorLock.RLock()
+	defer c.aggregatorLock.RUnlock()
+
+	val, exists := c.aggregator.Get(slot)
+	if !exists {
+		return []uint64{}
+	}
+	return val.([]uint64)
+}
+
+// GetPersistentSubnets retrieves the persistent subnet and expiration time of that validator's
+// subscription.
+func (c *subnetIDs) GetPersistentSubnets(pubkey []byte) ([]uint64, bool, time.Time) {
+	c.subnetsLock.RLock()
+	defer c.subnetsLock.RUnlock()
+
+	id, duration, ok := c.persistentSubnets.GetWithExpiration(string(pubkey))
+	if !ok {
+		return []uint64{}, ok, time.Time{}
+	}
+	return id.([]uint64), ok, duration
+}
+
+// GetAllSubnets retrieves all the non-expired subscribed subnets of all the validators
+// in the cache.
+func (c *subnetIDs) GetAllSubnets() []uint64 {
+	c.subnetsLock.RLock()
+	defer c.subnetsLock.RUnlock()
+
+	itemsMap := c.persistentSubnets.Items()
+	committees := []uint64{}
+
+	for _, v := range itemsMap {
+		if v.Expired() {
+			continue
+		}
+		committees = append(committees, v.Object.([]uint64)...)
+	}
+	return sliceutil.SetUint64(committees)
+}
+
+// AddPersistentCommittee adds the relevant committee for that particular validator along with its
+// expiration period.
+func (c *subnetIDs) AddPersistentCommittee(pubkey []byte, comIndex []uint64, duration time.Duration) {
+	c.subnetsLock.Lock()
+	defer c.subnetsLock.Unlock()
+
+	c.persistentSubnets.Set(string(pubkey), comIndex, duration)
+}

beacon-chain/cache/subnet_ids_test.go

@@ -0,0 +1,66 @@
+package cache
+
+import (
+	"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)
+	assert.Equal(t, 0, len(committeeIDs), "Empty cache returned an object")
+
+	c.AddAggregatorSubnetID(slot, 1)
+	res := c.GetAggregatorSubnetIDs(slot)
+	assert.DeepEqual(t, []uint64{1}, res)
+
+	c.AddAggregatorSubnetID(slot, 2)
+	res = c.GetAggregatorSubnetIDs(slot)
+	assert.DeepEqual(t, []uint64{1, 2}, res)
+
+	c.AddAggregatorSubnetID(slot, 3)
+	res = c.GetAggregatorSubnetIDs(slot)
+	assert.DeepEqual(t, []uint64{1, 2, 3}, res)
+
+	committeeIDs = c.GetAttesterSubnetIDs(slot)
+	assert.Equal(t, 0, len(committeeIDs), "Empty cache returned an object")
+
+	c.AddAttesterSubnetID(slot, 11)
+	res = c.GetAttesterSubnetIDs(slot)
+	assert.DeepEqual(t, []uint64{11}, res)
+
+	c.AddAttesterSubnetID(slot, 22)
+	res = c.GetAttesterSubnetIDs(slot)
+	assert.DeepEqual(t, []uint64{11, 22}, res)
+
+	c.AddAttesterSubnetID(slot, 33)
+	res = c.GetAttesterSubnetIDs(slot)
+	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 := uint64(0); i < 20; i++ {
+		pubkey := [48]byte{byte(i)}
+
+		idxs, ok, _ := c.GetPersistentSubnets(pubkey[:])
+		if !ok {
+			t.Errorf("Couldn't find entry in cache for pubkey %#x", pubkey)
+			continue
+		}
+		require.Equal(t, i, idxs[0])
+	}
+	coms := c.GetAllSubnets()
+	assert.Equal(t, 20, len(coms))
+}

beacon-chain/core/blocks/BUILD.bazel

@@ -1,25 +1,37 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+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 = [
-        "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__",
     ],
     deps = [
-        "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/state/stateutils: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/featureconfig:go_default_library",
+        "//shared/depositutil:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/mathutil:go_default_library",
         "//shared/params:go_default_library",
@@ -38,19 +50,33 @@ 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_test.go",
+        "block_regression_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"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/state/stateutils: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",
@@ -58,6 +84,5 @@ go_test(
         "@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,327 @@
+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/params"
+	"go.opencensus.io/trace"
+)
+
+// ProcessAttestations applies processing operations to a block's inner attestation
+// records.
+func ProcessAttestations(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	body *ethpb.BeaconBlockBody,
+) (*stateTrie.BeaconState, error) {
+	var err error
+	for idx, attestation := range 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 := ProcessAttestationNoVerify(ctx, beaconState, att)
+	if err != nil {
+		return nil, err
+	}
+	return beaconState, VerifyAttestation(ctx, beaconState, att)
+}
+
+// ProcessAttestationsNoVerify applies processing operations to a block's inner attestation
+// records. The only difference would be that the attestation signature would not be verified.
+func ProcessAttestationsNoVerify(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	body *ethpb.BeaconBlockBody,
+) (*stateTrie.BeaconState, error) {
+	var err error
+	for idx, attestation := range body.Attestations {
+		beaconState, err = ProcessAttestationNoVerify(ctx, beaconState, attestation)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not verify attestation at index %d in block", idx)
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessAttestationNoVerify processes the attestation without verifying the attestation signature. This
+// method is used to validate attestations whose signatures have already been verified.
+func ProcessAttestationNoVerify(
+	ctx context.Context,
+	beaconState *stateTrie.BeaconState,
+	att *ethpb.Attestation,
+) (*stateTrie.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "core.ProcessAttestationNoVerify")
+	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)
+	}
+
+	return beaconState, nil
+}
+
+// VerifyAttestations will verify the signatures of the provided attestations. This method performs
+// a single BLS verification call to verify the signatures of all of the provided attestations. All
+// of the provided attestations must have valid signatures or this method will return an error.
+// This method does not determine which attestation signature is invalid, only that one or more
+// attestation signatures were not valid.
+func VerifyAttestations(ctx context.Context, beaconState *stateTrie.BeaconState, atts []*ethpb.Attestation) error {
+	ctx, span := trace.StartSpan(ctx, "core.VerifyAttestations")
+	defer span.End()
+	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 := verifyAttestationsWithDomain(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 verifyAttestationsWithDomain(ctx, beaconState, postForkAtts, currDomain)
+}
+
+// VerifyAttestation converts and attestation into an indexed attestation and verifies
+// the signature in that attestation.
+func VerifyAttestation(ctx context.Context, beaconState *stateTrie.BeaconState, att *ethpb.Attestation) error {
+	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
+	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 verifyAttestationsWithDomain(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 := bls.VerifyMultipleSignatures(set.Signatures, set.Messages, set.PublicKeys)
+	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
+}