Minor runtime fixes (#2961)

* Minor fixes for runtime

* use comments

* goimports

* revert beacon-chain/core/state/state.go and fix comment for lint

* fix test too

.bazelrc

@@ -1,222 +1,5 @@
 # Print warnings for tests with inappropriate test size or timeout.
 test --test_verbose_timeout_warnings
 
-# Only build test targets when running bazel test //...
-test --build_tests_only
-test --test_output=errors
-
-# E2E run with debug gotag
-test:e2e --define gotags=debug
-
-# Clearly indicate that coverage is enabled to disable certain nogo checks.
-coverage --define=coverage_enabled=1
-
 # Fix for rules_docker. See: https://github.com/bazelbuild/rules_docker/issues/842
 build --host_force_python=PY2
-test --host_force_python=PY2
-run --host_force_python=PY2
-
-# Networking is blocked for tests by default, add "requires-network" tag to your test if networking
-# is required within the sandbox. Network sandboxing only works on linux.
-build --sandbox_default_allow_network=false
-
-# Stamp binaries with git information
-build --workspace_status_command=./hack/workspace_status.sh
-build --stamp
-
-# Prevent PATH changes from rebuilding when switching from IDE to command line.
-build --incompatible_strict_action_env
-test --incompatible_strict_action_env
-run --incompatible_strict_action_env
-
-build --define blst_disabled=false
-test --define blst_disabled=false
-run --define blst_disabled=false
-
-build:blst_disabled --define blst_disabled=true
-build:blst_disabled --define gotags=blst_disabled
-
-build:minimal --//proto:network=minimal
-build:minimal --@io_bazel_rules_go//go/config:tags=minimal
-
-# Release flags
-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 --@io_bazel_rules_go//go/config:tags=fuzz
-
-# 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
-
-# Ignore GoStdLib with remote caching
-build --modify_execution_info='GoStdlib.*=+no-remote-cache'
-
-# Set bazel gotag
-build --define gotags=bazel

.bazelversion

@@ -1 +0,0 @@
-5.0.0

.buildkite-bazelrc

@@ -2,45 +2,45 @@
 # 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_timeout=3600
-#build:remote-cache --spawn_strategy=standalone
-#build:remote-cache --strategy=Javac=standalone
-#build:remote-cache --strategy=Closure=standalone
-#build:remote-cache --strategy=Genrule=standalone
+build:remote-cache --remote_cache=grpcs://remotebuildexecution.googleapis.com
+build:remote-cache --remote_timeout=3600
+build:remote-cache --auth_enabled=true
+build:remote-cache --spawn_strategy=standalone
+build:remote-cache --strategy=Javac=standalone
+build:remote-cache --strategy=Closure=standalone
+build:remote-cache --strategy=Genrule=standalone
+
+# Build results backend.                                                        
+build:remote-cache --bes_results_url="https://source.cloud.google.com/results/invocations/"
+build:remote-cache --bes_backend=buildeventservice.googleapis.com               
+build:remote-cache --bes_timeout=60s                                            
+build:remote-cache --project_id=prysmaticlabs  
+build:remote-cache --bes_upload_mode=fully_async
 
 # Prysm specific remote-cache properties.
-#build:remote-cache --disk_cache=
-build:remote-cache --remote_download_minimal
-build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
-build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
-build:remote-cache --remote_local_fallback
-build:remote-cache --experimental_remote_cache_async
-build:remote-cache --experimental_remote_merkle_tree_cache
-build:remote-cache --experimental_action_cache_store_output_metadata
-build:remote-cache --experimental_remote_cache_compression
-# 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-cache --incompatible_strict_action_env=true
+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 --experimental_use_hermetic_linux_sandbox
+build:remote-cache --experimental_remote_download_outputs=minimal
+build:remote-cache --experimental_inmemory_jdeps_files
+build:remote-cache --experimental_inmemory_dotd_files
 
 # Import workspace options.
 import %workspace%/.bazelrc
 
-startup --host_jvm_args=-Xmx4g --host_jvm_args=-Xms2g
 build --experimental_strict_action_env
+build --disk_cache=/tmp/bazelbuilds
+build --experimental_multi_threaded_digest
 build --sandbox_tmpfs_path=/tmp
 build --verbose_failures
 build --announce_rc
 build --show_progress_rate_limit=5
-build --curses=no --color=no
+build --curses=yes --color=yes
 build --keep_going
 build --test_output=errors
 build --flaky_test_attempts=5
+build --jobs=50
+test --local_test_jobs=2
 # Disabled race detection due to unstable test results under constrained environment build kite
 # build --features=race
-
-# Better caching
-build:nostamp --nostamp
-build:nostamp --workspace_status_command=./hack/workspace_status_ci.sh

.codecov.yml

@@ -30,4 +30,4 @@ comment:
 
 ignore:
   - "**/*.pb.go"
-  - "**/testing/**/*"
+  - "**/*_mock.go"

.deepsource.toml

@@ -1,26 +0,0 @@
-version = 1
-
-exclude_patterns = [
-  "tools/analyzers/**",
-  "validator/keymanager/remote/keymanager_test.go",
-  "validator/web/site_data.go"
-]
-
-[[analyzers]]
-name = "go"
-enabled = true
-
-[analyzers.meta]
-import_paths = ["github.com/prysmaticlabs/prysm"]
-
-[[analyzers]]
-name = "test-coverage"
-enabled = true
-
-[[analyzers]]
-name = "shell"
-enabled = true
-
-[[analyzers]]
-name = "secrets"
-enabled = true

.dockerignore

@@ -1,2 +0,0 @@
-bazel-*
-.git

.github/CODEOWNERS

@@ -1,16 +0,0 @@
-# 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
-
-# Radek and Nishant are responsible for changes that can affect the native state feature.
-# See https://www.notion.so/prysmaticlabs/Native-Beacon-State-Redesign-6cc9744b4ec1439bb34fa829b36a35c1
-/beacon-chain/state/fieldtrie/ @rkapka @nisdas
-/beacon-chain/state/v1/ @rkapka @nisdas
-/beacon-chain/state/v2/ @rkapka @nisdas
-/beacon-chain/state/v3/ @rkapka @nisdas
-/beacon-chain/state/state-native/ @rkapka @nisdas

.github/ISSUE_TEMPLATE/bug_report.md

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

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

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

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

@@ -1,30 +0,0 @@
-<!-- Thanks for sending a PR! Before submitting:
-
-1. If this is your first PR, check out our contribution guide here https://docs.prylabs.network/docs/contribute/contribution-guidelines
-   You will then need to sign our Contributor License Agreement (CLA), which will show up as a comment from a bot in this pull request after you open it. We cannot review code without a signed CLA.
-2. Please file an associated tracking issue if this pull request is non-trivial and requires context for our team to understand. 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

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

.github/actions/gofmt/action.yml

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

@@ -1,15 +0,0 @@
-#!/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

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

.github/actions/gomodtidy/action.yml

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

.github/actions/gomodtidy/entrypoint.sh

@@ -1,34 +0,0 @@
-#!/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 -compat=1.17
-
-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

@@ -1,13 +0,0 @@
-# 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/go.yml

@@ -1,94 +0,0 @@
-name: Go
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ '*' ]
-
-jobs:
-  formatting:
-    name: Formatting
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Go mod tidy checker
-        id: gomodtidy
-        uses: ./.github/actions/gomodtidy
-
-      - name: Gofmt checker
-        id: gofmt
-        uses: ./.github/actions/gofmt
-        with:
-          path: ./
-
-      - name: GoImports checker
-        id: goimports
-        uses: Jerome1337/goimports-action@v1.0.2
-        with:
-          goimports-path: ./
-
-  gosec:
-    name: Gosec scan
-    runs-on: ubuntu-latest
-    env:
-      GO111MODULE: on
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Set up Go 1.17
-        uses: actions/setup-go@v3
-        with:
-          go-version: 1.17
-      - name: Run Gosec Security Scanner
-        run: | # https://github.com/securego/gosec/issues/469
-          export PATH=$PATH:$(go env GOPATH)/bin
-          go install github.com/securego/gosec/v2/cmd/gosec@latest
-          gosec -exclude=G307 -exclude-dir=crypto/bls/herumi ./...
-
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set up Go 1.17
-        uses: actions/setup-go@v3
-        with:
-          go-version: 1.17
-          id: go
-
-      - name: Golangci-lint
-        uses: golangci/golangci-lint-action@v2
-        with:
-          args: --print-issued-lines --sort-results --no-config --timeout=10m --disable-all -E deadcode  -E errcheck -E gosimple --skip-files=validator/web/site_data.go --skip-dirs=proto --go=1.17
-          version: v1.45.2
-          skip-go-installation: true
-
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up Go 1.x
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.17
-        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
-        # Use blst tag to allow go and bazel builds for blst.
-        run: go build -v ./...
-
-# Tests run via Bazel for now...
-#      - name: Test
-#        run: go test -v ./...

.github/workflows/horusec.yaml

@@ -1,22 +0,0 @@
-name: Horusec Security Scan
-
-on:
-  schedule:
-    # Runs cron at 16.00 UTC on
-    - cron: '0 0 * * SUN'
-
-jobs:
-  Horusec_Scan:
-    name: horusec-Scan
-    runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/develop'
-    steps:
-    - name: Check out code
-      uses: actions/checkout@v2
-      with: # Required when commit authors is enabled
-        fetch-depth: 0
-        
-    - name: Running Security Scan
-      run: |
-        curl -fsSL https://raw.githubusercontent.com/ZupIT/horusec/main/deployments/scripts/install.sh | bash -s latest
-        horusec start -t="10000" -p="./" -e="true" -i="**/crypto/bls/herumi/**, **/**/*_test.go, **/third_party/afl/**, **/crypto/keystore/key.go"

.gitignore

@@ -4,9 +4,6 @@ bazel-*
 .DS_Store
 .swp
 
-# Ignore VI/Vim swapfiles
-.*.sw?
-
 # IntelliJ
 .idea
 .ijwb
@@ -17,7 +14,6 @@ bazel-*
 # Coverage outputs
 coverage.txt
 profile.out
-profile.grind
 
 # Nodejs
 node_modules
@@ -25,10 +21,4 @@ yarn-error.log
 .vscode/
 
 # Ignore password file
-password.txt
-
-# Dist files
-dist
-
-# deepsource cli
-bin
+password.txt 

.policy.yml

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

.travis.yml

@@ -12,7 +12,7 @@ matrix:
         - go get ${gobuild_args} -t ./...
         - go get ${gobuild_args} github.com/golangci/golangci-lint/cmd/golangci-lint
       script:
-        - golangci-lint run --skip-dirs ./proto
+        - golangci-lint run
       email: false
       after_success:
         - wget https://raw.githubusercontent.com/k3rn31p4nic/travis-ci-discord-webhook/master/send.sh

.well-known/security.pub

@@ -1,218 +0,0 @@
------BEGIN PGP PUBLIC KEY BLOCK-----
-
-mQINBFpZUO0BEAC/tqN6QctJKSOF+A7jrBzvNvs6rVEi9Hn55u/scKNIPkSRJRTy
-8kVsDMha+EKXka8oQiVM+sHoHMIMCa3tdicm1/k5f67X8dqadQmFP4DhYRYIKCKT
-TkntNG568ynf/yUs/YY9Ce8H17JvgytkLK50mxMxycUlYREMaRPMR8Wt1Arrd9QT
-U0I2cZemeqUORKuiVuZjj/7BVDHvSXHvzpi5zKI86sJQTnzcuGqyNsrUU4n4sYrb
-I+0TfEHzmSdxoAXSaMYjomPLmbaSdBiK/CeNKF8xuFCKJRd8wOUe5FcIN3DCdk0e
-yoFye5RMC+W09Ro+tK/jTQ/sTUuNLJm0VUlddQQeoGlhQdLLwiU4PJqcyeL4KaN1
-l8cVml7xr1CdemhGV4wmEqAgxnNFN5mKnS2KcDaHxRz7MoGNdgVVQuxxaE0+OsdJ
-zCKtA12Q/OcR24qYVFg5+O+bUNhy23mqIxx0HiQ0DsK+IDvcLLWqta0aP9wd9wxG
-eObh9WkCxELTLg8xlbe0d7R3juaRjBLdD5d3UyjqGh+7zUflMsFhpUPraNXdKzvm
-AqT25cveadM7q/CNzFXeCwmKjZab8Jic8VB80KcikmX6y9eGOHwjFixBogxowlBq
-3KpeNTqJMNHYBzEb0V18P8huKVO0SMfg11Z1/nU4NA4lcjiVImb5xnJS0wARAQAB
-tCxQcmVzdG9uIFZhbiBMb29uIDxwcmVzdG9uQHByeXNtYXRpY2xhYnMuY29tPokC
-NwQTAQgAIQUCWuZ7uwIbAwULCQgHAgYVCAkKCwIEFgIDAQIeAQIXgAAKCRBy4z5N
-8aUDbtchD/4hQDTj7qsccQKpaL8furw+OWuoZtX38smO9LrcSoLaZlk5NRxFNlhQ
-FaL6iyDLoDkWUXEPg94x1dMFBUfMdIuh6iEF2pcvCN6WG3Pd2j2kG6OxaIx+rI7a
-eaD2Wds312etYATu+7AI6pxlQVqPeZi6kZVvXo8r9qzEnl1nifo7d3L4ut6FerDz
-/ptvIuhW++BEgksILkwMA44U7owTllkZ5wSbXRJer0bI/jLPLTaRETVMgWmF5L2n
-PWKhBnhBXf/P00zTHVoba0peJ/RGdzlb1JZH+uCQk0wGBl0rBMUmiihIB8DZBZDX
-5prwMdoHG9qAT9SuJ8ZOjPKaBHVVVw4JOU6rX2+p9E49CVATsdoPfWVbNyVRGi5f
-Oo0bJPZU3uO10Q09CIeyqT6JPDCZYS7po2bpfFjQTDkoIv0uPWOsV5l3cvFxVlcD
-Pvir4669xhujmoVBOrp18mn/W/rMft2TJ84inp0seKSKdwBUeEyIZwwu1YTorFe4
-bgJghDu/Y+K4y0wq7rpPimoiXSoJOaaIPrOzsKAVu20zJB4eoulXlPwHexix8wwf
-xeVH4bGl3wtTFWKja0+EQVdxpt+uUlABvrheQbNlNGz5ROOAtjvwASI3YW/jVVaG
-wSbOUuMEHfC1rSnj5Y9fN6FbilxJAZ2UbvZE6iXqqemfRdFuB5yedbQmUHJlc3Rv
-biBWYW4gTG9vbiA8cHJlc3RvbjkwQGdtYWlsLmNvbT6JAjcEEwEIACEFAlqrvbMC
-GwMFCwkIBwIGFQgJCgsCBBYCAwECHgECF4AACgkQcuM+TfGlA269zg/9FynobfLE
-Vh+Aid7l5C6pprHflHpdNVhdHzjvosLKfPMCcBJLyCLAIueKC0vvKbt5kyNV6Adl
-6fibdO/vRrNsEdmKXTdfDnN03yVX+VO54rqyuweR09CbLHakECh5awWpk0x9E/Gc
-3MlU8YDCVNPcWAw8JPZZ0y6s50/MFFXya+/opw45neH6WXrbqbIapzZ4V1bhkloF
-TTz7LYp1dk6qjus/f1jHgujclJ6FazG+OqCpzJ22lnuwNYs8sv1DclW+lEUfIin5
-PvzcSRCCd6NilFRSGzfBhM7wxZrAp0JzWXpM1jmd2WHtgErusTaTXRTATjPf9Chg
-SE9UT3EJvJ5fPxuxm+qOAowpJwe8Irv+YuMzL8C6C2BhZIV8XID3/cErNeQbPocj
-QFksmBEwpe9EG3Yhd5SmSXRhCtBFnyFKyOqPpAE2s+U0b7qsnWc50UFbIytPEm4C
-YmdNL6IVilp/+LYFcRWWK/ppOtvtgbj8r7+Foidi/tCauJGt2BzhWH7DkLEdXGxk
-PfR/rTgyuAQZowl03DaNwAPKegY2SIuROO9kpQACwTWZNg4l2yrZv09qrKBhohyn
-b2i4pwHPZ5/bWLikdzENcJuvbH5qhf6tV0FIaNGbTkWX00uI++bvWAxxE25jZv56
-e7VTaWuMt8Ly4DBcwl5JyWuvZ74+yv7QGp20WlByZXN0b24gVmFuIExvb24gKDB4
-ZjcxRTlDNzY2Q2RmMTY5ZURGYkUyNzQ5NDkwOTQzQzFEQzZiOEE1NSkgPHByZXN0
-b25AbWFjaGluZXBvd2VyZWQuY29tPokCNwQTAQgAIQUCWllQ7QIbAwULCQgHAgYV
-CAkKCwIEFgIDAQIeAQIXgAAKCRBy4z5N8aUDbmvdD/4jkT1IXJyj65sgHus0HHYC
-MBp6mzvtpDcPljg/5Nl1WXydv4zYGnEnIwWIqDYwwvokOKllxAjgevcplHqZa0cb
-7XKCFk5h+56FLPHv9e0WK1fOFeo2ad3imNRstSHgaumGAWHJMg9vWbDisGv1zjQ0
-usFkrMKoX34YzMt8KBD7IuQyeBkYNupT8EfByeA9Ta+wkvS+X6BojsFB1UWDAFCY
-z8RgTcWIFjWtGZwIkWUKCzebqXbElpJF8ckZU9q4qVhyZ2DT+8BS/Lm0Sf4z6VTC
-4EN10ZuN+F+J3DMR2Zuudp4X5OUGkDG4KuU/kvj6EJRWpbTS1D9ReK7hoApIbV72
-Um6Mf7kC9EKvxgL1gOfl4aj3Io9M0R8FT/0WSMduQzf/jI3XqdNH0nYo2kTDdZm8
-S972cyvt6frKYy6RsOlPz1+S61iCmupsRY+HyKDTa0vnpXg2c4dE1neF5eMI6SVw
-viJvCG2cflctJ2PLiINZJYAg87gV5Rm1i/Lt2YG5zdxAXXJt2R0uuU9fv4DcHZLU
-yx69Yuh+5UiEaXYU7xoRCdZJYyHbvaC2hPcDGnEa3K1QbgnI5hGAtG3cwdbYC5e3
-bcaJb/LdwzkdRnHLgpxa/UTAIfejEI1U2kvVvNoe/HvEXq/OPrhFDvE4rW8AzbX+
-ISTWWRY0lLSr8/SD0TDJMbkBDQRam2geAQgA0kESOibOO3CcXrHtqP9lPGmj6rVe
-G18fRmPDJiWtx863QqJeByuuUKwrGkPW/sqtIa5Ano+iXVHpk7m955nRjBmz4gd8
-xqSGZd9XpNObYPA5iirAO8ztpgQvuvsHH9y9Ge50NnR7hQSMUbGVeCUU/vljwT60
-/U+UPnsTAmkhvkEI72x50l5Ih9ihcBcr5jJpi08XktE3sFOoannac0kZQJ6WXFrY
-4ILbv8fVqcRf44xMKOlFB9qHhleGW0H9ZUjTKs9quRt7r5D1MOiwrZDjNN3LqMco
-oWj37hb+3KkmIIsAYB2DjnWYkMPu2B0O4uSOHYAWfEJtRvA8qW7sWj+q1wARAQAB
-iQIlBBgBCAAPBQJam2geAhsgBQkB4TOAAAoJEHLjPk3xpQNulz0P/2m9veAAGGCO
-yPsqiNVVa8lrhmLGh/W+BaoszQ/r+pfin4xTOV5K5h3MC5CVJM0JxP/cxNol+Nmr
-cYGbZgq4QhLlH6PdQ7cReL5ED6Wi+eHb4ocvXJqUuZ2Gl8Z7gzQzp+WFbLrn8vXj
-LcyGGEETV84jy+X5cKu24eAjTFK+unfqwfxXFZP5vhIEVe7+uG6A/pMB5eLDqEUh
-FQUcWqCF2Imt08Kcn7HL31GoIY0ABHdD+ICXZE5lTm6iJGzpFBKdTMm/e5igCJ3v
-/tgtWZbnvyseLR/T/gU1JyheS9kNXP5sICwicBbY/vnGdEP6OKpDOSfQam5x4BBj
-cvsBnsNuonY7OJn4iLY6LviQ0MM91PbaJUUJrp9Uyi4hj9iO/MZBaG0Giu0FKjG6
-Vk+RlCYPjYIvHflQLZHe9BWLPN1AvaLKszt3IYaxS5seXCu0ZqHDGCBVqVCNDDJk
-MJbHlrOVZ9T6mZhA+aQ1EJvTWk3MNj1AOyCJdiXtOOdg+4Fm5dN7nLpumLIg2yP2
-afI7YfrPGA7sm+T0IMnOWxkK+KODC7OV9h/QjyBJDcUYGXLapuK9eP80cr8hKvH7
-S3G4Top/rXDpnBNQ2azCqmUwaJWNRhLucC80Vd00d4pWIOwAPWpiV70Fq8OhQFhT
-PNXwFXVLwtNfPvPxN1s+Vk+BBXp+M19AuQENBFqbaC8BCADSq89Z9xWRS2fvWI/N
-+yEWliIU8XiqC9Ch+/6mS2LEyzB1pPLIIQcRvM6rq2dxXIRveVGpb63ck9vUtuJG
-//es+DnDkO7re+ZmWHX+LAqMYNdaobSYxHkkR4CcY2HbPSEUbb//Zwk4BDyp3g3W
-bKK9noVbslZuSwWNrxjX/Hieh/dIGYkNFeWOlmNfUYsevzqNDjsziOagyXKxLc++
-hUM3GKgzXRQJBvBpgzQc4bRY+YGHXtZurk9AiZ4ZBhWv2Qrb5OYYislE9sdv3KWV
-Iv1EBpbkAJ9MM1HgS8bkIOIpNs4XxHY6fTWWdrXi+NgZXQwQRYaWTQsXL3mktarS
-fFfTABEBAAGJAiUEGAEIAA8FAlqbaC8CGwwFCQHhM4AACgkQcuM+TfGlA24vqg/8
-CsVBHO4mh8SSaxdWNEU+mG4pU230BRCwrfn42wuSKb7WNLTTcWMDNI0KY/JNcWSq
-G2qa6lngiAyOS72Jd635ptZ6Wvjd0WtBt90NN2jtn+aRqwQ8uItlYMQscofFzskj
-QnBF+NWER+44nxboghuQ041m6aI2XmYUErSOBZi6onbC3svH6coMldkkiueWFbdB
-qac3UXue4LUcaGR5T9pCQsLgTl3D8V5icEM+HpTVVGQZkVrOuKMKe6T9N5FS/WFu
-T6CuFf/OyU15a6RE4WW9QqKYsaHl8B6+0P7uqPoVIxs8hfJcwaUu9XwIiZYBZg7N
-yYCQ7JBapC5KZlIcTCfFSxby8lCJoZbIM3Pk/pgCuKxGaS9rHHUGuIvz8TfnM9FO
-2zlxl4E6k3NFgGKF3p6oiKayC74o6EOw50p6DMjrisG7kkWVsTRCMINF7CcfeVme
-MI9ljGAMB1hPtHPhl27hMRfq+/iIbR9gb7+Xw2yKQL2QRjMDIGGxP3q4NjD4tV8P
-VyTbAAwNARG8oMpNM628v3tsW+WYNot1SPUQuZbIx1pCwMeTqljWsdQxWRVW5UxM
-dnXTCqZhQwH0ICG/jbepbP6ciVB/CSa7TVohEK6jiTMorhqynRMMJ6p48Z6HIlyY
-0Ss8q9K29eXaqmLB8Oy3HmupqxH95TqMntqivzf6i6e5AQ0EWptoPQEIAL1OdDIl
-7E3VKAEWH5GnMzdnl9bju/ovoMjLqGevHS9Gyz4OPyZvCQ2pS8k0sgqwsn4F8vWM
-7L3xKTyQTSYOPby3do58+kxUrdTNlqGKEEcZDG+MSzxKyft7m+37fzbg6tcU+O3L
-/7m8nYWQSRKJeist7Q8HrQJzehuzcgAnNmpeBqXHnAwRBvtqORvz5cQAIQ4EsEvP
-f/unTjw95JtL1LtBOaOaynF9ap/TZ34OvDdARmZSdqPpRtEvjfgIboIYYt1dNmDH
-kiSaaKaqBLCJTD2z5KT8ccDeF8lzYHAYzNy8v2lTc9vagCZH+lf3d2d6umNcr4y1
-NGEN4ZEhrmt/lP0AEQEAAYkDRAQYAQgADwUCWptoPQIbAgUJAeEzgAEpCRBy4z5N
-8aUDbsBdIAQZAQgABgUCWptoPQAKCRD619WmVzqkJDTvB/49MQNQk8YJTwAnbdSH
-7stU2uQFBbkljE8Juz5WJK53lL6xUVUp/3gKrQio1F+z9uRVqRh0cQnqX6mPMe5a
-2dlHEIDHTJjSlR5GCCBRDbssV6SN72xSVgbxVGZ9L32qUYtiwGnxwXQC9D9KsonD
-YfGfUhD1CLAldr6HwhJkOq4QKz5GF4ty8sMKEcpM5UaR2sa2y6Ebn9Vzma10YaVp
-X7RlZM/iTiDhTmWuxLh7e21DI95k/eFqHpKA912N0n1BdzZPbwk83nVRxXg793NU
-RFpegzlLawtaCW9oVJOYqErMGOYN5nbXAHXsr5X7Or70v1Yo1khgzNOfnirO57T9
-VjT0J1QP/j1xobgMuNda7Fpwc0xo2oIKEf+SWY9GQrkUK7wCLDbpgbGVxTmREkyE
-6oyDzW1QpQXRjLS9Wvtun0J3Wn6r6Aar0VaGKa7uiiq8UORWtFkWQAzzyBj87Rjx
-eWZWV1dzLK7eMJdyN0gsOzcejrsOqf1sydzvhm4K66byjDZ78piv0DdyPIb4OsiQ
-QU2GH+QwGRYIkYlU9f9g+hSasAfzvrATHlJZNrOjOCgXbut/yP9ug3DHKj76wmoU
-n/Y4rpmskAzIQrZIpimkpNBmZVTGr4bkWcokVzrRFor3NCpl1qA1K9Cd43wARH8t
-Zwk4evI4abbqUId0vVNCKSSDyCCjgNwRsmU8RXdn7r0vs4ObKuWfY9Yl2y8tq3qO
-YPHr0r50YXWtKqUNy5JUc3Ow9DFR1p4O4yfmiSyTLUyOYbglfvtnO32OJkrrZ8Kq
-iSDnyiq9u2nYJAEHk7AchF5TJrTCnd8yWNIjohild+wc+rMKktspoEcxmT6zaK4T
-AymmEe3jzQhlxptpBm68t2E5kaYFQh+NnizXlRcmFjBgEhH2CxCoerUpK82Y+MuE
-S/ODmF9kULre14aXAAspj4vldQ/LJm0SYEfTkE1sDipJQUzv6oS5AFloQDXZPWTB
-15P+Xsj8sJV9hWCfJZVmppWuPg/pCYXwdjUHUYouTz3ZL6qnUbm2uQINBFpZUO0B
-EADZkfsbXPpDcMALUgVmB3cJU90tFqc8Q5guK9oSs3ibx4SmyhBVmeF2TF6PQNoK
-YvpUR50hAcx2AbwtY51u0XxrAr8kFiL6R5ce/0pVMfXGchcC58CJ3uf+O+OPt080
-ftyVSTsY9xEnBohMoJescn0L/IPaM6KkkIFIMAI4Ct3QCHox7WHgPLrqB7Efx2Dj
-Qkgjbioqj8zVKDwxTs0S3sknch675gOhsCkaI7KMcRGACDinKRF3wQha4brNa8En
-vPTV01Cv0ttCo6NCcbQzQi8QQYpMQcWVkquEJWweZQvL/OvYWdT13JgnIp66pkmo
-+JvGTOqQpSnIx6OQnV9yqwqsg4E0dkCE+9rDYAHpwvmRkaI2sItjN4KAEQdTWES8
-RgGVgfCtvNH87PqpaPIgarMDY/j5KqTDp/7Nc5oGLCmhwZiYzQa7Bm5uVNnYIyOO
-d1IjfclgVdVAzMOmrFytvXFCBcga1khL15taC7s6Vuld89TgMZdSot2RVz8W8Xc+
-39ZrBvzrCeYsPq5/U0Z85cnOSw4skwh06wsxTvL1D70SilI2c0YdR1sVgbhq04HN
-7FyE7SDQ1GqxyTJAU+OPH3Pk97Bl25vWD43RCCIjSUHhKzQRPno2ItObFepE+QJH
-lSO1YMXmZDAfsRts3dca3VSDOdAQely6G7HQu5kXWXGtRQARAQABiQIfBBgBCAAJ
-BQJaWVDtAhsMAAoJEHLjPk3xpQNuRlsQAKnkyjjXRvfMB3eKZ1PrWf7DBx5WL8Hk
-r2QAnv0diDeRTzotQyzKivf3/W3gQc9kQi/ilaPuuXeW+yKiNQaIbai7EC0DdyHa
-qG9s8F7UDoojFOGCc3OVpQvuucVbv4a6EpqXBI6ayrQW0jMXakiuIF/dL5uCGRLn
-sPMB87xJfMrkqEziymJMooQTRckgj2S9J2QYDZFxmKChPl1kXMlmx6Y4FhzrsYwo
-I47hW9hHG1+8129FOgwYTwELEuX6FKShcKpyy77b4Tar3UvdzNkfaysFPvX3O7Oh
-Bes2VgfslEZSgK2CScigvLIz9Ehe9CUw6WEC6LZW3bbC+Cbz624gOsm/GYI9Llsc
-5/NMMwQTCoTRm+b0UAYQvzHDS7km9yceNSfFlkpE/lWnIt9E0H+8bOwEbYF8y2qy
-yLXIm7MYEm4UnUZ0j8kihP+wSHsZP2xPhjEUcQw1ZWhWLACvzlEC0a3zsovoJ6U8
-zrqqfEBtuQgfwwJRWArMLQn/rlEJSrTrFfehwhvH3dPVSU36N5nBA8ls5YlSHBQv
-38dChpBXu3wzFhetkSuHxdlfopeZMtDmljnIkBNTEFg01oqJNPbyiX2JQcfKizCt
-maCIiJY+hOYIKkJdkt1FyOhADBciebxCQrpIIzWupeyQNuVj3I4g6YaQX00+kgiB
-H1XKrAg/dpMNmQENBFrHiEoBCADASg9zHYzaSU0/1q1hcmTHU6H4syCQXHHd3zF7
-n/RcsGnt4RBuUi/BUvNp3zYR6uFOyyk6LPV1hq2Ca8e/oSFrDYxqLladESQd9GNN
-stDeK3HinsWJCVwSbkzNJbUtyr6SclmWt66vNqBZngMallJRQe8QDqpg0ZSZj/0d
-VGxPBR16zc/2ddGnXJFe/V5XAWAap9SEo44pyGK4xf87Bgq8jT33LuQtd8exOk3E
-atkK5jLEn9xmiheoSePEhOoQSrJMHfMjFka0PYZlCeaaHw7r7yXb/VoHFOAPxb6k
-a1cunbp39b4z7Jy9kLBy0tbDnAs/sLp4LUN3Vx1JLoXBSIsHABEBAAG0JFJhdWwg
-Sm9yZGFuIDxyYXVsQHByeXNtYXRpY2xhYnMuY29tPokBNwQTAQoAIQUCWseISgIb
-AwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRCVRSpwGBD+26lmB/wJxChWwva0
-StjMRSk3V7JTBPi5RNQm3VY8UydUNjsXzHVvtjUczOj+zHfo8tYUYa/ypWujXEX9
-bVYVMr9JGNjm+rysI1gmW1gcx9pZr9gde4CR4Owfpwjh8oFnSrBBrcaelb0Krrv4
-Okms43fEw1bWpllayal5SqknOIxpw1ZiNpG3jVe/C9n1/3Nw4XF5R0RHDxXTu6Hu
-H3t7zRQwAJcOod6ccRdzNR9CsGdnOoNPG3pqs9w6zWUp0QETMAMcEpSLCJumaVfQ
-24PK+MF92F5JRwNVt80xSLA9KMyNnv/ZvxZXXLjkIhsAmwYkHUs3WSm5HJ4qqOCX
-V8VwFbwnea3eiQIzBBABCgAdFiEECuAFHWR7o8GpF69AcuM+TfGlA24FAl9zs2AA
-CgkQcuM+TfGlA24dMA/+N31SPAXVgwiNasBknb+YSq2/OQPogxQUc8tupvDcQ62H
-u0kvA7pUPUFjITJ1xsm8CRXfb7Hge9rNUw9Y2MNKf4sIDQs3bFeKOiAGVbO8Z055
-5VCTWWPhXzjWoR84YWrx0Go8WT/V3Lahy4frGA3Vsza6wzi2P6c7LF4jqX2iBD1l
-OpAYNGyt0sX/RLp3s2jOTWJwVyRR4UKSZOgpi9OTGLXrq5oU2dpwEIzBmhaWIs+u
-oD5/4TaAt4lEFu3Sxk5w8fJlUXbM4IG8A1l+dnRPF5rtjtfvuX0GeQcDtJ5e1qHj
-7PvVj8HjGPwxqsAjYHpg6QjyQCdtHYHdboEIU+OXMYRPRh2Iv0GUoeuMqoSsvFgn
-c9PGN8Ai5u+oNzKeLJhpxpLV7s9zAbsripdnvDBn7RwuNx2ziqZayxoYvFRCAQl5
-wzr0/eo/wq36D9EI7uJ2I3yt1g/VkwWQsAeE2skuGGbwed263cWTkl6g1w+vlDY3
-/jc3a8HcS0zIUX194ChrbbNezGb74mQFoLk6PksLfhXseAKCs8bvPaTwIm0JGTMT
-YzkRufrv1+I9KPFy3fTpvnMZTbud4nPCLsK179whk+Jrdv866i+E2WZ1JyzIZ9bB
-P1x+ABi82PMdzhTw+pTkR1CVHmrmOiSi2MHRYGMedM9ECGnPIdab5d75r1qkuvO5
-AQ0EWseISgEIAKHrgTVeZ0CWZMETk7NFjDTvBpoTMQDT7DDe2vFQHc8D2AvR3Aod
-+CUaOeY0Yp0GOemd7BEcUbpYbCQk1B9G8vHNcQqTMLjBgujXwF6w2c+lqEu2/tyI
-2/uGCOBDs4wuQZo+akCCMekqYjdZBfZV6nQzf/l7eQHIq+sNtnSiZmHdH46PLi7/
-17wR9GxzKvuv1R73DCyekCcz1Puo0b7lfGD28kESJK1Mg9SAOqVjtaS58Oxo+Y1M
-ZWRqh0tkAkgOBpdyddGy6TX/9c3a0U3eBQweRpNDh0eCEh5UsYDluL4NtXj7rVYd
-4mHONJzI3h1LnKWvpVYmk703MPmtgeJwNzEAEQEAAYkBHwQYAQoACQUCWseISgIb
-DAAKCRCVRSpwGBD+25PxCACNBj/2HBSpdYAxEGhNHSaw62y7Jwuf7NbsKIAqygzi
-m2+dxae7PbAm64jEXYJA5GaCOs4xO52S/2+1N87e5J86VRNg0vlA9/ivFzERAxEg
-rgIUyGXYfS8oA/4r5+PfKt/NvXO2wH3MPakrqZqXhOv+1IPvOt03wWoZKmYyVT6g
-YnzutOsvH6cbhUh/D0WpuU8ZgkrFu5Xe7ynZoLm1qQOA23pkxxQbeNs0uoKUja9v
-bx4eBtaliLc6rsXt+1WzdXA5ZRNqkdn87Tz5IU0FuQYVblYvPz9QoUlvx5siWVaP
-Mmc7dIctWaWyaJmgjkLKdy36ydS5axhqn158yIjOZV3emQINBF8h6lMBEACovC4z
-oieJ9iMZpWfylsLQKkeEmfSXnjcjW4RLUjs2CRWj+W6H7eCRy/MBOdx+6zAb8TE/
-n/TSlP5l5Xx40BGDAMUZVFrJVEkMPK5kUmNzybg7PiuMd3qZE+pNyHEXXlLU77Dn
-VO26TD9RvpKXdjm+ATsnQ6rvDNszkYI2Bj1tPxwZ7bRi96U/upL3WfYOsTLHirM3
-pEkI3zfMZj8ufDX9XlmGrQ384E/hTgjpLXmDm/jMRlX3mRzDkV1HO+gEicfePm5+
-K4eWlMCNXN5bcGwoEFY2LwAojRcbRaH/UH2S3btkG2eSK2fOFEwQ0G4vIyoLF60R
-cEk1s6cYIgk3kVsmNSzA5iJ81nD5bbfTceUKsjTZiw5RmN0Vh5g75pw+3uoXB+55
-egabEIt/GTZZlP6zhd/CKjTQR0R4+ZaEbZFOCtABukC5xfWGCRdNmXAWMBe0MYpW
-ub2TRLISLfNNc7GWM4Y17d9aRhaql9gY6QLIRNGYuvGPiRMaJADZx46LtbWo8YiG
-xLId7H8D+/0MSzMOg7RhELqYScYDigiVEXkTHA3QSprf/ohjm8woRhQY5CjCEZp5
-8MvhD40VAo4Gxgx1V8lwB3CD3kDgFEaUZh2H+N/fmRegACN2lzEm1krOiS7sAB48
-/Av99/1VXalLoBbzFTnuAYwnmLk8vdparT5LlwARAQABtChUZXJlbmNlIFRzYW8g
-PHRlcmVuY2VAcHJ5c21hdGljbGFicy5jb20+iQJOBBMBCAA4FiEEMX1ukQWPjzwj
-A7p3VjE+RFgSl6YFAl8h6lMCGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ
-VjE+RFgSl6YJgBAAqIAMzMFf/+qE896kuXYSlmaYtzhrMXgQVD09UgSq4JfVYudE
-e8EfamWz8RFV7znxHO/5Fp4yoWeDGc2b40DhivvRb1p4XSJi+F64moeHt+qn4Hay
-CDs5wGv40KJk0+2r7iILc3Gw4NP6r4c2HU2EqSW8fn/bYM3yxLsYEXt5zhgipKpR
-CB4WmqojW+CxXkj8dv4CyY+HlKJ6nZWstK42h736njM44rjMDSDt3lv0ZYykopTw
-09THnHkWOXY4PSrKOzE+OqsPMPOD3Gq3bYPqQ0ZgdS4FeuDesqqHjJabRX+7DgJK
-lLEnylfDlvDKf6I/tqrAfqCCdQvEjpdQXG84GSdK//wT1biunHvGeyHM/PZx9V5O
-X8YoecswcYjozU1F7x8buk8GxV7ZuJ2pbdXr7jTou1dA7e4Nas9Qu1RcK39MoTYc
-Ub467ONFCX+Y3MzELTnEyx4hSwTxlWg7VjCQ63zrFOd8VG0WUydlqiHgIE8WCJVE
-pQlrr2v/A6ieM1HY1Ftjt+mk/qncqibCdyIofyV4o5FrVo8arx74jR+Lhvkp1T9N
-uRj8V6M3g9vxJdAsy1O5/ZrdwKJ6Yy1n62+9b/uxhklYONK7DpDlWU0ZLWHlKEIV
-zzfILCiLf+nxMQdVwuthlcysg8JwYEE8xDXc851ciuj0ygv3Wm0BY44V6/m5Ag0E
-XyHqUwEQALuKzOAlo75p2vSYD7TecE/E0hBOS+cjs8kRH+oIzm5fx7sf00SC1jU2
-q5QLYLixNeT+l0bD70R7b8r2uFu1aZL7pQqbGIGisLHlxu8611+PCpE5AsQi3Wui
-IZ6Y8K7grJ28vviBiZUBY3iCCRH0LuvyZN3R0zgyMGbzouQk5wuGJUkRHJKtV5by
-FVEl3CYudRtAp5LPFw6j7UzT5yQqBmY6tXp5WMmmAvOtnu8ohpRhzY21dJMlSykX
-Ne9rcARy8mVWNdcXJUIc85z0BmyrdiA4YY0XiZTHD9mslj+af4QHsaS+p3aorTLD
-5BKkp5Ek79a1BUxBjrao4W2fljYf129/SHbwds/Dup26zB2vi/fhbfVPvevXLPpi
-Vm4uz8fE4D5lPYZAdu5GtO2V9kWbhDtU1R1SJSdFDI9Sev3B+NLrstclGfdbFQKF
-shbUxydjSX56OJvh5hee50PcCz+Ab+usoyUPkcOfET/L55AdqJo3cVYtnAKpOJG/
-mKP5Ih3LZVm9wCdWTCzboEtDfLlcjCc5kLiE9Pq7sKMnXm/NcXNFWBkRuaHg+Mt5
-Yk659/Q6oUG3yUrS2d7cSeuNRWNlaRlnk3hZtB13xpmoHGYmrMOe7wiEE5xEnOju
-1ctRRRX6lNUPlSvID83Y9JSYL9hYMbidRmFY28AIddT/PjVTgfi1ABEBAAGJAjYE
-GAEIACAWIQQxfW6RBY+PPCMDundWMT5EWBKXpgUCXyHqUwIbDAAKCRBWMT5EWBKX
-poMOD/4/sRLnK94pY2qtSSfNZEumOdQVvges08u34saG4mT1iLD9TcRgsFvgwcTV
-Pec9Git4iJmoJpFylvOzoBWmtDzJ7TB3JxvtwUfFH2uZ22k12eChyAFHI8TxASqI
-TV2YwkIgB2PTmva1GrdNKM6y5bfS1BdS0u+Etgp4zN9nyQECY2sM2accUi2S7JBV
-7o6lEJWCRgFUwIfY6fdfxhZo/w0g2u5wftUQYlbXWSQLImFFZBc/13k8EMxsfbMi
-LQ/wxKEfe1ZwFoXqIS6cq8CHTdj70QO7K9ah6krGPmL23LVuxlkQIR7mT5yFJtv2
-VRT4IYgOUl6rAd08B6MOy6MOMa14FpNrAybPK8Yd/eSdUNciVf17q33Yc15x+trs
-En1hHbDS82xaLJ/Ld4mANeJVt3FodgVmzZGpKheFEOFXXeuX1ZZ4c9TgX+0wBKoh
-aBb8EGBVo4aV4GbZ/gEa8wls5NNTwd56H4G94hiq+qFM39x4YjhAvkM0hLRYzR05
-tSCdlEbkh2K6RbOhBPsNHCbypWRt2fN8/q4uLPJJt7NRQ2zi6H/x04HGblhXdX6H
-mmYjJv1LTbem9VptcpvPauNsibeIvIWA2nYM2ncDWt6gJpOH9Zh4fHuaG4aCdNmJ
-hPNeJNnmLcpDQvR9wU5w7e5tC/ZSeTZ5ul1zOKa1qZ4lJ50BDQ==
-=a30p
------END PGP PUBLIC KEY BLOCK-----

.well-known/security.txt

@@ -3,24 +3,24 @@ Hash: SHA512
 
 Contact: mailto:security@prysmaticlabs.com
 Encryption: openpgp4fpr:0AE0051D647BA3C1A917AF4072E33E4DF1A5036E
-Encryption: openpgp4fpr:CD08DE68C60B82D3EE2A3F7D95452A701810FEDB
-Encryption: openpgp4fpr:317D6E91058F8F3C2303BA7756313E44581297A6
-Encryption: openpgp4fpr:79C59A585E3FD3AFFA00F5C22940A6479DA7C9EC
+Encryption: openpgp4fpr:341396BAFACC28C5082327F889725027FC8EC0D4
+Encryption: openpgp4fpr:8B7814F1B221A8E8AA465FC7BDBF744ADE1A0033
 Preferred-Languages: en
 Canonical: https://github.com/prysmaticlabs/prysm/tree/master/.well-known/security.txt
+
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEECuAFHWR7o8GpF69AcuM+TfGlA24FAmGOfiYACgkQcuM+TfGl
-A24YwRAAiQk3w6yzqSEggrOlNoNn04iu/rWZdn5ihkQgzACXy8XH2D1gdKLChE/X
-7e5bUtgE2aCuHryQjwoKxqZakviBJFstVmHgF64rXv2zKhpqA30Mj4fI+T3zn8I+
-+FpFV0TTsxNLDx+AcR1eQ1nSayO7ImUDIfOQNDDnSZZy42Bc+F+QIGKB3aH/8bpG
-kT+bDTZrXvX+TE1gZTbAtZG8sH8g/zadoWEHIhfXUuYb0kTz+DRzAxoqU4j4Z4ee
-1zSfFAgfJwxJP4kWD7s4xkE1sBbCgGBeD6cW/C2lbcfIei+XSizLpHW3jD9dNqh4
-fLkmEspSa/LV/iXFq8nFzu/GLww4q+sQZDzzDKZyws54CrATinRitZMhzoIL0bTn
-yFZVOGHosFAMEVZ36dl1Aw2+B2W6tr2CVr9c5zfV+kup5/KZH1EmT5nYY/zFwfg2
-jYCFB5wmYeiyWZvuprgJXRArgVZLZaJxwWazlPVk4i/4vPvRgvfHqOwHCBe8DXy0
-VHPhpewwb/ECYek1KoaNQflgR8iH2GMHkC5RjhGDAt1S0AQDtite5m4ZYt1kvO9E
-k/znkv89dduhL9CKDvZvnI+DICwsTrf//4KJ8PM/qaPAJa4GvtiUU/eS/jKBivtv
-OP5dZQtX6KPc9ewqqZgn622uHSezoBidgeTkdZsJ6tw2eIu0lsY=
-=V7L0
+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
 -----END PGP SIGNATURE-----

BUILD.bazel

@@ -3,21 +3,12 @@ load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 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("@vaticle_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
-load("@bazel_skylib//rules:common_settings.bzl", "string_setting")
 
 prefix = "github.com/prysmaticlabs/prysm"
 
-exports_files([
-    "LICENSE.md",
-])
+exports_files(["genesis.json"])
 
 # gazelle:prefix github.com/prysmaticlabs/prysm
-# gazelle:map_kind go_library go_library @prysm//tools/go:def.bzl
-# gazelle:map_kind go_test go_test @prysm//tools/go:def.bzl
-# gazelle:map_kind go_repository go_repository @prysm//tools/go:def.bzl
-# gazelle:build_tags bazel
-# gazelle:exclude tools/analyzers/**/testdata/**
 gazelle(
     name = "gazelle",
     prefix = prefix,
@@ -26,16 +17,7 @@ gazelle(
 # Protobuf compiler (non-gRPC)
 alias(
     name = "proto_compiler",
-    actual = "@io_bazel_rules_go//proto:go_proto",
-    visibility = [
-        "//proto:__subpackages__",
-    ],
-)
-
-# Cast protobuf compiler (non-gRPC)
-alias(
-    name = "cast_proto_compiler",
-    actual = "@com_github_prysmaticlabs_protoc_gen_go_cast//:go_cast",
+    actual = "@io_bazel_rules_go//proto:gogofast_proto",
     visibility = [
         "//proto:__subpackages__",
     ],
@@ -44,22 +26,28 @@ alias(
 # Protobuf compiler (gRPC)
 alias(
     name = "grpc_proto_compiler",
-    actual = "@io_bazel_rules_go//proto:go_grpc",
-    visibility = ["//visibility:public"],
+    actual = "@io_bazel_rules_go//proto:gogofast_grpc",
+    visibility = [
+        "//proto:__subpackages__",
+    ],
 )
 
-# Cast protobuf compiler (gRPC)
+# Protobuf gRPC compiler without gogoproto. Required for gRPC gateway.
 alias(
-    name = "cast_grpc_proto_compiler",
-    actual = "@com_github_prysmaticlabs_protoc_gen_go_cast//:go_cast_grpc",
-    visibility = ["//visibility:public"],
+    name = "grpc_nogogo_proto_compiler",
+    actual = "@io_bazel_rules_go//proto:go_grpc",
+    visibility = [
+        "//proto:__subpackages__",
+    ],
 )
 
 # Protobuf gRPC gateway compiler
 alias(
     name = "grpc_gateway_proto_compiler",
-    actual = "@com_github_grpc_ecosystem_grpc_gateway_v2//protoc-gen-grpc-gateway:go_gen_grpc_gateway",
-    visibility = ["//visibility:public"],
+    actual = "@grpc_ecosystem_grpc_gateway//protoc-gen-grpc-gateway:go_gen_grpc_gateway",
+    visibility = [
+        "//proto:__subpackages__",
+    ],
 )
 
 gometalinter(
@@ -88,69 +76,35 @@ nogo(
     config = "nogo_config.json",
     visibility = ["//visibility:public"],
     deps = [
-        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unreachable:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/tests:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/structtag:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/shift:go_default_library",
-        # "@org_golang_x_tools//go/analysis/passes/shadow:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/printf:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/pkgfact:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/nilness:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/nilfunc:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/loopclosure:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/httpresponse:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/findcall:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/copylock:go_default_library",
-        #  "@org_golang_x_tools//go/analysis/passes/cgocall:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/buildtag:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/buildssa:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/bools:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/atomic:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/assign:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/inspect:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/asmdecl:go_default_library",
-        "//tools/analyzers/comparesame:go_default_library",
-        "//tools/analyzers/cryptorand:go_default_library",
-        "//tools/analyzers/errcheck:go_default_library",
-        "//tools/analyzers/featureconfig:go_default_library",
-        "//tools/analyzers/gocognit:go_default_library",
-        "//tools/analyzers/ineffassign:go_default_library",
-        "//tools/analyzers/interfacechecker:go_default_library",
-        "//tools/analyzers/maligned:go_default_library",
-        "//tools/analyzers/nop:go_default_library",
-        "//tools/analyzers/properpermissions:go_default_library",
-        "//tools/analyzers/recursivelock:go_default_library",
-        "//tools/analyzers/shadowpredecl:go_default_library",
-        "//tools/analyzers/slicedirect:go_default_library",
-        "//tools/analyzers/uintcast:go_default_library",
-    ] + select({
-        # nogo checks that fail with coverage enabled.
-        ":coverage_enabled": [],
-        "//conditions:default": [
-            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_default_library",
-            "@org_golang_x_tools//go/analysis/passes/composite:go_default_library",
-        ],
-    }),
-)
-
-config_setting(
-    name = "coverage_enabled",
-    values = {"define": "coverage_enabled=1"},
-)
-
-common_files = {
-    "//:LICENSE.md": "LICENSE.md",
-    "//:README.md": "README.md",
-}
-
-sh_binary(
-    name = "prysm_sh",
-    srcs = ["prysm.sh"],
-    visibility = ["//visibility:public"],
+        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/unreachable:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/tests:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/structtag:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/shift:go_tool_library",
+        # "@org_golang_x_tools//go/analysis/passes/shadow:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/printf:go_tool_library",
+        "@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",
+        "@org_golang_x_tools//go/analysis/passes/bools:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/atomic:go_tool_library",
+        "@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",
+    ],
 )

CONTRIBUTING.md

@@ -1,10 +1,8 @@
 # Contribution Guidelines
 
-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? 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.
 
-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/CTYGPUJ) drop us a line there if you want to get more involved or have any questions on our implementation!
+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!
 
 ## Contribution Steps
 
@@ -62,6 +60,12 @@ Changes that only affect a single file can be tested with
 $ go test <file_you_are_working_on>
 ```
 
+Changes that affect multiple files can be tested with ...
+
+```
+$ golangci-lint run && bazel test //...
+```
+
 **10. Stage the file or files that you want to commit.**
 
 ```
@@ -175,7 +179,7 @@ We consider two types of contributions to our repo and categorize them as follow
 
 ### Part-Time Contributors
 
-Anyone can become a part-time contributor and help out on implementing Ethereum consensus. The responsibilities of a part-time contributor include:
+Anyone can become a part-time contributor and help out on implementing sharding. The responsibilities of a part-time contributor include:
 
 -   Engaging in Gitter conversations, asking the questions on how to begin contributing to the project
 -   Opening up github issues to express interest in code to implement
@@ -186,11 +190,13 @@ Anyone can become a part-time contributor and help out on implementing Ethereum
 -   Follow up on open PRs
     -   Have an estimated timeframe to completion and let the core contributors know if a PR will take longer than expected
 
+We do not expect all part-time contributors to be experts on all the latest sharding documentation, but all contributors should at least be familiarized with our sharding [README.md](https://github.com/prysmaticlabs/prysm/blob/master/validator/README.md) and have gone through the required Ethereum readings as posted on our [READINGS.md](https://github.com/prysmaticlabs/prysm/blob/master/docs/READINGS.md) document.
+
 ### Core Contributors
 
 Core contributors are remote contractors of Prysmatic Labs, LLC. and are considered critical team members of our organization. Core devs have all of the responsibilities of part-time contributors plus the majority of the following:
 
--   Stay up to date on the latest beacon chain specification
+-   Stay up to date on the latest beacon chain sepcification
 -   Monitor github issues and PR’s to make sure owner, labels, descriptions are correct
 -   Formulate independent ideas, suggest new work to do, point out improvements to existing approaches
 -   Participate in code review, ensure code quality is excellent, and have ensure high code coverage

DEPENDENCIES.md

@@ -1,80 +0,0 @@
-# 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
-./hack/update-go-pbs.sh
-./hack/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 -prune=true
-```
-
-The deps.bzl file should have been updated with the dependency and any transitive dependencies. 
-
-Do NOT add new `go_repository` to the WORKSPACE file. All dependencies should live in deps.bzl.
-
-## Running tests
-
-To enable conditional compilation and custom configuration for tests (where compiled code has more 
-debug info, while not being completely optimized), we rely on Go's build tags/constraints mechanism 
-(see official docs on [build constraints](https://golang.org/pkg/go/build/#hdr-Build_Constraints)). 
-Therefore, whenever using `go test`, do not forget to pass in extra build tag, eg:
-
-```bash
-go test ./beacon-chain/sync/initial-sync -tags develop 
-```

INTEROP.md

@@ -1,84 +0,0 @@
-# Prysm Client Interoperability Guide
-
-This README details how to setup Prysm for interop testing for usage with other Ethereum consensus clients.
-
-## Installation & Setup
-
-1. Install [Bazel](https://docs.bazel.build/versions/master/install.html) **(Recommended)**
-2. `git clone https://github.com/prysmaticlabs/prysm && cd prysm`
-3. `bazel build //...`
-
-## Starting from Genesis
-
-Prysm supports a few ways to quickly launch a beacon node from basic configurations:
-
-- `NumValidators + GenesisTime`: Launches a beacon node by deterministically generating a state from a num-validators flag along with a genesis time **(Recommended)**
-- `SSZ Genesis`: Launches a beacon node  from a .ssz file containing a SSZ-encoded, genesis beacon state
-
-## Generating a Genesis State
-
-To setup the necessary files for these quick starts, Prysm provides a tool to generate a `genesis.ssz` from
-a deterministically generated set of validator private keys following the official interop YAML format 
-[here](https://github.com/ethereum/eth2.0-pm/blob/master/interop/mocked_start).
-
-You can use `bazel run //tools/genesis-state-gen` to create a deterministic genesis state for interop.
-
-### Usage
-
-- **--genesis-time** uint: Unix timestamp used as the genesis time in the generated genesis state (defaults to now)
-- **--mainnet-config** bool: Select whether genesis state should be generated with mainnet or minimal (default) params
-- **--num-validators** int: Number of validators to deterministically include in the generated genesis state
-- **--output-ssz** string: Output filename of the SSZ marshaling of the generated genesis state
-
-The example below creates 64 validator keys, instantiates a genesis state with those 64 validators and with genesis unix timestamp 1567542540,
-and finally writes a ssz encoded output to ~/Desktop/genesis.ssz. This file can be used to kickstart the beacon chain in the next section.
-
-```
-bazel run //tools/genesis-state-gen -- --output-ssz ~/Desktop/genesis.ssz --num-validators 64 --genesis-time 1567542540
-```
-
-## Launching a Beacon Node + Validator Client
-
-### Launching from Pure CLI Flags
-
-Open up two terminal windows, run:
-
-```
-bazel run //beacon-chain -- \
---bootstrap-node= \
---deposit-contract $(curl -s https://prylabs.net/contract) \
---force-clear-db \
---interop-num-validators 64 \
---interop-eth1data-votes
-```
-
-This will deterministically generate a beacon genesis state and start
-the system with 64 validators and the genesis time set to the current unix timestamp.
-Wait a bit until your beacon chain starts, and in the other window:
-
-```
-bazel run //validator -- --keymanager=interop --keymanageropts='{"keys":64}'
-```
-
-This will launch and kickstart the system with your 64 validators performing their duties accordingly.
-
-### Launching from `genesis.ssz`
-
-Assuming you generated a `genesis.ssz` file with 64 validators, open up two terminal windows, run:
-
-```
- bazel run //beacon-chain -- \
---bootstrap-node= \
---deposit-contract $(curl -s https://prylabs.net/contract) \
---force-clear-db \
---interop-genesis-state /path/to/genesis.ssz \
---interop-eth1data-votes
-```
-
-Wait a bit until your beacon chain starts, and in the other window:
-
-```
-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

@@ -0,0 +1,13 @@
+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,35 +1,145 @@
-# Prysm: An Ethereum Consensus Implementation Written in Go
+# Prysm: Ethereum 'Serenity' 2.0 Go Implementation
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
-[![Go Report Card](https://goreportcard.com/badge/github.com/prysmaticlabs/prysm)](https://goreportcard.com/report/github.com/prysmaticlabs/prysm)
-[![Consensus_Spec_Version 1.1.8](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.1.8-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.1.8)
-[![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
+[![ETH2.0_Spec_Version 0.8.0](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v0.8.0-blue.svg)](https://github.com/ethereum/eth2.0-specs/commit/8d324b7497bcb558e0183a30002d78d18704e3fa)
+[![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 Consensus](https://ethereum.org/en/eth2/) specification, developed by [Prysmatic Labs](https://prysmaticlabs.com). See the [Changelog](https://github.com/prysmaticlabs/prysm/releases) for details of the latest releases and upcoming breaking changes.
+This is the Core repository for Prysm, [Prysmatic Labs](https://prysmaticlabs.com)' [Go](https://golang.org/) implementation of the Ethereum protocol 2.0 (Serenity).
 
-### Getting Started
+### Need assistance?
+A more detailed set of installation and usage instructions as well as explanations of each component are available on our [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.
 
-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 our [Discord](https://discord.gg/CTYGPUJ).
+**Interested in what's next?** Be sure to read our [Roadmap Reference Implementation](https://github.com/prysmaticlabs/prysm/blob/master/docs/ROADMAP.md) document. This page outlines the basics of sharding as well as the various short-term milestones that we hope to achieve over the coming year.
 
-### Staking on Mainnet
+### Come join the testnet!
+Participation is now open to the public in our testnet release for Ethereum 2.0 phase 0. Visit [prylabs.net](https://prylabs.net) for more information on the project itself or to sign  up as a validator on the network.
 
-To participate in staking, you can join the [official eth2 launchpad](https://launchpad.ethereum.org). The launchpad is the only recommended way to become a validator on mainnet. You can explore validator rewards/penalties via Bitfly's block explorer: [beaconcha.in](https://beaconcha.in), and follow the latest blocks added to the chain on [beaconscan](https://beaconscan.com).
+# Table of Contents
 
+- [Dependencies](#dependencies)
+- [Installation](#installation)
+    - [Build Via Docker](#build-via-docker)
+    - [Build Via Bazel](#build-via-bazel)
+- [Running an Ethereum 2.0 Beacon Node](#running-an-ethereum-20-beacon-node)
+- [Staking ETH: Running a Validator Client](#staking-eth-running-a-validator-client)
+-   [Testing Prysm](#testing-prysm)
+-   [Contributing](#contributing)
+-   [License](#license)
+
+## Dependencies
+Prysm can be installed either with Docker **(recommended method)** 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)
+  - A modern GNU/Linux operating system
+
+## Installation
+
+### Build via Docker
+1. Ensure you are running the most recent version of Docker by issuing the command:
+```
+docker -v
+```
+2.  To pull the Prysm images from the server, issue the following commands:
+```
+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:
+```
+bazel version
+```
+2. Clone this repository and enter the directory:
+```
+git clone https://github.com/prysmaticlabs/prysm
+cd prysm
+```
+3. Build both the beacon chain node implementation and the validator client:
+```
+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.
+
+## Running an Ethereum 2.0 Beacon Node
+To understand the role that both the beacon node and validator play in Prysm, see [this section of our documentation](https://prysmaticlabs.gitbook.io/prysm/how-prysm-works/basic-architecture-overview).
+
+### Running via Docker
+
+**Docker on Linux/Mac:**
+1. To start your beacon node, issue the following command:
+```
+docker run -v /tmp/prysm-data:/data -p 4000:4000 \
+  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 to container (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 ```/tmp/prysm-data/``` 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.
+
+4) To run the beacon node, issue the following command:
+```
+docker run -it -v c:/tmp/prysm-data:/data -p 4000:4000 gcr.io/prysmaticlabs/prysm/beacon-chain:latest --datadir=/data --clear-db
+```
+
+### Running via Bazel
+
+1) To start your Beacon Node with Bazel, issue the following command:
+```
+bazel run //beacon-chain -- --clear-db --datadir=/tmp/prysm-data
+```
+
+This will sync up the Beacon Node with the latest head block in the network.
+
+
+## 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 the Validator Deposit Contract to activate your validator (discussed in the section below). First though, you will need to create a *validator client* to connect to this node in order to stake and participate. 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 Goerli ETH 
+
+Using your validator deposit data from the previous step, follow the instructions found on https://alpha.prylabs.net/participate to make a deposit.
+
+It will take a while for the nodes in the network to process your deposit, but once your node is active, the validator will begin doing its responsibility. 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, you'll start gradually losing your deposit until you are removed from the system. 
+
+### Starting the validator with Bazel
+
+1. Open another terminal window. Enter your Prysm directory and run the validator by issuing the following command:
+```
+cd prysm
+bazel run //validator
+```
+**Congratulations, you are now running Ethereum 2.0 Phase 0!**
+
+## Testing Prysm
+
+**To run the unit tests of our system**, issue the command:
+```
+bazel test //...
+```
+
+**To run our linter**, make sure you have [golangci-lint](https://https://github.com/golangci/golangci-lint) installed and then issue the command:
+```
+golangci-lint run
+```
 
 ## Contributing
-### Branches
-Prysm maintains two permanent branches:
-
-* [master](https://github.com/prysmaticlabs/prysm/tree/master): This points to the latest stable release. It is ideal for most users.
-* [develop](https://github.com/prysmaticlabs/prysm/tree/develop): This is used for development, it contains the latest PRs. Developers should base their PRs on this branch.
-
-### Guide
-Want to get involved? Check out our [Contribution Guide](https://docs.prylabs.network/docs/contribute/contribution-guidelines/) to learn more!
+We have put all of our contribution guidelines into [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/master/CONTRIBUTING.md)! Check it out to get started.
 
 ## License
-
 [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html)
-
-## Legal Disclaimer
-
-[Terms of Use](/TERMS_OF_SERVICE.md)

SECURITY.md

@@ -1,11 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-[Releases](https://github.com/prysmaticlabs/prysm/releases/) contains all available releases. We recommend using the [most recently released version](https://github.com/prysmaticlabs/prysm/releases/latest).
-
-## Reporting a Vulnerability
-
-Please see our signed [security.txt](https://github.com/prysmaticlabs/prysm/blob/develop/.well-known/security.txt) for preferred encryption and reporting destination.
-
-**Please do not file a public ticket** mentioning the vulnerability, as doing so could increase the likelihood of the vulnerability being used before a fix has been created, released and installed on the network.

TERMS_OF_SERVICE.md

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

api/client/beacon/BUILD.bazel

@@ -1,54 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "checkpoint.go",
-        "client.go",
-        "doc.go",
-        "errors.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/client/beacon",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/rpc/apimiddleware:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz/detect:go_default_library",
-        "//io/file:go_default_library",
-        "//network/forks:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/block:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@org_golang_x_mod//semver:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "checkpoint_test.go",
-        "client_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/state:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/ssz/detect:go_default_library",
-        "//network/forks:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-    ],
-)

api/client/beacon/checkpoint.go

@@ -1,262 +0,0 @@
-package beacon
-
-import (
-	"context"
-	"fmt"
-	"path"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
-	"github.com/prysmaticlabs/prysm/io/file"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	log "github.com/sirupsen/logrus"
-	"golang.org/x/mod/semver"
-)
-
-// OriginData represents the BeaconState and SignedBeaconBlock necessary to start an empty Beacon Node
-// using Checkpoint Sync.
-type OriginData struct {
-	wsd *WeakSubjectivityData
-	sb  []byte
-	bb  []byte
-	st  state.BeaconState
-	b   block.SignedBeaconBlock
-	cf  *detect.VersionedUnmarshaler
-}
-
-// CheckpointString returns the standard string representation of a Checkpoint for the block root and epoch for the
-// SignedBeaconBlock value found by DownloadOriginData.
-// The format is a a hex-encoded block root, followed by the epoch of the block, separated by a colon. For example:
-// "0x1c35540cac127315fabb6bf29181f2ae0de1a3fc909d2e76ba771e61312cc49a:74888"
-func (od *OriginData) CheckpointString() string {
-	return fmt.Sprintf("%#x:%d", od.wsd.BlockRoot, od.wsd.Epoch)
-}
-
-// SaveBlock saves the downloaded block to a unique file in the given path.
-// For readability and collision avoidance, the file name includes: type, config name, slot and root
-func (od *OriginData) SaveBlock(dir string) (string, error) {
-	blockPath := path.Join(dir, fname("state", od.cf, od.st.Slot(), od.wsd.BlockRoot))
-	return blockPath, file.WriteFile(blockPath, od.sb)
-}
-
-// SaveState saves the downloaded state to a unique file in the given path.
-// For readability and collision avoidance, the file name includes: type, config name, slot and root
-func (od *OriginData) SaveState(dir string) (string, error) {
-	statePath := path.Join(dir, fname("state", od.cf, od.st.Slot(), od.wsd.StateRoot))
-	return statePath, file.WriteFile(statePath, od.sb)
-}
-
-// StateBytes returns the ssz-encoded bytes of the downloaded BeaconState value.
-func (od *OriginData) StateBytes() []byte {
-	return od.sb
-}
-
-// BlockBytes returns the ssz-encoded bytes of the downloaded SignedBeaconBlock value.
-func (od *OriginData) BlockBytes() []byte {
-	return od.bb
-}
-
-func fname(prefix string, cf *detect.VersionedUnmarshaler, slot types.Slot, root [32]byte) string {
-	return fmt.Sprintf("%s_%s_%s_%d-%#x.ssz", prefix, cf.Config.ConfigName, version.String(cf.Fork), slot, root)
-}
-
-// this method downloads the head state, which can be used to find the correct chain config
-// and use prysm's helper methods to compute the latest weak subjectivity epoch.
-func getWeakSubjectivityEpochFromHead(ctx context.Context, client *Client) (types.Epoch, error) {
-	headBytes, err := client.GetState(ctx, IdHead)
-	if err != nil {
-		return 0, err
-	}
-	cf, err := detect.FromState(headBytes)
-	if err != nil {
-		return 0, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in remote head state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-	headState, err := cf.UnmarshalBeaconState(headBytes)
-	if err != nil {
-		return 0, errors.Wrap(err, "error unmarshaling state to correct version")
-	}
-
-	epoch, err := helpers.LatestWeakSubjectivityEpoch(ctx, headState, cf.Config)
-	if err != nil {
-		return 0, errors.Wrap(err, "error computing the weak subjectivity epoch from head state")
-	}
-
-	log.Printf("(computed client-side) weak subjectivity epoch = %d", epoch)
-	return epoch, nil
-}
-
-const (
-	prysmMinimumVersion     = "v2.0.7"
-	prysmImplementationName = "Prysm"
-)
-
-// ErrUnsupportedPrysmCheckpointVersion indicates remote beacon node can't be used for checkpoint retrieval.
-var ErrUnsupportedPrysmCheckpointVersion = errors.New("node does not meet minimum version requirements for checkpoint retrieval")
-
-// for older endpoints or clients that do not support the weak_subjectivity api method
-// we gather the necessary data for a checkpoint sync by:
-// - inspecting the remote server's head state and computing the weak subjectivity epoch locally
-// - requesting the state at the first slot of the epoch
-// - using hash_tree_root(state.latest_block_header) to compute the block the state integrates
-// - requesting that block by its root
-func downloadBackwardsCompatible(ctx context.Context, client *Client) (*OriginData, error) {
-	log.Print("falling back to generic checkpoint derivation, weak_subjectivity API not supported by server")
-	nv, err := client.GetNodeVersion(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to proceed with fallback method without confirming node version")
-	}
-	if nv.implementation == prysmImplementationName && semver.Compare(nv.semver, prysmMinimumVersion) < 0 {
-		return nil, errors.Wrapf(ErrUnsupportedPrysmCheckpointVersion, "%s < minimum (%s)", nv.semver, prysmMinimumVersion)
-	}
-	epoch, err := getWeakSubjectivityEpochFromHead(ctx, client)
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing weak subjectivity epoch via head state inspection")
-	}
-
-	// use first slot of the epoch for the state slot
-	slot, err := slots.EpochStart(epoch)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error computing first slot of epoch=%d", epoch)
-	}
-
-	log.Printf("requesting checkpoint state at slot %d", slot)
-	// get the state at the first slot of the epoch
-	stateBytes, err := client.GetState(ctx, IdFromSlot(slot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to request state by slot from api, slot=%d", slot)
-	}
-
-	// ConfigFork is used to unmarshal the BeaconState so we can read the block root in latest_block_header
-	cf, err := detect.FromState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-
-	st, err := cf.UnmarshalBeaconState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
-	}
-
-	// compute state and block roots
-	stateRoot, err := st.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of state")
-	}
-
-	header := st.LatestBlockHeader()
-	header.StateRoot = stateRoot[:]
-	computedBlockRoot, err := header.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error while computing block root using state data")
-	}
-
-	blockBytes, err := client.GetBlock(ctx, IdFromRoot(computedBlockRoot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting block by root = %d", computedBlockRoot)
-	}
-	block, err := cf.UnmarshalBeaconBlock(blockBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
-	}
-	blockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root for block obtained via root")
-	}
-
-	log.Printf("BeaconState slot=%d, Block slot=%d", st.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconBlock root computed from state=%#x, Block htr=%#x", computedBlockRoot, blockRoot)
-
-	return &OriginData{
-		wsd: &WeakSubjectivityData{
-			BlockRoot: blockRoot,
-			StateRoot: stateRoot,
-			Epoch:     epoch,
-		},
-		st: st,
-		sb: stateBytes,
-		b:  block,
-		bb: blockBytes,
-		cf: cf,
-	}, nil
-}
-
-// DownloadOriginData attempts to use the proposed weak_subjectivity beacon node api
-// to obtain the weak_subjectivity metadata (epoch, block_root, state_root) needed to sync
-// a beacon node from the canonical weak subjectivity checkpoint. As this is a proposed API
-// that will only be supported by prysm at first, in the event of a 404 we fallback to using a
-// different technique where we first download the head state which can be used to compute the
-// weak subjectivity epoch on the client side.
-func DownloadOriginData(ctx context.Context, client *Client) (*OriginData, error) {
-	ws, err := client.GetWeakSubjectivity(ctx)
-	if err != nil {
-		// a 404/405 is expected if querying an endpoint that doesn't support the weak subjectivity checkpoint api
-		if !errors.Is(err, ErrNotOK) {
-			return nil, errors.Wrap(err, "unexpected API response for prysm-only weak subjectivity checkpoint API")
-		}
-		// fall back to vanilla Beacon Node API method
-		return downloadBackwardsCompatible(ctx, client)
-	}
-	log.Printf("server weak subjectivity checkpoint response - epoch=%d, block_root=%#x, state_root=%#x", ws.Epoch, ws.BlockRoot, ws.StateRoot)
-
-	// use first slot of the epoch for the block slot
-	slot, err := slots.EpochStart(ws.Epoch)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error computing first slot of epoch=%d", ws.Epoch)
-	}
-	log.Printf("requesting checkpoint state at slot %d", slot)
-
-	stateBytes, err := client.GetState(ctx, IdFromSlot(slot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to request state by slot from api, slot=%d", slot)
-	}
-	cf, err := detect.FromState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-
-	state, err := cf.UnmarshalBeaconState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
-	}
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to compute htr for state at slot=%d", slot)
-	}
-
-	blockRoot, err := state.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of latest_block_header")
-	}
-	blockBytes, err := client.GetBlock(ctx, IdFromRoot(ws.BlockRoot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting block by slot = %d", slot)
-	}
-	block, err := cf.UnmarshalBeaconBlock(blockBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
-	}
-	realBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block")
-	}
-	log.Printf("BeaconState slot=%d, Block slot=%d", state.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconState latest_block_header htr=%#xd, block htr=%#x", blockRoot, realBlockRoot)
-	return &OriginData{
-		wsd: ws,
-		st:  state,
-		b:   block,
-		sb:  stateBytes,
-		bb:  blockBytes,
-		cf:  cf,
-	}, nil
-}

api/client/beacon/checkpoint_test.go

@@ -1,407 +0,0 @@
-package beacon
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/network/forks"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time/slots"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-type testRT struct {
-	rt func(*http.Request) (*http.Response, error)
-}
-
-func (rt *testRT) RoundTrip(req *http.Request) (*http.Response, error) {
-	if rt.rt != nil {
-		return rt.rt(req)
-	}
-	return nil, errors.New("RoundTripper not implemented")
-}
-
-var _ http.RoundTripper = &testRT{}
-
-func marshalToEnvelope(val interface{}) ([]byte, error) {
-	raw, err := json.Marshal(val)
-	if err != nil {
-		return nil, errors.Wrap(err, "error marshaling value to place in data envelope")
-	}
-	env := struct {
-		Data json.RawMessage `json:"data"`
-	}{
-		Data: raw,
-	}
-	return json.Marshal(env)
-}
-
-func TestMarshalToEnvelope(t *testing.T) {
-	d := struct {
-		Version string `json:"version"`
-	}{
-		Version: "Prysm/v2.0.5 (linux amd64)",
-	}
-	encoded, err := marshalToEnvelope(d)
-	require.NoError(t, err)
-	expected := `{"data":{"version":"Prysm/v2.0.5 (linux amd64)"}}`
-	require.Equal(t, expected, string(encoded))
-}
-
-func TestFallbackVersionCheck(t *testing.T) {
-	c := &Client{
-		hc:     &http.Client{},
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-	c.hc.Transport = &testRT{rt: func(req *http.Request) (*http.Response, error) {
-		res := &http.Response{Request: req}
-		switch req.URL.Path {
-		case getNodeVersionPath:
-			res.StatusCode = http.StatusOK
-			b := bytes.NewBuffer(nil)
-			d := struct {
-				Version string `json:"version"`
-			}{
-				Version: "Prysm/v2.0.5 (linux amd64)",
-			}
-			encoded, err := marshalToEnvelope(d)
-			require.NoError(t, err)
-			b.Write(encoded)
-			res.Body = io.NopCloser(b)
-		case getWeakSubjectivityPath:
-			res.StatusCode = http.StatusNotFound
-		}
-
-		return res, nil
-	}}
-
-	ctx := context.Background()
-	_, err := DownloadOriginData(ctx, c)
-	require.ErrorIs(t, err, ErrUnsupportedPrysmCheckpointVersion)
-}
-
-func TestFname(t *testing.T) {
-	vu := &detect.VersionedUnmarshaler{
-		Config: params.MainnetConfig(),
-		Fork:   version.Phase0,
-	}
-	slot := types.Slot(23)
-	prefix := "block"
-	var root [32]byte
-	copy(root[:], []byte{0x23, 0x23, 0x23})
-	expected := "block_mainnet_phase0_23-0x2323230000000000000000000000000000000000000000000000000000000000.ssz"
-	actual := fname(prefix, vu, slot, root)
-	require.Equal(t, expected, actual)
-
-	vu.Config = params.MinimalSpecConfig()
-	vu.Fork = version.Altair
-	slot = 17
-	prefix = "state"
-	copy(root[29:], []byte{0x17, 0x17, 0x17})
-	expected = "state_minimal_altair_17-0x2323230000000000000000000000000000000000000000000000000000171717.ssz"
-	actual = fname(prefix, vu, slot, root)
-	require.Equal(t, expected, actual)
-}
-
-func TestDownloadOriginData(t *testing.T) {
-	ctx := context.Background()
-	cfg := params.MainnetConfig()
-
-	epoch := cfg.AltairForkEpoch - 1
-	// set up checkpoint state, using the epoch that will be computed as the ws checkpoint state based on the head state
-	wSlot, err := slots.EpochStart(epoch)
-	require.NoError(t, err)
-	wst, err := util.NewBeaconState()
-	require.NoError(t, err)
-	fork, err := forkForEpoch(cfg, epoch)
-	require.NoError(t, wst.SetFork(fork))
-
-	// set up checkpoint block
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, wrapper.SetBlockParentRoot(b, cfg.ZeroHash))
-	require.NoError(t, wrapper.SetBlockSlot(b, wSlot))
-	require.NoError(t, wrapper.SetProposerIndex(b, 0))
-
-	// set up state header pointing at checkpoint block - this is how the block is downloaded by root
-	header, err := b.Header()
-	require.NoError(t, err)
-	require.NoError(t, wst.SetLatestBlockHeader(header.Header))
-
-	// order of operations can be confusing here:
-	// - when computing the state root, make sure block header is complete, EXCEPT the state root should be zero-value
-	// - before computing the block root (to match the request route), the block should include the state root
-	//   *computed from the state with a header that does not have a state root set yet*
-	wRoot, err := wst.HashTreeRoot(ctx)
-	require.NoError(t, err)
-
-	require.NoError(t, wrapper.SetBlockStateRoot(b, wRoot))
-	serBlock, err := b.MarshalSSZ()
-	require.NoError(t, err)
-	bRoot, err := b.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	wsSerialized, err := wst.MarshalSSZ()
-	require.NoError(t, err)
-	expectedWSD := WeakSubjectivityData{
-		BlockRoot: bRoot,
-		StateRoot: wRoot,
-		Epoch:     epoch,
-	}
-
-	hc := &http.Client{
-		Transport: &testRT{rt: func(req *http.Request) (*http.Response, error) {
-			res := &http.Response{Request: req}
-			switch req.URL.Path {
-			case getWeakSubjectivityPath:
-				res.StatusCode = http.StatusOK
-				cp := struct {
-					Epoch string `json:"epoch"`
-					Root  string `json:"root"`
-				}{
-					Epoch: fmt.Sprintf("%d", slots.ToEpoch(b.Block().Slot())),
-					Root:  fmt.Sprintf("%#x", bRoot),
-				}
-				wsr := struct {
-					Checkpoint interface{} `json:"ws_checkpoint"`
-					StateRoot  string      `json:"state_root"`
-				}{
-					Checkpoint: cp,
-					StateRoot:  fmt.Sprintf("%#x", wRoot),
-				}
-				rb, err := marshalToEnvelope(wsr)
-				require.NoError(t, err)
-				res.Body = io.NopCloser(bytes.NewBuffer(rb))
-			case renderGetStatePath(IdFromSlot(wSlot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(wsSerialized))
-			case renderGetBlockPath(IdFromRoot(bRoot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serBlock))
-			}
-
-			return res, nil
-		}},
-	}
-	c := &Client{
-		hc:     hc,
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-
-	od, err := DownloadOriginData(ctx, c)
-	require.NoError(t, err)
-	require.Equal(t, expectedWSD.Epoch, od.wsd.Epoch)
-	require.Equal(t, expectedWSD.StateRoot, od.wsd.StateRoot)
-	require.Equal(t, expectedWSD.BlockRoot, od.wsd.BlockRoot)
-	require.DeepEqual(t, wsSerialized, od.sb)
-	require.DeepEqual(t, serBlock, od.bb)
-	require.DeepEqual(t, wst.Fork().CurrentVersion, od.cf.Version[:])
-	require.DeepEqual(t, version.Phase0, od.cf.Fork)
-}
-
-// runs downloadBackwardsCompatible directly
-// and via DownloadOriginData with a round tripper that triggers the backwards compatible code path
-func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
-	ctx := context.Background()
-	cfg := params.MainnetConfig()
-
-	st, expectedEpoch := defaultTestHeadState(t, cfg)
-	serialized, err := st.MarshalSSZ()
-	require.NoError(t, err)
-
-	// set up checkpoint state, using the epoch that will be computed as the ws checkpoint state based on the head state
-	wSlot, err := slots.EpochStart(expectedEpoch)
-	require.NoError(t, err)
-	wst, err := util.NewBeaconState()
-	require.NoError(t, err)
-	fork, err := forkForEpoch(cfg, cfg.GenesisEpoch)
-	require.NoError(t, wst.SetFork(fork))
-
-	// set up checkpoint block
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, wrapper.SetBlockParentRoot(b, cfg.ZeroHash))
-	require.NoError(t, wrapper.SetBlockSlot(b, wSlot))
-	require.NoError(t, wrapper.SetProposerIndex(b, 0))
-
-	// set up state header pointing at checkpoint block - this is how the block is downloaded by root
-	header, err := b.Header()
-	require.NoError(t, err)
-	require.NoError(t, wst.SetLatestBlockHeader(header.Header))
-
-	// order of operations can be confusing here:
-	// - when computing the state root, make sure block header is complete, EXCEPT the state root should be zero-value
-	// - before computing the block root (to match the request route), the block should include the state root
-	//   *computed from the state with a header that does not have a state root set yet*
-	wRoot, err := wst.HashTreeRoot(ctx)
-	require.NoError(t, err)
-
-	require.NoError(t, wrapper.SetBlockStateRoot(b, wRoot))
-	serBlock, err := b.MarshalSSZ()
-	require.NoError(t, err)
-	bRoot, err := b.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	wsSerialized, err := wst.MarshalSSZ()
-	require.NoError(t, err)
-
-	hc := &http.Client{
-		Transport: &testRT{rt: func(req *http.Request) (*http.Response, error) {
-			res := &http.Response{Request: req}
-			switch req.URL.Path {
-			case getNodeVersionPath:
-				res.StatusCode = http.StatusOK
-				b := bytes.NewBuffer(nil)
-				d := struct {
-					Version string `json:"version"`
-				}{
-					Version: "Lighthouse/v0.1.5 (Linux x86_64)",
-				}
-				encoded, err := marshalToEnvelope(d)
-				require.NoError(t, err)
-				b.Write(encoded)
-				res.Body = io.NopCloser(b)
-			case getWeakSubjectivityPath:
-				res.StatusCode = http.StatusNotFound
-			case renderGetStatePath(IdHead):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serialized))
-			case renderGetStatePath(IdFromSlot(wSlot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(wsSerialized))
-			case renderGetBlockPath(IdFromRoot(bRoot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serBlock))
-			}
-
-			return res, nil
-		}},
-	}
-	c := &Client{
-		hc:     hc,
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-
-	odPub, err := DownloadOriginData(ctx, c)
-	require.NoError(t, err)
-
-	odPriv, err := downloadBackwardsCompatible(ctx, c)
-	require.NoError(t, err)
-	require.DeepEqual(t, odPriv.wsd, odPub.wsd)
-	require.DeepEqual(t, odPriv.sb, odPub.sb)
-	require.DeepEqual(t, odPriv.bb, odPub.bb)
-	require.DeepEqual(t, odPriv.cf.Fork, odPub.cf.Fork)
-	require.DeepEqual(t, odPriv.cf.Version, odPub.cf.Version)
-}
-
-func TestGetWeakSubjectivityEpochFromHead(t *testing.T) {
-	st, expectedEpoch := defaultTestHeadState(t, params.MainnetConfig())
-	serialized, err := st.MarshalSSZ()
-	require.NoError(t, err)
-	hc := &http.Client{
-		Transport: &testRT{rt: func(req *http.Request) (*http.Response, error) {
-			res := &http.Response{Request: req}
-			switch req.URL.Path {
-			case renderGetStatePath(IdHead):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serialized))
-			}
-			return res, nil
-		}},
-	}
-	c := &Client{
-		hc:     hc,
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-	actualEpoch, err := getWeakSubjectivityEpochFromHead(context.Background(), c)
-	require.NoError(t, err)
-	require.Equal(t, expectedEpoch, actualEpoch)
-}
-
-func forkForEpoch(cfg *params.BeaconChainConfig, epoch types.Epoch) (*ethpb.Fork, error) {
-	os := forks.NewOrderedSchedule(cfg)
-	currentVersion, err := os.VersionForEpoch(epoch)
-	if err != nil {
-		return nil, err
-	}
-	prevVersion, err := os.Previous(currentVersion)
-	if err != nil {
-		if !errors.Is(err, forks.ErrNoPreviousVersion) {
-			return nil, err
-		}
-		// use same version for both in the case of genesis
-		prevVersion = currentVersion
-	}
-	forkEpoch := cfg.ForkVersionSchedule[currentVersion]
-	return &ethpb.Fork{
-		PreviousVersion: prevVersion[:],
-		CurrentVersion:  currentVersion[:],
-		Epoch:           forkEpoch,
-	}, nil
-}
-
-func defaultTestHeadState(t *testing.T, cfg *params.BeaconChainConfig) (state.BeaconState, types.Epoch) {
-	st, err := util.NewBeaconStateAltair()
-	require.NoError(t, err)
-
-	fork, err := forkForEpoch(cfg, cfg.AltairForkEpoch)
-	require.NoError(t, err)
-	require.NoError(t, st.SetFork(fork))
-
-	slot, err := slots.EpochStart(cfg.AltairForkEpoch)
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(slot))
-
-	var validatorCount, avgBalance uint64 = 100, 35
-	require.NoError(t, populateValidators(cfg, st, validatorCount, avgBalance))
-	require.NoError(t, st.SetFinalizedCheckpoint(&ethpb.Checkpoint{
-		Epoch: fork.Epoch - 10,
-		Root:  make([]byte, 32),
-	}))
-	// to see the math for this, look at helpers.LatestWeakSubjectivityEpoch
-	// and for the values use mainnet config values, the validatorCount and avgBalance above, and altair fork epoch
-	expectedEpoch := slots.ToEpoch(st.Slot()) - 224
-	return st, expectedEpoch
-}
-
-// TODO(10429): refactor beacon state options in testing/util to take a state.BeaconState so this can become an option
-func populateValidators(cfg *params.BeaconChainConfig, st state.BeaconState, valCount, avgBalance uint64) error {
-	validators := make([]*ethpb.Validator, valCount)
-	balances := make([]uint64, len(validators))
-	for i := uint64(0); i < valCount; i++ {
-		validators[i] = &ethpb.Validator{
-			PublicKey:             make([]byte, cfg.BLSPubkeyLength),
-			WithdrawalCredentials: make([]byte, 32),
-			EffectiveBalance:      avgBalance * 1e9,
-			ExitEpoch:             cfg.FarFutureEpoch,
-		}
-		balances[i] = validators[i].EffectiveBalance
-	}
-
-	if err := st.SetValidators(validators); err != nil {
-		return err
-	}
-	if err := st.SetBalances(balances); err != nil {
-		return err
-	}
-
-	return nil
-}

api/client/beacon/client.go

@@ -1,446 +0,0 @@
-package beacon
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/url"
-	"path"
-	"regexp"
-	"sort"
-	"strconv"
-	"text/template"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/network/forks"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/apimiddleware"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	getSignedBlockPath      = "/eth/v2/beacon/blocks"
-	getBlockRootPath        = "/eth/v1/beacon/blocks/{{.Id}}/root"
-	getForkForStatePath     = "/eth/v1/beacon/states/{{.Id}}/fork"
-	getWeakSubjectivityPath = "/eth/v1/beacon/weak_subjectivity"
-	getForkSchedulePath     = "/eth/v1/config/fork_schedule"
-	getStatePath            = "/eth/v2/debug/beacon/states"
-	getNodeVersionPath      = "/eth/v1/node/version"
-)
-
-// StateOrBlockId represents the block_id / state_id parameters that several of the Eth Beacon API methods accept.
-// StateOrBlockId constants are defined for named identifiers, and helper methods are provided
-// for slot and root identifiers. Example text from the Eth Beacon Node API documentation:
-//
-// "Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>."
-type StateOrBlockId string
-
-const (
-	IdFinalized StateOrBlockId = "finalized"
-	IdGenesis   StateOrBlockId = "genesis"
-	IdHead      StateOrBlockId = "head"
-	IdJustified StateOrBlockId = "justified"
-)
-
-// IdFromRoot encodes a block root in the format expected by the API in places where a root can be used to identify
-// a BeaconState or SignedBeaconBlock.
-func IdFromRoot(r [32]byte) StateOrBlockId {
-	return StateOrBlockId(fmt.Sprintf("%#x", r))
-}
-
-// IdFromRoot encodes a Slot in the format expected by the API in places where a slot can be used to identify
-// a BeaconState or SignedBeaconBlock.
-func IdFromSlot(s types.Slot) StateOrBlockId {
-	return StateOrBlockId(strconv.FormatUint(uint64(s), 10))
-}
-
-// idTemplate is used to create template functions that can interpolate StateOrBlockId values.
-func idTemplate(ts string) func(StateOrBlockId) string {
-	t := template.Must(template.New("").Parse(ts))
-	f := func(id StateOrBlockId) string {
-		b := bytes.NewBuffer(nil)
-		err := t.Execute(b, struct{ Id string }{Id: string(id)})
-		if err != nil {
-			panic(fmt.Sprintf("invalid idTemplate: %s", ts))
-		}
-		return b.String()
-	}
-	// run the template to ensure that it is valid
-	// this should happen load time (using package scoped vars) to ensure runtime errors aren't possible
-	_ = f(IdGenesis)
-	return f
-}
-
-// ClientOpt is a functional option for the Client type (http.Client wrapper)
-type ClientOpt func(*Client)
-
-// WithTimeout sets the .Timeout attribute of the wrapped http.Client.
-func WithTimeout(timeout time.Duration) ClientOpt {
-	return func(c *Client) {
-		c.hc.Timeout = timeout
-	}
-}
-
-// Client provides a collection of helper methods for calling the Eth Beacon Node API endpoints.
-type Client struct {
-	hc     *http.Client
-	host   string
-	scheme string
-}
-
-// NewClient constructs a new client with the provided options (ex WithTimeout).
-// `host` is the base host + port used to construct request urls. This value can be
-// a URL string, or NewClient will assume an http endpoint if just `host:port` is used.
-func NewClient(host string, opts ...ClientOpt) (*Client, error) {
-	host, err := validHostname(host)
-	if err != nil {
-		return nil, err
-	}
-	c := &Client{
-		hc:     &http.Client{},
-		scheme: "http",
-		host:   host,
-	}
-	for _, o := range opts {
-		o(c)
-	}
-	return c, nil
-}
-
-func validHostname(h string) (string, error) {
-	// try to parse as url (being permissive)
-	u, err := url.Parse(h)
-	if err == nil && u.Host != "" {
-		return u.Host, nil
-	}
-	// try to parse as host:port
-	host, port, err := net.SplitHostPort(h)
-	if err != nil {
-		return "", err
-	}
-	return fmt.Sprintf("%s:%s", host, port), nil
-}
-
-// NodeURL returns a human-readable string representation of the beacon node base url.
-func (c *Client) NodeURL() string {
-	u := &url.URL{
-		Scheme: c.scheme,
-		Host:   c.host,
-	}
-	return u.String()
-}
-
-func (c *Client) urlForPath(methodPath string) *url.URL {
-	u := &url.URL{
-		Scheme: c.scheme,
-		Host:   c.host,
-	}
-	u.Path = path.Join(u.Path, methodPath)
-	return u
-}
-
-type reqOption func(*http.Request)
-
-func withSSZEncoding() reqOption {
-	return func(req *http.Request) {
-		req.Header.Set("Accept", "application/octet-stream")
-	}
-}
-
-// get is a generic, opinionated GET function to reduce boilerplate amongst the getters in this package.
-func (c *Client) get(ctx context.Context, path string, opts ...reqOption) ([]byte, error) {
-	u := c.urlForPath(path)
-	log.Printf("requesting %s", u.String())
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	for _, o := range opts {
-		o(req)
-	}
-	r, err := c.hc.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	b, err := io.ReadAll(r.Body)
-	if err != nil {
-		return nil, errors.Wrap(err, "error reading http response body from GetBlock")
-	}
-	return b, nil
-}
-
-func renderGetBlockPath(id StateOrBlockId) string {
-	return path.Join(getSignedBlockPath, string(id))
-}
-
-// GetBlock retrieves the SignedBeaconBlock for the given block id.
-// Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-// The return value contains the ssz-encoded bytes.
-func (c *Client) GetBlock(ctx context.Context, blockId StateOrBlockId) ([]byte, error) {
-	blockPath := renderGetBlockPath(blockId)
-	b, err := c.get(ctx, blockPath, withSSZEncoding())
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting state by id = %s", blockId)
-	}
-	return b, nil
-}
-
-var getBlockRootTpl = idTemplate(getBlockRootPath)
-
-// GetBlockRoot retrieves the hash_tree_root of the BeaconBlock for the given block id.
-// Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-func (c *Client) GetBlockRoot(ctx context.Context, blockId StateOrBlockId) ([32]byte, error) {
-	rootPath := getBlockRootTpl(blockId)
-	b, err := c.get(ctx, rootPath)
-	if err != nil {
-		return [32]byte{}, errors.Wrapf(err, "error requesting block root by id = %s", blockId)
-	}
-	jsonr := &struct{ Data struct{ Root string } }{}
-	err = json.Unmarshal(b, jsonr)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "error decoding json data from get block root response")
-	}
-	rs, err := hexutil.Decode(jsonr.Data.Root)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, fmt.Sprintf("error decoding hex-encoded value %s", jsonr.Data.Root))
-	}
-	return bytesutil.ToBytes32(rs), nil
-}
-
-var getForkTpl = idTemplate(getForkForStatePath)
-
-// GetFork queries the Beacon Node API for the Fork from the state identified by stateId.
-// Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-func (c *Client) GetFork(ctx context.Context, stateId StateOrBlockId) (*ethpb.Fork, error) {
-	body, err := c.get(ctx, getForkTpl(stateId))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting fork by state id = %s", stateId)
-	}
-	fr := &forkResponse{}
-	dataWrapper := &struct{ Data *forkResponse }{Data: fr}
-	err = json.Unmarshal(body, dataWrapper)
-	if err != nil {
-		return nil, errors.Wrap(err, "error decoding json response in GetFork")
-	}
-
-	return fr.Fork()
-}
-
-// GetForkSchedule retrieve all forks, past present and future, of which this node is aware.
-func (c *Client) GetForkSchedule(ctx context.Context) (forks.OrderedSchedule, error) {
-	body, err := c.get(ctx, getForkSchedulePath)
-	if err != nil {
-		return nil, errors.Wrap(err, "error requesting fork schedule")
-	}
-	fsr := &forkScheduleResponse{}
-	err = json.Unmarshal(body, fsr)
-	if err != nil {
-		return nil, err
-	}
-	ofs, err := fsr.OrderedForkSchedule()
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("problem unmarshaling %s response", getForkSchedulePath))
-	}
-	return ofs, nil
-}
-
-type NodeVersion struct {
-	implementation string
-	semver         string
-	systemInfo     string
-}
-
-var versionRE = regexp.MustCompile(`^(\w+)\/(v\d+\.\d+\.\d+) \((.*)\)$`)
-
-func parseNodeVersion(v string) (*NodeVersion, error) {
-	groups := versionRE.FindStringSubmatch(v)
-	if len(groups) != 4 {
-		return nil, errors.Wrapf(ErrInvalidNodeVersion, "could not be parsed: %s", v)
-	}
-	return &NodeVersion{
-		implementation: groups[1],
-		semver:         groups[2],
-		systemInfo:     groups[3],
-	}, nil
-}
-
-// GetNodeVersion requests that the beacon node identify information about its implementation in a format
-// similar to a HTTP User-Agent field. ex: Lighthouse/v0.1.5 (Linux x86_64)
-func (c *Client) GetNodeVersion(ctx context.Context) (*NodeVersion, error) {
-	b, err := c.get(ctx, getNodeVersionPath)
-	if err != nil {
-		return nil, errors.Wrap(err, "error requesting node version")
-	}
-	d := struct {
-		Data struct {
-			Version string `json:"version"`
-		} `json:"data"`
-	}{}
-	err = json.Unmarshal(b, &d)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error unmarshaling response body: %s", string(b))
-	}
-	return parseNodeVersion(d.Data.Version)
-}
-
-func renderGetStatePath(id StateOrBlockId) string {
-	return path.Join(getStatePath, string(id))
-}
-
-// GetState retrieves the BeaconState for the given state id.
-// State identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded stateRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-// The return value contains the ssz-encoded bytes.
-func (c *Client) GetState(ctx context.Context, stateId StateOrBlockId) ([]byte, error) {
-	statePath := path.Join(getStatePath, string(stateId))
-	b, err := c.get(ctx, statePath, withSSZEncoding())
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting state by id = %s", stateId)
-	}
-	return b, nil
-}
-
-// GetWeakSubjectivity calls a proposed API endpoint that is unique to prysm
-// This api method does the following:
-// - computes weak subjectivity epoch
-// - finds the highest non-skipped block preceding the epoch
-// - returns the htr of the found block and returns this + the value of state_root from the block
-func (c *Client) GetWeakSubjectivity(ctx context.Context) (*WeakSubjectivityData, error) {
-	body, err := c.get(ctx, getWeakSubjectivityPath)
-	if err != nil {
-		return nil, err
-	}
-	v := &apimiddleware.WeakSubjectivityResponse{}
-	err = json.Unmarshal(body, v)
-	if err != nil {
-		return nil, err
-	}
-	epoch, err := strconv.ParseUint(v.Data.Checkpoint.Epoch, 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	blockRoot, err := hexutil.Decode(v.Data.Checkpoint.Root)
-	if err != nil {
-		return nil, err
-	}
-	stateRoot, err := hexutil.Decode(v.Data.StateRoot)
-	if err != nil {
-		return nil, err
-	}
-	return &WeakSubjectivityData{
-		Epoch:     types.Epoch(epoch),
-		BlockRoot: bytesutil.ToBytes32(blockRoot),
-		StateRoot: bytesutil.ToBytes32(stateRoot),
-	}, nil
-}
-
-// WeakSubjectivityData represents the state root, block root and epoch of the BeaconState + SignedBeaconBlock
-// that falls at the beginning of the current weak subjectivity period. These values can be used to construct
-// a weak subjectivity checkpoint, or to download a BeaconState+SignedBeaconBlock pair that can be used to bootstrap
-// a new Beacon Node using Checkpoint Sync.
-type WeakSubjectivityData struct {
-	BlockRoot [32]byte
-	StateRoot [32]byte
-	Epoch     types.Epoch
-}
-
-func non200Err(response *http.Response) error {
-	bodyBytes, err := ioutil.ReadAll(response.Body)
-	var body string
-	if err != nil {
-		body = "(Unable to read response body.)"
-	} else {
-		body = "response body:\n" + string(bodyBytes)
-	}
-	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
-	switch response.StatusCode {
-	case 404:
-		return errors.Wrap(ErrNotFound, msg)
-	default:
-		return errors.Wrap(ErrNotOK, msg)
-	}
-}
-
-type forkResponse struct {
-	PreviousVersion string `json:"previous_version"`
-	CurrentVersion  string `json:"current_version"`
-	Epoch           string `json:"epoch"`
-}
-
-func (f *forkResponse) Fork() (*ethpb.Fork, error) {
-	epoch, err := strconv.ParseUint(f.Epoch, 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	cSlice, err := hexutil.Decode(f.CurrentVersion)
-	if err != nil {
-		return nil, err
-	}
-	if len(cSlice) != 4 {
-		return nil, fmt.Errorf("got %d byte version for CurrentVersion, expected 4 bytes. hex=%s", len(cSlice), f.CurrentVersion)
-	}
-	pSlice, err := hexutil.Decode(f.PreviousVersion)
-	if err != nil {
-		return nil, err
-	}
-	if len(pSlice) != 4 {
-		return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(pSlice), f.PreviousVersion)
-	}
-	return &ethpb.Fork{
-		CurrentVersion:  cSlice,
-		PreviousVersion: pSlice,
-		Epoch:           types.Epoch(epoch),
-	}, nil
-}
-
-type forkScheduleResponse struct {
-	Data []forkResponse
-}
-
-func (fsr *forkScheduleResponse) OrderedForkSchedule() (forks.OrderedSchedule, error) {
-	ofs := make(forks.OrderedSchedule, 0)
-	for _, d := range fsr.Data {
-		epoch, err := strconv.Atoi(d.Epoch)
-		if err != nil {
-			return nil, err
-		}
-		vSlice, err := hexutil.Decode(d.CurrentVersion)
-		if err != nil {
-			return nil, err
-		}
-		if len(vSlice) != 4 {
-			return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(vSlice), d.CurrentVersion)
-		}
-		version := bytesutil.ToBytes4(vSlice)
-		ofs = append(ofs, forks.ForkScheduleEntry{
-			Version: version,
-			Epoch:   types.Epoch(uint64(epoch)),
-		})
-	}
-	sort.Sort(ofs)
-	return ofs, nil
-}

api/client/beacon/client_test.go

@@ -1,58 +0,0 @@
-package beacon
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestParseNodeVersion(t *testing.T) {
-	cases := []struct {
-		name string
-		v    string
-		err  error
-		nv   *NodeVersion
-	}{
-		{
-			name: "empty string",
-			v:    "",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "Prysm as the version string",
-			v:    "Prysm",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "semver only",
-			v:    "v2.0.6",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "implementation and semver only",
-			v:    "Prysm/v2.0.6",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "complete version",
-			v:    "Prysm/v2.0.6 (linux amd64)",
-			nv: &NodeVersion{
-				implementation: "Prysm",
-				semver:         "v2.0.6",
-				systemInfo:     "linux amd64",
-			},
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			nv, err := parseNodeVersion(c.v)
-			if c.err != nil {
-				require.ErrorIs(t, err, c.err)
-			} else {
-				require.NoError(t, err)
-				require.DeepEqual(t, c.nv, nv)
-			}
-		})
-	}
-}

api/client/beacon/doc.go

@@ -1,6 +0,0 @@
-/*
-Package beacon provides a client for interacting with the standard Eth Beacon Node API.
-Interactive swagger documentation for the API is available here: https://ethereum.github.io/beacon-APIs/
-
-*/
-package beacon

api/client/beacon/errors.go

@@ -1,13 +0,0 @@
-package beacon
-
-import "github.com/pkg/errors"
-
-// ErrNotOK is used to indicate when an HTTP request to the Beacon Node API failed with any non-2xx response code.
-// More specific errors may be returned, but an error in reaction to a non-2xx response will always wrap ErrNotOK.
-var ErrNotOK = errors.New("did not receive 2xx response from API")
-
-// ErrNotFound specifically means that a '404 - NOT FOUND' response was received from the API.
-var ErrNotFound = errors.Wrap(ErrNotOK, "recv 404 NotFound response from API")
-
-// ErrInvalidNodeVersion indicates that the /eth/v1/node/version api response format was not recognized.
-var ErrInvalidNodeVersion = errors.New("invalid node version response")

api/gateway/BUILD.bazel

@@ -1,42 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "gateway.go",
-        "log.go",
-        "options.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/gateway",
-    visibility = [
-        "//beacon-chain:__subpackages__",
-        "//validator:__subpackages__",
-    ],
-    deps = [
-        "//api/gateway/apimiddleware:go_default_library",
-        "//runtime:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_rs_cors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_grpc//connectivity:go_default_library",
-        "@org_golang_google_grpc//credentials:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["gateway_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//api/gateway/apimiddleware:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@com_github_urfave_cli_v2//:go_default_library",
-    ],
-)

api/gateway/apimiddleware/BUILD.bazel

@@ -1,40 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "api_middleware.go",
-        "log.go",
-        "param_handling.go",
-        "process_field.go",
-        "process_request.go",
-        "structs.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/gateway/apimiddleware",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//api/grpc:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_wealdtech_go_bytesutil//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "param_handling_test.go",
-        "process_request_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//api/grpc:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-    ],
-)

api/gateway/apimiddleware/api_middleware.go

@@ -1,265 +0,0 @@
-package apimiddleware
-
-import (
-	"net/http"
-	"reflect"
-	"time"
-
-	"github.com/gorilla/mux"
-)
-
-// ApiProxyMiddleware is a proxy between an Ethereum consensus API HTTP client and grpc-gateway.
-// The purpose of the proxy is to handle HTTP requests and gRPC responses in such a way that:
-//   - Ethereum consensus API requests can be handled by grpc-gateway correctly
-//   - gRPC responses can be returned as spec-compliant Ethereum consensus API responses
-type ApiProxyMiddleware struct {
-	GatewayAddress  string
-	EndpointCreator EndpointFactory
-	Timeout         time.Duration
-	router          *mux.Router
-}
-
-// EndpointFactory is responsible for creating new instances of Endpoint values.
-type EndpointFactory interface {
-	Create(path string) (*Endpoint, error)
-	Paths() []string
-	IsNil() bool
-}
-
-// Endpoint is a representation of an API HTTP endpoint that should be proxied by the middleware.
-type Endpoint struct {
-	Path               string          // The path of the HTTP endpoint.
-	GetResponse        interface{}     // The struct corresponding to the JSON structure used in a GET response.
-	PostRequest        interface{}     // The struct corresponding to the JSON structure used in a POST request.
-	PostResponse       interface{}     // The struct corresponding to the JSON structure used in a POST response.
-	DeleteRequest      interface{}     // The struct corresponding to the JSON structure used in a DELETE request.
-	DeleteResponse     interface{}     // The struct corresponding to the JSON structure used in a DELETE response.
-	RequestURLLiterals []string        // Names of URL parameters that should not be base64-encoded.
-	RequestQueryParams []QueryParam    // Query parameters of the request.
-	Err                ErrorJson       // The struct corresponding to the error that should be returned in case of a request failure.
-	Hooks              HookCollection  // A collection of functions that can be invoked at various stages of the request/response cycle.
-	CustomHandlers     []CustomHandler // Functions that will be executed instead of the default request/response behaviour.
-}
-
-// RunDefault expresses whether the default processing logic should be carried out after running a pre hook.
-type RunDefault bool
-
-// DefaultEndpoint returns an Endpoint with default configuration, e.g. DefaultErrorJson for error handling.
-func DefaultEndpoint() Endpoint {
-	return Endpoint{
-		Err: &DefaultErrorJson{},
-	}
-}
-
-// QueryParam represents a single query parameter's metadata.
-type QueryParam struct {
-	Name string
-	Hex  bool
-	Enum bool
-}
-
-// CustomHandler is a function that can be invoked at the very beginning of the request,
-// essentially replacing the whole default request/response logic with custom logic for a specific endpoint.
-type CustomHandler = func(m *ApiProxyMiddleware, endpoint Endpoint, w http.ResponseWriter, req *http.Request) (handled bool)
-
-// HookCollection contains hooks that can be used to amend the default request/response cycle with custom logic for a specific endpoint.
-type HookCollection struct {
-	OnPreDeserializeRequestBodyIntoContainer      func(endpoint *Endpoint, w http.ResponseWriter, req *http.Request) (RunDefault, ErrorJson)
-	OnPostDeserializeRequestBodyIntoContainer     func(endpoint *Endpoint, w http.ResponseWriter, req *http.Request) ErrorJson
-	OnPreDeserializeGrpcResponseBodyIntoContainer func([]byte, interface{}) (RunDefault, ErrorJson)
-	OnPreSerializeMiddlewareResponseIntoJson      func(interface{}) (RunDefault, []byte, ErrorJson)
-}
-
-// fieldProcessor applies the processing function f to a value when the tag is present on the field.
-type fieldProcessor struct {
-	tag string
-	f   func(value reflect.Value) error
-}
-
-// Run starts the proxy, registering all proxy endpoints.
-func (m *ApiProxyMiddleware) Run(gatewayRouter *mux.Router) {
-	for _, path := range m.EndpointCreator.Paths() {
-		gatewayRouter.HandleFunc(path, m.WithMiddleware(path))
-	}
-	m.router = gatewayRouter
-}
-
-// ServeHTTP for the proxy middleware.
-func (m *ApiProxyMiddleware) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	m.router.ServeHTTP(w, req)
-}
-
-// WithMiddleware wraps the given endpoint handler with the middleware logic.
-func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		endpoint, err := m.EndpointCreator.Create(path)
-		if err != nil {
-			log.WithError(err).Errorf("Could not create endpoint for path: %s", path)
-			return
-		}
-
-		for _, handler := range endpoint.CustomHandlers {
-			if handler(m, *endpoint, w, req) {
-				return
-			}
-		}
-
-		if req.Method == "POST" {
-			if errJson := handlePostRequestForEndpoint(endpoint, w, req); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-		}
-
-		if req.Method == "DELETE" {
-			if errJson := handleDeleteRequestForEndpoint(endpoint, req); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-		}
-
-		if errJson := m.PrepareRequestForProxying(*endpoint, req); errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-		grpcResp, errJson := m.ProxyRequest(req)
-		if errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-		grpcRespBody, errJson := ReadGrpcResponseBody(grpcResp.Body)
-		if errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-
-		var respJson []byte
-		if !GrpcResponseIsEmpty(grpcRespBody) {
-			respHasError, errJson := HandleGrpcResponseError(endpoint.Err, grpcResp, grpcRespBody, w)
-			if errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-			if respHasError {
-				return
-			}
-
-			var resp interface{}
-			if req.Method == "GET" {
-				resp = endpoint.GetResponse
-			} else if req.Method == "DELETE" {
-				resp = endpoint.DeleteResponse
-			} else {
-				resp = endpoint.PostResponse
-			}
-			if errJson := deserializeGrpcResponseBodyIntoContainerWrapped(endpoint, grpcRespBody, resp); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-			if errJson := ProcessMiddlewareResponseFields(resp); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-
-			respJson, errJson = serializeMiddlewareResponseIntoJsonWrapped(endpoint, respJson, resp)
-			if errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-		}
-
-		if errJson := WriteMiddlewareResponseHeadersAndBody(grpcResp, respJson, w); errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-		if errJson := Cleanup(grpcResp.Body); errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-	}
-}
-
-func handlePostRequestForEndpoint(endpoint *Endpoint, w http.ResponseWriter, req *http.Request) ErrorJson {
-	if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
-		return errJson
-	}
-	if errJson := ProcessRequestContainerFields(endpoint.PostRequest); errJson != nil {
-		return errJson
-	}
-	return SetRequestBodyToRequestContainer(endpoint.PostRequest, req)
-}
-
-func handleDeleteRequestForEndpoint(endpoint *Endpoint, req *http.Request) ErrorJson {
-	if errJson := DeserializeRequestBodyIntoContainer(req.Body, endpoint.DeleteRequest); errJson != nil {
-		return errJson
-	}
-	if errJson := ProcessRequestContainerFields(endpoint.DeleteRequest); errJson != nil {
-		return errJson
-	}
-	return SetRequestBodyToRequestContainer(endpoint.DeleteRequest, req)
-}
-
-func deserializeRequestBodyIntoContainerWrapped(endpoint *Endpoint, req *http.Request, w http.ResponseWriter) ErrorJson {
-	runDefault := true
-	if endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer != nil {
-		run, errJson := endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer(endpoint, w, req)
-		if errJson != nil {
-			return errJson
-		}
-		if !run {
-			runDefault = false
-		}
-	}
-	if runDefault {
-		if errJson := DeserializeRequestBodyIntoContainer(req.Body, endpoint.PostRequest); errJson != nil {
-			return errJson
-		}
-	}
-	if endpoint.Hooks.OnPostDeserializeRequestBodyIntoContainer != nil {
-		if errJson := endpoint.Hooks.OnPostDeserializeRequestBodyIntoContainer(endpoint, w, req); errJson != nil {
-			return errJson
-		}
-	}
-	return nil
-}
-
-func deserializeGrpcResponseBodyIntoContainerWrapped(endpoint *Endpoint, grpcResponseBody []byte, resp interface{}) ErrorJson {
-	runDefault := true
-	if endpoint.Hooks.OnPreDeserializeGrpcResponseBodyIntoContainer != nil {
-		run, errJson := endpoint.Hooks.OnPreDeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, resp)
-		if errJson != nil {
-			return errJson
-		}
-		if !run {
-			runDefault = false
-		}
-	}
-	if runDefault {
-		if errJson := DeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, resp); errJson != nil {
-			return errJson
-		}
-	}
-	return nil
-}
-
-func serializeMiddlewareResponseIntoJsonWrapped(endpoint *Endpoint, respJson []byte, resp interface{}) ([]byte, ErrorJson) {
-	runDefault := true
-	var errJson ErrorJson
-	if endpoint.Hooks.OnPreSerializeMiddlewareResponseIntoJson != nil {
-		var run RunDefault
-		run, respJson, errJson = endpoint.Hooks.OnPreSerializeMiddlewareResponseIntoJson(resp)
-		if errJson != nil {
-			return nil, errJson
-		}
-		if !run {
-			runDefault = false
-		}
-	}
-	if runDefault {
-		respJson, errJson = SerializeMiddlewareResponseIntoJson(resp)
-		if errJson != nil {
-			return nil, errJson
-		}
-	}
-	return respJson, nil
-}

api/gateway/apimiddleware/log.go

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

api/gateway/apimiddleware/param_handling.go

@@ -1,103 +0,0 @@
-package apimiddleware
-
-import (
-	"encoding/base64"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/gorilla/mux"
-	butil "github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/wealdtech/go-bytesutil"
-)
-
-// HandleURLParameters processes URL parameters, allowing parameterized URLs to be safely and correctly proxied to grpc-gateway.
-func HandleURLParameters(url string, req *http.Request, literals []string) ErrorJson {
-	segments := strings.Split(url, "/")
-
-segmentsLoop:
-	for i, s := range segments {
-		// We only care about segments which are parameterized.
-		if isRequestParam(s) {
-			// Don't do anything with parameters which should be forwarded literally to gRPC.
-			for _, l := range literals {
-				if s == "{"+l+"}" {
-					continue segmentsLoop
-				}
-			}
-
-			routeVar := mux.Vars(req)[s[1:len(s)-1]]
-			bRouteVar := []byte(routeVar)
-			if butil.IsHex(bRouteVar) {
-				var err error
-				bRouteVar, err = bytesutil.FromHexString(string(bRouteVar))
-				if err != nil {
-					return InternalServerErrorWithMessage(err, "could not process URL parameter")
-				}
-			}
-			// Converting hex to base64 may result in a value which malforms the URL.
-			// We use URLEncoding to safely escape such values.
-			base64RouteVar := base64.URLEncoding.EncodeToString(bRouteVar)
-
-			// Merge segments back into the full URL.
-			splitPath := strings.Split(req.URL.Path, "/")
-			splitPath[i] = base64RouteVar
-			req.URL.Path = strings.Join(splitPath, "/")
-		}
-	}
-	return nil
-}
-
-// HandleQueryParameters processes query parameters, allowing them to be safely and correctly proxied to grpc-gateway.
-func HandleQueryParameters(req *http.Request, params []QueryParam) ErrorJson {
-	queryParams := req.URL.Query()
-
-	normalizeQueryValues(queryParams)
-
-	for key, vals := range queryParams {
-		for _, p := range params {
-			if key == p.Name {
-				if p.Hex {
-					queryParams.Del(key)
-					for _, v := range vals {
-						b := []byte(v)
-						if butil.IsHex(b) {
-							var err error
-							b, err = bytesutil.FromHexString(v)
-							if err != nil {
-								return InternalServerErrorWithMessage(err, "could not process query parameter")
-							}
-						}
-						queryParams.Add(key, base64.URLEncoding.EncodeToString(b))
-					}
-				}
-				if p.Enum {
-					queryParams.Del(key)
-					for _, v := range vals {
-						// gRPC expects uppercase enum values.
-						queryParams.Add(key, strings.ToUpper(v))
-					}
-				}
-			}
-		}
-	}
-	req.URL.RawQuery = queryParams.Encode()
-	return nil
-}
-
-// isRequestParam verifies whether the passed string is a request parameter.
-// Request parameters are enclosed in { and }.
-func isRequestParam(s string) bool {
-	return len(s) > 2 && s[0] == '{' && s[len(s)-1] == '}'
-}
-
-func normalizeQueryValues(queryParams url.Values) {
-	// Replace comma-separated values with individual values.
-	for key, vals := range queryParams {
-		splitVals := make([]string, 0)
-		for _, v := range vals {
-			splitVals = append(splitVals, strings.Split(v, ",")...)
-		}
-		queryParams[key] = splitVals
-	}
-}

api/gateway/apimiddleware/param_handling_test.go

@@ -1,124 +0,0 @@
-package apimiddleware
-
-import (
-	"bytes"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/gorilla/mux"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestHandleURLParameters(t *testing.T) {
-	var body bytes.Buffer
-
-	t.Run("no_params", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example/bar", &body)
-
-		errJson := HandleURLParameters("/not_param", request, []string{})
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "/bar", request.URL.Path)
-	})
-
-	t.Run("with_params", func(t *testing.T) {
-		muxVars := make(map[string]string)
-		muxVars["bar_param"] = "bar"
-		muxVars["quux_param"] = "quux"
-		request := httptest.NewRequest("GET", "http://foo.example/bar/baz/quux", &body)
-		request = mux.SetURLVars(request, muxVars)
-
-		errJson := HandleURLParameters("/{bar_param}/not_param/{quux_param}", request, []string{})
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "/YmFy/baz/cXV1eA==", request.URL.Path)
-	})
-
-	t.Run("with_literal", func(t *testing.T) {
-		muxVars := make(map[string]string)
-		muxVars["bar_param"] = "bar"
-		request := httptest.NewRequest("GET", "http://foo.example/bar/baz", &body)
-		request = mux.SetURLVars(request, muxVars)
-
-		errJson := HandleURLParameters("/{bar_param}/not_param/", request, []string{"bar_param"})
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "/bar/baz", request.URL.Path)
-	})
-
-	t.Run("with_hex", func(t *testing.T) {
-		muxVars := make(map[string]string)
-		muxVars["hex_param"] = "0x626172"
-		request := httptest.NewRequest("GET", "http://foo.example/0x626172/baz", &body)
-		request = mux.SetURLVars(request, muxVars)
-
-		errJson := HandleURLParameters("/{hex_param}/not_param/", request, []string{})
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "/YmFy/baz", request.URL.Path)
-	})
-}
-
-func TestHandleQueryParameters(t *testing.T) {
-	var body bytes.Buffer
-
-	t.Run("regular_params", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example?bar=bar&baz=baz", &body)
-
-		errJson := HandleQueryParameters(request, []QueryParam{{Name: "bar"}, {Name: "baz"}})
-		require.Equal(t, true, errJson == nil)
-		query := request.URL.Query()
-		v, ok := query["bar"]
-		require.Equal(t, true, ok, "query param not found")
-		require.Equal(t, 1, len(v), "wrong number of query param values")
-		assert.Equal(t, "bar", v[0])
-		v, ok = query["baz"]
-		require.Equal(t, true, ok, "query param not found")
-		require.Equal(t, 1, len(v), "wrong number of query param values")
-		assert.Equal(t, "baz", v[0])
-	})
-
-	t.Run("hex_and_enum_params", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example?hex=0x626172&baz=baz", &body)
-
-		errJson := HandleQueryParameters(request, []QueryParam{{Name: "hex", Hex: true}, {Name: "baz", Enum: true}})
-		require.Equal(t, true, errJson == nil)
-		query := request.URL.Query()
-		v, ok := query["hex"]
-		require.Equal(t, true, ok, "query param not found")
-		require.Equal(t, 1, len(v), "wrong number of query param values")
-		assert.Equal(t, "YmFy", v[0])
-		v, ok = query["baz"]
-		require.Equal(t, true, ok, "query param not found")
-		require.Equal(t, 1, len(v), "wrong number of query param values")
-		assert.Equal(t, "BAZ", v[0])
-	})
-}
-
-func TestIsRequestParam(t *testing.T) {
-	tests := []struct {
-		s string
-		b bool
-	}{
-		{"", false},
-		{"{", false},
-		{"}", false},
-		{"{}", false},
-		{"{x}", true},
-		{"{very_long_parameter_name_with_underscores}", true},
-	}
-	for _, tt := range tests {
-		b := isRequestParam(tt.s)
-		assert.Equal(t, tt.b, b)
-	}
-}
-
-func TestNormalizeQueryValues(t *testing.T) {
-	input := make(map[string][]string)
-	input["key"] = []string{"value1", "value2,value3,value4", "value5"}
-
-	normalizeQueryValues(input)
-	require.Equal(t, 5, len(input["key"]))
-	assert.Equal(t, "value1", input["key"][0])
-	assert.Equal(t, "value2", input["key"][1])
-	assert.Equal(t, "value3", input["key"][2])
-	assert.Equal(t, "value4", input["key"][3])
-	assert.Equal(t, "value5", input["key"][4])
-}

api/gateway/apimiddleware/process_field.go

@@ -1,108 +0,0 @@
-package apimiddleware
-
-import (
-	"encoding/base64"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
-	"github.com/wealdtech/go-bytesutil"
-)
-
-// processField calls each processor function on any field that has the matching tag set.
-// It is a recursive function.
-func processField(s interface{}, processors []fieldProcessor) error {
-	kind := reflect.TypeOf(s).Kind()
-	if kind != reflect.Ptr && kind != reflect.Slice && kind != reflect.Array {
-		return fmt.Errorf("processing fields of kind '%v' is unsupported", kind)
-	}
-
-	t := reflect.TypeOf(s).Elem()
-	v := reflect.Indirect(reflect.ValueOf(s))
-
-	for i := 0; i < t.NumField(); i++ {
-		switch v.Field(i).Kind() {
-		case reflect.Slice:
-			sliceElem := t.Field(i).Type.Elem()
-			kind := sliceElem.Kind()
-			// Recursively process slices to struct pointers.
-			if kind == reflect.Ptr && sliceElem.Elem().Kind() == reflect.Struct {
-				for j := 0; j < v.Field(i).Len(); j++ {
-					if err := processField(v.Field(i).Index(j).Interface(), processors); err != nil {
-						return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-					}
-				}
-			}
-			// Process each string in string slices.
-			if kind == reflect.String {
-				for _, proc := range processors {
-					_, hasTag := t.Field(i).Tag.Lookup(proc.tag)
-					if hasTag {
-						for j := 0; j < v.Field(i).Len(); j++ {
-							if err := proc.f(v.Field(i).Index(j)); err != nil {
-								return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-							}
-						}
-					}
-				}
-
-			}
-		// Recursively process struct pointers.
-		case reflect.Ptr:
-			if v.Field(i).Elem().Kind() == reflect.Struct {
-				if err := processField(v.Field(i).Interface(), processors); err != nil {
-					return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-				}
-			}
-		default:
-			field := t.Field(i)
-			for _, proc := range processors {
-				if _, hasTag := field.Tag.Lookup(proc.tag); hasTag {
-					if err := proc.f(v.Field(i)); err != nil {
-						return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func hexToBase64Processor(v reflect.Value) error {
-	b, err := bytesutil.FromHexString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(base64.StdEncoding.EncodeToString(b))
-	return nil
-}
-
-func base64ToHexProcessor(v reflect.Value) error {
-	if v.String() == "" {
-		return nil
-	}
-	b, err := base64.StdEncoding.DecodeString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(hexutil.Encode(b))
-	return nil
-}
-
-func enumToLowercaseProcessor(v reflect.Value) error {
-	v.SetString(strings.ToLower(v.String()))
-	return nil
-}
-
-func timeToUnixProcessor(v reflect.Value) error {
-	t, err := time.Parse(time.RFC3339, v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(strconv.FormatUint(uint64(t.Unix()), 10))
-	return nil
-}

api/gateway/apimiddleware/process_request.go

@@ -1,263 +0,0 @@
-package apimiddleware
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/api/grpc"
-)
-
-// DeserializeRequestBodyIntoContainer deserializes the request's body into an endpoint-specific struct.
-func DeserializeRequestBodyIntoContainer(body io.Reader, requestContainer interface{}) ErrorJson {
-	decoder := json.NewDecoder(body)
-	decoder.DisallowUnknownFields()
-	if err := decoder.Decode(&requestContainer); err != nil {
-		if strings.Contains(err.Error(), "json: unknown field") {
-			e := errors.Wrap(err, "could not decode request body")
-			return &DefaultErrorJson{
-				Message: e.Error(),
-				Code:    http.StatusBadRequest,
-			}
-		}
-		return InternalServerErrorWithMessage(err, "could not decode request body")
-	}
-	return nil
-}
-
-// ProcessRequestContainerFields processes fields of an endpoint-specific container according to field tags.
-func ProcessRequestContainerFields(requestContainer interface{}) ErrorJson {
-	if err := processField(requestContainer, []fieldProcessor{
-		{
-			tag: "hex",
-			f:   hexToBase64Processor,
-		},
-	}); err != nil {
-		return InternalServerErrorWithMessage(err, "could not process request data")
-	}
-	return nil
-}
-
-// SetRequestBodyToRequestContainer makes the endpoint-specific container the new body of the request.
-func SetRequestBodyToRequestContainer(requestContainer interface{}, req *http.Request) ErrorJson {
-	// Serialize the struct, which now includes a base64-encoded value, into JSON.
-	j, err := json.Marshal(requestContainer)
-	if err != nil {
-		return InternalServerErrorWithMessage(err, "could not marshal request")
-	}
-	// Set the body to the new JSON.
-	req.Body = ioutil.NopCloser(bytes.NewReader(j))
-	req.Header.Set("Content-Length", strconv.Itoa(len(j)))
-	req.ContentLength = int64(len(j))
-	return nil
-}
-
-// PrepareRequestForProxying applies additional logic to the request so that it can be correctly proxied to grpc-gateway.
-func (m *ApiProxyMiddleware) PrepareRequestForProxying(endpoint Endpoint, req *http.Request) ErrorJson {
-	req.URL.Scheme = "http"
-	req.URL.Host = m.GatewayAddress
-	req.RequestURI = ""
-	if errJson := HandleURLParameters(endpoint.Path, req, endpoint.RequestURLLiterals); errJson != nil {
-		return errJson
-	}
-	if errJson := HandleQueryParameters(req, endpoint.RequestQueryParams); errJson != nil {
-		return errJson
-	}
-	// We have to add the prefix after handling parameters because adding the prefix changes URL segment indexing.
-	req.URL.Path = "/internal" + req.URL.Path
-	return nil
-}
-
-// ProxyRequest proxies the request to grpc-gateway.
-func (m *ApiProxyMiddleware) ProxyRequest(req *http.Request) (*http.Response, ErrorJson) {
-	// We do not use http.DefaultClient because it does not have any timeout.
-	netClient := &http.Client{Timeout: m.Timeout}
-	grpcResp, err := netClient.Do(req)
-	if err != nil {
-		if err, ok := err.(net.Error); ok && err.Timeout() {
-			return nil, TimeoutError()
-		}
-		return nil, InternalServerErrorWithMessage(err, "could not proxy request")
-	}
-	if grpcResp == nil {
-		return nil, &DefaultErrorJson{Message: "nil response from gRPC-gateway", Code: http.StatusInternalServerError}
-	}
-	return grpcResp, nil
-}
-
-// ReadGrpcResponseBody reads the body from the grpc-gateway's response.
-func ReadGrpcResponseBody(r io.Reader) ([]byte, ErrorJson) {
-	body, err := ioutil.ReadAll(r)
-	if err != nil {
-		return nil, InternalServerErrorWithMessage(err, "could not read response body")
-	}
-	return body, nil
-}
-
-// HandleGrpcResponseError acts on an error that resulted from a grpc-gateway's response.
-func HandleGrpcResponseError(errJson ErrorJson, resp *http.Response, respBody []byte, w http.ResponseWriter) (bool, ErrorJson) {
-	responseHasError := false
-	if err := json.Unmarshal(respBody, errJson); err != nil {
-		return false, InternalServerErrorWithMessage(err, "could not unmarshal error")
-	}
-	if errJson.Msg() != "" {
-		responseHasError = true
-		// Something went wrong, but the request completed, meaning we can write headers and the error message.
-		for h, vs := range resp.Header {
-			for _, v := range vs {
-				w.Header().Set(h, v)
-			}
-		}
-		// Handle gRPC timeout.
-		if resp.StatusCode == http.StatusGatewayTimeout {
-			WriteError(w, TimeoutError(), resp.Header)
-		} else {
-			// Set code to HTTP code because unmarshalled body contained gRPC code.
-			errJson.SetCode(resp.StatusCode)
-			WriteError(w, errJson, resp.Header)
-		}
-	}
-	return responseHasError, nil
-}
-
-// GrpcResponseIsEmpty determines whether the grpc-gateway's response body contains no data.
-func GrpcResponseIsEmpty(grpcResponseBody []byte) bool {
-	return len(grpcResponseBody) == 0 || string(grpcResponseBody) == "{}"
-}
-
-// DeserializeGrpcResponseBodyIntoContainer deserializes the grpc-gateway's response body into an endpoint-specific struct.
-func DeserializeGrpcResponseBodyIntoContainer(body []byte, responseContainer interface{}) ErrorJson {
-	if err := json.Unmarshal(body, &responseContainer); err != nil {
-		return InternalServerErrorWithMessage(err, "could not unmarshal response")
-	}
-	return nil
-}
-
-// ProcessMiddlewareResponseFields processes fields of an endpoint-specific container according to field tags.
-func ProcessMiddlewareResponseFields(responseContainer interface{}) ErrorJson {
-	if err := processField(responseContainer, []fieldProcessor{
-		{
-			tag: "hex",
-			f:   base64ToHexProcessor,
-		},
-		{
-			tag: "enum",
-			f:   enumToLowercaseProcessor,
-		},
-		{
-			tag: "time",
-			f:   timeToUnixProcessor,
-		},
-	}); err != nil {
-		return InternalServerErrorWithMessage(err, "could not process response data")
-	}
-	return nil
-}
-
-// SerializeMiddlewareResponseIntoJson serializes the endpoint-specific response struct into a JSON representation.
-func SerializeMiddlewareResponseIntoJson(responseContainer interface{}) (jsonResponse []byte, errJson ErrorJson) {
-	j, err := json.Marshal(responseContainer)
-	if err != nil {
-		return nil, InternalServerErrorWithMessage(err, "could not marshal response")
-	}
-	return j, nil
-}
-
-// WriteMiddlewareResponseHeadersAndBody populates headers and the body of the final response.
-func WriteMiddlewareResponseHeadersAndBody(grpcResp *http.Response, responseJson []byte, w http.ResponseWriter) ErrorJson {
-	var statusCodeHeader string
-	for h, vs := range grpcResp.Header {
-		// We don't want to expose any gRPC metadata in the HTTP response, so we skip forwarding metadata headers.
-		if strings.HasPrefix(h, "Grpc-Metadata") {
-			if h == "Grpc-Metadata-"+grpc.HttpCodeMetadataKey {
-				statusCodeHeader = vs[0]
-			}
-		} else {
-			for _, v := range vs {
-				w.Header().Set(h, v)
-			}
-		}
-	}
-	if !GrpcResponseIsEmpty(responseJson) {
-		w.Header().Set("Content-Length", strconv.Itoa(len(responseJson)))
-		if statusCodeHeader != "" {
-			code, err := strconv.Atoi(statusCodeHeader)
-			if err != nil {
-				return InternalServerErrorWithMessage(err, "could not parse status code")
-			}
-			w.WriteHeader(code)
-		} else {
-			w.WriteHeader(grpcResp.StatusCode)
-		}
-		if _, err := io.Copy(w, ioutil.NopCloser(bytes.NewReader(responseJson))); err != nil {
-			return InternalServerErrorWithMessage(err, "could not write response message")
-		}
-	} else {
-		w.Header().Set("Content-Length", "0")
-		w.WriteHeader(grpcResp.StatusCode)
-	}
-	return nil
-}
-
-// WriteError writes the error by manipulating headers and the body of the final response.
-func WriteError(w http.ResponseWriter, errJson ErrorJson, responseHeader http.Header) {
-	// Include custom error in the error JSON.
-	hasCustomError := false
-	if responseHeader != nil {
-		customError, ok := responseHeader["Grpc-Metadata-"+grpc.CustomErrorMetadataKey]
-		if ok {
-			hasCustomError = true
-			// Assume header has only one value and read the 0 index.
-			if err := json.Unmarshal([]byte(customError[0]), errJson); err != nil {
-				log.WithError(err).Error("Could not unmarshal custom error message")
-				return
-			}
-		}
-	}
-
-	var j []byte
-	if hasCustomError {
-		var err error
-		j, err = json.Marshal(errJson)
-		if err != nil {
-			log.WithError(err).Error("Could not marshal error message")
-			return
-		}
-	} else {
-		var err error
-		// We marshal the response body into a DefaultErrorJson if the custom error is not present.
-		// This is because the ErrorJson argument is the endpoint's error definition, which may contain custom fields.
-		// In such a scenario marhaling the endpoint's error would populate the resulting JSON
-		// with these fields even if they are not present in the gRPC header.
-		d := &DefaultErrorJson{
-			Message: errJson.Msg(),
-			Code:    errJson.StatusCode(),
-		}
-		j, err = json.Marshal(d)
-		if err != nil {
-			log.WithError(err).Error("Could not marshal error message")
-			return
-		}
-	}
-
-	w.Header().Set("Content-Length", strconv.Itoa(len(j)))
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(errJson.StatusCode())
-	if _, err := io.Copy(w, ioutil.NopCloser(bytes.NewReader(j))); err != nil {
-		log.WithError(err).Error("Could not write error message")
-	}
-}
-
-// Cleanup performs final cleanup on the initial response from grpc-gateway.
-func Cleanup(grpcResponseBody io.ReadCloser) ErrorJson {
-	if err := grpcResponseBody.Close(); err != nil {
-		return InternalServerErrorWithMessage(err, "could not close response body")
-	}
-	return nil
-}

api/gateway/apimiddleware/process_request_test.go

@@ -1,409 +0,0 @@
-package apimiddleware
-
-import (
-	"bytes"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/api/grpc"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/sirupsen/logrus/hooks/test"
-)
-
-type testRequestContainer struct {
-	TestString    string
-	TestHexString string `hex:"true"`
-}
-
-func defaultRequestContainer() *testRequestContainer {
-	return &testRequestContainer{
-		TestString:    "test string",
-		TestHexString: "0x666F6F", // hex encoding of "foo"
-	}
-}
-
-type testResponseContainer struct {
-	TestString string
-	TestHex    string `hex:"true"`
-	TestEnum   string `enum:"true"`
-	TestTime   string `time:"true"`
-}
-
-func defaultResponseContainer() *testResponseContainer {
-	return &testResponseContainer{
-		TestString: "test string",
-		TestHex:    "Zm9v", // base64 encoding of "foo"
-		TestEnum:   "Test Enum",
-		TestTime:   "2006-01-02T15:04:05Z",
-	}
-}
-
-type testErrorJson struct {
-	Message     string
-	Code        int
-	CustomField string
-}
-
-// StatusCode returns the error's underlying error code.
-func (e *testErrorJson) StatusCode() int {
-	return e.Code
-}
-
-// Msg returns the error's underlying message.
-func (e *testErrorJson) Msg() string {
-	return e.Message
-}
-
-// SetCode sets the error's underlying error code.
-func (e *testErrorJson) SetCode(code int) {
-	e.Code = code
-}
-
-// SetMsg sets the error's underlying message.
-func (e *testErrorJson) SetMsg(msg string) {
-	e.Message = msg
-}
-
-func TestDeserializeRequestBodyIntoContainer(t *testing.T) {
-	t.Run("ok", func(t *testing.T) {
-		var bodyJson bytes.Buffer
-		err := json.NewEncoder(&bodyJson).Encode(defaultRequestContainer())
-		require.NoError(t, err)
-
-		container := &testRequestContainer{}
-		errJson := DeserializeRequestBodyIntoContainer(&bodyJson, container)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "test string", container.TestString)
-	})
-
-	t.Run("error", func(t *testing.T) {
-		var bodyJson bytes.Buffer
-		bodyJson.Write([]byte("foo"))
-		errJson := DeserializeRequestBodyIntoContainer(&bodyJson, &testRequestContainer{})
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "could not decode request body"))
-		assert.Equal(t, http.StatusInternalServerError, errJson.StatusCode())
-	})
-
-	t.Run("unknown field", func(t *testing.T) {
-		var bodyJson bytes.Buffer
-		bodyJson.Write([]byte("{\"foo\":\"foo\"}"))
-		errJson := DeserializeRequestBodyIntoContainer(&bodyJson, &testRequestContainer{})
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "could not decode request body"))
-		assert.Equal(t, http.StatusBadRequest, errJson.StatusCode())
-	})
-}
-
-func TestProcessRequestContainerFields(t *testing.T) {
-	t.Run("ok", func(t *testing.T) {
-		container := defaultRequestContainer()
-
-		errJson := ProcessRequestContainerFields(container)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "Zm9v", container.TestHexString)
-	})
-
-	t.Run("error", func(t *testing.T) {
-		errJson := ProcessRequestContainerFields("foo")
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "could not process request data"))
-		assert.Equal(t, http.StatusInternalServerError, errJson.StatusCode())
-	})
-}
-
-func TestSetRequestBodyToRequestContainer(t *testing.T) {
-	var body bytes.Buffer
-	request := httptest.NewRequest("GET", "http://foo.example", &body)
-
-	errJson := SetRequestBodyToRequestContainer(defaultRequestContainer(), request)
-	require.Equal(t, true, errJson == nil)
-	container := &testRequestContainer{}
-	require.NoError(t, json.NewDecoder(request.Body).Decode(container))
-	assert.Equal(t, "test string", container.TestString)
-	contentLengthHeader, ok := request.Header["Content-Length"]
-	require.Equal(t, true, ok)
-	require.Equal(t, 1, len(contentLengthHeader), "wrong number of header values")
-	assert.Equal(t, "55", contentLengthHeader[0])
-	assert.Equal(t, int64(55), request.ContentLength)
-}
-
-func TestPrepareRequestForProxying(t *testing.T) {
-	middleware := &ApiProxyMiddleware{
-		GatewayAddress: "http://gateway.example",
-	}
-	// We will set some params to make the request more interesting.
-	endpoint := Endpoint{
-		Path:               "/{url_param}",
-		RequestURLLiterals: []string{"url_param"},
-		RequestQueryParams: []QueryParam{{Name: "query_param"}},
-	}
-	var body bytes.Buffer
-	request := httptest.NewRequest("GET", "http://foo.example?query_param=bar", &body)
-
-	errJson := middleware.PrepareRequestForProxying(endpoint, request)
-	require.Equal(t, true, errJson == nil)
-	assert.Equal(t, "http", request.URL.Scheme)
-	assert.Equal(t, middleware.GatewayAddress, request.URL.Host)
-	assert.Equal(t, "", request.RequestURI)
-}
-
-func TestReadGrpcResponseBody(t *testing.T) {
-	var b bytes.Buffer
-	b.Write([]byte("foo"))
-
-	body, jsonErr := ReadGrpcResponseBody(&b)
-	require.Equal(t, true, jsonErr == nil)
-	assert.Equal(t, "foo", string(body))
-}
-
-func TestHandleGrpcResponseError(t *testing.T) {
-	response := &http.Response{
-		StatusCode: 400,
-		Header: http.Header{
-			"Foo": []string{"foo"},
-			"Bar": []string{"bar"},
-		},
-	}
-	writer := httptest.NewRecorder()
-	errJson := &testErrorJson{
-		Message: "foo",
-		Code:    400,
-	}
-	b, err := json.Marshal(errJson)
-	require.NoError(t, err)
-
-	hasError, e := HandleGrpcResponseError(errJson, response, b, writer)
-	require.Equal(t, true, e == nil)
-	assert.Equal(t, true, hasError)
-	v, ok := writer.Header()["Foo"]
-	require.Equal(t, true, ok, "header not found")
-	require.Equal(t, 1, len(v), "wrong number of header values")
-	assert.Equal(t, "foo", v[0])
-	v, ok = writer.Header()["Bar"]
-	require.Equal(t, true, ok, "header not found")
-	require.Equal(t, 1, len(v), "wrong number of header values")
-	assert.Equal(t, "bar", v[0])
-	assert.Equal(t, 400, errJson.StatusCode())
-}
-
-func TestGrpcResponseIsEmpty(t *testing.T) {
-	t.Run("nil", func(t *testing.T) {
-		assert.Equal(t, true, GrpcResponseIsEmpty(nil))
-	})
-	t.Run("empty_slice", func(t *testing.T) {
-		assert.Equal(t, true, GrpcResponseIsEmpty(make([]byte, 0)))
-	})
-	t.Run("empty_brackets", func(t *testing.T) {
-		assert.Equal(t, true, GrpcResponseIsEmpty([]byte("{}")))
-	})
-	t.Run("non_empty", func(t *testing.T) {
-		assert.Equal(t, false, GrpcResponseIsEmpty([]byte("{\"foo\":\"bar\"})")))
-	})
-}
-
-func TestDeserializeGrpcResponseBodyIntoContainer(t *testing.T) {
-	t.Run("ok", func(t *testing.T) {
-		body, err := json.Marshal(defaultRequestContainer())
-		require.NoError(t, err)
-
-		container := &testRequestContainer{}
-		errJson := DeserializeGrpcResponseBodyIntoContainer(body, container)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "test string", container.TestString)
-	})
-
-	t.Run("error", func(t *testing.T) {
-		var bodyJson bytes.Buffer
-		bodyJson.Write([]byte("foo"))
-		errJson := DeserializeGrpcResponseBodyIntoContainer(bodyJson.Bytes(), &testRequestContainer{})
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "could not unmarshal response"))
-		assert.Equal(t, http.StatusInternalServerError, errJson.StatusCode())
-	})
-}
-
-func TestProcessMiddlewareResponseFields(t *testing.T) {
-	t.Run("Ok", func(t *testing.T) {
-		container := defaultResponseContainer()
-
-		errJson := ProcessMiddlewareResponseFields(container)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, "0x666f6f", container.TestHex)
-		assert.Equal(t, "test enum", container.TestEnum)
-		assert.Equal(t, "1136214245", container.TestTime)
-	})
-
-	t.Run("error", func(t *testing.T) {
-		errJson := ProcessMiddlewareResponseFields("foo")
-		require.NotNil(t, errJson)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "could not process response data"))
-		assert.Equal(t, http.StatusInternalServerError, errJson.StatusCode())
-	})
-}
-
-func TestSerializeMiddlewareResponseIntoJson(t *testing.T) {
-	container := defaultResponseContainer()
-	j, errJson := SerializeMiddlewareResponseIntoJson(container)
-	assert.Equal(t, true, errJson == nil)
-	cToDeserialize := &testResponseContainer{}
-	require.NoError(t, json.Unmarshal(j, cToDeserialize))
-	assert.Equal(t, "test string", cToDeserialize.TestString)
-}
-
-func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
-	t.Run("GET", func(t *testing.T) {
-		response := &http.Response{
-			Header: http.Header{
-				"Foo": []string{"foo"},
-				"Grpc-Metadata-" + grpc.HttpCodeMetadataKey: []string{"204"},
-			},
-		}
-		container := defaultResponseContainer()
-		responseJson, err := json.Marshal(container)
-		require.NoError(t, err)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
-		require.Equal(t, true, errJson == nil)
-		v, ok := writer.Header()["Foo"]
-		require.Equal(t, true, ok, "header not found")
-		require.Equal(t, 1, len(v), "wrong number of header values")
-		assert.Equal(t, "foo", v[0])
-		v, ok = writer.Header()["Content-Length"]
-		require.Equal(t, true, ok, "header not found")
-		require.Equal(t, 1, len(v), "wrong number of header values")
-		assert.Equal(t, "102", v[0])
-		assert.Equal(t, 204, writer.Code)
-		assert.DeepEqual(t, responseJson, writer.Body.Bytes())
-	})
-
-	t.Run("GET_no_grpc_status_code_header", func(t *testing.T) {
-		response := &http.Response{
-			Header:     http.Header{},
-			StatusCode: 204,
-		}
-		container := defaultResponseContainer()
-		responseJson, err := json.Marshal(container)
-		require.NoError(t, err)
-		writer := httptest.NewRecorder()
-
-		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, 204, writer.Code)
-	})
-
-	t.Run("GET_invalid_status_code", func(t *testing.T) {
-		response := &http.Response{
-			Header: http.Header{},
-		}
-
-		// Set invalid status code.
-		response.Header["Grpc-Metadata-"+grpc.HttpCodeMetadataKey] = []string{"invalid"}
-
-		container := defaultResponseContainer()
-		responseJson, err := json.Marshal(container)
-		require.NoError(t, err)
-		writer := httptest.NewRecorder()
-
-		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
-		require.Equal(t, false, errJson == nil)
-		assert.Equal(t, true, strings.Contains(errJson.Msg(), "could not parse status code"))
-		assert.Equal(t, http.StatusInternalServerError, errJson.StatusCode())
-	})
-
-	t.Run("POST", func(t *testing.T) {
-		response := &http.Response{
-			Header:     http.Header{},
-			StatusCode: 204,
-		}
-		container := defaultResponseContainer()
-		responseJson, err := json.Marshal(container)
-		require.NoError(t, err)
-		writer := httptest.NewRecorder()
-
-		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, 204, writer.Code)
-	})
-
-	t.Run("POST_with_response_body", func(t *testing.T) {
-		response := &http.Response{
-			Header:     http.Header{},
-			StatusCode: 204,
-		}
-		container := defaultResponseContainer()
-		responseJson, err := json.Marshal(container)
-		require.NoError(t, err)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, 204, writer.Code)
-		assert.DeepEqual(t, responseJson, writer.Body.Bytes())
-	})
-
-	t.Run("POST_with_empty_json_body", func(t *testing.T) {
-		response := &http.Response{
-			Header:     http.Header{},
-			StatusCode: 204,
-		}
-		responseJson, err := json.Marshal(struct{}{})
-		require.NoError(t, err)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, 204, writer.Code)
-		assert.DeepEqual(t, []byte(nil), writer.Body.Bytes())
-		assert.Equal(t, "0", writer.Header()["Content-Length"][0])
-	})
-}
-
-func TestWriteError(t *testing.T) {
-	t.Run("ok", func(t *testing.T) {
-		responseHeader := http.Header{
-			"Grpc-Metadata-" + grpc.CustomErrorMetadataKey: []string{"{\"CustomField\":\"bar\"}"},
-		}
-		errJson := &testErrorJson{
-			Message: "foo",
-			Code:    500,
-		}
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		WriteError(writer, errJson, responseHeader)
-		v, ok := writer.Header()["Content-Length"]
-		require.Equal(t, true, ok, "header not found")
-		require.Equal(t, 1, len(v), "wrong number of header values")
-		assert.Equal(t, "48", v[0])
-		v, ok = writer.Header()["Content-Type"]
-		require.Equal(t, true, ok, "header not found")
-		require.Equal(t, 1, len(v), "wrong number of header values")
-		assert.Equal(t, "application/json", v[0])
-		assert.Equal(t, 500, writer.Code)
-		eDeserialize := &testErrorJson{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), eDeserialize))
-		assert.Equal(t, "foo", eDeserialize.Message)
-		assert.Equal(t, 500, eDeserialize.Code)
-		assert.Equal(t, "bar", eDeserialize.CustomField)
-	})
-
-	t.Run("invalid_custom_error_header", func(t *testing.T) {
-		logHook := test.NewGlobal()
-
-		responseHeader := http.Header{
-			"Grpc-Metadata-" + grpc.CustomErrorMetadataKey: []string{"invalid"},
-		}
-
-		WriteError(httptest.NewRecorder(), &testErrorJson{}, responseHeader)
-		assert.LogsContain(t, logHook, "Could not unmarshal custom error message")
-	})
-}

api/gateway/apimiddleware/structs.go

@@ -1,69 +0,0 @@
-package apimiddleware
-
-import (
-	"net/http"
-
-	"github.com/pkg/errors"
-)
-
-// ---------------
-// Error handling.
-// ---------------
-
-// ErrorJson describes common functionality of all JSON error representations.
-type ErrorJson interface {
-	StatusCode() int
-	SetCode(code int)
-	Msg() string
-	SetMsg(msg string)
-}
-
-// DefaultErrorJson is a JSON representation of a simple error value, containing only a message and an error code.
-type DefaultErrorJson struct {
-	Message string `json:"message"`
-	Code    int    `json:"code"`
-}
-
-// InternalServerErrorWithMessage returns a DefaultErrorJson with 500 code and a custom message.
-func InternalServerErrorWithMessage(err error, message string) *DefaultErrorJson {
-	e := errors.Wrapf(err, message)
-	return &DefaultErrorJson{
-		Message: e.Error(),
-		Code:    http.StatusInternalServerError,
-	}
-}
-
-// InternalServerError returns a DefaultErrorJson with 500 code.
-func InternalServerError(err error) *DefaultErrorJson {
-	return &DefaultErrorJson{
-		Message: err.Error(),
-		Code:    http.StatusInternalServerError,
-	}
-}
-
-func TimeoutError() *DefaultErrorJson {
-	return &DefaultErrorJson{
-		Message: "Request timeout",
-		Code:    http.StatusRequestTimeout,
-	}
-}
-
-// StatusCode returns the error's underlying error code.
-func (e *DefaultErrorJson) StatusCode() int {
-	return e.Code
-}
-
-// Msg returns the error's underlying message.
-func (e *DefaultErrorJson) Msg() string {
-	return e.Message
-}
-
-// SetCode sets the error's underlying error code.
-func (e *DefaultErrorJson) SetCode(code int) {
-	e.Code = code
-}
-
-// SetMsg sets the error's underlying message.
-func (e *DefaultErrorJson) SetMsg(msg string) {
-	e.Message = msg
-}

api/gateway/gateway.go

@@ -1,256 +0,0 @@
-// Package gateway defines a grpc-gateway server that serves HTTP-JSON traffic and acts a proxy between HTTP and gRPC.
-package gateway
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"net/http"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/gorilla/mux"
-	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/api/gateway/apimiddleware"
-	"github.com/prysmaticlabs/prysm/runtime"
-	"github.com/rs/cors"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/connectivity"
-	"google.golang.org/grpc/credentials"
-)
-
-var _ runtime.Service = (*Gateway)(nil)
-
-// PbMux serves grpc-gateway requests for selected patterns using registered protobuf handlers.
-type PbMux struct {
-	Registrations []PbHandlerRegistration // Protobuf registrations to be registered in Mux.
-	Patterns      []string                // URL patterns that will be handled by Mux.
-	Mux           *gwruntime.ServeMux     // The router that will be used for grpc-gateway requests.
-}
-
-// PbHandlerRegistration is a function that registers a protobuf handler.
-type PbHandlerRegistration func(context.Context, *gwruntime.ServeMux, *grpc.ClientConn) error
-
-// MuxHandler is a function that implements the mux handler functionality.
-type MuxHandler func(
-	apiMiddlewareHandler *apimiddleware.ApiProxyMiddleware,
-	h http.HandlerFunc,
-	w http.ResponseWriter,
-	req *http.Request,
-)
-
-// Config parameters for setting up the gateway service.
-type config struct {
-	maxCallRecvMsgSize           uint64
-	remoteCert                   string
-	gatewayAddr                  string
-	remoteAddr                   string
-	allowedOrigins               []string
-	apiMiddlewareEndpointFactory apimiddleware.EndpointFactory
-	muxHandler                   MuxHandler
-	pbHandlers                   []*PbMux
-	router                       *mux.Router
-	timeout                      time.Duration
-}
-
-// Gateway is the gRPC gateway to serve HTTP JSON traffic as a proxy and forward it to the gRPC server.
-type Gateway struct {
-	cfg          *config
-	conn         *grpc.ClientConn
-	server       *http.Server
-	cancel       context.CancelFunc
-	proxy        *apimiddleware.ApiProxyMiddleware
-	ctx          context.Context
-	startFailure error
-}
-
-// New returns a new instance of the Gateway.
-func New(ctx context.Context, opts ...Option) (*Gateway, error) {
-	g := &Gateway{
-		ctx: ctx,
-		cfg: &config{
-			router: mux.NewRouter(),
-		},
-	}
-	for _, opt := range opts {
-		if err := opt(g); err != nil {
-			return nil, err
-		}
-	}
-	return g, nil
-}
-
-// Start the gateway service.
-func (g *Gateway) Start() {
-	ctx, cancel := context.WithCancel(g.ctx)
-	g.cancel = cancel
-
-	conn, err := g.dial(ctx, "tcp", g.cfg.remoteAddr)
-	if err != nil {
-		log.WithError(err).Error("Failed to connect to gRPC server")
-		g.startFailure = err
-		return
-	}
-	g.conn = conn
-
-	for _, h := range g.cfg.pbHandlers {
-		for _, r := range h.Registrations {
-			if err := r(ctx, h.Mux, g.conn); err != nil {
-				log.WithError(err).Error("Failed to register handler")
-				g.startFailure = err
-				return
-			}
-		}
-		for _, p := range h.Patterns {
-			g.cfg.router.PathPrefix(p).Handler(h.Mux)
-		}
-	}
-
-	corsMux := g.corsMiddleware(g.cfg.router)
-
-	if g.cfg.apiMiddlewareEndpointFactory != nil && !g.cfg.apiMiddlewareEndpointFactory.IsNil() {
-		g.registerApiMiddleware()
-	}
-
-	if g.cfg.muxHandler != nil {
-		g.cfg.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			g.cfg.muxHandler(g.proxy, corsMux.ServeHTTP, w, r)
-		})
-	}
-
-	g.server = &http.Server{
-		Addr:    g.cfg.gatewayAddr,
-		Handler: corsMux,
-	}
-
-	go func() {
-		log.WithField("address", g.cfg.gatewayAddr).Info("Starting gRPC gateway")
-		if err := g.server.ListenAndServe(); err != http.ErrServerClosed {
-			log.WithError(err).Error("Failed to start gRPC gateway")
-			g.startFailure = err
-			return
-		}
-	}()
-}
-
-// Status of grpc gateway. Returns an error if this service is unhealthy.
-func (g *Gateway) Status() error {
-	if g.startFailure != nil {
-		return g.startFailure
-	}
-	if s := g.conn.GetState(); s != connectivity.Ready {
-		return fmt.Errorf("grpc server is %s", s)
-	}
-	return nil
-}
-
-// Stop the gateway with a graceful shutdown.
-func (g *Gateway) Stop() error {
-	if g.server != nil {
-		shutdownCtx, shutdownCancel := context.WithTimeout(g.ctx, 2*time.Second)
-		defer shutdownCancel()
-		if err := g.server.Shutdown(shutdownCtx); err != nil {
-			if errors.Is(err, context.DeadlineExceeded) {
-				log.Warn("Existing connections terminated")
-			} else {
-				log.WithError(err).Error("Failed to gracefully shut down server")
-			}
-		}
-	}
-	if g.cancel != nil {
-		g.cancel()
-	}
-	return nil
-}
-
-func (g *Gateway) corsMiddleware(h http.Handler) http.Handler {
-	c := cors.New(cors.Options{
-		AllowedOrigins:   g.cfg.allowedOrigins,
-		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
-		AllowCredentials: true,
-		MaxAge:           600,
-		AllowedHeaders:   []string{"*"},
-	})
-	return c.Handler(h)
-}
-
-const swaggerDir = "proto/prysm/v1alpha1/"
-
-// SwaggerServer returns swagger specification files located under "/swagger/"
-func SwaggerServer() http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if !strings.HasSuffix(r.URL.Path, ".swagger.json") {
-			log.Debugf("Not found: %s", r.URL.Path)
-			http.NotFound(w, r)
-			return
-		}
-
-		log.Debugf("Serving %s\n", r.URL.Path)
-		p := strings.TrimPrefix(r.URL.Path, "/swagger/")
-		p = path.Join(swaggerDir, p)
-		http.ServeFile(w, r, p)
-	}
-}
-
-// dial the gRPC server.
-func (g *Gateway) dial(ctx context.Context, network, addr string) (*grpc.ClientConn, error) {
-	switch network {
-	case "tcp":
-		return g.dialTCP(ctx, addr)
-	case "unix":
-		return g.dialUnix(ctx, addr)
-	default:
-		return nil, fmt.Errorf("unsupported network type %q", network)
-	}
-}
-
-// dialTCP creates a client connection via TCP.
-// "addr" must be a valid TCP address with a port number.
-func (g *Gateway) dialTCP(ctx context.Context, addr string) (*grpc.ClientConn, error) {
-	security := grpc.WithInsecure()
-	if len(g.cfg.remoteCert) > 0 {
-		creds, err := credentials.NewClientTLSFromFile(g.cfg.remoteCert, "")
-		if err != nil {
-			return nil, err
-		}
-		security = grpc.WithTransportCredentials(creds)
-	}
-	opts := []grpc.DialOption{
-		security,
-		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
-	}
-
-	return grpc.DialContext(ctx, addr, opts...)
-}
-
-// dialUnix creates a client connection via a unix domain socket.
-// "addr" must be a valid path to the socket.
-func (g *Gateway) dialUnix(ctx context.Context, addr string) (*grpc.ClientConn, error) {
-	d := func(addr string, timeout time.Duration) (net.Conn, error) {
-		return net.DialTimeout("unix", addr, timeout)
-	}
-	f := func(ctx context.Context, addr string) (net.Conn, error) {
-		if deadline, ok := ctx.Deadline(); ok {
-			return d(addr, time.Until(deadline))
-		}
-		return d(addr, 0)
-	}
-	opts := []grpc.DialOption{
-		grpc.WithInsecure(),
-		grpc.WithContextDialer(f),
-		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
-	}
-	return grpc.DialContext(ctx, addr, opts...)
-}
-
-func (g *Gateway) registerApiMiddleware() {
-	g.proxy = &apimiddleware.ApiProxyMiddleware{
-		GatewayAddress:  g.cfg.gatewayAddr,
-		EndpointCreator: g.cfg.apiMiddlewareEndpointFactory,
-		Timeout:         g.cfg.timeout,
-	}
-	log.Info("Starting API middleware")
-	g.proxy.Run(g.cfg.router)
-}

api/gateway/gateway_test.go

@@ -1,128 +0,0 @@
-package gateway
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"testing"
-
-	"github.com/gorilla/mux"
-	"github.com/prysmaticlabs/prysm/api/gateway/apimiddleware"
-	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-	"github.com/urfave/cli/v2"
-)
-
-type mockEndpointFactory struct {
-}
-
-func (*mockEndpointFactory) Paths() []string {
-	return []string{}
-}
-
-func (*mockEndpointFactory) Create(_ string) (*apimiddleware.Endpoint, error) {
-	return nil, nil
-}
-
-func (*mockEndpointFactory) IsNil() bool {
-	return false
-}
-
-func TestGateway_Customized(t *testing.T) {
-	r := mux.NewRouter()
-	cert := "cert"
-	origins := []string{"origin"}
-	size := uint64(100)
-	endpointFactory := &mockEndpointFactory{}
-
-	opts := []Option{
-		WithRouter(r),
-		WithRemoteCert(cert),
-		WithAllowedOrigins(origins),
-		WithMaxCallRecvMsgSize(size),
-		WithApiMiddleware(endpointFactory),
-		WithMuxHandler(func(
-			_ *apimiddleware.ApiProxyMiddleware,
-			_ http.HandlerFunc,
-			_ http.ResponseWriter,
-			_ *http.Request,
-		) {
-		}),
-	}
-
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
-
-	assert.Equal(t, r, g.cfg.router)
-	assert.Equal(t, cert, g.cfg.remoteCert)
-	require.Equal(t, 1, len(g.cfg.allowedOrigins))
-	assert.Equal(t, origins[0], g.cfg.allowedOrigins[0])
-	assert.Equal(t, size, g.cfg.maxCallRecvMsgSize)
-	assert.Equal(t, endpointFactory, g.cfg.apiMiddlewareEndpointFactory)
-}
-
-func TestGateway_StartStop(t *testing.T) {
-	hook := logTest.NewGlobal()
-
-	app := cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ctx := cli.NewContext(&app, set, nil)
-
-	gatewayPort := ctx.Int(flags.GRPCGatewayPort.Name)
-	gatewayHost := ctx.String(flags.GRPCGatewayHost.Name)
-	rpcHost := ctx.String(flags.RPCHost.Name)
-	selfAddress := fmt.Sprintf("%s:%d", rpcHost, ctx.Int(flags.RPCPort.Name))
-	gatewayAddress := fmt.Sprintf("%s:%d", gatewayHost, gatewayPort)
-
-	opts := []Option{
-		WithGatewayAddr(gatewayAddress),
-		WithRemoteAddr(selfAddress),
-		WithMuxHandler(func(
-			_ *apimiddleware.ApiProxyMiddleware,
-			_ http.HandlerFunc,
-			_ http.ResponseWriter,
-			_ *http.Request,
-		) {
-		}),
-	}
-
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
-
-	g.Start()
-	go func() {
-		require.LogsContain(t, hook, "Starting gRPC gateway")
-		require.LogsDoNotContain(t, hook, "Starting API middleware")
-	}()
-	err = g.Stop()
-	require.NoError(t, err)
-}
-
-func TestGateway_NilHandler_NotFoundHandlerRegistered(t *testing.T) {
-	app := cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ctx := cli.NewContext(&app, set, nil)
-
-	gatewayPort := ctx.Int(flags.GRPCGatewayPort.Name)
-	gatewayHost := ctx.String(flags.GRPCGatewayHost.Name)
-	rpcHost := ctx.String(flags.RPCHost.Name)
-	selfAddress := fmt.Sprintf("%s:%d", rpcHost, ctx.Int(flags.RPCPort.Name))
-	gatewayAddress := fmt.Sprintf("%s:%d", gatewayHost, gatewayPort)
-
-	opts := []Option{
-		WithGatewayAddr(gatewayAddress),
-		WithRemoteAddr(selfAddress),
-	}
-
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
-
-	writer := httptest.NewRecorder()
-	g.cfg.router.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
-	assert.Equal(t, http.StatusNotFound, writer.Code)
-}

api/gateway/options.go

@@ -1,93 +0,0 @@
-package gateway
-
-import (
-	"time"
-
-	"github.com/gorilla/mux"
-	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"github.com/prysmaticlabs/prysm/api/gateway/apimiddleware"
-)
-
-type Option func(g *Gateway) error
-
-func (g *Gateway) SetRouter(r *mux.Router) *Gateway {
-	g.cfg.router = r
-	return g
-}
-
-func WithPbHandlers(handlers []*PbMux) Option {
-	return func(g *Gateway) error {
-		g.cfg.pbHandlers = handlers
-		return nil
-	}
-}
-
-func WithMuxHandler(m MuxHandler) Option {
-	return func(g *Gateway) error {
-		g.cfg.muxHandler = m
-		return nil
-	}
-}
-
-func WithGatewayAddr(addr string) Option {
-	return func(g *Gateway) error {
-		g.cfg.gatewayAddr = addr
-		return nil
-	}
-}
-
-func WithRemoteAddr(addr string) Option {
-	return func(g *Gateway) error {
-		g.cfg.remoteAddr = addr
-		return nil
-	}
-}
-
-// WithRouter allows adding a custom mux router to the gateway.
-func WithRouter(r *mux.Router) Option {
-	return func(g *Gateway) error {
-		g.cfg.router = r
-		return nil
-	}
-}
-
-// WithAllowedOrigins allows adding a set of allowed origins to the gateway.
-func WithAllowedOrigins(origins []string) Option {
-	return func(g *Gateway) error {
-		g.cfg.allowedOrigins = origins
-		return nil
-	}
-}
-
-// WithRemoteCert allows adding a custom certificate to the gateway,
-func WithRemoteCert(cert string) Option {
-	return func(g *Gateway) error {
-		g.cfg.remoteCert = cert
-		return nil
-	}
-}
-
-// WithMaxCallRecvMsgSize allows specifying the maximum allowed gRPC message size.
-func WithMaxCallRecvMsgSize(size uint64) Option {
-	return func(g *Gateway) error {
-		g.cfg.maxCallRecvMsgSize = size
-		return nil
-	}
-}
-
-// WithApiMiddleware allows adding an API middleware proxy to the gateway.
-func WithApiMiddleware(endpointFactory apimiddleware.EndpointFactory) Option {
-	return func(g *Gateway) error {
-		g.cfg.apiMiddlewareEndpointFactory = endpointFactory
-		return nil
-	}
-}
-
-// WithTimeout allows changing the timeout value for API calls.
-func WithTimeout(seconds uint64) Option {
-	return func(g *Gateway) error {
-		g.cfg.timeout = time.Second * time.Duration(seconds)
-		gwruntime.DefaultContextTimeout = time.Second * time.Duration(seconds)
-		return nil
-	}
-}

api/grpc/BUILD.bazel

@@ -1,30 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "grpcutils.go",
-        "parameters.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/grpc",
-    visibility = ["//visibility:public"],
-    deps = [
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_grpc//metadata:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["grpcutils_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_grpc//metadata:go_default_library",
-    ],
-)

api/grpc/grpcutils.go

@@ -1,96 +0,0 @@
-package grpc
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/sirupsen/logrus"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-)
-
-// LogRequests logs the gRPC backend as well as request duration when the log level is set to debug
-// or higher.
-func LogRequests(
-	ctx context.Context,
-	method string, req,
-	reply interface{},
-	cc *grpc.ClientConn,
-	invoker grpc.UnaryInvoker,
-	opts ...grpc.CallOption,
-) error {
-	// Shortcut when debug logging is not enabled.
-	if logrus.GetLevel() < logrus.DebugLevel {
-		return invoker(ctx, method, req, reply, cc, opts...)
-	}
-
-	var header metadata.MD
-	opts = append(
-		opts,
-		grpc.Header(&header),
-	)
-	start := time.Now()
-	err := invoker(ctx, method, req, reply, cc, opts...)
-	logrus.WithField("backend", header["x-backend"]).
-		WithField("method", method).WithField("duration", time.Since(start)).
-		Debug("gRPC request finished.")
-	return err
-}
-
-// LogStream prints the method at DEBUG level at the start of the stream.
-func LogStream(
-	ctx context.Context,
-	sd *grpc.StreamDesc,
-	conn *grpc.ClientConn,
-	method string,
-	streamer grpc.Streamer,
-	opts ...grpc.CallOption,
-) (grpc.ClientStream, error) {
-	// Shortcut when debug logging is not enabled.
-	if logrus.GetLevel() < logrus.DebugLevel {
-		return streamer(ctx, sd, conn, method, opts...)
-	}
-
-	var header metadata.MD
-	opts = append(
-		opts,
-		grpc.Header(&header),
-	)
-	strm, err := streamer(ctx, sd, conn, method, opts...)
-	logrus.WithField("backend", header["x-backend"]).
-		WithField("method", method).
-		Debug("gRPC stream started.")
-	return strm, err
-}
-
-// AppendHeaders parses the provided GRPC headers
-// and attaches them to the provided context.
-func AppendHeaders(parent context.Context, headers []string) context.Context {
-	for _, h := range headers {
-		if h != "" {
-			keyValue := strings.Split(h, "=")
-			if len(keyValue) < 2 {
-				logrus.Warnf("Incorrect gRPC header flag format. Skipping %v", keyValue[0])
-				continue
-			}
-			parent = metadata.AppendToOutgoingContext(parent, keyValue[0], strings.Join(keyValue[1:], "="))
-		}
-	}
-	return parent
-}
-
-// AppendCustomErrorHeader sets a CustomErrorMetadataKey gRPC header on the passed in context,
-// using the passed in error data as the header's value. The data is serialized as JSON.
-func AppendCustomErrorHeader(ctx context.Context, errorData interface{}) error {
-	j, err := json.Marshal(errorData)
-	if err != nil {
-		return fmt.Errorf("could not marshal error data into JSON: %w", err)
-	}
-	if err := grpc.SetHeader(ctx, metadata.Pairs(CustomErrorMetadataKey, string(j))); err != nil {
-		return fmt.Errorf("could not set custom error header: %w", err)
-	}
-	return nil
-}

api/grpc/grpcutils_test.go

@@ -1,78 +0,0 @@
-package grpc
-
-import (
-	"context"
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-)
-
-type customErrorData struct {
-	Message string `json:"message"`
-}
-
-func TestAppendHeaders(t *testing.T) {
-	t.Run("one_header", func(t *testing.T) {
-		ctx := AppendHeaders(context.Background(), []string{"first=value1"})
-		md, ok := metadata.FromOutgoingContext(ctx)
-		require.Equal(t, true, ok, "Failed to read context metadata")
-		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")
-		assert.Equal(t, "value1", md.Get("first")[0])
-	})
-
-	t.Run("multiple_headers", func(t *testing.T) {
-		ctx := AppendHeaders(context.Background(), []string{"first=value1", "second=value2"})
-		md, ok := metadata.FromOutgoingContext(ctx)
-		require.Equal(t, true, ok, "Failed to read context metadata")
-		require.Equal(t, 2, md.Len(), "MetadataV0 contains wrong number of values")
-		assert.Equal(t, "value1", md.Get("first")[0])
-		assert.Equal(t, "value2", md.Get("second")[0])
-	})
-
-	t.Run("one_empty_header", func(t *testing.T) {
-		ctx := AppendHeaders(context.Background(), []string{"first=value1", ""})
-		md, ok := metadata.FromOutgoingContext(ctx)
-		require.Equal(t, true, ok, "Failed to read context metadata")
-		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")
-		assert.Equal(t, "value1", md.Get("first")[0])
-	})
-
-	t.Run("incorrect_header", func(t *testing.T) {
-		logHook := logTest.NewGlobal()
-		ctx := AppendHeaders(context.Background(), []string{"first=value1", "second"})
-		md, ok := metadata.FromOutgoingContext(ctx)
-		require.Equal(t, true, ok, "Failed to read context metadata")
-		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")
-		assert.Equal(t, "value1", md.Get("first")[0])
-		assert.LogsContain(t, logHook, "Skipping second")
-	})
-
-	t.Run("header_value_with_equal_sign", func(t *testing.T) {
-		ctx := AppendHeaders(context.Background(), []string{"first=value=1"})
-		md, ok := metadata.FromOutgoingContext(ctx)
-		require.Equal(t, true, ok, "Failed to read context metadata")
-		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")
-		assert.Equal(t, "value=1", md.Get("first")[0])
-	})
-}
-
-func TestAppendCustomErrorHeader(t *testing.T) {
-	stream := &runtime.ServerTransportStream{}
-	ctx := grpc.NewContextWithServerTransportStream(context.Background(), stream)
-	data := &customErrorData{Message: "foo"}
-	require.NoError(t, AppendCustomErrorHeader(ctx, data))
-	// The stream used in test setup sets the metadata key in lowercase.
-	value, ok := stream.Header()[strings.ToLower(CustomErrorMetadataKey)]
-	require.Equal(t, true, ok, "Failed to retrieve custom error metadata value")
-	expected, err := json.Marshal(data)
-	require.NoError(t, err)
-	assert.Equal(t, string(expected), value[0])
-
-}

api/grpc/parameters.go

@@ -1,8 +0,0 @@
-package grpc
-
-// CustomErrorMetadataKey is the name of the metadata key storing additional error information.
-// Metadata value is expected to be a byte-encoded JSON object.
-const CustomErrorMetadataKey = "Custom-Error"
-
-// HttpCodeMetadataKey is the key to use when setting custom HTTP status codes in gRPC metadata.
-const HttpCodeMetadataKey = "X-Http-Code"

api/pagination/BUILD.bazel

@@ -1,22 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["pagination.go"],
-    importpath = "github.com/prysmaticlabs/prysm/api/pagination",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//config/params:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["pagination_test.go"],
-    deps = [
-        ":go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-    ],
-)

api/pagination/pagination.go

@@ -1,43 +0,0 @@
-// Package pagination contains useful pagination-related helpers.
-package pagination
-
-import (
-	"fmt"
-	"strconv"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/config/params"
-)
-
-// StartAndEndPage takes in the requested page token, wanted page size, total page size.
-// It returns start, end page and the next page token.
-func StartAndEndPage(pageToken string, pageSize, totalSize int) (int, int, string, error) {
-	if pageToken == "" {
-		pageToken = "0"
-	}
-	if pageSize == 0 {
-		pageSize = params.BeaconConfig().DefaultPageSize
-	}
-
-	token, err := strconv.Atoi(pageToken)
-	if err != nil {
-		return 0, 0, "", errors.Wrap(err, "could not convert page token")
-	}
-
-	// Start page can not be greater than set size.
-	start := token * pageSize
-	if start >= totalSize {
-		return 0, 0, "", fmt.Errorf("page start %d >= list %d", start, totalSize)
-	}
-
-	// End page can not go out of bound.
-	end := start + pageSize
-	nextPageToken := strconv.Itoa(token + 1)
-
-	if end >= totalSize {
-		end = totalSize
-		nextPageToken = "" // Return an empty next page token for the last page of a set
-	}
-
-	return start, end, nextPageToken, nil
-}

api/pagination/pagination_test.go

@@ -1,87 +0,0 @@
-package pagination_test
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/api/pagination"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestStartAndEndPage(t *testing.T) {
-	tests := []struct {
-		token     string
-		pageSize  int
-		totalSize int
-		nextToken string
-		start     int
-		end       int
-	}{
-		{
-			token:     "0",
-			pageSize:  9,
-			totalSize: 100,
-			nextToken: "1",
-			start:     0,
-			end:       9,
-		},
-		{
-			token:     "10",
-			pageSize:  4,
-			totalSize: 100,
-			nextToken: "11",
-			start:     40,
-			end:       44,
-		},
-		{
-			token:     "100",
-			pageSize:  5,
-			totalSize: 1000,
-			nextToken: "101",
-			start:     500,
-			end:       505,
-		},
-		{
-			token:     "3",
-			pageSize:  33,
-			totalSize: 100,
-			nextToken: "",
-			start:     99,
-			end:       100,
-		},
-		{
-			token:     "34",
-			pageSize:  500,
-			totalSize: 17500,
-			nextToken: "",
-			start:     17000,
-			end:       17500,
-		},
-	}
-
-	for _, test := range tests {
-		start, end, next, err := pagination.StartAndEndPage(test.token, test.pageSize, test.totalSize)
-		require.NoError(t, err)
-		if test.start != start {
-			t.Errorf("expected start and computed start are not equal %d, %d", test.start, start)
-		}
-		if test.end != end {
-			t.Errorf("expected end and computed end are not equal %d, %d", test.end, end)
-		}
-		if test.nextToken != next {
-			t.Errorf("expected next token and computed next token are not equal %v, %v", test.nextToken, next)
-		}
-	}
-}
-
-func TestStartAndEndPage_CannotConvertPage(t *testing.T) {
-	wanted := "could not convert page token: strconv.Atoi: parsing"
-	_, _, _, err := pagination.StartAndEndPage("bad", 0, 0)
-	assert.ErrorContains(t, wanted, err)
-}
-
-func TestStartAndEndPage_ExceedsMaxPage(t *testing.T) {
-	wanted := "page start 0 >= list 0"
-	_, _, _, err := pagination.StartAndEndPage("", 0, 0)
-	assert.ErrorContains(t, wanted, err)
-}

async/BUILD.bazel

@@ -1,33 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "debounce.go",
-        "every.go",
-        "multilock.go",
-        "scatter.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/async",
-    visibility = ["//visibility:public"],
-    deps = ["@com_github_sirupsen_logrus//:go_default_library"],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "benchmark_test.go",
-        "debounce_test.go",
-        "every_test.go",
-        "multilock_test.go",
-        "scatter_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_stretchr_testify//assert:go_default_library",
-    ],
-)

async/abool/BUILD.bazel

@@ -1,14 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["abool.go"],
-    importpath = "github.com/prysmaticlabs/prysm/async/abool",
-    visibility = ["//visibility:public"],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["abool_test.go"],
-    embed = [":go_default_library"],
-)

async/abool/abool.go

@@ -1,72 +0,0 @@
-// Package abool provides atomic Boolean type for cleaner code and
-// better performance.
-// All rights reserved to https://github.com/tevino/abool.
-package abool
-
-import "sync/atomic"
-
-// New creates an AtomicBool with default set to false.
-func New() *AtomicBool {
-	return new(AtomicBool)
-}
-
-// NewBool creates an AtomicBool with given default value.
-func NewBool(ok bool) *AtomicBool {
-	ab := New()
-	if ok {
-		ab.Set()
-	}
-	return ab
-}
-
-// AtomicBool is an atomic Boolean.
-// Its methods are all atomic, thus safe to be called by multiple goroutines simultaneously.
-// Note: When embedding into a struct one should always use *AtomicBool to avoid copy.
-type AtomicBool int32
-
-// Set sets the Boolean to true.
-func (ab *AtomicBool) Set() {
-	atomic.StoreInt32((*int32)(ab), 1)
-}
-
-// UnSet sets the Boolean to false.
-func (ab *AtomicBool) UnSet() {
-	atomic.StoreInt32((*int32)(ab), 0)
-}
-
-// IsSet returns whether the Boolean is true.
-func (ab *AtomicBool) IsSet() bool {
-	return atomic.LoadInt32((*int32)(ab))&1 == 1
-}
-
-// IsNotSet returns whether the Boolean is false.
-func (ab *AtomicBool) IsNotSet() bool {
-	return !ab.IsSet()
-}
-
-// SetTo sets the boolean with given Boolean.
-func (ab *AtomicBool) SetTo(yes bool) {
-	if yes {
-		atomic.StoreInt32((*int32)(ab), 1)
-	} else {
-		atomic.StoreInt32((*int32)(ab), 0)
-	}
-}
-
-// Toggle inverts the Boolean then returns the value before inverting.
-func (ab *AtomicBool) Toggle() bool {
-	return atomic.AddInt32((*int32)(ab), 1)&1 == 0
-}
-
-// SetToIf sets the Boolean to new only if the Boolean matches the old.
-// Returns whether the set was done.
-func (ab *AtomicBool) SetToIf(old, curr bool) (set bool) {
-	var o, n int32
-	if old {
-		o = 1
-	}
-	if curr {
-		n = 1
-	}
-	return atomic.CompareAndSwapInt32((*int32)(ab), o, n)
-}

async/abool/abool_test.go

@@ -1,298 +0,0 @@
-// All rights reserved to https://github.com/tevino/abool.
-package abool
-
-import (
-	"math"
-	"sync"
-	"sync/atomic"
-	"testing"
-)
-
-func TestDefaultValue(t *testing.T) {
-	t.Parallel()
-	v := New()
-	if v.IsSet() {
-		t.Fatal("Empty value of AtomicBool should be false")
-	}
-
-	v = NewBool(true)
-	if !v.IsSet() {
-		t.Fatal("NewValue(true) should be true")
-	}
-
-	v = NewBool(false)
-	if v.IsSet() {
-		t.Fatal("NewValue(false) should be false")
-	}
-}
-
-func TestIsNotSet(t *testing.T) {
-	t.Parallel()
-	v := New()
-
-	if v.IsSet() == v.IsNotSet() {
-		t.Fatal("AtomicBool.IsNotSet() should be the opposite of IsSet()")
-	}
-}
-
-func TestSetUnSet(t *testing.T) {
-	t.Parallel()
-	v := New()
-
-	v.Set()
-	if !v.IsSet() {
-		t.Fatal("AtomicBool.Set() failed")
-	}
-
-	v.UnSet()
-	if v.IsSet() {
-		t.Fatal("AtomicBool.UnSet() failed")
-	}
-}
-
-func TestSetTo(t *testing.T) {
-	t.Parallel()
-	v := New()
-
-	v.SetTo(true)
-	if !v.IsSet() {
-		t.Fatal("AtomicBool.SetTo(true) failed")
-	}
-
-	v.SetTo(false)
-	if v.IsSet() {
-		t.Fatal("AtomicBool.SetTo(false) failed")
-	}
-
-	if set := v.SetToIf(true, false); set || v.IsSet() {
-		t.Fatal("AtomicBool.SetTo(true, false) failed")
-	}
-
-	if set := v.SetToIf(false, true); !set || !v.IsSet() {
-		t.Fatal("AtomicBool.SetTo(false, true) failed")
-	}
-}
-
-func TestToggle(t *testing.T) {
-	t.Parallel()
-	v := New()
-
-	_ = v.Toggle()
-	if !v.IsSet() {
-		t.Fatal("AtomicBool.Toggle() to true failed")
-	}
-
-	prev := v.Toggle()
-	if v.IsSet() == prev {
-		t.Fatal("AtomicBool.Toggle() to false failed")
-	}
-}
-
-func TestToogleMultipleTimes(t *testing.T) {
-	t.Parallel()
-
-	v := New()
-	pre := !v.IsSet()
-	for i := 0; i < 100; i++ {
-		v.SetTo(false)
-		for j := 0; j < i; j++ {
-			pre = v.Toggle()
-		}
-
-		expected := i%2 != 0
-		if v.IsSet() != expected {
-			t.Fatalf("AtomicBool.Toogle() doesn't work after %d calls, expected: %v, got %v", i, expected, v.IsSet())
-		}
-
-		if pre == v.IsSet() {
-			t.Fatalf("AtomicBool.Toogle() returned wrong value at the %dth calls, expected: %v, got %v", i, !v.IsSet(), pre)
-		}
-	}
-}
-
-func TestToogleAfterOverflow(t *testing.T) {
-	t.Parallel()
-
-	var value int32 = math.MaxInt32
-	v := (*AtomicBool)(&value)
-
-	valueBeforeToggle := *(*int32)(v)
-
-	// test first toggle after overflow
-	v.Toggle()
-	expected := math.MaxInt32%2 == 0
-	if v.IsSet() != expected {
-		t.Fatalf("AtomicBool.Toogle() doesn't work after overflow, expected: %v, got %v", expected, v.IsSet())
-	}
-
-	// make sure overflow happened
-	var valueAfterToggle = *(*int32)(v)
-	if valueAfterToggle >= valueBeforeToggle {
-		t.Fatalf("Overflow does not happen as expected, before %d, after: %d", valueBeforeToggle, valueAfterToggle)
-	}
-
-	// test second toggle after overflow
-	v.Toggle()
-	expected = !expected
-	if v.IsSet() != expected {
-		t.Fatalf("AtomicBool.Toogle() doesn't work after the second call after overflow, expected: %v, got %v", expected, v.IsSet())
-	}
-}
-
-func TestRace(t *testing.T) {
-	t.Parallel()
-
-	repeat := 10000
-	var wg sync.WaitGroup
-	wg.Add(repeat * 4)
-	v := New()
-
-	// Writer
-	go func() {
-		for i := 0; i < repeat; i++ {
-			v.Set()
-			wg.Done()
-		}
-	}()
-
-	// Reader
-	go func() {
-		for i := 0; i < repeat; i++ {
-			v.IsSet()
-			wg.Done()
-		}
-	}()
-
-	// Writer
-	go func() {
-		for i := 0; i < repeat; i++ {
-			v.UnSet()
-			wg.Done()
-		}
-	}()
-
-	// Reader And Writer
-	go func() {
-		for i := 0; i < repeat; i++ {
-			v.Toggle()
-			wg.Done()
-		}
-	}()
-
-	wg.Wait()
-}
-
-func ExampleAtomicBool() {
-	cond := New()             // default to false
-	cond.Set()                // Sets to true
-	cond.IsSet()              // Returns true
-	cond.UnSet()              // Sets to false
-	cond.IsNotSet()           // Returns true
-	cond.SetTo(true)          // Sets to whatever you want
-	cond.SetToIf(true, false) // Sets to `new` only if the Boolean matches the `old`, returns whether succeeded
-	cond.Toggle()             // Inverts the boolean then returns the value before inverting
-}
-
-// Benchmark Read
-
-func BenchmarkMutexRead(b *testing.B) {
-	var m sync.RWMutex
-	var v bool
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		m.RLock()
-		_ = v
-		m.RUnlock()
-	}
-}
-
-func BenchmarkAtomicValueRead(b *testing.B) {
-	var v atomic.Value
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = v.Load() != nil
-	}
-}
-
-func BenchmarkAtomicBoolRead(b *testing.B) {
-	v := New()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = v.IsSet()
-	}
-}
-
-// Benchmark Write
-
-func BenchmarkMutexWrite(b *testing.B) {
-	var m sync.RWMutex
-	var v bool
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		m.RLock()
-		v = true
-		m.RUnlock()
-	}
-	b.StopTimer()
-	_ = v
-}
-
-func BenchmarkAtomicValueWrite(b *testing.B) {
-	var v atomic.Value
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		v.Store(true)
-	}
-}
-
-func BenchmarkAtomicBoolWrite(b *testing.B) {
-	v := New()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		v.Set()
-	}
-}
-
-// Benchmark CAS
-
-func BenchmarkMutexCAS(b *testing.B) {
-	var m sync.RWMutex
-	var v bool
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		m.Lock()
-		if !v {
-			v = true
-		}
-		m.Unlock()
-	}
-}
-
-func BenchmarkAtomicBoolCAS(b *testing.B) {
-	v := New()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		v.SetToIf(false, true)
-	}
-}
-
-// Benchmark toggle
-
-func BenchmarkMutexToggle(b *testing.B) {
-	var m sync.RWMutex
-	var v bool
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		m.Lock()
-		v = !v
-		m.Unlock()
-	}
-}
-
-func BenchmarkAtomicBoolToggle(b *testing.B) {
-	v := New()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		v.Toggle()
-	}
-}

async/benchmark_test.go

@@ -1,63 +0,0 @@
-package async_test
-
-import (
-	"crypto/rand"
-	"crypto/sha256"
-	"sync"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/async"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	log "github.com/sirupsen/logrus"
-)
-
-var input [][]byte
-
-const (
-	benchmarkElements    = 65536
-	benchmarkElementSize = 32
-	benchmarkHashRuns    = 128
-)
-
-func init() {
-	input = make([][]byte, benchmarkElements)
-	for i := 0; i < benchmarkElements; i++ {
-		input[i] = make([]byte, benchmarkElementSize)
-		_, err := rand.Read(input[i])
-		if err != nil {
-			log.WithError(err).Debug("Cannot read from rand")
-		}
-	}
-}
-
-// hash repeatedly hashes the data passed to it
-func hash(input [][]byte) [][]byte {
-	output := make([][]byte, len(input))
-	for i := range input {
-		copy(output, input)
-		for j := 0; j < benchmarkHashRuns; j++ {
-			hash := sha256.Sum256(output[i])
-			output[i] = hash[:]
-		}
-	}
-	return output
-}
-
-func BenchmarkHash(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		hash(input)
-	}
-}
-
-func BenchmarkHashMP(b *testing.B) {
-	output := make([][]byte, len(input))
-	for i := 0; i < b.N; i++ {
-		workerResults, err := async.Scatter(len(input), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
-			return hash(input[offset : offset+entries]), nil
-		})
-		require.NoError(b, err)
-		for _, result := range workerResults {
-			copy(output[result.Offset:], result.Extent.([][]byte))
-		}
-	}
-}

async/debounce.go

@@ -1,45 +0,0 @@
-package async
-
-import (
-	"context"
-	"time"
-)
-
-// Debounce events fired over a channel by a specified duration, ensuring no events
-// are handled until a certain interval of time has passed.
-func Debounce(ctx context.Context, interval time.Duration, eventsChan <-chan interface{}, handler func(interface{})) {
-	var timer *time.Timer
-	defer func() {
-		if timer != nil {
-			timer.Stop()
-		}
-	}()
-	for {
-		select {
-		// Wait until an event is triggered.
-		case event := <-eventsChan:
-			timer = time.NewTimer(interval)
-		loop:
-			for {
-				// If an event is received, wait the specified interval before calling the handler.
-				// If another event is received before the interval has passed, store
-				// it and reset the timer.
-				select {
-				case event = <-eventsChan:
-					// Reset timer.
-					timer.Stop()
-					timer = time.NewTimer(interval)
-				case <-timer.C:
-					// Stop the current timer, handle the request, and wait for more events.
-					timer.Stop()
-					handler(event)
-					break loop
-				case <-ctx.Done():
-					return
-				}
-			}
-		case <-ctx.Done():
-			return
-		}
-	}
-}

async/debounce_test.go

@@ -1,116 +0,0 @@
-package async_test
-
-import (
-	"context"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/async"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestDebounce_NoEvents(t *testing.T) {
-	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(context.Background())
-	interval := time.Second
-	timesHandled := 0
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-	go func() {
-		time.AfterFunc(interval, func() {
-			cancel()
-		})
-	}()
-	go func() {
-		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-			timesHandled++
-		})
-		wg.Done()
-	}()
-	if util.WaitTimeout(wg, interval*2) {
-		t.Fatalf("Test should have exited by now, timed out")
-	}
-	assert.Equal(t, 0, timesHandled, "Wrong number of handled calls")
-}
-
-func TestDebounce_CtxClosing(t *testing.T) {
-	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(context.Background())
-	interval := time.Second
-	timesHandled := 0
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-	go func() {
-		ticker := time.NewTicker(time.Millisecond * 100)
-		defer ticker.Stop()
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case <-ticker.C:
-				eventsChan <- struct{}{}
-			}
-		}
-	}()
-	go func() {
-		time.AfterFunc(interval, func() {
-			cancel()
-		})
-	}()
-	go func() {
-		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-			timesHandled++
-		})
-		wg.Done()
-	}()
-	if util.WaitTimeout(wg, interval*2) {
-		t.Fatalf("Test should have exited by now, timed out")
-	}
-	assert.Equal(t, 0, timesHandled, "Wrong number of handled calls")
-}
-
-func TestDebounce_SingleHandlerInvocation(t *testing.T) {
-	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(context.Background())
-	interval := time.Second
-	timesHandled := 0
-	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-		timesHandled++
-	})
-	for i := 0; i < 100; i++ {
-		eventsChan <- struct{}{}
-	}
-	// We should expect 100 rapid fire changes to only have caused
-	// 1 handler to trigger after the debouncing period.
-	time.Sleep(interval * 2)
-	assert.Equal(t, 1, timesHandled, "Wrong number of handled calls")
-	cancel()
-}
-
-func TestDebounce_MultipleHandlerInvocation(t *testing.T) {
-	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(context.Background())
-	interval := time.Second
-	timesHandled := 0
-	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-		timesHandled++
-	})
-	for i := 0; i < 100; i++ {
-		eventsChan <- struct{}{}
-	}
-	require.Equal(t, 0, timesHandled, "Events must prevent from handler execution")
-
-	// By this time the first event should be triggered.
-	time.Sleep(2 * time.Second)
-	assert.Equal(t, 1, timesHandled, "Wrong number of handled calls")
-
-	// Second event.
-	eventsChan <- struct{}{}
-	time.Sleep(2 * time.Second)
-	assert.Equal(t, 2, timesHandled, "Wrong number of handled calls")
-
-	cancel()
-}

async/event/BUILD.bazel

@@ -1,29 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "feed.go",
-        "subscription.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/async/event",
-    visibility = ["//visibility:public"],
-    deps = ["//time/mclock:go_default_library"],
-)
-
-go_test(
-    name = "go_default_test",
-    size = "small",
-    srcs = [
-        "example_feed_test.go",
-        "example_scope_test.go",
-        "example_subscription_test.go",
-        "feed_test.go",
-        "subscription_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-    ],
-)

async/event/feed.go

@@ -1,255 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package event contains an event feed implementation for process communication.
-package event
-
-import (
-	"errors"
-	"reflect"
-	"sync"
-)
-
-var errBadChannel = errors.New("event: Subscribe argument does not have sendable channel type")
-
-// Feed implements one-to-many subscriptions where the carrier of events is a channel.
-// Values sent to a Feed are delivered to all subscribed channels simultaneously.
-//
-// Feeds can only be used with a single type. The type is determined by the first Send or
-// Subscribe operation. Subsequent calls to these methods panic if the type does not
-// match.
-//
-// The zero value is ready to use.
-type Feed struct {
-	once      sync.Once        // ensures that init only runs once
-	sendLock  chan struct{}    // sendLock has a one-element buffer and is empty when held.It protects sendCases.
-	removeSub chan interface{} // interrupts Send
-	sendCases caseList         // the active set of select cases used by Send
-
-	// The inbox holds newly subscribed channels until they are added to sendCases.
-	mu    sync.Mutex
-	inbox caseList
-	etype reflect.Type
-}
-
-// This is the index of the first actual subscription channel in sendCases.
-// sendCases[0] is a SelectRecv case for the removeSub channel.
-const firstSubSendCase = 1
-
-type feedTypeError struct {
-	got, want reflect.Type
-	op        string
-}
-
-func (e feedTypeError) Error() string {
-	return "event: wrong type in " + e.op + " got " + e.got.String() + ", want " + e.want.String()
-}
-
-func (f *Feed) init() {
-	f.removeSub = make(chan interface{})
-	f.sendLock = make(chan struct{}, 1)
-	f.sendLock <- struct{}{}
-	f.sendCases = caseList{{Chan: reflect.ValueOf(f.removeSub), Dir: reflect.SelectRecv}}
-}
-
-// Subscribe adds a channel to the feed. Future sends will be delivered on the channel
-// until the subscription is canceled. All channels added must have the same element type.
-//
-// The channel should have ample buffer space to avoid blocking other subscribers.
-// Slow subscribers are not dropped.
-func (f *Feed) Subscribe(channel interface{}) Subscription {
-	f.once.Do(f.init)
-
-	chanval := reflect.ValueOf(channel)
-	chantyp := chanval.Type()
-	if chantyp.Kind() != reflect.Chan || chantyp.ChanDir()&reflect.SendDir == 0 {
-		panic(errBadChannel)
-	}
-	sub := &feedSub{feed: f, channel: chanval, err: make(chan error, 1)}
-
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	if !f.typecheck(chantyp.Elem()) {
-		panic(feedTypeError{op: "Subscribe", got: chantyp, want: reflect.ChanOf(reflect.SendDir, f.etype)})
-	}
-	// Add the select case to the inbox.
-	// The next Send will add it to f.sendCases.
-	cas := reflect.SelectCase{Dir: reflect.SelectSend, Chan: chanval}
-	f.inbox = append(f.inbox, cas)
-	return sub
-}
-
-// note: callers must hold f.mu
-func (f *Feed) typecheck(typ reflect.Type) bool {
-	if f.etype == nil {
-		f.etype = typ
-		return true
-	}
-	// In the event the feed's type is an actual interface, we
-	// perform an interface conformance check here.
-	if f.etype.Kind() == reflect.Interface && typ.Implements(f.etype) {
-		return true
-	}
-	return f.etype == typ
-}
-
-func (f *Feed) remove(sub *feedSub) {
-	// Delete from inbox first, which covers channels
-	// that have not been added to f.sendCases yet.
-	ch := sub.channel.Interface()
-	f.mu.Lock()
-	index := f.inbox.find(ch)
-	if index != -1 {
-		f.inbox = f.inbox.delete(index)
-		f.mu.Unlock()
-		return
-	}
-	f.mu.Unlock()
-
-	select {
-	case f.removeSub <- ch:
-		// Send will remove the channel from f.sendCases.
-	case <-f.sendLock:
-		// No Send is in progress, delete the channel now that we have the send lock.
-		f.sendCases = f.sendCases.delete(f.sendCases.find(ch))
-		f.sendLock <- struct{}{}
-	}
-}
-
-// Send delivers to all subscribed channels simultaneously.
-// It returns the number of subscribers that the value was sent to.
-func (f *Feed) Send(value interface{}) (nsent int) {
-	rvalue := reflect.ValueOf(value)
-
-	f.once.Do(f.init)
-	<-f.sendLock
-
-	// Add new cases from the inbox after taking the send lock.
-	f.mu.Lock()
-	f.sendCases = append(f.sendCases, f.inbox...)
-	f.inbox = nil
-
-	if !f.typecheck(rvalue.Type()) {
-		f.sendLock <- struct{}{}
-		panic(feedTypeError{op: "Send", got: rvalue.Type(), want: f.etype})
-	}
-	f.mu.Unlock()
-
-	// Set the sent value on all channels.
-	for i := firstSubSendCase; i < len(f.sendCases); i++ {
-		f.sendCases[i].Send = rvalue
-	}
-
-	// Send until all channels except removeSub have been chosen. 'cases' tracks a prefix
-	// of sendCases. When a send succeeds, the corresponding case moves to the end of
-	// 'cases' and it shrinks by one element.
-	cases := f.sendCases
-	for {
-		// Fast path: try sending without blocking before adding to the select set.
-		// This should usually succeed if subscribers are fast enough and have free
-		// buffer space.
-		for i := firstSubSendCase; i < len(cases); i++ {
-			if cases[i].Chan.TrySend(rvalue) {
-				nsent++
-				cases = cases.deactivate(i)
-				i--
-			}
-		}
-		if len(cases) == firstSubSendCase {
-			break
-		}
-		// Select on all the receivers, waiting for them to unblock.
-		chosen, recv, _ := reflect.Select(cases)
-		if chosen == 0 /* <-f.removeSub */ {
-			index := f.sendCases.find(recv.Interface())
-			f.sendCases = f.sendCases.delete(index)
-			if index >= 0 && index < len(cases) {
-				// Shrink 'cases' too because the removed case was still active.
-				cases = f.sendCases[:len(cases)-1]
-			}
-		} else {
-			cases = cases.deactivate(chosen)
-			nsent++
-		}
-	}
-
-	// Forget about the sent value and hand off the send lock.
-	for i := firstSubSendCase; i < len(f.sendCases); i++ {
-		f.sendCases[i].Send = reflect.Value{}
-	}
-	f.sendLock <- struct{}{}
-	return nsent
-}
-
-type feedSub struct {
-	feed    *Feed
-	channel reflect.Value
-	errOnce sync.Once
-	err     chan error
-}
-
-// Unsubscribe remove feed subscription.
-func (sub *feedSub) Unsubscribe() {
-	sub.errOnce.Do(func() {
-		sub.feed.remove(sub)
-		close(sub.err)
-	})
-}
-
-// Err returns error channel.
-func (sub *feedSub) Err() <-chan error {
-	return sub.err
-}
-
-type caseList []reflect.SelectCase
-
-// find returns the index of a case containing the given channel.
-func (cs caseList) find(channel interface{}) int {
-	for i, cas := range cs {
-		if cas.Chan.Interface() == channel {
-			return i
-		}
-	}
-	return -1
-}
-
-// delete removes the given case from cs.
-func (cs caseList) delete(index int) caseList {
-	return append(cs[:index], cs[index+1:]...)
-}
-
-// deactivate moves the case at index into the non-accessible portion of the cs slice.
-func (cs caseList) deactivate(index int) caseList {
-	last := len(cs) - 1
-	cs[index], cs[last] = cs[last], cs[index]
-	return cs[:last]
-}
-
-// func (cs caseList) String() string {
-//     s := "["
-//     for i, cas := range cs {
-//             if i != 0 {
-//                     s += ", "
-//             }
-//             switch cas.Dir {
-//             case reflect.SelectSend:
-//                     s += fmt.Sprintf("%v<-", cas.Chan.Interface())
-//             case reflect.SelectRecv:
-//                     s += fmt.Sprintf("<-%v", cas.Chan.Interface())
-//             }
-//     }
-//     return s + "]"
-// }

async/event/feed_test.go

@@ -1,507 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package event
-
-import (
-	"fmt"
-	"reflect"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/testing/assert"
-)
-
-func TestFeedPanics(t *testing.T) {
-	{
-		var f Feed
-		f.Send(2)
-		want := feedTypeError{op: "Send", got: reflect.TypeOf(uint64(0)), want: reflect.TypeOf(0)}
-		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
-	}
-	{
-		var f Feed
-		ch := make(chan int)
-		f.Subscribe(ch)
-		want := feedTypeError{op: "Send", got: reflect.TypeOf(uint64(0)), want: reflect.TypeOf(0)}
-		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
-	}
-	{
-		var f Feed
-		f.Send(2)
-		want := feedTypeError{op: "Subscribe", got: reflect.TypeOf(make(chan uint64)), want: reflect.TypeOf(make(chan<- int))}
-		assert.NoError(t, checkPanic(want, func() { f.Subscribe(make(chan uint64)) }))
-	}
-	{
-		var f Feed
-		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(make(<-chan int)) }))
-	}
-	{
-		var f Feed
-		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(0) }))
-	}
-}
-
-func checkPanic(want error, fn func()) (err error) {
-	defer func() {
-		panicResult := recover()
-		if panicResult == nil {
-			err = fmt.Errorf("didn't panic")
-		} else if !reflect.DeepEqual(panicResult, want) {
-			err = fmt.Errorf("panicked with wrong error: got %q, want %q", panicResult, want)
-		}
-	}()
-	fn()
-	return nil
-}
-
-func TestFeed(t *testing.T) {
-	var feed Feed
-	var done, subscribed sync.WaitGroup
-	subscriber := func(i int) {
-		defer done.Done()
-
-		subchan := make(chan int)
-		sub := feed.Subscribe(subchan)
-		timeout := time.NewTimer(2 * time.Second)
-		subscribed.Done()
-
-		select {
-		case v := <-subchan:
-			if v != 1 {
-				t.Errorf("%d: received value %d, want 1", i, v)
-			}
-		case <-timeout.C:
-			t.Errorf("%d: receive timeout", i)
-		}
-
-		sub.Unsubscribe()
-		select {
-		case _, ok := <-sub.Err():
-			if ok {
-				t.Errorf("%d: error channel not closed after unsubscribe", i)
-			}
-		case <-timeout.C:
-			t.Errorf("%d: unsubscribe timeout", i)
-		}
-	}
-
-	const n = 1000
-	done.Add(n)
-	subscribed.Add(n)
-	for i := 0; i < n; i++ {
-		go subscriber(i)
-	}
-	subscribed.Wait()
-	if nsent := feed.Send(1); nsent != n {
-		t.Errorf("first send delivered %d times, want %d", nsent, n)
-	}
-	if nsent := feed.Send(2); nsent != 0 {
-		t.Errorf("second send delivered %d times, want 0", nsent)
-	}
-	done.Wait()
-}
-
-func TestFeedSubscribeSameChannel(t *testing.T) {
-	var (
-		feed Feed
-		done sync.WaitGroup
-		ch   = make(chan int)
-		sub1 = feed.Subscribe(ch)
-		sub2 = feed.Subscribe(ch)
-		_    = feed.Subscribe(ch)
-	)
-	expectSends := func(value, n int) {
-		if nsent := feed.Send(value); nsent != n {
-			t.Errorf("send delivered %d times, want %d", nsent, n)
-		}
-		done.Done()
-	}
-	expectRecv := func(wantValue, n int) {
-		for i := 0; i < n; i++ {
-			if v := <-ch; v != wantValue {
-				t.Errorf("received %d, want %d", v, wantValue)
-			}
-		}
-	}
-
-	done.Add(1)
-	go expectSends(1, 3)
-	expectRecv(1, 3)
-	done.Wait()
-
-	sub1.Unsubscribe()
-
-	done.Add(1)
-	go expectSends(2, 2)
-	expectRecv(2, 2)
-	done.Wait()
-
-	sub2.Unsubscribe()
-
-	done.Add(1)
-	go expectSends(3, 1)
-	expectRecv(3, 1)
-	done.Wait()
-}
-
-func TestFeedSubscribeBlockedPost(_ *testing.T) {
-	var (
-		feed   Feed
-		nsends = 2000
-		ch1    = make(chan int)
-		ch2    = make(chan int)
-		wg     sync.WaitGroup
-	)
-	defer wg.Wait()
-
-	feed.Subscribe(ch1)
-	wg.Add(nsends)
-	for i := 0; i < nsends; i++ {
-		go func() {
-			feed.Send(99)
-			wg.Done()
-		}()
-	}
-
-	sub2 := feed.Subscribe(ch2)
-	defer sub2.Unsubscribe()
-
-	// We're done when ch1 has received N times.
-	// The number of receives on ch2 depends on scheduling.
-	for i := 0; i < nsends; {
-		select {
-		case <-ch1:
-			i++
-		case <-ch2:
-		}
-	}
-}
-
-func TestFeedUnsubscribeBlockedPost(_ *testing.T) {
-	var (
-		feed   Feed
-		nsends = 200
-		chans  = make([]chan int, 2000)
-		subs   = make([]Subscription, len(chans))
-		bchan  = make(chan int)
-		bsub   = feed.Subscribe(bchan)
-		wg     sync.WaitGroup
-	)
-	for i := range chans {
-		chans[i] = make(chan int, nsends)
-	}
-
-	// Queue up some Sends. None of these can make progress while bchan isn't read.
-	wg.Add(nsends)
-	for i := 0; i < nsends; i++ {
-		go func() {
-			feed.Send(99)
-			wg.Done()
-		}()
-	}
-	// Subscribe the other channels.
-	for i, ch := range chans {
-		subs[i] = feed.Subscribe(ch)
-	}
-	// Unsubscribe them again.
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-	// Unblock the Sends.
-	bsub.Unsubscribe()
-	wg.Wait()
-}
-
-// Checks that unsubscribing a channel during Send works even if that
-// channel has already been sent on.
-func TestFeedUnsubscribeSentChan(_ *testing.T) {
-	var (
-		feed Feed
-		ch1  = make(chan int)
-		ch2  = make(chan int)
-		sub1 = feed.Subscribe(ch1)
-		sub2 = feed.Subscribe(ch2)
-		wg   sync.WaitGroup
-	)
-	defer sub2.Unsubscribe()
-
-	wg.Add(1)
-	go func() {
-		feed.Send(0)
-		wg.Done()
-	}()
-
-	// Wait for the value on ch1.
-	<-ch1
-	// Unsubscribe ch1, removing it from the send cases.
-	sub1.Unsubscribe()
-
-	// Receive ch2, finishing Send.
-	<-ch2
-	wg.Wait()
-
-	// Send again. This should send to ch2 only, so the wait group will unblock
-	// as soon as a value is received on ch2.
-	wg.Add(1)
-	go func() {
-		feed.Send(0)
-		wg.Done()
-	}()
-	<-ch2
-	wg.Wait()
-}
-
-func TestFeedUnsubscribeFromInbox(t *testing.T) {
-	var (
-		feed Feed
-		ch1  = make(chan int)
-		ch2  = make(chan int)
-		sub1 = feed.Subscribe(ch1)
-		sub2 = feed.Subscribe(ch1)
-		sub3 = feed.Subscribe(ch2)
-	)
-	assert.Equal(t, 3, len(feed.inbox))
-	assert.Equal(t, 1, len(feed.sendCases), "sendCases is non-empty after unsubscribe")
-
-	sub1.Unsubscribe()
-	sub2.Unsubscribe()
-	sub3.Unsubscribe()
-	assert.Equal(t, 0, len(feed.inbox), "Inbox is non-empty after unsubscribe")
-	assert.Equal(t, 1, len(feed.sendCases), "sendCases is non-empty after unsubscribe")
-}
-
-func BenchmarkFeedSend1000(b *testing.B) {
-	var (
-		done  sync.WaitGroup
-		feed  Feed
-		nsubs = 1000
-	)
-	subscriber := func(ch <-chan int) {
-		for i := 0; i < b.N; i++ {
-			<-ch
-		}
-		done.Done()
-	}
-	done.Add(nsubs)
-	for i := 0; i < nsubs; i++ {
-		ch := make(chan int, 200)
-		feed.Subscribe(ch)
-		go subscriber(ch)
-	}
-
-	// The actual benchmark.
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		if feed.Send(i) != nsubs {
-			panic("wrong number of sends")
-		}
-	}
-
-	b.StopTimer()
-	done.Wait()
-}
-
-func TestFeed_Send(t *testing.T) {
-	tests := []struct {
-		name        string
-		evFeed      *Feed
-		testSetup   func(fd *Feed, t *testing.T, o interface{})
-		obj         interface{}
-		expectPanic bool
-	}{
-		{
-			name:   "normal struct",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedWithPointer, 1)
-				fd.Subscribe(testChan)
-			},
-			obj: testFeedWithPointer{
-				a: new(uint64),
-				b: new(string),
-			},
-			expectPanic: false,
-		},
-		{
-			name:   "un-implemented interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface, 1)
-				fd.Subscribe(testChan)
-			},
-			obj: testFeedWithPointer{
-				a: new(uint64),
-				b: new(string),
-			},
-			expectPanic: true,
-		},
-		{
-			name:   "semi-implemented interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface, 1)
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed2{
-				a: 0,
-				b: "",
-				c: []byte{'A'},
-			},
-			expectPanic: true,
-		},
-		{
-			name:   "fully-implemented interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface)
-				// Make it unbuffered to allow message to
-				// pass through
-				go func() {
-					a := <-testChan
-					if !reflect.DeepEqual(a, o) {
-						t.Errorf("Got = %v, want = %v", a, o)
-					}
-				}()
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed{
-				a: 0,
-				b: "",
-			},
-			expectPanic: false,
-		},
-		{
-			name:   "fully-implemented interface with additional methods",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface)
-				// Make it unbuffered to allow message to
-				// pass through
-				go func() {
-					a := <-testChan
-					if !reflect.DeepEqual(a, o) {
-						t.Errorf("Got = %v, want = %v", a, o)
-					}
-				}()
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed3{
-				a: 0,
-				b: "",
-				c: []byte{'A'},
-				d: []byte{'B'},
-			},
-			expectPanic: false,
-		},
-		{
-			name:   "concrete types implementing the same interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeed, 1)
-				// Make it unbuffered to allow message to
-				// pass through
-				go func() {
-					a := <-testChan
-					if !reflect.DeepEqual(a, o) {
-						t.Errorf("Got = %v, want = %v", a, o)
-					}
-				}()
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed3{
-				a: 0,
-				b: "",
-				c: []byte{'A'},
-				d: []byte{'B'},
-			},
-			expectPanic: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			defer func() {
-				if r := recover(); r != nil {
-					if !tt.expectPanic {
-						t.Errorf("panic triggered when unexpected: %v", r)
-					}
-				} else {
-					if tt.expectPanic {
-						t.Error("panic not triggered when expected")
-					}
-				}
-			}()
-			tt.testSetup(tt.evFeed, t, tt.obj)
-			if gotNsent := tt.evFeed.Send(tt.obj); gotNsent != 1 {
-				t.Errorf("Send() = %v, want %v", gotNsent, 1)
-			}
-		})
-	}
-}
-
-// The following objects below are a collection of different
-// struct types to test with.
-type testFeed struct {
-	a uint64
-	b string
-}
-
-func (testFeed) method1() {
-
-}
-
-func (testFeed) method2() {
-
-}
-
-type testFeedWithPointer struct {
-	a *uint64
-	b *string
-}
-
-type testFeed2 struct {
-	a uint64
-	b string
-	c []byte
-}
-
-func (testFeed2) method1() {
-
-}
-
-type testFeed3 struct {
-	a    uint64
-	b    string
-	c, d []byte
-}
-
-func (testFeed3) method1() {
-
-}
-
-func (testFeed3) method2() {
-
-}
-
-func (testFeed3) method3() {
-
-}
-
-type testFeedIface interface {
-	method1()
-	method2()
-}

async/every.go

@@ -1,31 +0,0 @@
-// Package async includes helpers for scheduling runnable, periodic functions and contains useful helpers for converting multi-processor computation.
-package async
-
-import (
-	"context"
-	"reflect"
-	"runtime"
-	"time"
-
-	log "github.com/sirupsen/logrus"
-)
-
-// RunEvery runs the provided command periodically.
-// It runs in a goroutine, and can be cancelled by finishing the supplied context.
-func RunEvery(ctx context.Context, period time.Duration, f func()) {
-	funcName := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
-	ticker := time.NewTicker(period)
-	go func() {
-		for {
-			select {
-			case <-ticker.C:
-				log.WithField("function", funcName).Trace("running")
-				f()
-			case <-ctx.Done():
-				log.WithField("function", funcName).Debug("context is closed, exiting")
-				ticker.Stop()
-				return
-			}
-		}
-	}()
-}

async/every_test.go

@@ -1,39 +0,0 @@
-package async_test
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/async"
-)
-
-func TestEveryRuns(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-
-	i := 0
-	async.RunEvery(ctx, 100*time.Millisecond, func() {
-		i++
-	})
-
-	// Sleep for a bit and ensure the value has increased.
-	time.Sleep(200 * time.Millisecond)
-
-	if i == 0 {
-		t.Error("Counter failed to increment with ticker")
-	}
-
-	cancel()
-
-	// Sleep for a bit to let the cancel take place.
-	time.Sleep(100 * time.Millisecond)
-
-	last := i
-
-	// Sleep for a bit and ensure the value has not increased.
-	time.Sleep(200 * time.Millisecond)
-
-	if i != last {
-		t.Error("Counter incremented after stop")
-	}
-}

async/multilock.go

@@ -1,139 +0,0 @@
-/*
-Copyright 2017 Albert Tedja
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package async
-
-import (
-	"runtime"
-	"sort"
-)
-
-var locks = struct {
-	lock chan byte
-	list map[string]chan byte
-}{
-	lock: make(chan byte, 1),
-	list: make(map[string]chan byte),
-}
-
-type Lock struct {
-	keys   []string
-	chans  []chan byte
-	lock   chan byte
-	unlock chan byte
-}
-
-func (lk *Lock) Lock() {
-	lk.lock <- 1
-
-	// get the channels and attempt to acquire them
-	lk.chans = make([]chan byte, 0, len(lk.keys))
-	for i := 0; i < len(lk.keys); {
-		ch := getChan(lk.keys[i])
-		_, ok := <-ch
-		if ok {
-			lk.chans = append(lk.chans, ch)
-			i++
-		}
-	}
-
-	lk.unlock <- 1
-}
-
-// Unlocks this lock. Must be called after Lock.
-// Can only be invoked if there is a previous call to Lock.
-func (lk *Lock) Unlock() {
-	<-lk.unlock
-
-	if lk.chans != nil {
-		for _, ch := range lk.chans {
-			ch <- 1
-		}
-		lk.chans = nil
-	}
-	// Clean unused channels after the unlock.
-	Clean()
-	<-lk.lock
-}
-
-// Temporarily unlocks, gives up the cpu time to other goroutine, and attempts to lock again.
-func (lk *Lock) Yield() {
-	lk.Unlock()
-	runtime.Gosched()
-	lk.Lock()
-}
-
-// Creates a new multilock for the specified keys
-func NewMultilock(locks ...string) *Lock {
-	if len(locks) == 0 {
-		return nil
-	}
-
-	locks = unique(locks)
-	sort.Strings(locks)
-	return &Lock{
-		keys:   locks,
-		lock:   make(chan byte, 1),
-		unlock: make(chan byte, 1),
-	}
-}
-
-// Cleans old unused locks. Returns removed keys.
-func Clean() []string {
-	locks.lock <- 1
-	defer func() { <-locks.lock }()
-
-	toDelete := make([]string, 0, len(locks.list))
-	for key, ch := range locks.list {
-		select {
-		case <-ch:
-			close(ch)
-			toDelete = append(toDelete, key)
-		default:
-		}
-	}
-
-	for _, del := range toDelete {
-		delete(locks.list, del)
-	}
-
-	return toDelete
-}
-
-// Create and get the channel for the specified key.
-func getChan(key string) chan byte {
-	locks.lock <- 1
-	defer func() { <-locks.lock }()
-
-	if locks.list[key] == nil {
-		locks.list[key] = make(chan byte, 1)
-		locks.list[key] <- 1
-	}
-	return locks.list[key]
-}
-
-// Return a new string with unique elements.
-func unique(arr []string) []string {
-	if arr == nil || len(arr) <= 1 {
-		return arr
-	}
-
-	found := map[string]bool{}
-	result := make([]string, 0, len(arr))
-	for _, v := range arr {
-		if !found[v] {
-			found[v] = true
-			result = append(result, v)
-		}
-	}
-	return result
-}

async/multilock_test.go

@@ -1,341 +0,0 @@
-/*
-Copyright 2017 Albert Tedja
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package async
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestUnique(t *testing.T) {
-	var arr []string
-	assert := assert.New(t)
-
-	arr = []string{"a", "b", "c"}
-	assert.Equal(arr, unique(arr))
-
-	arr = []string{"a", "a", "a"}
-	assert.Equal([]string{"a"}, unique(arr))
-
-	arr = []string{"a", "a", "b"}
-	assert.Equal([]string{"a", "b"}, unique(arr))
-
-	arr = []string{"a", "b", "a"}
-	assert.Equal([]string{"a", "b"}, unique(arr))
-
-	arr = []string{"a", "b", "c", "b", "d"}
-	assert.Equal([]string{"a", "b", "c", "d"}, unique(arr))
-}
-
-func TestGetChan(t *testing.T) {
-	ch1 := getChan("a")
-	ch2 := getChan("aa")
-	ch3 := getChan("a")
-
-	assert := assert.New(t)
-	assert.NotEqual(ch1, ch2)
-	assert.Equal(ch1, ch3)
-}
-
-func TestLockUnlock(_ *testing.T) {
-	var wg sync.WaitGroup
-
-	wg.Add(5)
-
-	go func() {
-		lock := NewMultilock("dog", "cat", "owl")
-		lock.Lock()
-		defer lock.Unlock()
-
-		<-time.After(100 * time.Millisecond)
-		wg.Done()
-	}()
-
-	go func() {
-		lock := NewMultilock("cat", "dog", "bird")
-		lock.Lock()
-		defer lock.Unlock()
-
-		<-time.After(100 * time.Millisecond)
-		wg.Done()
-	}()
-
-	go func() {
-		lock := NewMultilock("cat", "bird", "owl")
-		lock.Lock()
-		defer lock.Unlock()
-
-		<-time.After(100 * time.Millisecond)
-		wg.Done()
-	}()
-
-	go func() {
-		lock := NewMultilock("bird", "owl", "snake")
-		lock.Lock()
-		defer lock.Unlock()
-
-		<-time.After(100 * time.Millisecond)
-		wg.Done()
-	}()
-
-	go func() {
-		lock := NewMultilock("owl", "snake")
-		lock.Lock()
-		defer lock.Unlock()
-
-		<-time.After(1 * time.Second)
-		wg.Done()
-	}()
-
-	wg.Wait()
-}
-
-func TestLockUnlock_CleansUnused(t *testing.T) {
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		lock := NewMultilock("dog", "cat", "owl")
-		lock.Lock()
-		assert.Equal(t, 3, len(locks.list))
-		lock.Unlock()
-
-		wg.Done()
-	}()
-	wg.Wait()
-	// We expect that unlocking completely cleared the locks list
-	// given all 3 lock keys were unused at time of unlock.
-	assert.Equal(t, 0, len(locks.list))
-}
-
-func TestLockUnlock_DoesNotCleanIfHeldElsewhere(t *testing.T) {
-	var wg sync.WaitGroup
-	wg.Add(2)
-	go func() {
-		lock := NewMultilock("cat")
-		lock.Lock()
-		// We take 200 milliseconds to release the lock on "cat"
-		<-time.After(200 * time.Millisecond)
-		lock.Unlock()
-		// Assert that at the end of this goroutine, all locks are cleared.
-		assert.Equal(t, 0, len(locks.list))
-		wg.Done()
-	}()
-	go func() {
-		lock := NewMultilock("dog", "cat", "owl")
-		lock.Lock()
-		// We release the locks after 100 milliseconds, and check that "cat" is not
-		// cleared as a lock for it is still held by the previous goroutine.
-		<-time.After(100 * time.Millisecond)
-		lock.Unlock()
-		assert.Equal(t, 1, len(locks.list))
-		_, ok := locks.list["cat"]
-		assert.Equal(t, true, ok)
-		wg.Done()
-	}()
-	wg.Wait()
-	// We expect that at the end of this test, all locks are cleared.
-	assert.Equal(t, 0, len(locks.list))
-}
-
-func TestYield(t *testing.T) {
-	var wg sync.WaitGroup
-
-	wg.Add(2)
-	var resources = map[string]int{}
-
-	go func() {
-		lock := NewMultilock("A", "C")
-		lock.Lock()
-		defer lock.Unlock()
-
-		for resources["ac"] == 0 {
-			lock.Yield()
-		}
-		resources["dc"] = 10
-
-		wg.Done()
-	}()
-
-	go func() {
-		lock := NewMultilock("D", "C")
-		lock.Lock()
-		defer lock.Unlock()
-
-		resources["ac"] = 5
-		for resources["dc"] == 0 {
-			lock.Yield()
-		}
-
-		wg.Done()
-	}()
-
-	wg.Wait()
-
-	assert.Equal(t, 5, resources["ac"])
-	assert.Equal(t, 10, resources["dc"])
-}
-
-func TestClean(t *testing.T) {
-	var wg sync.WaitGroup
-
-	wg.Add(3)
-
-	// some goroutine that holds multiple locks
-	go1done := make(chan bool, 1)
-	go func() {
-	Loop:
-		for {
-			select {
-			case <-go1done:
-				break Loop
-			default:
-				lock := NewMultilock("A", "B", "C", "E", "Z")
-				lock.Lock()
-				<-time.After(30 * time.Millisecond)
-				lock.Unlock()
-			}
-		}
-		wg.Done()
-	}()
-
-	// another goroutine
-	go2done := make(chan bool, 1)
-	go func() {
-	Loop:
-		for {
-			select {
-			case <-go2done:
-				break Loop
-			default:
-				lock := NewMultilock("B", "C", "K", "L", "Z")
-				lock.Lock()
-				<-time.After(200 * time.Millisecond)
-				lock.Unlock()
-			}
-		}
-		wg.Done()
-	}()
-
-	// this one cleans up the locks every 100 ms
-	done := make(chan bool, 1)
-	go func() {
-		c := time.Tick(100 * time.Millisecond)
-	Loop:
-		for {
-			select {
-			case <-done:
-				break Loop
-			case <-c:
-				Clean()
-			}
-		}
-		wg.Done()
-	}()
-
-	<-time.After(2 * time.Second)
-	go1done <- true
-	go2done <- true
-	<-time.After(1 * time.Second)
-	done <- true
-	wg.Wait()
-	assert.Equal(t, []string{}, Clean())
-}
-
-func TestBankAccountProblem(t *testing.T) {
-	var wg sync.WaitGroup
-	wg.Add(3)
-
-	joe := 50.0
-	susan := 100.0
-
-	// withdraw $80 from joe, only if balance is sufficient
-	go func() {
-		lock := NewMultilock("joe")
-		lock.Lock()
-		defer lock.Unlock()
-
-		for joe < 80.0 {
-			lock.Yield()
-		}
-		joe -= 80.0
-
-		wg.Done()
-	}()
-
-	// transfer $200 from susan to joe, only if balance is sufficient
-	go func() {
-		lock := NewMultilock("joe", "susan")
-		lock.Lock()
-		defer lock.Unlock()
-
-		for susan < 200.0 {
-			lock.Yield()
-		}
-
-		susan -= 200.0
-		joe += 200.0
-
-		wg.Done()
-	}()
-
-	// susan deposit $300 to cover balance
-	go func() {
-		lock := NewMultilock("susan")
-		lock.Lock()
-		defer lock.Unlock()
-
-		susan += 300.0
-
-		wg.Done()
-	}()
-
-	wg.Wait()
-	assert.Equal(t, 170.0, joe)
-	assert.Equal(t, 200.0, susan)
-}
-
-func TestSyncCondCompatibility(t *testing.T) {
-	var wg sync.WaitGroup
-	wg.Add(2)
-	cond := sync.NewCond(NewMultilock("A", "C"))
-	var testValues = [3]string{"foo", "bar", "fizz!"}
-	sharedRsc := testValues[0]
-
-	go func() {
-		cond.L.Lock()
-		for sharedRsc == testValues[0] {
-			cond.Wait()
-		}
-		sharedRsc = testValues[2]
-		cond.Broadcast()
-		cond.L.Unlock()
-		wg.Done()
-	}()
-
-	go func() {
-		cond.L.Lock()
-		sharedRsc = testValues[1]
-		cond.Broadcast()
-		for sharedRsc == testValues[1] {
-			cond.Wait()
-		}
-		cond.L.Unlock()
-		wg.Done()
-	}()
-
-	wg.Wait()
-	assert.Equal(t, testValues[2], sharedRsc)
-}

async/scatter.go

@@ -1,77 +0,0 @@
-package async
-
-import (
-	"errors"
-	"runtime"
-	"sync"
-)
-
-// WorkerResults are the results of a scatter worker.
-type WorkerResults struct {
-	Offset int
-	Extent interface{}
-}
-
-// Scatter scatters a computation across multiple goroutines.
-// This breaks the task in to a number of chunks and executes those chunks in parallel with the function provided.
-// Results returned are collected and presented a a set of WorkerResults, which can be reassembled by the calling function.
-// Any error that occurs in the workers will be passed back to the calling function.
-func Scatter(inputLen int, sFunc func(int, int, *sync.RWMutex) (interface{}, error)) ([]*WorkerResults, error) {
-	if inputLen <= 0 {
-		return nil, errors.New("input length must be greater than 0")
-	}
-
-	chunkSize := calculateChunkSize(inputLen)
-	workers := inputLen / chunkSize
-	if inputLen%chunkSize != 0 {
-		workers++
-	}
-	resultCh := make(chan *WorkerResults, workers)
-	defer close(resultCh)
-	errorCh := make(chan error, workers)
-	defer close(errorCh)
-	mutex := new(sync.RWMutex)
-	for worker := 0; worker < workers; worker++ {
-		offset := worker * chunkSize
-		entries := chunkSize
-		if offset+entries > inputLen {
-			entries = inputLen - offset
-		}
-		go func(offset int, entries int) {
-			extent, err := sFunc(offset, entries, mutex)
-			if err != nil {
-				errorCh <- err
-			} else {
-				resultCh <- &WorkerResults{
-					Offset: offset,
-					Extent: extent,
-				}
-			}
-		}(offset, entries)
-	}
-
-	// Collect results from workers
-	results := make([]*WorkerResults, workers)
-	for i := 0; i < workers; i++ {
-		select {
-		case result := <-resultCh:
-			results[i] = result
-		case err := <-errorCh:
-			return nil, err
-		}
-	}
-	return results, nil
-}
-
-// calculateChunkSize calculates a suitable chunk size for the purposes of parallelisation.
-func calculateChunkSize(items int) int {
-	// Start with a simple even split
-	chunkSize := items / runtime.GOMAXPROCS(0)
-
-	// Add 1 if we have leftovers (or if we have fewer items than processors).
-	if chunkSize == 0 || items%chunkSize != 0 {
-		chunkSize++
-	}
-
-	return chunkSize
-}

async/scatter_test.go

@@ -1,108 +0,0 @@
-package async_test
-
-import (
-	"errors"
-	"sync"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/async"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestDouble(t *testing.T) {
-	tests := []struct {
-		name     string
-		inValues int
-		err      error
-	}{
-		{
-			name:     "0",
-			inValues: 0,
-			err:      errors.New("input length must be greater than 0"),
-		},
-		{
-			name:     "1",
-			inValues: 1,
-		},
-		{
-			name:     "1023",
-			inValues: 1023,
-		},
-		{
-			name:     "1024",
-			inValues: 1024,
-		},
-		{
-			name:     "1025",
-			inValues: 1025,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			inValues := make([]int, test.inValues)
-			for i := 0; i < test.inValues; i++ {
-				inValues[i] = i
-			}
-			outValues := make([]int, test.inValues)
-			workerResults, err := async.Scatter(len(inValues), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
-				extent := make([]int, entries)
-				for i := 0; i < entries; i++ {
-					extent[i] = inValues[offset+i] * 2
-				}
-				return extent, nil
-			})
-			if test.err != nil {
-				assert.ErrorContains(t, test.err.Error(), err)
-			} else {
-				require.NoError(t, err)
-				for _, result := range workerResults {
-					copy(outValues[result.Offset:], result.Extent.([]int))
-				}
-
-				for i := 0; i < test.inValues; i++ {
-					require.Equal(t, inValues[i]*2, outValues[i], "Outvalue at %d mismatch", i)
-				}
-			}
-		})
-	}
-}
-
-func TestMutex(t *testing.T) {
-	totalRuns := 1048576
-	val := 0
-	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
-		for i := 0; i < entries; i++ {
-			mu.Lock()
-			val++
-			mu.Unlock()
-		}
-		return nil, nil
-	})
-	require.NoError(t, err)
-
-	if val != totalRuns {
-		t.Fatalf("Unexpected value: expected \"%v\", found \"%v\"", totalRuns, val)
-	}
-}
-
-func TestError(t *testing.T) {
-	totalRuns := 1024
-	val := 0
-	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
-		for i := 0; i < entries; i++ {
-			mu.Lock()
-			val++
-			if val == 1011 {
-				mu.Unlock()
-				return nil, errors.New("bad number")
-			}
-			mu.Unlock()
-		}
-		return nil, nil
-	})
-	if err == nil {
-		t.Fatalf("Missing expected error")
-	}
-}

bazel.sh

@@ -1,11 +0,0 @@
-#!/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,19 +1,84 @@
-load("//tools:target_migration.bzl", "moved_targets")
+load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library", "go_test")
+load("@io_bazel_rules_docker//go:image.bzl", "go_image")
+load("@io_bazel_rules_docker//container:container.bzl", "container_push")
 
-moved_targets(
-    [
-        ":push_images_debug",
-        ":push_images_alpine",
-        ":push_images",
-        ":image_bundle_debug",
-        ":image_debug",
-        ":image_bundle_alpine",
-        ":image_bundle",
-        ":image_with_creation_time",
-        ":image_alpine",
-        ":image",
-        ":go_default_test",
-        ":beacon-chain",
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "main.go",
+        "usage.go",
+    ],
+    data = [
+        "//proto/beacon/rpc/v1:swagger",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain",
+    visibility = ["//beacon-chain:__subpackages__"],
+    deps = [
+        "//beacon-chain/node:go_default_library",
+        "//beacon-chain/utils:go_default_library",
+        "//shared/cmd:go_default_library",
+        "//shared/debug:go_default_library",
+        "//shared/featureconfig:go_default_library",
+        "//shared/logutil:go_default_library",
+        "//shared/version: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_x_cray_logrus_prefixed_formatter//:go_default_library",
+        "@org_uber_go_automaxprocs//:go_default_library",
     ],
-    "//cmd/beacon-chain",
+)
+
+go_image(
+    name = "image",
+    srcs = [
+        "main.go",
+        "usage.go",
+    ],
+    goarch = "amd64",
+    goos = "linux",
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain",
+    race = "off",
+    static = "off",  # Static enabled binary seems to cause issues with DNS lookup with cgo.
+    tags = ["manual"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//beacon-chain/node:go_default_library",
+        "//beacon-chain/utils:go_default_library",
+        "//shared/cmd:go_default_library",
+        "//shared/debug:go_default_library",
+        "//shared/featureconfig:go_default_library",
+        "//shared/logutil:go_default_library",
+        "//shared/version: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_x_cray_logrus_prefixed_formatter//:go_default_library",
+        "@org_uber_go_automaxprocs//:go_default_library",
+    ],
+)
+
+container_push(
+    name = "push_image",
+    format = "Docker",
+    image = ":image",
+    registry = "gcr.io",
+    repository = "prysmaticlabs/prysm/beacon-chain",
+    tag = "{DOCKER_TAG}",
+    tags = ["manual"],
+    visibility = ["//visibility:private"],
+)
+
+go_binary(
+    name = "beacon-chain",
+    embed = [":go_default_library"],
+    visibility = ["//beacon-chain:__subpackages__"],
+)
+
+go_test(
+    name = "go_default_test",
+    size = "small",
+    srcs = ["usage_test.go"],
+    embed = [":go_default_library"],
+    deps = ["@com_github_urfave_cli//:go_default_library"],
 )

beacon-chain/README.md

@@ -1,9 +1,10 @@
 # Prysmatic Labs Beacon Chain Implementation
 
-This is the main project folder for the beacon chain implementation of Ethereum written in Go by [Prysmatic Labs](https://prysmaticlabs.com).
+This is the main project folder for the beacon chain implementation of Ethereum Serenity in Golang by [Prysmatic Labs](https://prysmaticlabs.com). Before you begin, check out our [Contribution Guidelines](https://github.com/prysmaticlabs/prysm/blob/master/CONTRIBUTING.md) and join our active chat room on Discord or Gitter below:
 
-You can also read our main [README](https://github.com/prysmaticlabs/prysm/blob/master/README.md) and join our active chat room on Discord.
+[![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)
 
-[![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
-
-Also, read the official beacon chain [specification](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/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/core/0_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/attestation/BUILD.bazel

@@ -0,0 +1,42 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "service.go",
+        "vote_metrics.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/attestation",
+    visibility = ["//beacon-chain:__subpackages__"],
+    deps = [
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/db:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/event:go_default_library",
+        "//shared/messagehandler:go_default_library",
+        "//shared/params:go_default_library",
+        "@com_github_gogo_protobuf//proto:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    size = "small",
+    srcs = ["service_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//beacon-chain/internal:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+    ],
+)

beacon-chain/attestation/service.go

@@ -0,0 +1,292 @@
+// Package attestation defines the life-cycle and status of single and aggregated attestation.
+package attestation
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/event"
+	handler "github.com/prysmaticlabs/prysm/shared/messagehandler"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/sirupsen/logrus"
+)
+
+var log = logrus.WithField("prefix", "attestation")
+
+// TargetHandler provides an interface for fetching latest attestation targets
+// and updating attestations in batches.
+type TargetHandler interface {
+	LatestAttestationTarget(state *pb.BeaconState, validatorIndex uint64) (*pb.AttestationTarget, error)
+	BatchUpdateLatestAttestation(ctx context.Context, atts []*pb.Attestation) error
+}
+
+type attestationStore struct {
+	sync.RWMutex
+	m map[[48]byte]*pb.Attestation
+}
+
+// Service represents a service that handles the internal
+// logic of managing single and aggregated attestation.
+type Service struct {
+	ctx          context.Context
+	cancel       context.CancelFunc
+	beaconDB     *db.BeaconDB
+	incomingFeed *event.Feed
+	incomingChan chan *pb.Attestation
+	// store is the mapping of individual
+	// validator's public key to it's latest attestation.
+	store              attestationStore
+	pooledAttestations []*pb.Attestation
+	poolLimit          int
+}
+
+// Config options for the service.
+type Config struct {
+	BeaconDB *db.BeaconDB
+}
+
+// NewAttestationService instantiates a new service instance that will
+// be registered into a running beacon node.
+func NewAttestationService(ctx context.Context, cfg *Config) *Service {
+	ctx, cancel := context.WithCancel(ctx)
+	return &Service{
+		ctx:                ctx,
+		cancel:             cancel,
+		beaconDB:           cfg.BeaconDB,
+		incomingFeed:       new(event.Feed),
+		incomingChan:       make(chan *pb.Attestation, params.BeaconConfig().DefaultBufferSize),
+		store:              attestationStore{m: make(map[[48]byte]*pb.Attestation)},
+		pooledAttestations: make([]*pb.Attestation, 0, 1),
+		poolLimit:          1,
+	}
+}
+
+// Start an attestation service's main event loop.
+func (a *Service) Start() {
+	log.Info("Starting service")
+	go a.attestationPool()
+}
+
+// Stop the Attestation service's main event loop and associated goroutines.
+func (a *Service) Stop() error {
+	defer a.cancel()
+	log.Info("Stopping service")
+	return nil
+}
+
+// Status always returns nil.
+// TODO(#1201): Add service health checks.
+func (a *Service) Status() error {
+	return nil
+}
+
+// IncomingAttestationFeed returns a feed that any service can send incoming p2p attestations into.
+// The attestation service will subscribe to this feed in order to relay incoming attestations.
+func (a *Service) IncomingAttestationFeed() *event.Feed {
+	return a.incomingFeed
+}
+
+// LatestAttestationTarget returns the target block that the validator index attested to,
+// the highest slotNumber attestation in attestation pool gets returned.
+//
+// Spec pseudocode definition:
+//	Let `get_latest_attestation_target(store: Store, validator_index: ValidatorIndex) ->
+//		BeaconBlock` be the target block in the attestation
+//		`get_latest_attestation(store, validator_index)`.
+func (a *Service) LatestAttestationTarget(beaconState *pb.BeaconState, index uint64) (*pb.AttestationTarget, error) {
+	if index >= uint64(len(beaconState.Validators)) {
+		return nil, fmt.Errorf("invalid validator index %d", index)
+	}
+	validator := beaconState.Validators[index]
+
+	pubKey := bytesutil.ToBytes48(validator.Pubkey)
+	a.store.RLock()
+	defer a.store.RUnlock()
+	if _, exists := a.store.m[pubKey]; !exists {
+		return nil, nil
+	}
+
+	attestation := a.store.m[pubKey]
+	if attestation == nil {
+		return nil, nil
+	}
+	targetRoot := bytesutil.ToBytes32(attestation.Data.BeaconBlockRoot)
+	if !a.beaconDB.HasBlock(targetRoot) {
+		return nil, nil
+	}
+
+	return a.beaconDB.AttestationTarget(targetRoot)
+}
+
+// attestationPool takes an newly received attestation from sync service
+// and updates attestation pool.
+func (a *Service) attestationPool() {
+	incomingSub := a.incomingFeed.Subscribe(a.incomingChan)
+	defer incomingSub.Unsubscribe()
+	for {
+		select {
+		case <-a.ctx.Done():
+			log.Debug("Attestation pool closed, exiting goroutine")
+			return
+		// Listen for a newly received incoming attestation from the sync service.
+		case attestations := <-a.incomingChan:
+			handler.SafelyHandleMessage(a.ctx, a.handleAttestation, attestations)
+		}
+	}
+}
+
+func (a *Service) handleAttestation(ctx context.Context, msg proto.Message) error {
+	attestation := msg.(*pb.Attestation)
+	a.pooledAttestations = append(a.pooledAttestations, attestation)
+	if len(a.pooledAttestations) > a.poolLimit {
+		if err := a.BatchUpdateLatestAttestation(ctx, a.pooledAttestations); err != nil {
+			return err
+		}
+		state, err := a.beaconDB.HeadState(ctx)
+		if err != nil {
+			return err
+		}
+
+		// This sets the pool limit, once the old pool is cleared out. It does by using the number of active
+		// validators per slot as an estimate. The active indices here are not used in the actual processing
+		// of attestations.
+		count, err := helpers.ActiveValidatorCount(state, helpers.CurrentEpoch(state))
+		if err != nil {
+			return err
+		}
+		attPerSlot := count / params.BeaconConfig().SlotsPerEpoch
+		// we only set the limit at 70% of the calculated amount to be safe so that relevant attestations
+		// arent carried over to the next batch.
+		a.poolLimit = int(attPerSlot) * 7 / 10
+		if a.poolLimit == 0 {
+			a.poolLimit++
+		}
+		attestationPoolLimit.Set(float64(a.poolLimit))
+		a.pooledAttestations = make([]*pb.Attestation, 0, a.poolLimit)
+	}
+	attestationPoolSize.Set(float64(len(a.pooledAttestations)))
+	return nil
+}
+
+// UpdateLatestAttestation inputs an new attestation and checks whether
+// the attesters who submitted this attestation with the higher slot number
+// have been noted in the attestation pool. If not, it updates the
+// attestation pool with attester's public key to attestation.
+func (a *Service) UpdateLatestAttestation(ctx context.Context, attestation *pb.Attestation) error {
+	totalAttestationSeen.Inc()
+
+	// Potential improvement, instead of getting the state,
+	// we could get a mapping of validator index to public key.
+	beaconState, err := a.beaconDB.HeadState(ctx)
+	if err != nil {
+		return err
+	}
+	return a.updateAttestation(beaconState, attestation)
+}
+
+// BatchUpdateLatestAttestation updates multiple attestations and adds them into the attestation store
+// if they are valid.
+func (a *Service) BatchUpdateLatestAttestation(ctx context.Context, attestations []*pb.Attestation) error {
+
+	if attestations == nil {
+		return nil
+	}
+	// Potential improvement, instead of getting the state,
+	// we could get a mapping of validator index to public key.
+	beaconState, err := a.beaconDB.HeadState(ctx)
+	if err != nil {
+		return err
+	}
+
+	for _, attestation := range attestations {
+		if err := a.updateAttestation(beaconState, attestation); err != nil {
+			log.Error(err)
+		}
+	}
+	return nil
+}
+
+// InsertAttestationIntoStore locks the store, inserts the attestation, then
+// unlocks the store again. This method may be used by external services
+// in testing to populate the attestation store.
+func (a *Service) InsertAttestationIntoStore(pubkey [48]byte, att *pb.Attestation) {
+	a.store.Lock()
+	defer a.store.Unlock()
+	a.store.m[pubkey] = att
+}
+
+func (a *Service) updateAttestation(beaconState *pb.BeaconState, attestation *pb.Attestation) error {
+	totalAttestationSeen.Inc()
+
+	committee, err := helpers.CrosslinkCommittee(beaconState, helpers.CurrentEpoch(beaconState), attestation.Data.Crosslink.Shard)
+	if err != nil {
+		return err
+	}
+	slot, err := helpers.AttestationDataSlot(beaconState, attestation.Data)
+	if err != nil {
+		return fmt.Errorf("could not get attestation slot: %v", err)
+	}
+	log.WithFields(logrus.Fields{
+		"attestationSlot":    slot,
+		"attestationShard":   attestation.Data.Crosslink.Shard,
+		"committeesList":     committee,
+		"lengthOfCommittees": len(committee),
+	}).Debug("Updating latest attestation")
+
+	// Check each bit of participation bitfield to find out which
+	// attester has submitted new attestation.
+	// This is has O(n) run time and could be optimized down the line.
+	for i := uint64(0); i < attestation.AggregationBits.Len(); i++ {
+		if !attestation.AggregationBits.BitAt(i) {
+			continue
+		}
+
+		if i >= uint64(len(committee)) {
+			// This should never happen.
+			log.Warnf("bitfield points to an invalid index in the committee: bitfield %08b", attestation.AggregationBits)
+			return nil
+		}
+
+		if int(committee[i]) >= len(beaconState.Validators) {
+			// This should never happen.
+			log.Warnf("index doesn't exist in validator registry: index %d", committee[i])
+			return nil
+		}
+
+		// If the attestation came from this attester. We use the slot committee to find the
+		// validator's actual index.
+		pubkey := bytesutil.ToBytes48(beaconState.Validators[committee[i]].Pubkey)
+		newAttestationSlot := slot
+		currentAttestationSlot := uint64(0)
+		a.store.Lock()
+		defer a.store.Unlock()
+		if _, exists := a.store.m[pubkey]; exists {
+			currentAttestationSlot = slot
+		}
+		// If the attestation is newer than this attester's one in pool.
+		if newAttestationSlot > currentAttestationSlot {
+			a.store.m[pubkey] = attestation
+
+			log.WithFields(
+				logrus.Fields{
+					"attestationSlot": slot,
+					"sourceEpoch":     attestation.Data.Source.Epoch,
+				},
+			).Debug("Attestation store updated")
+
+			blockRoot := bytesutil.ToBytes32(attestation.Data.BeaconBlockRoot)
+			votedBlock, err := a.beaconDB.Block(blockRoot)
+			if err != nil {
+				return err
+			}
+			reportVoteMetrics(committee[i], votedBlock)
+		}
+	}
+	return nil
+}

beacon-chain/attestation/service_test.go

@@ -0,0 +1,370 @@
+package attestation
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/go-ssz"
+	"github.com/prysmaticlabs/prysm/beacon-chain/internal"
+	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/sirupsen/logrus"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+)
+
+func init() {
+	logrus.SetLevel(logrus.DebugLevel)
+}
+
+var _ = TargetHandler(&Service{})
+
+func TestUpdateLatestAttestation_UpdatesLatest(t *testing.T) {
+	beaconDB := internal.SetupDB(t)
+	defer internal.TeardownDB(t, beaconDB)
+	ctx := context.Background()
+
+	var validators []*pb.Validator
+	for i := 0; i < 64; i++ {
+		validators = append(validators, &pb.Validator{
+			Pubkey:          []byte{byte(i)},
+			ActivationEpoch: 0,
+			ExitEpoch:       10,
+		})
+	}
+
+	beaconState := &pb.BeaconState{
+		Slot:             1,
+		Validators:       validators,
+		RandaoMixes:      make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	}
+	block := &pb.BeaconBlock{
+		Slot: 1,
+	}
+	if err := beaconDB.SaveBlock(block); err != nil {
+		t.Fatal(err)
+	}
+	if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
+		t.Fatal(err)
+	}
+	service := NewAttestationService(context.Background(), &Config{BeaconDB: beaconDB})
+
+	attestation := &pb.Attestation{
+		AggregationBits: bitfield.Bitlist{0x03},
+		Data: &pb.AttestationData{
+			Crosslink: &pb.Crosslink{
+				Shard: 1,
+			},
+			Target: &pb.Checkpoint{},
+			Source: &pb.Checkpoint{},
+		},
+	}
+
+	if err := service.UpdateLatestAttestation(ctx, attestation); err != nil {
+		t.Fatalf("could not update latest attestation: %v", err)
+	}
+	pubkey := bytesutil.ToBytes48(beaconState.Validators[10].Pubkey)
+	if service.store.m[pubkey].Data.Crosslink.Shard !=
+		attestation.Data.Crosslink.Shard {
+		t.Errorf("Incorrect shard stored, wanted: %d, got: %d",
+			attestation.Data.Crosslink.Shard, service.store.m[pubkey].Data.Crosslink.Shard)
+	}
+
+	beaconState = &pb.BeaconState{
+		Slot:             36,
+		Validators:       validators,
+		RandaoMixes:      make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	}
+	if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
+		t.Fatalf("could not save state: %v", err)
+	}
+
+	attestation.Data.Crosslink.Shard = 36
+	if err := service.UpdateLatestAttestation(ctx, attestation); err != nil {
+		t.Fatalf("could not update latest attestation: %v", err)
+	}
+	if service.store.m[pubkey].Data.Crosslink.Shard !=
+		attestation.Data.Crosslink.Shard {
+		t.Errorf("Incorrect shard stored, wanted: %d, got: %d",
+			attestation.Data.Crosslink.Shard, service.store.m[pubkey].Data.Crosslink.Shard)
+	}
+}
+
+func TestAttestationPool_UpdatesAttestationPool(t *testing.T) {
+	beaconDB := internal.SetupDB(t)
+	defer internal.TeardownDB(t, beaconDB)
+	ctx := context.Background()
+
+	var validators []*pb.Validator
+	for i := 0; i < 64; i++ {
+		validators = append(validators, &pb.Validator{
+			Pubkey:          []byte{byte(i)},
+			ActivationEpoch: 0,
+			ExitEpoch:       10,
+		})
+	}
+	beaconState := &pb.BeaconState{
+		Slot:       1,
+		Validators: validators,
+	}
+	block := &pb.BeaconBlock{
+		Slot: 1,
+	}
+	if err := beaconDB.SaveBlock(block); err != nil {
+		t.Fatal(err)
+	}
+	if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
+		t.Fatal(err)
+	}
+
+	service := NewAttestationService(context.Background(), &Config{BeaconDB: beaconDB})
+	attestation := &pb.Attestation{
+		AggregationBits: bitfield.Bitlist{0x80, 0x01},
+		Data: &pb.AttestationData{
+			Crosslink: &pb.Crosslink{
+				Shard: 1,
+			},
+		},
+	}
+
+	if err := service.handleAttestation(context.Background(), attestation); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestLatestAttestationTarget_CantGetAttestation(t *testing.T) {
+	beaconDB := internal.SetupDB(t)
+	defer internal.TeardownDB(t, beaconDB)
+	ctx := context.Background()
+
+	if err := beaconDB.SaveState(ctx, &pb.BeaconState{
+		Validators: []*pb.Validator{{}},
+	}); err != nil {
+		t.Fatalf("could not save state: %v", err)
+	}
+	service := NewAttestationService(context.Background(), &Config{BeaconDB: beaconDB})
+	headState, err := beaconDB.HeadState(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	index := uint64(100)
+	want := fmt.Sprintf("invalid validator index %d", index)
+	if _, err := service.LatestAttestationTarget(headState, index); !strings.Contains(err.Error(), want) {
+		t.Errorf("Wanted error to contain %s, received %v", want, err)
+	}
+}
+
+func TestLatestAttestationTarget_ReturnsLatestAttestedBlock(t *testing.T) {
+	beaconDB := internal.SetupDB(t)
+	defer internal.TeardownDB(t, beaconDB)
+	ctx := context.Background()
+
+	pubKey := []byte{'A'}
+	if err := beaconDB.SaveState(ctx, &pb.BeaconState{
+		Validators: []*pb.Validator{{Pubkey: pubKey}},
+	}); err != nil {
+		t.Fatalf("could not save state: %v", err)
+	}
+
+	block := &pb.BeaconBlock{Slot: 999}
+	if err := beaconDB.SaveBlock(block); err != nil {
+		t.Fatalf("could not save block: %v", err)
+	}
+	blockRoot, err := ssz.SigningRoot(block)
+	if err != nil {
+		log.Fatalf("could not hash block: %v", err)
+	}
+	if err := beaconDB.SaveAttestationTarget(ctx, &pb.AttestationTarget{
+		Slot:       block.Slot,
+		BlockRoot:  blockRoot[:],
+		ParentRoot: []byte{},
+	}); err != nil {
+		log.Fatalf("could not save att target: %v", err)
+	}
+
+	service := NewAttestationService(context.Background(), &Config{BeaconDB: beaconDB})
+
+	attestation := &pb.Attestation{
+		Data: &pb.AttestationData{
+			BeaconBlockRoot: blockRoot[:],
+		}}
+	pubKey48 := bytesutil.ToBytes48(pubKey)
+	service.store.m[pubKey48] = attestation
+
+	headState, err := beaconDB.HeadState(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	latestAttestedTarget, err := service.LatestAttestationTarget(headState, 0)
+	if err != nil {
+		t.Fatalf("Could not get latest attestation: %v", err)
+	}
+
+	if !bytes.Equal(blockRoot[:], latestAttestedTarget.BlockRoot) {
+		t.Errorf("Wanted: %v, got: %v", blockRoot[:], latestAttestedTarget.BlockRoot)
+	}
+}
+
+func TestUpdateLatestAttestation_InvalidIndex(t *testing.T) {
+	beaconDB := internal.SetupDB(t)
+	hook := logTest.NewGlobal()
+	defer internal.TeardownDB(t, beaconDB)
+	ctx := context.Background()
+
+	var validators []*pb.Validator
+	for i := 0; i < 64; i++ {
+		validators = append(validators, &pb.Validator{
+			Pubkey:          []byte{byte(i)},
+			ActivationEpoch: 0,
+			ExitEpoch:       10,
+		})
+	}
+
+	beaconState := &pb.BeaconState{
+		Slot:             1,
+		RandaoMixes:      make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		Validators:       validators,
+	}
+	block := &pb.BeaconBlock{
+		Slot: 1,
+	}
+	if err := beaconDB.SaveBlock(block); err != nil {
+		t.Fatal(err)
+	}
+	if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
+		t.Fatal(err)
+	}
+	service := NewAttestationService(context.Background(), &Config{BeaconDB: beaconDB})
+	attestation := &pb.Attestation{
+		AggregationBits: bitfield.Bitlist{0xC0, 0x01},
+		Data: &pb.AttestationData{
+			Crosslink: &pb.Crosslink{
+				Shard: 1,
+			},
+			Target: &pb.Checkpoint{},
+			Source: &pb.Checkpoint{},
+		},
+	}
+
+	wanted := "bitfield points to an invalid index in the committee"
+
+	if err := service.UpdateLatestAttestation(ctx, attestation); err != nil {
+		t.Error(err)
+	}
+
+	testutil.AssertLogsContain(t, hook, wanted)
+}
+
+func TestBatchUpdate_FromSync(t *testing.T) {
+	beaconDB := internal.SetupDB(t)
+	defer internal.TeardownDB(t, beaconDB)
+	ctx := context.Background()
+
+	var validators []*pb.Validator
+	var latestRandaoMixes [][]byte
+	var latestActiveIndexRoots [][]byte
+	for i := 0; i < 64; i++ {
+		validators = append(validators, &pb.Validator{
+			Pubkey:          []byte{byte(i)},
+			ActivationEpoch: 0,
+			ExitEpoch:       10,
+		})
+		latestRandaoMixes = append(latestRandaoMixes, []byte{'A'})
+		latestActiveIndexRoots = append(latestActiveIndexRoots, []byte{'B'})
+	}
+
+	beaconState := &pb.BeaconState{
+		Slot:             1,
+		Validators:       validators,
+		RandaoMixes:      latestRandaoMixes,
+		ActiveIndexRoots: latestActiveIndexRoots,
+	}
+	block := &pb.BeaconBlock{
+		Slot: 1,
+	}
+	if err := beaconDB.SaveBlock(block); err != nil {
+		t.Fatal(err)
+	}
+	if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
+		t.Fatal(err)
+	}
+	service := NewAttestationService(context.Background(), &Config{BeaconDB: beaconDB})
+	service.poolLimit = 9
+	for i := 0; i < 10; i++ {
+		attestation := &pb.Attestation{
+			AggregationBits: bitfield.Bitlist{0x80},
+			Data: &pb.AttestationData{
+				Target: &pb.Checkpoint{Epoch: 2},
+				Source: &pb.Checkpoint{},
+				Crosslink: &pb.Crosslink{
+					Shard: 1,
+				},
+			},
+		}
+		if err := service.handleAttestation(ctx, attestation); err != nil {
+			t.Fatalf("could not update latest attestation: %v", err)
+		}
+	}
+	if len(service.pooledAttestations) != 0 {
+		t.Errorf("pooled attestations were not cleared out, still %d attestations in pool", len(service.pooledAttestations))
+	}
+}
+
+func TestUpdateLatestAttestation_BatchUpdate(t *testing.T) {
+	beaconDB := internal.SetupDB(t)
+	defer internal.TeardownDB(t, beaconDB)
+	ctx := context.Background()
+
+	var validators []*pb.Validator
+	for i := 0; i < 64; i++ {
+		validators = append(validators, &pb.Validator{
+			Pubkey:          []byte{byte(i)},
+			ActivationEpoch: 0,
+			ExitEpoch:       10,
+		})
+	}
+
+	beaconState := &pb.BeaconState{
+		Slot:             1,
+		RandaoMixes:      make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		Validators:       validators,
+	}
+	block := &pb.BeaconBlock{
+		Slot: 1,
+	}
+	if err := beaconDB.SaveBlock(block); err != nil {
+		t.Fatal(err)
+	}
+	if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
+		t.Fatal(err)
+	}
+	service := NewAttestationService(context.Background(), &Config{BeaconDB: beaconDB})
+	attestations := make([]*pb.Attestation, 0)
+	for i := 0; i < 10; i++ {
+		attestations = append(attestations, &pb.Attestation{
+			AggregationBits: bitfield.Bitlist{0x80, 0x01},
+			Data: &pb.AttestationData{
+				Crosslink: &pb.Crosslink{
+					Shard: 1,
+				},
+				Target: &pb.Checkpoint{},
+				Source: &pb.Checkpoint{},
+			},
+		})
+	}
+
+	if err := service.BatchUpdateLatestAttestation(ctx, attestations); err != nil {
+		t.Fatalf("could not update latest attestation: %v", err)
+	}
+}

beacon-chain/attestation/vote_metrics.go

@@ -0,0 +1,41 @@
+package attestation
+
+import (
+	"strconv"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+)
+
+var (
+	validatorLastVoteGauge = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "validators_last_vote",
+		Help: "Votes of validators, updated when there's a new attestation",
+	}, []string{
+		"validatorIndex",
+	})
+	totalAttestationSeen = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "total_seen_attestations",
+		Help: "Total number of attestations seen by the validators",
+	})
+
+	attestationPoolLimit = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "attestation_pool_limit",
+		Help: "The limit of the attestation pool",
+	})
+	attestationPoolSize = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "attestation_pool_size",
+		Help: "The current size of the attestation pool",
+	})
+)
+
+func reportVoteMetrics(index uint64, block *pb.BeaconBlock) {
+	// Don't update vote metrics if the incoming block is nil.
+	if block == nil {
+		return
+	}
+
+	validatorLastVoteGauge.WithLabelValues(
+		"v" + strconv.Itoa(int(index))).Set(float64(block.Slot))
+}

beacon-chain/blockchain/BUILD.bazel

@@ -1,204 +1,74 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
     srcs = [
-        "chain_info.go",
-        "error.go",
-        "head.go",
-        "head_sync_committee_info.go",
-        "init_sync_process_block.go",
-        "log.go",
-        "metrics.go",
-        "new_slot.go",
-        "optimistic_sync.go",
-        "options.go",
-        "pow_block.go",
-        "process_attestation.go",
-        "process_attestation_helpers.go",
-        "process_block.go",
-        "process_block_helpers.go",
-        "receive_attestation.go",
-        "receive_block.go",
+        "block_processing.go",
+        "fork_choice.go",
         "service.go",
-        "state_balance_cache.go",
-        "weak_subjectivity_checks.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain",
-    visibility = [
-        "//beacon-chain:__subpackages__",
-        "//cmd/beacon-chain:__subpackages__",
-        "//testing/slasher/simulator:__pkg__",
-        "//testing/spectest:__subpackages__",
-    ],
+    visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//async:go_default_library",
-        "//async/event:go_default_library",
-        "//beacon-chain/blockchain/store:go_default_library",
+        "//beacon-chain/attestation:go_default_library",
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/cache/depositcache:go_default_library",
-        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks: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/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/core/state:go_default_library",
+        "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/db:go_default_library",
-        "//beacon-chain/db/filters:go_default_library",
-        "//beacon-chain/db/kv:go_default_library",
-        "//beacon-chain/forkchoice:go_default_library",
-        "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
-        "//beacon-chain/forkchoice/protoarray:go_default_library",
-        "//beacon-chain/forkchoice/types: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/operations:go_default_library",
         "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/stategen:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
-        "//config/features:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
-        "//monitoring/tracing:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/eth/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
-        "//proto/prysm/v1alpha1/block:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_holiman_uint256//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/event:go_default_library",
+        "//shared/featureconfig:go_default_library",
+        "//shared/p2p:go_default_library",
+        "@com_github_gogo_protobuf//proto: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_eth2_types//: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",
     ],
 )
 
-test_suite(
-    name = "go_default_test",
-    tests = [
-        ":go_raceoff_test",
-        ":go_raceon_test",
-    ],
-)
-
 go_test(
-    name = "go_raceoff_test",
+    name = "go_default_test",
     size = "medium",
     srcs = [
-        "blockchain_test.go",
-        "chain_info_test.go",
-        "checktags_test.go",
-        "head_sync_committee_info_test.go",
-        "head_test.go",
-        "init_test.go",
-        "log_test.go",
-        "metrics_test.go",
-        "mock_test.go",
-        "optimistic_sync_test.go",
-        "pow_block_test.go",
-        "process_attestation_test.go",
-        "process_block_test.go",
-        "receive_attestation_test.go",
-        "receive_block_test.go",
+        "block_processing_test.go",
+        "fork_choice_reorg_test.go",
+        "fork_choice_test.go",
         "service_test.go",
-        "weak_subjectivity_checks_test.go",
     ],
     embed = [":go_default_library"],
-    gotags = ["develop"],
     deps = [
-        "//async/event:go_default_library",
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/cache/depositcache:go_default_library",
+        "//beacon-chain/attestation:go_default_library",
+        "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/core/state:go_default_library",
+        "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/db:go_default_library",
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/internal:go_default_library",
         "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/powchain/testing:go_default_library",
-        "//beacon-chain/state/stateutil:go_default_library",
-        "//beacon-chain/state/v1:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//shared/bls:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/event:go_default_library",
+        "//shared/featureconfig:go_default_library",
+        "//shared/hashutil:go_default_library",
+        "//shared/p2p:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
+        "//shared/trieutil: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",
+        "@com_github_gogo_protobuf//proto:go_default_library",
+        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_x_net//context:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_raceon_test",
-    srcs = [
-        "chain_info_norace_test.go",
-        "checktags_test.go",
-        "init_test.go",
-        "mock_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",
-    ],
-    gotags = ["develop"],
-    race = "on",
-    tags = ["race_on"],
-    deps = [
-        "//async/event:go_default_library",
-        "//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",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/db:go_default_library",
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/p2p:go_default_library",
-        "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/powchain/testing:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util: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",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_x_net//context:go_default_library",
     ],
 )

beacon-chain/blockchain/block_processing.go

@@ -0,0 +1,310 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/prysmaticlabs/go-ssz"
+	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
+	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/featureconfig"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+)
+
+// BlockReceiver interface defines the methods in the blockchain service which
+// directly receives a new block from other services and applies the full processing pipeline.
+type BlockReceiver interface {
+	CanonicalBlockFeed() *event.Feed
+	ReceiveBlock(ctx context.Context, block *pb.BeaconBlock) (*pb.BeaconState, error)
+	IsCanonical(slot uint64, hash []byte) bool
+	UpdateCanonicalRoots(block *pb.BeaconBlock, root [32]byte)
+}
+
+// BlockProcessor defines a common interface for methods useful for directly applying state transitions
+// to beacon blocks and generating a new beacon state from the Ethereum 2.0 core primitives.
+type BlockProcessor interface {
+	VerifyBlockValidity(ctx context.Context, block *pb.BeaconBlock, beaconState *pb.BeaconState) error
+	AdvanceState(ctx context.Context, beaconState *pb.BeaconState, block *pb.BeaconBlock) (*pb.BeaconState, error)
+	CleanupBlockOperations(ctx context.Context, block *pb.BeaconBlock) error
+}
+
+// BlockFailedProcessingErr represents a block failing a state transition function.
+type BlockFailedProcessingErr struct {
+	err error
+}
+
+func (b *BlockFailedProcessingErr) Error() string {
+	return fmt.Sprintf("block failed processing: %v", b.err)
+}
+
+// ReceiveBlock is a function that defines the operations that are preformed on
+// any block that is received from p2p layer or rpc. It performs the following actions: It checks the block to see
+// 1. Verify a block passes pre-processing conditions
+// 2. Save and broadcast the block via p2p to other peers
+// 3. Apply the block state transition function and account for skip slots.
+// 4. Process and cleanup any block operations, such as attestations and deposits, which would need to be
+//    either included or flushed from the beacon node's runtime.
+func (c *ChainService) ReceiveBlock(ctx context.Context, block *pb.BeaconBlock) (*pb.BeaconState, error) {
+	c.receiveBlockLock.Lock()
+	defer c.receiveBlockLock.Unlock()
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlock")
+	defer span.End()
+	parentRoot := bytesutil.ToBytes32(block.ParentRoot)
+	parent, err := c.beaconDB.Block(parentRoot)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get parent block: %v", err)
+	}
+	if parent == nil {
+		return nil, errors.New("parent does not exist in DB")
+	}
+	beaconState, err := c.beaconDB.HistoricalStateFromSlot(ctx, parent.Slot, parentRoot)
+	if err != nil {
+		return nil, fmt.Errorf("could not retrieve beacon state: %v", err)
+	}
+
+	blockRoot, err := ssz.SigningRoot(block)
+	if err != nil {
+		return nil, fmt.Errorf("could not hash beacon block")
+	}
+	// We first verify the block's basic validity conditions.
+	if err := c.VerifyBlockValidity(ctx, block, beaconState); err != nil {
+		return beaconState, fmt.Errorf("block with slot %d is not ready for processing: %v", block.Slot, err)
+	}
+
+	// We save the block to the DB and broadcast it to our peers.
+	if err := c.SaveAndBroadcastBlock(ctx, block); err != nil {
+		return beaconState, fmt.Errorf(
+			"could not save and broadcast beacon block with slot %d: %v",
+			block.Slot, err,
+		)
+	}
+
+	log.WithField("slotNumber", block.Slot).Info(
+		"Executing state transition")
+
+	// We then apply the block state transition accordingly to obtain the resulting beacon state.
+	beaconState, err = c.AdvanceState(ctx, beaconState, block)
+	if err != nil {
+		switch err.(type) {
+		case *BlockFailedProcessingErr:
+			// If the block fails processing, we mark it as blacklisted and delete it from our DB.
+			c.beaconDB.MarkEvilBlockHash(blockRoot)
+			if err := c.beaconDB.DeleteBlock(block); err != nil {
+				return nil, fmt.Errorf("could not delete bad block from db: %v", err)
+			}
+			return beaconState, err
+		default:
+			return beaconState, fmt.Errorf("could not apply block state transition: %v", err)
+		}
+	}
+
+	log.WithFields(logrus.Fields{
+		"slotNumber":   block.Slot,
+		"currentEpoch": helpers.SlotToEpoch(block.Slot),
+	}).Info("State transition complete")
+
+	// Check state root
+	if featureconfig.FeatureConfig().EnableCheckBlockStateRoot {
+		stateRoot, err := ssz.HashTreeRoot(beaconState)
+		if err != nil {
+			return nil, fmt.Errorf("could not hash beacon state: %v", err)
+		}
+		if !bytes.Equal(block.StateRoot, stateRoot[:]) {
+			return nil, fmt.Errorf("beacon state root is not equal to block state root: %#x != %#x", stateRoot, block.StateRoot)
+		}
+	}
+
+	// We process the block's contained deposits, attestations, and other operations
+	// and that may need to be stored or deleted from the beacon node's persistent storage.
+	if err := c.CleanupBlockOperations(ctx, block); err != nil {
+		return beaconState, fmt.Errorf("could not process block deposits, attestations, and other operations: %v", err)
+	}
+
+	log.WithField("slot", block.Slot).Info("Finished processing beacon block")
+	return beaconState, nil
+}
+
+// VerifyBlockValidity cross-checks the block against the pre-processing conditions from
+// Ethereum 2.0, namely:
+//   The parent block with root block.parent_root has been processed and accepted.
+//   The node has processed its state up to slot, block.slot - 1.
+//   The Ethereum 1.0 block pointed to by the state.processed_pow_receipt_root has been processed and accepted.
+//   The node's local clock time is greater than or equal to state.genesis_time + block.slot * SECONDS_PER_SLOT.
+func (c *ChainService) VerifyBlockValidity(
+	ctx context.Context,
+	block *pb.BeaconBlock,
+	beaconState *pb.BeaconState,
+) error {
+	if block.Slot == 0 {
+		return fmt.Errorf("cannot process a genesis block: received block with slot %d",
+			block.Slot)
+	}
+	powBlockFetcher := c.web3Service.Client().BlockByHash
+	if err := b.IsValidBlock(ctx, beaconState, block,
+		c.beaconDB.HasBlock, powBlockFetcher, c.genesisTime); err != nil {
+		return fmt.Errorf("block does not fulfill pre-processing conditions %v", err)
+	}
+	return nil
+}
+
+// SaveAndBroadcastBlock stores the block in persistent storage and then broadcasts it to
+// peers via p2p. Blocks which have already been saved are not processed again via p2p, which is why
+// the order of operations is important in this function to prevent infinite p2p loops.
+func (c *ChainService) SaveAndBroadcastBlock(ctx context.Context, block *pb.BeaconBlock) error {
+	blockRoot, err := ssz.SigningRoot(block)
+	if err != nil {
+		return fmt.Errorf("could not tree hash incoming block: %v", err)
+	}
+	if err := c.beaconDB.SaveBlock(block); err != nil {
+		return fmt.Errorf("failed to save block: %v", err)
+	}
+	if err := c.beaconDB.SaveAttestationTarget(ctx, &pb.AttestationTarget{
+		Slot:       block.Slot,
+		BlockRoot:  blockRoot[:],
+		ParentRoot: block.ParentRoot,
+	}); err != nil {
+		return fmt.Errorf("failed to save attestation target: %v", err)
+	}
+	// Announce the new block to the network.
+	c.p2p.Broadcast(ctx, &pb.BeaconBlockAnnounce{
+		Hash:       blockRoot[:],
+		SlotNumber: block.Slot,
+	})
+	return nil
+}
+
+// CleanupBlockOperations processes and cleans up any block operations relevant to the beacon node
+// such as attestations, exits, and deposits. We update the latest seen attestation by validator
+// in the local node's runtime, cleanup and remove pending deposits which have been included in the block
+// from our node's local cache, and process validator exits and more.
+func (c *ChainService) CleanupBlockOperations(ctx context.Context, block *pb.BeaconBlock) error {
+	// Forward processed block to operation pool to remove individual operation from DB.
+	if c.opsPoolService.IncomingProcessedBlockFeed().Send(block) == 0 {
+		log.Error("Sent processed block to no subscribers")
+	}
+
+	if err := c.attsService.BatchUpdateLatestAttestation(ctx, block.Body.Attestations); err != nil {
+		return fmt.Errorf("failed to update latest attestation for store: %v", err)
+	}
+
+	// Remove pending deposits from the deposit queue.
+	for _, dep := range block.Body.Deposits {
+		c.beaconDB.RemovePendingDeposit(ctx, dep)
+	}
+	return nil
+}
+
+// AdvanceState executes the Ethereum 2.0 core state transition for the beacon chain and
+// updates important checkpoints and local persistent data during epoch transitions. It serves as a wrapper
+// around the more low-level, core state transition function primitive.
+func (c *ChainService) AdvanceState(
+	ctx context.Context,
+	beaconState *pb.BeaconState,
+	block *pb.BeaconBlock,
+) (*pb.BeaconState, error) {
+	finalizedEpoch := beaconState.FinalizedCheckpoint.Epoch
+	newState, err := state.ExecuteStateTransition(
+		ctx,
+		beaconState,
+		block,
+		&state.TransitionConfig{
+			VerifySignatures: false, // We disable signature verification for now.
+			Logging:          true,  // We enable logging in this state transition call.
+		},
+	)
+	if err != nil {
+		return beaconState, &BlockFailedProcessingErr{err}
+	}
+	// Prune the block cache and helper caches on every new finalized epoch.
+	if newState.FinalizedCheckpoint.Epoch > finalizedEpoch {
+		helpers.ClearAllCaches()
+		c.beaconDB.ClearBlockCache()
+	}
+
+	log.WithField(
+		"slotsSinceGenesis", newState.Slot,
+	).Info("Slot transition successfully processed")
+
+	if block != nil {
+		log.WithField(
+			"slotsSinceGenesis", newState.Slot,
+		).Info("Block transition successfully processed")
+
+		blockRoot, err := ssz.SigningRoot(block)
+		if err != nil {
+			return nil, err
+		}
+		// Save Historical States.
+		if err := c.beaconDB.SaveHistoricalState(ctx, beaconState, blockRoot); err != nil {
+			return nil, fmt.Errorf("could not save historical state: %v", err)
+		}
+	}
+
+	if helpers.IsEpochEnd(newState.Slot) {
+		// Save activated validators of this epoch to public key -> index DB.
+		if err := c.saveValidatorIdx(newState); err != nil {
+			return newState, fmt.Errorf("could not save validator index: %v", err)
+		}
+		// Delete exited validators of this epoch to public key -> index DB.
+		if err := c.deleteValidatorIdx(newState); err != nil {
+			return newState, fmt.Errorf("could not delete validator index: %v", err)
+		}
+		// Update FFG checkpoints in DB.
+		if err := c.updateFFGCheckPts(ctx, newState); err != nil {
+			return newState, fmt.Errorf("could not update FFG checkpts: %v", err)
+		}
+		log.WithField(
+			"SlotsSinceGenesis", newState.Slot,
+		).Info("Epoch transition successfully processed")
+	}
+	return newState, nil
+}
+
+// saveValidatorIdx saves the validators public key to index mapping in DB, these
+// validators were activated from current epoch. After it saves, current epoch key
+// is deleted from ActivatedValidators mapping.
+func (c *ChainService) saveValidatorIdx(state *pb.BeaconState) error {
+	nextEpoch := helpers.CurrentEpoch(state) + 1
+	activatedValidators := validators.ActivatedValFromEpoch(nextEpoch)
+	var idxNotInState []uint64
+	for _, idx := range activatedValidators {
+		// If for some reason the activated validator indices is not in state,
+		// we skip them and save them to process for next epoch.
+		if int(idx) >= len(state.Validators) {
+			idxNotInState = append(idxNotInState, idx)
+			continue
+		}
+		pubKey := state.Validators[idx].Pubkey
+		if err := c.beaconDB.SaveValidatorIndex(pubKey, int(idx)); err != nil {
+			return fmt.Errorf("could not save validator index: %v", err)
+		}
+	}
+	// Since we are processing next epoch, save the can't processed validator indices
+	// to the epoch after that.
+	validators.InsertActivatedIndices(nextEpoch+1, idxNotInState)
+	validators.DeleteActivatedVal(helpers.CurrentEpoch(state))
+	return nil
+}
+
+// deleteValidatorIdx deletes the validators public key to index mapping in DB, the
+// validators were exited from current epoch. After it deletes, current epoch key
+// is deleted from ExitedValidators mapping.
+func (c *ChainService) deleteValidatorIdx(state *pb.BeaconState) error {
+	exitedValidators := validators.ExitedValFromEpoch(helpers.CurrentEpoch(state) + 1)
+	for _, idx := range exitedValidators {
+		pubKey := state.Validators[idx].Pubkey
+		if err := c.beaconDB.DeleteValidatorIndex(pubKey); err != nil {
+			return fmt.Errorf("could not delete validator index: %v", err)
+		}
+	}
+	validators.DeleteExitedVal(helpers.CurrentEpoch(state))
+	return nil
+}

beacon-chain/blockchain/blockchain_test.go

@@ -1,15 +0,0 @@
-package blockchain
-
-import (
-	"io/ioutil"
-	"testing"
-
-	"github.com/sirupsen/logrus"
-)
-
-func TestMain(m *testing.M) {
-	logrus.SetLevel(logrus.DebugLevel)
-	logrus.SetOutput(ioutil.Discard)
-
-	m.Run()
-}

beacon-chain/blockchain/chain_info.go

@@ -1,391 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"time"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	"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
-	FinalizationFetcher
-	GenesisFetcher
-	CanonicalFetcher
-	ForkFetcher
-	TimeFetcher
-	HeadDomainFetcher
-}
-
-// TimeFetcher retrieves the Ethereum consensus data that's related to time.
-type TimeFetcher interface {
-	GenesisTime() time.Time
-	CurrentSlot() types.Slot
-}
-
-// GenesisFetcher retrieves the Ethereum consensus data related to its genesis.
-type GenesisFetcher interface {
-	GenesisValidatorsRoot() [32]byte
-}
-
-// HeadFetcher defines a common interface for methods in blockchain service which
-// directly retrieves head related data.
-type HeadFetcher interface {
-	HeadSlot() types.Slot
-	HeadRoot(ctx context.Context) ([]byte, error)
-	HeadBlock(ctx context.Context) (block.SignedBeaconBlock, error)
-	HeadState(ctx context.Context) (state.BeaconState, error)
-	HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error)
-	HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error)
-	HeadGenesisValidatorsRoot() [32]byte
-	HeadETH1Data() *ethpb.Eth1Data
-	HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool)
-	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error)
-	ChainHeads() ([][32]byte, []types.Slot)
-	IsOptimistic(ctx context.Context) (bool, error)
-	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
-	HeadSyncCommitteeFetcher
-	HeadDomainFetcher
-	ForkChoicer() forkchoice.ForkChoicer
-}
-
-// ForkFetcher retrieves the current fork information of the Ethereum beacon chain.
-type ForkFetcher interface {
-	CurrentFork() *ethpb.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 {
-	FinalizedCheckpt() *ethpb.Checkpoint
-	CurrentJustifiedCheckpt() *ethpb.Checkpoint
-	PreviousJustifiedCheckpt() *ethpb.Checkpoint
-}
-
-// FinalizedCheckpt returns the latest finalized checkpoint from chain store.
-func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
-	cp := s.store.FinalizedCheckpt()
-	if cp == nil {
-		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	}
-
-	return ethpb.CopyCheckpoint(cp)
-}
-
-// CurrentJustifiedCheckpt returns the current justified checkpoint from chain store.
-func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
-	cp := s.store.JustifiedCheckpt()
-	if cp == nil {
-		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	}
-
-	return ethpb.CopyCheckpoint(cp)
-}
-
-// PreviousJustifiedCheckpt returns the previous justified checkpoint from chain store.
-func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
-	cp := s.store.PrevJustifiedCheckpt()
-	if cp == nil {
-		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	}
-
-	return ethpb.CopyCheckpoint(cp)
-}
-
-// BestJustifiedCheckpt returns the best justified checkpoint from store.
-func (s *Service) BestJustifiedCheckpt() *ethpb.Checkpoint {
-	cp := s.store.BestJustifiedCheckpt()
-	// If there is no best justified checkpoint, return the checkpoint with root as zeros to be used for genesis cases.
-	if cp == nil {
-		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	}
-
-	return ethpb.CopyCheckpoint(cp)
-}
-
-// HeadSlot returns the slot of the head of the chain.
-func (s *Service) HeadSlot() types.Slot {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if !s.hasHeadState() {
-		return 0
-	}
-
-	return s.headSlot()
-}
-
-// HeadRoot returns the root of the head of the chain.
-func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if s.headRoot() != params.BeaconConfig().ZeroHash {
-		r := s.headRoot()
-		return r[:], nil
-	}
-
-	b, err := s.cfg.BeaconDB.HeadBlock(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if b == nil || b.IsNil() {
-		return params.BeaconConfig().ZeroHash[:], nil
-	}
-
-	r, err := b.Block().HashTreeRoot()
-	if err != nil {
-		return nil, err
-	}
-
-	return r[:], nil
-}
-
-// HeadBlock returns the head block of the chain.
-// 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) (block.SignedBeaconBlock, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if s.hasHeadState() {
-		return s.headBlock(), nil
-	}
-
-	return s.cfg.BeaconDB.HeadBlock(ctx)
-}
-
-// HeadState returns the head state of the chain.
-// 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()
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	ok := s.hasHeadState()
-	span.AddAttributes(trace.BoolAttribute("cache_hit", ok))
-
-	if ok {
-		return s.headState(ctx), nil
-	}
-
-	return s.cfg.StateGen.StateByRoot(ctx, s.headRoot())
-}
-
-// HeadValidatorsIndices returns a list of active validator indices from the head view of a given epoch.
-func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if !s.hasHeadState() {
-		return []types.ValidatorIndex{}, nil
-	}
-	return helpers.ActiveValidatorIndices(ctx, s.headState(ctx), epoch)
-}
-
-// HeadSeed returns the seed from the head view of a given epoch.
-func (s *Service) HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if !s.hasHeadState() {
-		return [32]byte{}, nil
-	}
-
-	return helpers.Seed(s.headState(ctx), epoch, params.BeaconConfig().DomainBeaconAttester)
-}
-
-// HeadGenesisValidatorsRoot returns genesis validators root of the head state.
-func (s *Service) HeadGenesisValidatorsRoot() [32]byte {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if !s.hasHeadState() {
-		return [32]byte{}
-	}
-
-	return s.headGenesisValidatorsRoot()
-}
-
-// HeadETH1Data returns the eth1data of the current head state.
-func (s *Service) HeadETH1Data() *ethpb.Eth1Data {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if !s.hasHeadState() {
-		return &ethpb.Eth1Data{}
-	}
-	return s.head.state.Eth1Data()
-}
-
-// GenesisTime returns the genesis time of beacon chain.
-func (s *Service) GenesisTime() time.Time {
-	return s.genesisTime
-}
-
-// GenesisValidatorsRoot returns the genesis validator
-// root of the chain.
-func (s *Service) GenesisValidatorsRoot() [32]byte {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if !s.hasHeadState() {
-		return [32]byte{}
-	}
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
-}
-
-// CurrentFork retrieves the latest fork information of the beacon chain.
-func (s *Service) CurrentFork() *ethpb.Fork {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	if !s.hasHeadState() {
-		return &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		}
-	}
-	return s.head.state.Fork()
-}
-
-// 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 not been finalized, check fork choice store to see if the block is canonical
-	if s.cfg.ForkChoiceStore.HasNode(blockRoot) {
-		return s.cfg.ForkChoiceStore.IsCanonical(blockRoot), nil
-	}
-
-	// If the block has been finalized, the block will always be part of the canonical chain.
-	return s.cfg.BeaconDB.IsFinalizedBlock(ctx, blockRoot), nil
-}
-
-// ChainHeads returns all possible chain heads (leaves of fork choice tree).
-// Heads roots and heads slots are returned.
-func (s *Service) ChainHeads() ([][32]byte, []types.Slot) {
-	return s.cfg.ForkChoiceStore.Tips()
-}
-
-// HeadPublicKeyToValidatorIndex returns the validator index of the `pubkey` in current head state.
-func (s *Service) HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-	if !s.hasHeadState() {
-		return 0, false
-	}
-	return s.headValidatorIndexAtPubkey(pubKey)
-}
-
-// HeadValidatorIndexToPublicKey returns the pubkey of the validator `index`  in current head state.
-func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-	if !s.hasHeadState() {
-		return [fieldparams.BLSPubkeyLength]byte{}, nil
-	}
-	v, err := s.headValidatorAtIndex(index)
-	if err != nil {
-		return [fieldparams.BLSPubkeyLength]byte{}, err
-	}
-	return v.PublicKey(), nil
-}
-
-// ForkChoicer returns the forkchoice interface
-func (s *Service) ForkChoicer() forkchoice.ForkChoicer {
-	return s.cfg.ForkChoiceStore
-}
-
-// IsOptimistic returns true if the current head is optimistic.
-func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-	if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {
-		return false, nil
-	}
-
-	return s.IsOptimisticForRoot(ctx, s.head.root)
-}
-
-// IsOptimisticForRoot takes the root and slot as arguments instead of the current head
-// and returns true if it is optimistic.
-func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(root)
-	if err == nil {
-		return optimistic, nil
-	}
-	if err != protoarray.ErrUnknownNodeRoot && err != doublylinkedtree.ErrNilNode {
-		return false, err
-	}
-	ss, err := s.cfg.BeaconDB.StateSummary(ctx, root)
-	if err != nil {
-		return false, err
-	}
-	if ss == nil {
-		return false, errInvalidNilSummary
-	}
-
-	validatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	if err != nil {
-		return false, err
-	}
-	if slots.ToEpoch(ss.Slot) > validatedCheckpoint.Epoch {
-		return true, nil
-	}
-
-	if slots.ToEpoch(ss.Slot)+1 < validatedCheckpoint.Epoch {
-		return false, nil
-	}
-
-	// checkpoint root could be zeros before the first finalized epoch. Use genesis root if the case.
-	lastValidated, err := s.cfg.BeaconDB.StateSummary(ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(validatedCheckpoint.Root)))
-	if err != nil {
-		return false, err
-	}
-	if lastValidated == nil {
-		return false, errInvalidNilSummary
-	}
-
-	if ss.Slot > lastValidated.Slot {
-		return true, nil
-	}
-
-	isCanonical, err := s.IsCanonical(ctx, root)
-	if err != nil {
-		return false, err
-	}
-
-	// historical non-canonical blocks here are returned as optimistic for safety.
-	return !isCanonical, nil
-}
-
-// SetGenesisTime sets the genesis time of beacon chain.
-func (s *Service) SetGenesisTime(t time.Time) {
-	s.genesisTime = t
-}
-
-// ForkChoiceStore returns the fork choice store in the service
-func (s *Service) ForkChoiceStore() forkchoice.ForkChoicer {
-	return s.cfg.ForkChoiceStore
-}

beacon-chain/blockchain/chain_info_norace_test.go

@@ -1,91 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestHeadSlot_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg: &config{BeaconDB: beaconDB},
-	}
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	st, _ := util.DeterministicGenesisState(t, 1)
-	wait := make(chan struct{})
-	go func() {
-		defer close(wait)
-		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
-	}()
-	s.HeadSlot()
-	<-wait
-}
-
-func TestHeadRoot_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
-		head: &head{root: [32]byte{'A'}},
-	}
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	wait := make(chan struct{})
-	st, _ := util.DeterministicGenesisState(t, 1)
-	go func() {
-		defer close(wait)
-		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
-
-	}()
-	_, err = s.HeadRoot(context.Background())
-	require.NoError(t, err)
-	<-wait
-}
-
-func TestHeadBlock_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
-	require.NoError(t, err)
-	s := &Service{
-		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
-		head: &head{block: wsb},
-	}
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	wait := make(chan struct{})
-	st, _ := util.DeterministicGenesisState(t, 1)
-	go func() {
-		defer close(wait)
-		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
-
-	}()
-	_, err = s.HeadBlock(context.Background())
-	require.NoError(t, err)
-	<-wait
-}
-
-func TestHeadState_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
-	}
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	wait := make(chan struct{})
-	st, _ := util.DeterministicGenesisState(t, 1)
-	go func() {
-		defer close(wait)
-		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
-
-	}()
-	_, err = s.HeadState(context.Background())
-	require.NoError(t, err)
-	<-wait
-}

beacon-chain/blockchain/chain_info_test.go

@@ -1,619 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"google.golang.org/protobuf/proto"
-)
-
-// Ensure Service implements chain info interface.
-var _ ChainInfoFetcher = (*Service)(nil)
-var _ TimeFetcher = (*Service)(nil)
-var _ ForkFetcher = (*Service)(nil)
-
-func TestFinalizedCheckpt_Nil(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	c := setupBeaconChain(t, beaconDB)
-	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], c.FinalizedCheckpt().Root, "Incorrect pre chain start value")
-}
-
-func TestHeadRoot_Nil(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	c := setupBeaconChain(t, beaconDB)
-	headRoot, err := c.HeadRoot(context.Background())
-	require.NoError(t, err)
-	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
-}
-
-func TestService_ForkChoiceStore(t *testing.T) {
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
-	p := c.ForkChoiceStore()
-	require.Equal(t, 0, int(p.FinalizedEpoch()))
-}
-
-func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-
-	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
-	c := setupBeaconChain(t, beaconDB)
-	c.store.SetFinalizedCheckpt(cp)
-
-	assert.Equal(t, cp.Epoch, c.FinalizedCheckpt().Epoch, "Unexpected finalized epoch")
-}
-
-func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-
-	genesisRoot := [32]byte{'A'}
-	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, beaconDB)
-	c.store.SetFinalizedCheckpt(cp)
-	c.originBlockRoot = genesisRoot
-	assert.DeepEqual(t, c.originBlockRoot[:], c.FinalizedCheckpt().Root)
-}
-
-func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-
-	c := setupBeaconChain(t, beaconDB)
-	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
-	cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
-	c.store.SetJustifiedCheckpt(cp)
-	assert.Equal(t, cp.Epoch, c.CurrentJustifiedCheckpt().Epoch, "Unexpected justified epoch")
-}
-
-func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-
-	c := setupBeaconChain(t, beaconDB)
-	genesisRoot := [32]byte{'B'}
-	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c.store.SetJustifiedCheckpt(cp)
-	c.originBlockRoot = genesisRoot
-	assert.DeepEqual(t, c.originBlockRoot[:], c.CurrentJustifiedCheckpt().Root)
-}
-
-func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-
-	cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
-	c := setupBeaconChain(t, beaconDB)
-	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
-	c.store.SetPrevJustifiedCheckpt(cp)
-	assert.Equal(t, cp.Epoch, c.PreviousJustifiedCheckpt().Epoch, "Unexpected previous justified epoch")
-}
-
-func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-
-	genesisRoot := [32]byte{'C'}
-	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, beaconDB)
-	c.store.SetPrevJustifiedCheckpt(cp)
-	c.originBlockRoot = genesisRoot
-	assert.DeepEqual(t, c.originBlockRoot[:], c.PreviousJustifiedCheckpt().Root)
-}
-
-func TestHeadSlot_CanRetrieve(t *testing.T) {
-	c := &Service{}
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
-	require.NoError(t, err)
-	c.head = &head{slot: 100, state: s}
-	assert.Equal(t, types.Slot(100), c.HeadSlot())
-}
-
-func TestHeadRoot_CanRetrieve(t *testing.T) {
-	c := &Service{}
-	c.head = &head{root: [32]byte{'A'}}
-	r, err := c.HeadRoot(context.Background())
-	require.NoError(t, err)
-	assert.Equal(t, [32]byte{'A'}, bytesutil.ToBytes32(r))
-}
-
-func TestHeadRoot_UseDB(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	c := &Service{cfg: &config{BeaconDB: beaconDB}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:]}))
-	require.NoError(t, beaconDB.SaveHeadBlockRoot(context.Background(), br))
-	r, err := c.HeadRoot(context.Background())
-	require.NoError(t, err)
-	assert.Equal(t, br, bytesutil.ToBytes32(r))
-}
-
-func TestHeadBlock_CanRetrieve(t *testing.T) {
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 1
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	c := &Service{}
-	c.head = &head{block: wsb, state: s}
-
-	recevied, err := c.HeadBlock(context.Background())
-	require.NoError(t, err)
-	assert.DeepEqual(t, b, recevied.Proto(), "Incorrect head block received")
-}
-
-func TestHeadState_CanRetrieve(t *testing.T) {
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Slot: 2, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
-	require.NoError(t, err)
-	c := &Service{}
-	c.head = &head{state: s}
-	headState, err := c.HeadState(context.Background())
-	require.NoError(t, err)
-	assert.DeepEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Incorrect head state received")
-}
-
-func TestGenesisTime_CanRetrieve(t *testing.T) {
-	c := &Service{genesisTime: time.Unix(999, 0)}
-	wanted := time.Unix(999, 0)
-	assert.Equal(t, wanted, c.GenesisTime(), "Did not get wanted genesis time")
-}
-
-func TestCurrentFork_CanRetrieve(t *testing.T) {
-	f := &ethpb.Fork{Epoch: 999}
-	s, err := v1.InitializeFromProto(&ethpb.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 TestCurrentFork_NilHeadSTate(t *testing.T) {
-	f := &ethpb.Fork{
-		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-	}
-	c := &Service{}
-	if !proto.Equal(c.CurrentFork(), f) {
-		t.Error("Received incorrect fork version")
-	}
-}
-
-func TestGenesisValidatorsRoot_CanRetrieve(t *testing.T) {
-	// Should not panic if head state is nil.
-	c := &Service{}
-	assert.Equal(t, [32]byte{}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
-
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
-	require.NoError(t, err)
-	c.head = &head{state: s}
-	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
-}
-
-func TestHeadETH1Data_Nil(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	c := setupBeaconChain(t, beaconDB)
-	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 := v1.InitializeFromProto(&ethpb.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")
-	}
-}
-
-func TestIsCanonical_Ok(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	c := setupBeaconChain(t, beaconDB)
-
-	blk := util.NewBeaconBlock()
-	blk.Block.Slot = 0
-	root, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
-	can, err := c.IsCanonical(ctx, root)
-	require.NoError(t, err)
-	assert.Equal(t, true, can)
-
-	can, err = c.IsCanonical(ctx, [32]byte{'a'})
-	require.NoError(t, err)
-	assert.Equal(t, false, can)
-}
-
-func TestService_HeadValidatorsIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
-
-	c.head = &head{}
-	indices, err := c.HeadValidatorsIndices(context.Background(), 0)
-	require.NoError(t, err)
-	require.Equal(t, 0, len(indices))
-
-	c.head = &head{state: s}
-	indices, err = c.HeadValidatorsIndices(context.Background(), 0)
-	require.NoError(t, err)
-	require.Equal(t, 10, len(indices))
-}
-
-func TestService_HeadSeed(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 1)
-	c := &Service{}
-	seed, err := helpers.Seed(s, 0, params.BeaconConfig().DomainBeaconAttester)
-	require.NoError(t, err)
-
-	c.head = &head{}
-	root, err := c.HeadSeed(context.Background(), 0)
-	require.NoError(t, err)
-	require.Equal(t, [32]byte{}, root)
-
-	c.head = &head{state: s}
-	root, err = c.HeadSeed(context.Background(), 0)
-	require.NoError(t, err)
-	require.DeepEqual(t, seed, root)
-}
-
-func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 1)
-	c := &Service{}
-
-	c.head = &head{}
-	root := c.HeadGenesisValidatorsRoot()
-	require.Equal(t, [32]byte{}, root)
-
-	c.head = &head{state: s}
-	root = c.HeadGenesisValidatorsRoot()
-	require.DeepEqual(t, root[:], s.GenesisValidatorsRoot())
-}
-func TestService_ChainHeads_ProtoArray(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0,
-		params.BeaconConfig().ZeroHash)}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
-
-	roots, slots := c.ChainHeads()
-	require.DeepEqual(t, [][32]byte{{'c'}, {'d'}, {'e'}}, roots)
-	require.DeepEqual(t, []types.Slot{102, 103, 104}, slots)
-}
-
-func TestService_ChainHeads_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
-
-	roots, slots := c.ChainHeads()
-	require.Equal(t, 3, len(roots))
-	rootMap := map[[32]byte]types.Slot{[32]byte{'c'}: 102, [32]byte{'d'}: 103, [32]byte{'e'}: 104}
-	for i, root := range roots {
-		slot, ok := rootMap[root]
-		require.Equal(t, true, ok)
-		require.Equal(t, slot, slots[i])
-	}
-}
-
-func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	_, e := c.HeadPublicKeyToValidatorIndex([fieldparams.BLSPubkeyLength]byte{})
-	require.Equal(t, false, e)
-
-	v, err := s.ValidatorAtIndex(0)
-	require.NoError(t, err)
-
-	i, e := c.HeadPublicKeyToValidatorIndex(bytesutil.ToBytes48(v.PublicKey))
-	require.Equal(t, true, e)
-	require.Equal(t, types.ValidatorIndex(0), i)
-}
-
-func TestService_HeadPublicKeyToValidatorIndexNil(t *testing.T) {
-	c := &Service{}
-	c.head = nil
-
-	idx, e := c.HeadPublicKeyToValidatorIndex([fieldparams.BLSPubkeyLength]byte{})
-	require.Equal(t, false, e)
-	require.Equal(t, types.ValidatorIndex(0), idx)
-
-	c.head = &head{state: nil}
-	i, e := c.HeadPublicKeyToValidatorIndex([fieldparams.BLSPubkeyLength]byte{})
-	require.Equal(t, false, e)
-	require.Equal(t, types.ValidatorIndex(0), i)
-}
-
-func TestService_HeadValidatorIndexToPublicKey(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	p, err := c.HeadValidatorIndexToPublicKey(context.Background(), 0)
-	require.NoError(t, err)
-
-	v, err := s.ValidatorAtIndex(0)
-	require.NoError(t, err)
-
-	require.Equal(t, bytesutil.ToBytes48(v.PublicKey), p)
-}
-
-func TestService_HeadValidatorIndexToPublicKeyNil(t *testing.T) {
-	c := &Service{}
-	c.head = nil
-
-	p, err := c.HeadValidatorIndexToPublicKey(context.Background(), 0)
-	require.NoError(t, err)
-	require.Equal(t, [fieldparams.BLSPubkeyLength]byte{}, p)
-
-	c.head = &head{state: nil}
-	p, err = c.HeadValidatorIndexToPublicKey(context.Background(), 0)
-	require.NoError(t, err)
-	require.Equal(t, [fieldparams.BLSPubkeyLength]byte{}, p)
-}
-
-func TestService_IsOptimistic_ProtoArray(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.BellatrixForkEpoch = 0
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-
-	opt, err := c.IsOptimistic(ctx)
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimistic_DoublyLinkedTree(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.BellatrixForkEpoch = 0
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-
-	opt, err := c.IsOptimistic(ctx)
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{genesisTime: time.Now()}
-	opt, err := c.IsOptimistic(ctx)
-	require.NoError(t, err)
-	require.Equal(t, false, opt)
-}
-
-func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-
-	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-
-	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 97
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(optimisticBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(validatedBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	_, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.ErrorContains(t, "nil summary returned from the DB", err)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	cp := &ethpb.Checkpoint{
-		Epoch: 1,
-		Root:  validatedRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, validatedRoot))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, cp))
-
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, validated)
-
-	// Before the first finalized epoch, finalized root could be zeros.
-	validatedCheckpoint = &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, br))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:], Slot: 10}))
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-}
-
-func TestService_IsOptimisticForRoot_DB_DoublyLinkedTree(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 97
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(optimisticBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(validatedBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	_, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.ErrorContains(t, "nil summary returned from the DB", err)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	cp := &ethpb.Checkpoint{
-		Epoch: 1,
-		Root:  validatedRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, validatedRoot))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, cp))
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, validated)
-
-	// Before the first finalized epoch, finalized root could be zeros.
-	validatedCheckpoint = &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, br))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:], Slot: 10}))
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-}
-
-func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 97
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(optimisticBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(validatedBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, validated)
-
-}

beacon-chain/blockchain/checktags_test.go

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

beacon-chain/blockchain/error.go

@@ -1,21 +0,0 @@
-package blockchain
-
-import "github.com/pkg/errors"
-
-var (
-	// errNilJustifiedInStore is returned when a nil justified checkpt is returned from store.
-	errNilJustifiedInStore = errors.New("nil justified checkpoint returned from store")
-	// errNilBestJustifiedInStore is returned when a nil justified checkpt is returned from store.
-	errNilBestJustifiedInStore = errors.New("nil best justified checkpoint returned from store")
-	// errNilFinalizedInStore is returned when a nil finalized checkpt is returned from store.
-	errNilFinalizedInStore = errors.New("nil finalized checkpoint returned from store")
-	// errInvalidNilSummary is returned when a nil summary is returned from the DB.
-	errInvalidNilSummary = errors.New("nil summary returned from the DB")
-	// errNilParentInDB is returned when a nil parent block is returned from the DB.
-	errNilParentInDB = errors.New("nil parent block in DB")
-	// errWrongBlockCount is returned when the wrong number of blocks or
-	// block roots is used
-	errWrongBlockCount = errors.New("wrong number of blocks or block roots")
-	// block is not a valid optimistic candidate block
-	errNotOptimisticCandidate = errors.New("block is not suitable for optimistic sync")
-)

beacon-chain/blockchain/fork_choice.go

@@ -0,0 +1,501 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/prysmaticlabs/go-ssz"
+	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+)
+
+var (
+	reorgCount = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "reorg_counter",
+		Help: "The number of chain reorganization events that have happened in the fork choice rule",
+	})
+)
+var blkAncestorCache = cache.NewBlockAncestorCache()
+
+// ForkChoice interface defines the methods for applying fork choice rule
+// operations to the blockchain.
+type ForkChoice interface {
+	ApplyForkChoiceRule(ctx context.Context, block *pb.BeaconBlock, computedState *pb.BeaconState) error
+}
+
+// TargetsFetcher defines a struct which can retrieve latest attestation targets
+// from a given justified state.
+type TargetsFetcher interface {
+	AttestationTargets(justifiedState *pb.BeaconState) (map[uint64]*pb.AttestationTarget, error)
+}
+
+// updateFFGCheckPts checks whether the existing FFG check points saved in DB
+// are not older than the ones just processed in state. If it's older, we update
+// the db with the latest FFG check points, both justification and finalization.
+func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconState) error {
+	lastJustifiedSlot := helpers.StartSlot(state.CurrentJustifiedCheckpoint.Epoch)
+	savedJustifiedBlock, err := c.beaconDB.JustifiedBlock()
+	if err != nil {
+		return err
+	}
+	// If the last processed justification slot in state is greater than
+	// the slot of justified block saved in DB.
+	if lastJustifiedSlot > savedJustifiedBlock.Slot {
+		// Retrieve the new justified block from DB using the new justified slot and save it.
+		newJustifiedBlock, err := c.beaconDB.CanonicalBlockBySlot(ctx, lastJustifiedSlot)
+		if err != nil {
+			return err
+		}
+		// If the new justified slot is a skip slot in db then we keep getting it's ancestors
+		// until we can get a block.
+		lastAvailBlkSlot := lastJustifiedSlot
+		for newJustifiedBlock == nil {
+			log.WithField("slot", lastAvailBlkSlot).Debug("Missing block in DB, looking one slot back")
+			lastAvailBlkSlot--
+			newJustifiedBlock, err = c.beaconDB.CanonicalBlockBySlot(ctx, lastAvailBlkSlot)
+			if err != nil {
+				return err
+			}
+		}
+
+		newJustifiedRoot, err := ssz.SigningRoot(newJustifiedBlock)
+		if err != nil {
+			return err
+		}
+		// Fetch justified state from historical states db.
+		newJustifiedState, err := c.beaconDB.HistoricalStateFromSlot(ctx, newJustifiedBlock.Slot, newJustifiedRoot)
+		if err != nil {
+			return err
+		}
+		if err := c.beaconDB.SaveJustifiedBlock(newJustifiedBlock); err != nil {
+			return err
+		}
+		if err := c.beaconDB.SaveJustifiedState(newJustifiedState); err != nil {
+			return err
+		}
+	}
+
+	lastFinalizedSlot := helpers.StartSlot(state.FinalizedCheckpoint.Epoch)
+	savedFinalizedBlock, err := c.beaconDB.FinalizedBlock()
+	// If the last processed finalized slot in state is greater than
+	// the slot of finalized block saved in DB.
+	if err != nil {
+		return err
+	}
+	if lastFinalizedSlot > savedFinalizedBlock.Slot {
+		// Retrieve the new finalized block from DB using the new finalized slot and save it.
+		newFinalizedBlock, err := c.beaconDB.CanonicalBlockBySlot(ctx, lastFinalizedSlot)
+		if err != nil {
+			return err
+		}
+		// If the new finalized slot is a skip slot in db then we keep getting it's ancestors
+		// until we can get a block.
+		lastAvailBlkSlot := lastFinalizedSlot
+		for newFinalizedBlock == nil {
+			log.WithField("slot", lastAvailBlkSlot).Debug("Missing block in DB, looking one slot back")
+			lastAvailBlkSlot--
+			newFinalizedBlock, err = c.beaconDB.CanonicalBlockBySlot(ctx, lastAvailBlkSlot)
+			if err != nil {
+				return err
+			}
+		}
+
+		newFinalizedRoot, err := ssz.SigningRoot(newFinalizedBlock)
+		if err != nil {
+			return err
+		}
+		// Generate the new finalized state with using new finalized block and
+		// save it.
+		newFinalizedState, err := c.beaconDB.HistoricalStateFromSlot(ctx, lastFinalizedSlot, newFinalizedRoot)
+		if err != nil {
+			return err
+		}
+		if err := c.beaconDB.SaveFinalizedBlock(newFinalizedBlock); err != nil {
+			return err
+		}
+		if err := c.beaconDB.SaveFinalizedState(newFinalizedState); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ApplyForkChoiceRule determines the current beacon chain head using LMD
+// GHOST as a block-vote weighted function to select a canonical head in
+// Ethereum Serenity. The inputs are the the recently processed block and its
+// associated state.
+func (c *ChainService) ApplyForkChoiceRule(
+	ctx context.Context,
+	block *pb.BeaconBlock,
+	postState *pb.BeaconState,
+) error {
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ApplyForkChoiceRule")
+	defer span.End()
+	log.Info("Applying LMD-GHOST Fork Choice Rule")
+
+	justifiedState, err := c.beaconDB.JustifiedState()
+	if err != nil {
+		return fmt.Errorf("could not retrieve justified state: %v", err)
+	}
+	attestationTargets, err := c.AttestationTargets(justifiedState)
+	if err != nil {
+		return fmt.Errorf("could not retrieve attestation target: %v", err)
+	}
+	justifiedHead, err := c.beaconDB.JustifiedBlock()
+	if err != nil {
+		return fmt.Errorf("could not retrieve justified head: %v", err)
+	}
+
+	newHead, err := c.lmdGhost(ctx, justifiedHead, justifiedState, attestationTargets)
+	if err != nil {
+		return fmt.Errorf("could not run fork choice: %v", err)
+	}
+	newHeadRoot, err := ssz.SigningRoot(newHead)
+	if err != nil {
+		return fmt.Errorf("could not hash new head block: %v", err)
+	}
+	c.canonicalBlocksLock.Lock()
+	defer c.canonicalBlocksLock.Unlock()
+	c.canonicalBlocks[newHead.Slot] = newHeadRoot[:]
+
+	currentHead, err := c.beaconDB.ChainHead()
+	if err != nil {
+		return fmt.Errorf("could not retrieve chain head: %v", err)
+	}
+	currentHeadRoot, err := ssz.SigningRoot(currentHead)
+	if err != nil {
+		return fmt.Errorf("could not hash current head block: %v", err)
+	}
+
+	isDescendant, err := c.isDescendant(currentHead, newHead)
+	if err != nil {
+		return fmt.Errorf("could not check if block is descendant: %v", err)
+	}
+
+	newState := postState
+	if !isDescendant && !proto.Equal(currentHead, newHead) {
+		log.WithFields(logrus.Fields{
+			"currentSlot": currentHead.Slot,
+			"currentRoot": fmt.Sprintf("%#x", bytesutil.Trunc(currentHeadRoot[:])),
+			"newSlot":     newHead.Slot,
+			"newRoot":     fmt.Sprintf("%#x", bytesutil.Trunc(newHeadRoot[:])),
+		}).Warn("Reorg happened")
+		// Only regenerate head state if there was a reorg.
+		newState, err = c.beaconDB.HistoricalStateFromSlot(ctx, newHead.Slot, newHeadRoot)
+		if err != nil {
+			return fmt.Errorf("could not gen state: %v", err)
+		}
+
+		for revertedSlot := currentHead.Slot; revertedSlot > newHead.Slot; revertedSlot-- {
+			delete(c.canonicalBlocks, revertedSlot)
+		}
+		reorgCount.Inc()
+	}
+
+	if proto.Equal(currentHead, newHead) {
+		log.WithFields(logrus.Fields{
+			"currentSlot": currentHead.Slot,
+			"currentRoot": fmt.Sprintf("%#x", bytesutil.Trunc(currentHeadRoot[:])),
+		}).Warn("Head did not change after fork choice, current head has the most votes")
+	}
+
+	// If we receive forked blocks.
+	if newHead.Slot != newState.Slot {
+		newState, err = c.beaconDB.HistoricalStateFromSlot(ctx, newHead.Slot, newHeadRoot)
+		if err != nil {
+			return fmt.Errorf("could not gen state: %v", err)
+		}
+	}
+
+	if err := c.beaconDB.UpdateChainHead(ctx, newHead, newState); err != nil {
+		return fmt.Errorf("failed to update chain: %v", err)
+	}
+	h, err := ssz.SigningRoot(newHead)
+	if err != nil {
+		return fmt.Errorf("could not hash head: %v", err)
+	}
+	log.WithFields(logrus.Fields{
+		"headRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(h[:])),
+		"headSlot":  newHead.Slot,
+		"stateSlot": newState.Slot,
+	}).Info("Chain head block and state updated")
+
+	return nil
+}
+
+// lmdGhost applies the Latest Message Driven, Greediest Heaviest Observed Sub-Tree
+// fork-choice rule defined in the Ethereum Serenity specification for the beacon chain.
+//
+// Spec pseudocode definition:
+//	def lmd_ghost(store: Store, start_state: BeaconState, start_block: BeaconBlock) -> BeaconBlock:
+//    """
+//    Execute the LMD-GHOST algorithm to find the head ``BeaconBlock``.
+//    """
+//    validators = start_state.validator_registry
+//    active_validator_indices = get_active_validator_indices(validators, slot_to_epoch(start_state.slot))
+//    attestation_targets = [
+//        (validator_index, get_latest_attestation_target(store, validator_index))
+//        for validator_index in active_validator_indices
+//    ]
+//
+//    def get_vote_count(block: BeaconBlock) -> int:
+//        return sum(
+//            get_effective_balance(start_state.validator_balances[validator_index]) // FORK_CHOICE_BALANCE_INCREMENT
+//            for validator_index, target in attestation_targets
+//            if get_ancestor(store, target, block.slot) == block
+//        )
+//
+//    head = start_block
+//    while 1:
+//        children = get_children(store, head)
+//        if len(children) == 0:
+//            return head
+//        head = max(children, key=get_vote_count)
+func (c *ChainService) lmdGhost(
+	ctx context.Context,
+	startBlock *pb.BeaconBlock,
+	startState *pb.BeaconState,
+	voteTargets map[uint64]*pb.AttestationTarget,
+) (*pb.BeaconBlock, error) {
+	highestSlot := c.beaconDB.HighestBlockSlot()
+	head := startBlock
+	for {
+		children, err := c.BlockChildren(ctx, head, highestSlot)
+		if err != nil {
+			return nil, fmt.Errorf("could not fetch block children: %v", err)
+		}
+		if len(children) == 0 {
+			return head, nil
+		}
+		maxChild := children[0]
+
+		maxChildVotes, err := VoteCount(maxChild, startState, voteTargets, c.beaconDB)
+		if err != nil {
+			return nil, fmt.Errorf("unable to determine vote count for block: %v", err)
+		}
+		for i := 1; i < len(children); i++ {
+			candidateChildVotes, err := VoteCount(children[i], startState, voteTargets, c.beaconDB)
+			if err != nil {
+				return nil, fmt.Errorf("unable to determine vote count for block: %v", err)
+			}
+			maxChildRoot, err := ssz.SigningRoot(maxChild)
+			if err != nil {
+				return nil, err
+			}
+			candidateChildRoot, err := ssz.SigningRoot(children[i])
+			if err != nil {
+				return nil, err
+			}
+			if candidateChildVotes > maxChildVotes ||
+				(candidateChildVotes == maxChildVotes && bytesutil.LowerThan(maxChildRoot[:], candidateChildRoot[:])) {
+				maxChild = children[i]
+			}
+		}
+		head = maxChild
+	}
+}
+
+// BlockChildren returns the child blocks of the given block up to a given
+// highest slot.
+//
+// ex:
+//       /- C - E
+// A - B - D - F
+//       \- G
+// Input: B. Output: [C, D, G]
+//
+// Spec pseudocode definition:
+//	get_children(store: Store, block: BeaconBlock) -> List[BeaconBlock]
+//		returns the child blocks of the given block.
+func (c *ChainService) BlockChildren(ctx context.Context, block *pb.BeaconBlock, highestSlot uint64) ([]*pb.BeaconBlock, error) {
+	blockRoot, err := ssz.SigningRoot(block)
+	if err != nil {
+		return nil, err
+	}
+	var children []*pb.BeaconBlock
+	startSlot := block.Slot + 1
+	for i := startSlot; i <= highestSlot; i++ {
+		kids, err := c.beaconDB.BlocksBySlot(ctx, i)
+		if err != nil {
+			return nil, fmt.Errorf("could not get block by slot: %v", err)
+		}
+		children = append(children, kids...)
+	}
+
+	filteredChildren := []*pb.BeaconBlock{}
+	for _, kid := range children {
+		parentRoot := bytesutil.ToBytes32(kid.ParentRoot)
+		if blockRoot == parentRoot {
+			filteredChildren = append(filteredChildren, kid)
+		}
+	}
+	return filteredChildren, nil
+}
+
+// isDescendant checks if the new head block is a descendant block of the current head.
+func (c *ChainService) isDescendant(currentHead *pb.BeaconBlock, newHead *pb.BeaconBlock) (bool, error) {
+	currentHeadRoot, err := ssz.SigningRoot(currentHead)
+	if err != nil {
+		return false, nil
+	}
+	for newHead.Slot > currentHead.Slot {
+		if bytesutil.ToBytes32(newHead.ParentRoot) == currentHeadRoot {
+			return true, nil
+		}
+		newHead, err = c.beaconDB.Block(bytesutil.ToBytes32(newHead.ParentRoot))
+		if err != nil {
+			return false, err
+		}
+		if newHead == nil {
+			return false, nil
+		}
+	}
+	return false, nil
+}
+
+// AttestationTargets retrieves the list of attestation targets since last finalized epoch,
+// each attestation target consists of validator index and its attestation target (i.e. the block
+// which the validator attested to)
+func (c *ChainService) AttestationTargets(state *pb.BeaconState) (map[uint64]*pb.AttestationTarget, error) {
+	indices, err := helpers.ActiveValidatorIndices(state, helpers.CurrentEpoch(state))
+	if err != nil {
+		return nil, err
+	}
+
+	attestationTargets := make(map[uint64]*pb.AttestationTarget)
+	for i, index := range indices {
+		target, err := c.attsService.LatestAttestationTarget(state, index)
+		if err != nil {
+			return nil, fmt.Errorf("could not retrieve attestation target: %v", err)
+		}
+		if target == nil {
+			continue
+		}
+		attestationTargets[uint64(i)] = target
+	}
+	return attestationTargets, nil
+}
+
+// VoteCount determines the number of votes on a beacon block by counting the number
+// of target blocks that have such beacon block as a common ancestor.
+//
+// Spec pseudocode definition:
+//  def get_vote_count(block: BeaconBlock) -> int:
+//        return sum(
+//            get_effective_balance(start_state.validator_balances[validator_index]) // FORK_CHOICE_BALANCE_INCREMENT
+//            for validator_index, target in attestation_targets
+//            if get_ancestor(store, target, block.slot) == block
+//        )
+func VoteCount(block *pb.BeaconBlock, state *pb.BeaconState, targets map[uint64]*pb.AttestationTarget, beaconDB *db.BeaconDB) (int, error) {
+	balances := 0
+	var ancestorRoot []byte
+	var err error
+
+	blockRoot, err := ssz.SigningRoot(block)
+	if err != nil {
+		return 0, err
+	}
+
+	for validatorIndex, target := range targets {
+		ancestorRoot, err = cachedAncestor(target, block.Slot, beaconDB)
+		if err != nil {
+			return 0, err
+		}
+		// This covers the following case, we start at B5, and want to process B6 and B7
+		// B6 can be processed, B7 can not be processed because it's pointed to the
+		// block older than current block 5.
+		// B4 - B5 - B6
+		//   \ - - - - - B7
+		if ancestorRoot == nil {
+			continue
+		}
+
+		if bytes.Equal(blockRoot[:], ancestorRoot) {
+			balances += int(state.Validators[validatorIndex].EffectiveBalance)
+		}
+	}
+	return balances, nil
+}
+
+// BlockAncestor obtains the ancestor at of a block at a certain slot.
+//
+// Spec pseudocode definition:
+//  def get_ancestor(store: Store, block: BeaconBlock, slot: Slot) -> BeaconBlock:
+//    """
+//    Get the ancestor of ``block`` with slot number ``slot``; return ``None`` if not found.
+//    """
+//    if block.slot == slot:
+//        return block
+//    elif block.slot < slot:
+//        return None
+//    else:
+//        return get_ancestor(store, store.get_parent(block), slot)
+func BlockAncestor(targetBlock *pb.AttestationTarget, slot uint64, beaconDB *db.BeaconDB) ([]byte, error) {
+	if targetBlock.Slot == slot {
+		return targetBlock.BlockRoot[:], nil
+	}
+	if targetBlock.Slot < slot {
+		return nil, nil
+	}
+	parentRoot := bytesutil.ToBytes32(targetBlock.ParentRoot)
+	parent, err := beaconDB.Block(parentRoot)
+	if err != nil {
+		return nil, fmt.Errorf("could not get parent block: %v", err)
+	}
+	if parent == nil {
+		return nil, fmt.Errorf("parent block does not exist: %v", err)
+	}
+	newTarget := &pb.AttestationTarget{
+		Slot:       parent.Slot,
+		BlockRoot:  parentRoot[:],
+		ParentRoot: parent.ParentRoot,
+	}
+	return BlockAncestor(newTarget, slot, beaconDB)
+}
+
+// cachedAncestor retrieves the cached ancestor target from block ancestor cache,
+// if it's not there it looks up the block tree get it and cache it.
+func cachedAncestor(target *pb.AttestationTarget, height uint64, beaconDB *db.BeaconDB) ([]byte, error) {
+	// check if the ancestor block of from a given block height was cached.
+	cachedAncestorInfo, err := blkAncestorCache.AncestorBySlot(target.BlockRoot, height)
+	if err != nil {
+		return nil, nil
+	}
+	if cachedAncestorInfo != nil {
+		return cachedAncestorInfo.Target.BlockRoot, nil
+	}
+
+	ancestorRoot, err := BlockAncestor(target, height, beaconDB)
+	if err != nil {
+		return nil, err
+	}
+	ancestor, err := beaconDB.Block(bytesutil.ToBytes32(ancestorRoot))
+	if err != nil {
+		return nil, err
+	}
+	if ancestor == nil {
+		return nil, nil
+	}
+	ancestorTarget := &pb.AttestationTarget{
+		Slot:       ancestor.Slot,
+		BlockRoot:  ancestorRoot,
+		ParentRoot: ancestor.ParentRoot,
+	}
+	if err := blkAncestorCache.AddBlockAncestor(&cache.AncestorInfo{
+		Height: height,
+		Hash:   target.BlockRoot,
+		Target: ancestorTarget,
+	}); err != nil {
+		return nil, err
+	}
+	return ancestorRoot, nil
+}

beacon-chain/blockchain/fork_choice_reorg_test.go

@@ -0,0 +1,234 @@
+package blockchain
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/prysmaticlabs/go-ssz"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/internal"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+)
+
+type mockAttestationHandler struct {
+	targets map[uint64]*pb.AttestationTarget
+}
+
+func (m *mockAttestationHandler) LatestAttestationTarget(beaconState *pb.BeaconState, idx uint64) (*pb.AttestationTarget, error) {
+	return m.targets[idx], nil
+}
+
+func (m *mockAttestationHandler) BatchUpdateLatestAttestation(ctx context.Context, atts []*pb.Attestation) error {
+	return nil
+}
+
+func TestApplyForkChoice_ChainSplitReorg(t *testing.T) {
+	// TODO(#2307): Fix test once v0.6 is merged.
+	t.Skip()
+	hook := logTest.NewGlobal()
+	beaconDB := internal.SetupDB(t)
+	defer internal.TeardownDB(t, beaconDB)
+
+	ctx := context.Background()
+	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
+	justifiedState, err := state.GenesisBeaconState(deposits, 0, nil)
+	if err != nil {
+		t.Fatalf("Can't generate genesis state: %v", err)
+	}
+	justifiedState.StateRoots = make([][]byte, params.BeaconConfig().HistoricalRootsLimit)
+	justifiedState.LatestBlockHeader = &pb.BeaconBlockHeader{
+		StateRoot: []byte{},
+	}
+
+	chainService := setupBeaconChain(t, beaconDB, nil)
+
+	// Construct a forked chain that looks as follows:
+	//    /------B1 ----B3 ----- B5 (current head)
+	// B0 --B2 -------------B4
+	blocks, roots := constructForkedChain(t, justifiedState)
+
+	// We then setup a canonical chain of the following blocks:
+	// B0->B1->B3->B5.
+	if err := chainService.beaconDB.SaveBlock(blocks[0]); err != nil {
+		t.Fatal(err)
+	}
+	if err := chainService.beaconDB.SaveJustifiedState(justifiedState); err != nil {
+		t.Fatal(err)
+	}
+	if err := chainService.beaconDB.SaveJustifiedBlock(blocks[0]); err != nil {
+		t.Fatal(err)
+	}
+	if err := chainService.beaconDB.UpdateChainHead(ctx, blocks[0], justifiedState); err != nil {
+		t.Fatal(err)
+	}
+	canonicalBlockIndices := []int{1, 3, 5}
+	postState := proto.Clone(justifiedState).(*pb.BeaconState)
+	for _, canonicalIndex := range canonicalBlockIndices {
+		postState, err = chainService.AdvanceState(ctx, postState, blocks[canonicalIndex])
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := chainService.beaconDB.SaveBlock(blocks[canonicalIndex]); err != nil {
+			t.Fatal(err)
+		}
+		if err := chainService.beaconDB.UpdateChainHead(ctx, blocks[canonicalIndex], postState); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	chainHead, err := chainService.beaconDB.ChainHead()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if chainHead.Slot != justifiedState.Slot+5 {
+		t.Errorf(
+			"Expected chain head with slot %d, received %d",
+			justifiedState.Slot+5,
+			chainHead.Slot,
+		)
+	}
+
+	// We then save forked blocks and their historical states (but do not update chain head).
+	// The fork is from B0->B2->B4.
+	forkedBlockIndices := []int{2, 4}
+	forkState := proto.Clone(justifiedState).(*pb.BeaconState)
+	for _, forkIndex := range forkedBlockIndices {
+		forkState, err = chainService.AdvanceState(ctx, forkState, blocks[forkIndex])
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := chainService.beaconDB.SaveBlock(blocks[forkIndex]); err != nil {
+			t.Fatal(err)
+		}
+		if err := chainService.beaconDB.SaveHistoricalState(ctx, forkState, roots[forkIndex]); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// Give the block from the forked chain, B4, the most votes.
+	voteTargets := make(map[uint64]*pb.AttestationTarget)
+	voteTargets[0] = &pb.AttestationTarget{
+		Slot:       blocks[5].Slot,
+		BlockRoot:  roots[5][:],
+		ParentRoot: blocks[5].ParentRoot,
+	}
+	for i := 1; i < len(deposits); i++ {
+		voteTargets[uint64(i)] = &pb.AttestationTarget{
+			Slot:       blocks[4].Slot,
+			BlockRoot:  roots[4][:],
+			ParentRoot: blocks[4].ParentRoot,
+		}
+	}
+	attHandler := &mockAttestationHandler{
+		targets: voteTargets,
+	}
+	chainService.attsService = attHandler
+
+	block4State, err := chainService.beaconDB.HistoricalStateFromSlot(ctx, blocks[4].Slot, roots[4])
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Applying the fork choice rule should reorg to B4 successfully.
+	if err := chainService.ApplyForkChoiceRule(ctx, blocks[4], block4State); err != nil {
+		t.Fatal(err)
+	}
+
+	newHead, err := chainService.beaconDB.ChainHead()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !proto.Equal(newHead, blocks[4]) {
+		t.Errorf(
+			"Expected chain head %v, received %v",
+			blocks[4],
+			newHead,
+		)
+	}
+	want := "Reorg happened"
+	testutil.AssertLogsContain(t, hook, want)
+}
+
+func constructForkedChain(t *testing.T, beaconState *pb.BeaconState) ([]*pb.BeaconBlock, [][32]byte) {
+	// Construct the following chain:
+	//    /------B1 ----B3 ----- B5 (current head)
+	// B0 --B2 -------------B4
+	blocks := make([]*pb.BeaconBlock, 6)
+	roots := make([][32]byte, 6)
+	var err error
+	blocks[0] = &pb.BeaconBlock{
+		Slot:       beaconState.Slot,
+		ParentRoot: []byte{'A'},
+		Body: &pb.BeaconBlockBody{
+			Eth1Data: &pb.Eth1Data{},
+		},
+	}
+	roots[0], err = ssz.SigningRoot(blocks[0])
+	if err != nil {
+		t.Fatalf("Could not hash block: %v", err)
+	}
+
+	blocks[1] = &pb.BeaconBlock{
+		Slot:       beaconState.Slot + 2,
+		ParentRoot: roots[0][:],
+		Body: &pb.BeaconBlockBody{
+			Eth1Data: &pb.Eth1Data{},
+		},
+	}
+	roots[1], err = ssz.SigningRoot(blocks[1])
+	if err != nil {
+		t.Fatalf("Could not hash block: %v", err)
+	}
+
+	blocks[2] = &pb.BeaconBlock{
+		Slot:       beaconState.Slot + 1,
+		ParentRoot: roots[0][:],
+		Body: &pb.BeaconBlockBody{
+			Eth1Data: &pb.Eth1Data{},
+		},
+	}
+	roots[2], err = ssz.SigningRoot(blocks[2])
+	if err != nil {
+		t.Fatalf("Could not hash block: %v", err)
+	}
+
+	blocks[3] = &pb.BeaconBlock{
+		Slot:       beaconState.Slot + 3,
+		ParentRoot: roots[1][:],
+		Body: &pb.BeaconBlockBody{
+			Eth1Data: &pb.Eth1Data{},
+		},
+	}
+	roots[3], err = ssz.SigningRoot(blocks[3])
+	if err != nil {
+		t.Fatalf("Could not hash block: %v", err)
+	}
+
+	blocks[4] = &pb.BeaconBlock{
+		Slot:       beaconState.Slot + 4,
+		ParentRoot: roots[2][:],
+		Body: &pb.BeaconBlockBody{
+			Eth1Data: &pb.Eth1Data{},
+		},
+	}
+	roots[4], err = ssz.SigningRoot(blocks[4])
+	if err != nil {
+		t.Fatalf("Could not hash block: %v", err)
+	}
+
+	blocks[5] = &pb.BeaconBlock{
+		Slot:       beaconState.Slot + 5,
+		ParentRoot: roots[3][:],
+		Body: &pb.BeaconBlockBody{
+			Eth1Data: &pb.Eth1Data{},
+		},
+	}
+	roots[5], err = ssz.SigningRoot(blocks[5])
+	if err != nil {
+		t.Fatalf("Could not hash block: %v", err)
+	}
+	return blocks, roots
+}

beacon-chain/blockchain/head.go

@@ -1,389 +0,0 @@
-package blockchain
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"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"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/features"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-)
-
-// UpdateAndSaveHeadWithBalances updates the beacon state head after getting justified balanced from cache.
-// This function is only used in spec-tests, it does save the head after updating it.
-func (s *Service) UpdateAndSaveHeadWithBalances(ctx context.Context) error {
-	cp := s.store.JustifiedCheckpt()
-	if cp == nil {
-		return errors.New("no justified checkpoint")
-	}
-	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(cp.Root))
-	if err != nil {
-		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", cp.Root)
-		return errors.Wrap(err, msg)
-	}
-	headRoot, err := s.updateHead(ctx, balances)
-	if err != nil {
-		return errors.Wrap(err, "could not update head")
-	}
-	headBlock, err := s.cfg.BeaconDB.Block(ctx, headRoot)
-	if err != nil {
-		return err
-	}
-	headState, err := s.cfg.StateGen.StateByRoot(ctx, headRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not retrieve head state in DB")
-	}
-	return s.saveHead(ctx, headRoot, headBlock, headState)
-}
-
-// This defines the current chain service's view of head.
-type head struct {
-	slot  types.Slot              // current head slot.
-	root  [32]byte                // current head root.
-	block block.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) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "blockChain.updateHead")
-	defer span.End()
-
-	// Get head from the fork choice service.
-	f := s.store.FinalizedCheckpt()
-	if f == nil {
-		return [32]byte{}, errNilFinalizedInStore
-	}
-	j := s.store.JustifiedCheckpt()
-	if j == nil {
-		return [32]byte{}, errNilJustifiedInStore
-	}
-	// To get head before the first justified epoch, the fork choice will start with origin root
-	// instead of zero hashes.
-	headStartRoot := bytesutil.ToBytes32(j.Root)
-	if headStartRoot == params.BeaconConfig().ZeroHash {
-		headStartRoot = s.originBlockRoot
-	}
-
-	// In order to process head, fork choice store requires justified info.
-	// If the fork choice store is missing justified block info, a node should
-	// re-initiate fork choice store using the latest justified info.
-	// This recovers a fatal condition and should not happen in run time.
-	if !s.cfg.ForkChoiceStore.HasNode(headStartRoot) {
-		jb, err := s.cfg.BeaconDB.Block(ctx, headStartRoot)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		if features.Get().EnableForkChoiceDoublyLinkedTree {
-			s.cfg.ForkChoiceStore = doublylinkedtree.New(j.Epoch, f.Epoch)
-		} else {
-			s.cfg.ForkChoiceStore = protoarray.New(j.Epoch, f.Epoch, bytesutil.ToBytes32(f.Root))
-		}
-		if err := s.insertBlockToForkChoiceStore(ctx, jb.Block(), headStartRoot, f, j); err != nil {
-			return [32]byte{}, err
-		}
-	}
-
-	return s.cfg.ForkChoiceStore.Head(ctx, j.Epoch, headStartRoot, balances, f.Epoch)
-}
-
-// 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, headBlock block.SignedBeaconBlock, headState state.BeaconState) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.saveHead")
-	defer span.End()
-
-	// Do nothing if head hasn't changed.
-	r, err := s.HeadRoot(ctx)
-	if err != nil {
-		return err
-	}
-	if headRoot == bytesutil.ToBytes32(r) {
-		return nil
-	}
-	if err := helpers.BeaconBlockIsNil(headBlock); err != nil {
-		return err
-	}
-	if headState == nil || headState.IsNil() {
-		return errors.New("cannot save nil head state")
-	}
-
-	// If the head state is not available, just return nil.
-	// There's nothing to cache
-	if !s.cfg.BeaconDB.HasStateSummary(ctx, headRoot) {
-		return nil
-	}
-
-	// A chain re-org occurred, so we fire an event notifying the rest of the services.
-	headSlot := s.HeadSlot()
-	newHeadSlot := headBlock.Block().Slot()
-	oldHeadRoot := s.headRoot()
-	oldStateRoot := s.headBlock().Block().StateRoot()
-	newStateRoot := headBlock.Block().StateRoot()
-	if bytesutil.ToBytes32(headBlock.Block().ParentRoot()) != bytesutil.ToBytes32(r) {
-		log.WithFields(logrus.Fields{
-			"newSlot": fmt.Sprintf("%d", newHeadSlot),
-			"oldSlot": fmt.Sprintf("%d", headSlot),
-		}).Debug("Chain reorg occurred")
-		absoluteSlotDifference := slots.AbsoluteValueSlotDifference(newHeadSlot, headSlot)
-		isOptimistic, err := s.IsOptimistic(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not check if node is optimistically synced")
-		}
-		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-			Type: statefeed.Reorg,
-			Data: &ethpbv1.EventChainReorg{
-				Slot:                newHeadSlot,
-				Depth:               absoluteSlotDifference,
-				OldHeadBlock:        oldHeadRoot[:],
-				NewHeadBlock:        headRoot[:],
-				OldHeadState:        oldStateRoot,
-				NewHeadState:        newStateRoot,
-				Epoch:               slots.ToEpoch(newHeadSlot),
-				ExecutionOptimistic: isOptimistic,
-			},
-		})
-
-		if err := s.saveOrphanedAtts(ctx, bytesutil.ToBytes32(r)); err != nil {
-			return err
-		}
-
-		reorgCount.Inc()
-	}
-
-	// Cache the new head info.
-	s.setHead(headRoot, headBlock, headState)
-
-	// Save the new head root to DB.
-	if err := s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, headRoot); err != nil {
-		return errors.Wrap(err, "could not save head root in DB")
-	}
-
-	// Forward an event capturing a new chain head over a common event feed
-	// done in a goroutine to avoid blocking the critical runtime main routine.
-	go func() {
-		if err := s.notifyNewHeadEvent(ctx, newHeadSlot, headState, newStateRoot, headRoot[:]); err != nil {
-			log.WithError(err).Error("Could not notify event feed of new chain head")
-		}
-	}()
-
-	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 block.SignedBeaconBlock, r [32]byte, hs state.BeaconState) error {
-	if err := helpers.BeaconBlockIsNil(b); err != nil {
-		return err
-	}
-	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
-	}
-
-	s.setHeadInitialSync(r, b.Copy(), 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 block.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: block.Copy(),
-		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 block.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: block.Copy(),
-		state: state,
-	}
-}
-
-// This returns the head slot.
-// This is a lock free version.
-func (s *Service) headSlot() types.Slot {
-	return s.head.slot
-}
-
-// This returns the head root.
-// It does a full copy on head root for immutability.
-// This is a lock free version.
-func (s *Service) headRoot() [32]byte {
-	if s.head == nil {
-		return params.BeaconConfig().ZeroHash
-	}
-
-	return s.head.root
-}
-
-// This returns the head block.
-// It does a full copy on head block for immutability.
-// This is a lock free version.
-func (s *Service) headBlock() block.SignedBeaconBlock {
-	return s.head.block.Copy()
-}
-
-// This returns the head state.
-// It does a full copy on head state for immutability.
-// This is a lock free version.
-func (s *Service) headState(ctx context.Context) state.BeaconState {
-	_, span := trace.StartSpan(ctx, "blockChain.headState")
-	defer span.End()
-
-	return s.head.state.Copy()
-}
-
-// This returns the genesis validators root of the head state.
-// This is a lock free version.
-func (s *Service) headGenesisValidatorsRoot() [32]byte {
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
-}
-
-// This returns the validator referenced by the provided index in
-// the head state.
-// This is a lock free version.
-func (s *Service) headValidatorAtIndex(index types.ValidatorIndex) (state.ReadOnlyValidator, error) {
-	return s.head.state.ValidatorAtIndexReadOnly(index)
-}
-
-// This returns the validator index referenced by the provided pubkey in
-// the head state.
-// This is a lock free version.
-func (s *Service) headValidatorIndexAtPubkey(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool) {
-	return s.head.state.ValidatorIndexByPubkey(pubKey)
-}
-
-// Returns true if head state exists.
-// This is the lock free version.
-func (s *Service) hasHeadState() bool {
-	return s.head != nil && s.head.state != nil
-}
-
-// Notifies a common event feed of a new chain head event. Called right after a new
-// chain head is determined, set, and saved to disk.
-func (s *Service) notifyNewHeadEvent(
-	ctx context.Context,
-	newHeadSlot types.Slot,
-	newHeadState state.BeaconState,
-	newHeadStateRoot,
-	newHeadRoot []byte,
-) error {
-	previousDutyDependentRoot := s.originBlockRoot[:]
-	currentDutyDependentRoot := s.originBlockRoot[:]
-
-	var previousDutyEpoch types.Epoch
-	currentDutyEpoch := slots.ToEpoch(newHeadSlot)
-	if currentDutyEpoch > 0 {
-		previousDutyEpoch = currentDutyEpoch.Sub(1)
-	}
-	currentDutySlot, err := slots.EpochStart(currentDutyEpoch)
-	if err != nil {
-		return errors.Wrap(err, "could not get duty slot")
-	}
-	previousDutySlot, err := slots.EpochStart(previousDutyEpoch)
-	if err != nil {
-		return errors.Wrap(err, "could not get duty slot")
-	}
-	if currentDutySlot > 0 {
-		currentDutyDependentRoot, err = helpers.BlockRootAtSlot(newHeadState, currentDutySlot-1)
-		if err != nil {
-			return errors.Wrap(err, "could not get duty dependent root")
-		}
-	}
-	if previousDutySlot > 0 {
-		previousDutyDependentRoot, err = helpers.BlockRootAtSlot(newHeadState, previousDutySlot-1)
-		if err != nil {
-			return errors.Wrap(err, "could not get duty dependent root")
-		}
-	}
-	isOptimistic, err := s.IsOptimistic(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not check if node is optimistically synced")
-	}
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.NewHead,
-		Data: &ethpbv1.EventHead{
-			Slot:                      newHeadSlot,
-			Block:                     newHeadRoot,
-			State:                     newHeadStateRoot,
-			EpochTransition:           slots.IsEpochStart(newHeadSlot),
-			PreviousDutyDependentRoot: previousDutyDependentRoot,
-			CurrentDutyDependentRoot:  currentDutyDependentRoot,
-			ExecutionOptimistic:       isOptimistic,
-		},
-	})
-	return nil
-}
-
-// This saves the attestations inside the beacon block with respect to root `orphanedRoot` back into the
-// attestation pool. It also filters out the attestations that is one epoch older as a
-// defense so invalid attestations don't flow into the attestation pool.
-func (s *Service) saveOrphanedAtts(ctx context.Context, orphanedRoot [32]byte) error {
-	if !features.Get().CorrectlyInsertOrphanedAtts {
-		return nil
-	}
-
-	orphanedBlk, err := s.cfg.BeaconDB.Block(ctx, orphanedRoot)
-	if err != nil {
-		return err
-	}
-
-	if orphanedBlk == nil || orphanedBlk.IsNil() {
-		return errors.New("orphaned block can't be nil")
-	}
-
-	for _, a := range orphanedBlk.Block().Body().Attestations() {
-		// Is the attestation one epoch older.
-		if a.Data.Slot+params.BeaconConfig().SlotsPerEpoch < s.CurrentSlot() {
-			continue
-		}
-		if helpers.IsAggregated(a) {
-			if err := s.cfg.AttPool.SaveAggregatedAttestation(a); err != nil {
-				return err
-			}
-		} else {
-			if err := s.cfg.AttPool.SaveUnaggregatedAttestation(a); err != nil {
-				return err
-			}
-		}
-		saveOrphanedAttCount.Inc()
-	}
-
-	return nil
-}

beacon-chain/blockchain/head_sync_committee_info.go

@@ -1,172 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/async"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-// Initialize the state cache for sync committees.
-var syncCommitteeHeadStateCache = cache.NewSyncCommitteeHeadState()
-
-// HeadSyncCommitteeFetcher is the interface that wraps the head sync committee related functions.
-// The head sync committee functions return callers sync committee indices and public keys with respect to current head state.
-type HeadSyncCommitteeFetcher interface {
-	HeadSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error)
-	HeadSyncCommitteePubKeys(ctx context.Context, slot types.Slot, committeeIndex types.CommitteeIndex) ([][]byte, error)
-}
-
-// HeadDomainFetcher is the interface that wraps the head sync domain related functions.
-// The head sync committee domain functions return callers domain data with respect to slot and head state.
-type HeadDomainFetcher interface {
-	HeadSyncCommitteeDomain(ctx context.Context, slot types.Slot) ([]byte, error)
-	HeadSyncSelectionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error)
-	HeadSyncContributionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error)
-}
-
-// HeadSyncCommitteeDomain returns the head sync committee domain using current head state advanced up to `slot`.
-func (s *Service) HeadSyncCommitteeDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
-	return s.domainWithHeadState(ctx, slot, params.BeaconConfig().DomainSyncCommittee)
-}
-
-// HeadSyncSelectionProofDomain returns the head sync committee domain using current head state advanced up to `slot`.
-func (s *Service) HeadSyncSelectionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
-	return s.domainWithHeadState(ctx, slot, params.BeaconConfig().DomainSyncCommitteeSelectionProof)
-}
-
-// HeadSyncContributionProofDomain returns the head sync committee domain using current head state advanced up to `slot`.
-func (s *Service) HeadSyncContributionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
-	return s.domainWithHeadState(ctx, slot, params.BeaconConfig().DomainContributionAndProof)
-}
-
-// HeadSyncCommitteeIndices returns the sync committee index position using the head state. Input `slot` is taken in consideration
-// where validator's duty for `slot - 1` is used for block inclusion in `slot`. That means when a validator is at epoch boundary
-// across EPOCHS_PER_SYNC_COMMITTEE_PERIOD then the valiator will be considered using next period sync committee.
-//
-// Spec definition:
-// Being assigned to a sync committee for a given slot means that the validator produces and broadcasts signatures for slot - 1 for inclusion in slot.
-// This means that when assigned to an epoch sync committee signatures must be produced and broadcast for slots on range
-// [compute_start_slot_at_epoch(epoch) - 1, compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH - 1)
-// rather than for the range
-// [compute_start_slot_at_epoch(epoch), compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH)
-func (s *Service) HeadSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
-	nextSlotEpoch := slots.ToEpoch(slot + 1)
-	currentEpoch := slots.ToEpoch(slot)
-
-	switch {
-	case slots.SyncCommitteePeriod(nextSlotEpoch) == slots.SyncCommitteePeriod(currentEpoch):
-		return s.headCurrentSyncCommitteeIndices(ctx, index, slot)
-	// At sync committee period boundary, validator should sample the next epoch sync committee.
-	case slots.SyncCommitteePeriod(nextSlotEpoch) == slots.SyncCommitteePeriod(currentEpoch)+1:
-		return s.headNextSyncCommitteeIndices(ctx, index, slot)
-	default:
-		// Impossible condition.
-		return nil, errors.New("could get calculate sync subcommittee based on the period")
-	}
-}
-
-// headCurrentSyncCommitteeIndices returns the input validator `index`'s position indices in the current sync committee with respect to `slot`.
-// Head state advanced up to `slot` is used for calculation.
-func (s *Service) headCurrentSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-	return helpers.CurrentPeriodSyncSubcommitteeIndices(headState, index)
-}
-
-// headNextSyncCommitteeIndices returns the input validator `index`'s position indices in the next sync committee with respect to `slot`.
-// Head state advanced up to `slot` is used for calculation.
-func (s *Service) headNextSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-	return helpers.NextPeriodSyncSubcommitteeIndices(headState, index)
-}
-
-// HeadSyncCommitteePubKeys returns the head sync committee public keys with respect to `slot` and subcommittee index `committeeIndex`.
-// Head state advanced up to `slot` is used for calculation.
-func (s *Service) HeadSyncCommitteePubKeys(ctx context.Context, slot types.Slot, committeeIndex types.CommitteeIndex) ([][]byte, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-
-	nextSlotEpoch := slots.ToEpoch(headState.Slot() + 1)
-	currEpoch := slots.ToEpoch(headState.Slot())
-
-	var syncCommittee *ethpb.SyncCommittee
-	if currEpoch == nextSlotEpoch || slots.SyncCommitteePeriod(currEpoch) == slots.SyncCommitteePeriod(nextSlotEpoch) {
-		syncCommittee, err = headState.CurrentSyncCommittee()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		syncCommittee, err = headState.NextSyncCommittee()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return altair.SyncSubCommitteePubkeys(syncCommittee, committeeIndex)
-}
-
-// returns calculated domain using input `domain` and `slot`.
-func (s *Service) domainWithHeadState(ctx context.Context, slot types.Slot, domain [4]byte) ([]byte, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorsRoot())
-}
-
-// returns the head state that is advanced up to `slot`. It utilizes the cache `syncCommitteeHeadState` by retrieving using `slot` as key.
-// For the cache miss, it processes head state up to slot and fill the cache with `slot` as key.
-func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot types.Slot) (state.BeaconState, error) {
-	var headState state.BeaconState
-	var err error
-	mLock := async.NewMultilock(fmt.Sprintf("%s-%d", "syncHeadState", slot))
-	mLock.Lock()
-	defer mLock.Unlock()
-
-	// If there's already a head state exists with the request slot, we don't need to process slots.
-	cachedState, err := syncCommitteeHeadStateCache.Get(slot)
-	switch {
-	case err == nil:
-		syncHeadStateHit.Inc()
-		headState = cachedState
-		return headState, nil
-	case errors.Is(err, cache.ErrNotFound):
-		headState, err = s.HeadState(ctx)
-		if err != nil {
-			return nil, err
-		}
-		if headState == nil || headState.IsNil() {
-			return nil, errors.New("nil state")
-		}
-		headState, err = transition.ProcessSlotsIfPossible(ctx, headState, slot)
-		if err != nil {
-			return nil, err
-		}
-		syncHeadStateMiss.Inc()
-		err = syncCommitteeHeadStateCache.Put(slot, headState)
-		return headState, err
-	default:
-		// In the event, we encounter another error
-		// we return it.
-		return nil, err
-	}
-}

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -1,176 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-func TestService_headSyncCommitteeFetcher_Errors(t *testing.T) {
-	beaconDB := dbtest.SetupDB(t)
-	c := &Service{
-		cfg: &config{
-			StateGen: stategen.New(beaconDB),
-		},
-	}
-	c.head = &head{}
-	_, err := c.headCurrentSyncCommitteeIndices(context.Background(), types.ValidatorIndex(0), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.headNextSyncCommitteeIndices(context.Background(), types.ValidatorIndex(0), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.HeadSyncCommitteePubKeys(context.Background(), types.Slot(0), types.CommitteeIndex(0))
-	require.ErrorContains(t, "nil state", err)
-}
-
-func TestService_HeadDomainFetcher_Errors(t *testing.T) {
-	beaconDB := dbtest.SetupDB(t)
-	c := &Service{
-		cfg: &config{
-			StateGen: stategen.New(beaconDB),
-		},
-	}
-	c.head = &head{}
-	_, err := c.HeadSyncCommitteeDomain(context.Background(), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.HeadSyncSelectionProofDomain(context.Background(), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.HeadSyncSelectionProofDomain(context.Background(), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-}
-
-func TestService_HeadSyncCommitteeIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Current period
-	slot := 2*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	a, err := c.HeadSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-
-	// Current period where slot-2 across EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-	slot = 3*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) - 2
-	b, err := c.HeadSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-	require.DeepEqual(t, a, b)
-
-	// Next period where slot-1 across EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-	slot = 3*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) - 1
-	b, err = c.HeadSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-	require.DeepNotEqual(t, a, b)
-}
-
-func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
-	slot := uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	indices, err := c.headCurrentSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-
-	// NextSyncCommittee becomes CurrentSyncCommittee so it should be empty by default.
-	require.Equal(t, 0, len(indices))
-}
-
-func TestService_headNextSyncCommitteeIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
-	slot := uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	indices, err := c.headNextSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-
-	// NextSyncCommittee should be be empty after `ProcessSyncCommitteeUpdates`. Validator should get indices.
-	require.NotEqual(t, 0, len(indices))
-}
-
-func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Process slot up to 2 * `EpochsPerSyncCommitteePeriod` so it can run `ProcessSyncCommitteeUpdates` twice.
-	slot := uint64(2*params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	pubkeys, err := c.HeadSyncCommitteePubKeys(context.Background(), types.Slot(slot), 0)
-	require.NoError(t, err)
-
-	// Any subcommittee should match the subcommittee size.
-	subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
-	require.Equal(t, int(subCommitteeSize), len(pubkeys))
-}
-
-func TestService_HeadSyncCommitteeDomain(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
-	require.NoError(t, err)
-
-	d, err := c.HeadSyncCommitteeDomain(context.Background(), 0)
-	require.NoError(t, err)
-
-	require.DeepEqual(t, wanted, d)
-}
-
-func TestService_HeadSyncContributionProofDomain(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorsRoot())
-	require.NoError(t, err)
-
-	d, err := c.HeadSyncContributionProofDomain(context.Background(), 0)
-	require.NoError(t, err)
-
-	require.DeepEqual(t, wanted, d)
-}
-
-func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorsRoot())
-	require.NoError(t, err)
-
-	d, err := c.HeadSyncSelectionProofDomain(context.Background(), 0)
-	require.NoError(t, err)
-
-	require.DeepEqual(t, wanted, d)
-}
-
-func TestSyncCommitteeHeadStateCache_RoundTrip(t *testing.T) {
-	c := syncCommitteeHeadStateCache
-	t.Cleanup(func() {
-		syncCommitteeHeadStateCache = cache.NewSyncCommitteeHeadState()
-	})
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
-	require.NoError(t, beaconState.SetSlot(100))
-	cachedState, err := c.Get(101)
-	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
-	require.Equal(t, nil, cachedState)
-	require.NoError(t, c.Put(101, beaconState))
-	cachedState, err = c.Get(101)
-	require.NoError(t, err)
-	require.DeepEqual(t, beaconState, cachedState)
-}