cleanup for PR

some quick readability improvements and simplifying the logic enforcing
the startup ordering of the attestation processing routine

.bazelrc

@@ -5,45 +5,84 @@ test --test_verbose_timeout_warnings
 test --build_tests_only
 test --test_output=errors
 
+# E2E run with debug gotag
+test:e2e --define gotags=debug
+
+# Clearly indicate that coverage is enabled to disable certain nogo checks.
+coverage --define=coverage_enabled=1
+
 # 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. This flag is no longer experimental after 0.29.0.
-# Network sandboxing only works on linux.
---experimental_sandbox_default_allow_network=false
+# is required within the sandbox. Network sandboxing only works on linux.
+build --sandbox_default_allow_network=false
 
-# Use mainnet protobufs at runtime
-run --define ssz=mainnet
-test --define ssz=mainnet
-build --define ssz=mainnet
+# 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
 
-# Disable kafka by default, it takes a long time to build...
-build --define kafka_enabled=false
-test --define kafka_enabled=false
-run --define kafka_enabled=false
+build --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 --workspace_status_command=./scripts/workspace_status.sh
-build:release --stamp
 build:release --compilation_mode=opt
+build:release --config=llvm
 
 # LLVM compiler for building C/C++ dependencies.
 build:llvm --crosstool_top=@llvm_toolchain//:toolchain
 build:llvm --define compiler=llvm
+build:llvm --copt -fno-sanitize=vptr,function
+build:llvm --linkopt -fno-sanitize=vptr,function
+
+build:asan --copt -fsanitize=address,undefined
+build:asan --copt -fno-omit-frame-pointer
+build:asan --linkopt -fsanitize=address,undefined
+build:asan --copt -fno-sanitize=vptr,function
+build:asan --linkopt -fno-sanitize=vptr,function
+build:asan --copt -DADDRESS_SANITIZER=1
+build:asan --copt -D__SANITIZE_ADDRESS__
+build:asan --linkopt -ldl
+
+build:llvm-asan --config=llvm
+build:llvm-asan --config=asan
+build:llvm-asan --linkopt -fuse-ld=ld.lld
+
+build:fuzz --define=gotags=libfuzzer
+build:fuzz --config=llvm-asan
+build:fuzz --copt=-fsanitize=fuzzer-no-link
+build:fuzz --linkopt=-fsanitize=fuzzer
+build:fuzz --copt=-fno-omit-frame-pointer
+build:fuzz --define=FUZZING_ENGINE=libfuzzer
+build:fuzz --copt=-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+build:fuzz --linkopt -Wl,--no-as-needed
+build:fuzz --define=gc_goopts=-d=libfuzzer,checkptr
+build:fuzz --run_under=//tools:fuzz_wrapper
+build:fuzz --compilation_mode=opt
+build:fuzz --define=blst_disabled=true
+
+test:fuzz --local_test_jobs="HOST_CPUS*.5"
 
 # 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:
 -----------------------------------------------
@@ -188,3 +227,6 @@ build:remote --remote_timeout=3600
 build:remote --experimental_remote_download_outputs=toplevel --experimental_inmemory_jdeps_files --experimental_inmemory_dotd_files
 
 build:remote --remote_local_fallback
+
+# Ignore GoStdLib with remote caching
+build --modify_execution_info='GoStdlib.*=+no-remote-cache'

.bazelversion

@@ -1 +1 @@
-3.0.0
+4.2.1

.buildkite-bazelrc

@@ -2,30 +2,27 @@
 # across machines, developers, and workspaces.
 # 
 # This config is loaded from https://github.com/bazelbuild/bazel-toolchains/blob/master/bazelrc/latest.bazelrc
-build:remote-cache --remote_cache=grpcs://remotebuildexecution.googleapis.com
-build:remote-cache --remote_timeout=3600
-build:remote-cache --auth_enabled=true
-build:remote-cache --spawn_strategy=standalone
-build:remote-cache --strategy=Javac=standalone
-build:remote-cache --strategy=Closure=standalone
-build:remote-cache --strategy=Genrule=standalone
-
-# Build results backend.                                                        
-#build:remote-cache --bes_results_url="https://source.cloud.google.com/results/invocations/"
-#build:remote-cache --bes_backend=buildeventservice.googleapis.com               
-#build:remote-cache --bes_timeout=60s                                            
-#build:remote-cache --project_id=prysmaticlabs
+#build:remote-cache --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
 
 # Prysm specific remote-cache properties.
-build:remote-cache --disk_cache=
-build:remote-cache --host_platform_remote_properties_override='properties:{name:\"cache-silo-key\" value:\"prysm\"}' 
-build:remote-cache --remote_instance_name=projects/prysmaticlabs/instances/default_instance
-build:remote-cache --remote_download_minimal
+#build:remote-cache --disk_cache=
+build:remote-cache --remote_download_toplevel
+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
+# 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
 
 # Import workspace options.
 import %workspace%/.bazelrc
 
-startup --host_jvm_args=-Xmx1000m --host_jvm_args=-Xms1000m
+startup --host_jvm_args=-Xmx2g --host_jvm_args=-Xms2g
 query --repository_cache=/tmp/repositorycache
 query --experimental_repository_cache_hardlinks
 build --repository_cache=/tmp/repositorycache
@@ -44,8 +41,9 @@ build --flaky_test_attempts=5
 # Disabled race detection due to unstable test results under constrained environment build kite
 # build --features=race
 
-# Enable kafka for CI tests only.
-test --define kafka_enabled=true
+# Disable flaky test detection for fuzzing.
+test:fuzz --flaky_test_attempts=1
 
-build --bes_backend=grpcs://builds.prylabs.net:1985
-build --bes_results_url=https://builds.prylabs.net/invocation/
+# 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"
-  - "**/*_mock.go"
+  - "**/testing/**/*"

.deepsource.toml

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

.github/CODEOWNERS

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

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/discussion.md

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

.github/ISSUE_TEMPLATE/feature_flag.md

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

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,30 @@
+<!-- Thanks for sending a PR! Before submitting:
+
+1. If this is your first PR, 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

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

.github/actions/gofmt/action.yml

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

.github/actions/gofmt/entrypoint.sh

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

.github/actions/gomodtidy/Dockerfile

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

.github/actions/gomodtidy/action.yml

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

.github/actions/gomodtidy/entrypoint.sh

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

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

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

.github/workflows/go.yml

@@ -0,0 +1,67 @@
+name: Go
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ '*' ]
+
+jobs:
+
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Go mod tidy checker
+        id: gomodtidy
+        uses: ./.github/actions/gomodtidy
+
+      - name: Gofmt checker
+        id: gofmt
+        uses: ./.github/actions/gofmt
+        with:
+          path: ./
+
+      - name: GoImports checker
+        id: goimports
+        uses: Jerome1337/goimports-action@v1.0.2
+        with:
+          goimports-path: ./
+
+      - name: Gosec security scanner
+        uses: securego/gosec@master
+        with:
+          args: '-exclude=G307 -exclude-dir=crypto/bls/herumi ./...'
+
+      - 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
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Go 1.x
+        uses: actions/setup-go@v2
+        with:
+          go-version: ^1.14
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Get dependencies
+        run: |
+          go get -v -t -d ./...
+
+      - name: Build
+        # 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 ./...

.gitignore

@@ -27,9 +27,12 @@ yarn-error.log
 # Ignore password file
 password.txt
 
-# go dependancy
-/go.mod
-/go.sum
-
 # Dist files
 dist
+
+# libfuzzer
+oom-*
+crash-*
+
+# deepsource cli
+bin

.policy.yml

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

.well-known/security.pub

@@ -0,0 +1,218 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=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:341396BAFACC28C5082327F889725027FC8EC0D4
-Encryption: openpgp4fpr:FEE44615A19049DF0CA0C2735E2B7E5734DFADCB
+Encryption: openpgp4fpr:CD08DE68C60B82D3EE2A3F7D95452A701810FEDB
+Encryption: openpgp4fpr:317D6E91058F8F3C2303BA7756313E44581297A6
+Encryption: openpgp4fpr:79C59A585E3FD3AFFA00F5C22940A6479DA7C9EC
 Preferred-Languages: en
 Canonical: https://github.com/prysmaticlabs/prysm/tree/master/.well-known/security.txt
-
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEECuAFHWR7o8GpF69AcuM+TfGlA24FAl6HrcwACgkQcuM+TfGl
-A26voQ/8DFB5wUHP0uyY8k7FGbxhLzSeImxomnUHJaUGfdczbCdYPMEHc9zI1iZP
-6LRiy9wS6qhqj/GSKVwvDPr+ZymXuV3L22GOP2lRhl7Z9Mm21ZJNOcoQBFOZnyHu
-DAy9HeTmeuJxYkf8weqZYXyzEoKJBDmfuWmEFjrtMcFXUfT3aJn1E2A/AQdcVQIC
-9L+iGWwFwjsPhcfaMuwcB7QMheDO6KSB7XPPCbrZ036Np8UTZ4qbZ5y73tlfkcOc
-tYTrMSPtS4eNutiDOP5Np36cLzRtNpm/BziAK+7ZKiYY0HI5h9IkCTLO4x2UmAMX
-sPoeaAB5z2QLIwmU9J2NhJrwiNMGTpJ+0bowy8U4cgzAX20CXVjRqGhy+cir8Ewg
-DjEGjWINUw6W0yzJp0mKSKzuOhdTTmzIYBeMBsyce+pgN1KGFCxeIwxGxyJzADdw
-mYQdljRXn4yEYP/KEpu/F2o8L4ptRO2jZWKvTvdzSSGGSyKyF4HsIRJ7m98DaB6S
-0oGq1KpbKKTbQi5g8UShGV2gPeMCs5ZIIqK2b/cRzUet18aUuofLmR4lkKZa9yEG
-rbzuJq/gB2vgQwExUEgVQ3/DfVc+y80e3YZ5s+rzV0vbLxl4Gh4yExpLo7hRf9iY
-EFvMzH+BEEb5VfCwByZyV1BmesZVIosr7K6UmVtPe0bZGvv3uIg=
-=5qpD
+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
 -----END PGP SIGNATURE-----

BUILD.bazel

@@ -4,6 +4,7 @@ load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
 load("@graknlabs_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
+load("@bazel_skylib//rules:common_settings.bzl", "string_setting")
 
 prefix = "github.com/prysmaticlabs/prysm"
 
@@ -12,6 +13,9 @@ exports_files([
 ])
 
 # 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(
     name = "gazelle",
     prefix = prefix,
@@ -20,7 +24,16 @@ gazelle(
 # Protobuf compiler (non-gRPC)
 alias(
     name = "proto_compiler",
-    actual = "@io_bazel_rules_go//proto:gogofast_proto",
+    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",
     visibility = [
         "//proto:__subpackages__",
     ],
@@ -29,21 +42,21 @@ alias(
 # Protobuf compiler (gRPC)
 alias(
     name = "grpc_proto_compiler",
-    actual = "@io_bazel_rules_go//proto:gogofast_grpc",
+    actual = "@io_bazel_rules_go//proto:go_grpc",
     visibility = ["//visibility:public"],
 )
 
-# Protobuf gRPC compiler without gogoproto. Required for gRPC gateway.
+# Cast protobuf compiler (gRPC)
 alias(
-    name = "grpc_nogogo_proto_compiler",
-    actual = "@io_bazel_rules_go//proto:go_grpc",
+    name = "cast_grpc_proto_compiler",
+    actual = "@com_github_prysmaticlabs_protoc_gen_go_cast//:go_cast_grpc",
     visibility = ["//visibility:public"],
 )
 
 # Protobuf gRPC gateway compiler
 alias(
     name = "grpc_gateway_proto_compiler",
-    actual = "@grpc_ecosystem_grpc_gateway//protoc-gen-grpc-gateway:go_gen_grpc_gateway",
+    actual = "@com_github_grpc_ecosystem_grpc_gateway_v2//protoc-gen-grpc-gateway:go_gen_grpc_gateway",
     visibility = ["//visibility:public"],
 )
 
@@ -85,15 +98,12 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/pkgfact:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/nilness:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/nilfunc:go_tool_library",
-        # lost cancel ignore doesn't seem to work when running with coverage
-        #"@org_golang_x_tools//go/analysis/passes/lostcancel:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/loopclosure:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/httpresponse:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/findcall:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/copylock:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/composite:go_tool_library",
         #  "@org_golang_x_tools//go/analysis/passes/cgocall:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/buildtag:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/buildssa:go_tool_library",
@@ -104,9 +114,29 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/inspect:go_tool_library",
         "@org_golang_x_tools//go/analysis/passes/asmdecl:go_tool_library",
         "//tools/analyzers/maligned:go_tool_library",
-        "//tools/analyzers/roughtime:go_tool_library",
+        "//tools/analyzers/cryptorand:go_tool_library",
         "//tools/analyzers/errcheck:go_tool_library",
-    ],
+        "//tools/analyzers/featureconfig:go_tool_library",
+        "//tools/analyzers/comparesame:go_tool_library",
+        "//tools/analyzers/shadowpredecl:go_tool_library",
+        "//tools/analyzers/nop:go_tool_library",
+        "//tools/analyzers/slicedirect:go_tool_library",
+        "//tools/analyzers/interfacechecker:go_tool_library",
+        "//tools/analyzers/ineffassign:go_tool_library",
+        "//tools/analyzers/properpermissions:go_tool_library",
+    ] + select({
+        # nogo checks that fail with coverage enabled.
+        ":coverage_enabled": [],
+        "//conditions:default": [
+            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_tool_library",
+            "@org_golang_x_tools//go/analysis/passes/composite:go_tool_library",
+        ],
+    }),
+)
+
+config_setting(
+    name = "coverage_enabled",
+    values = {"define": "coverage_enabled=1"},
 )
 
 common_files = {
@@ -114,8 +144,17 @@ common_files = {
     "//:README.md": "README.md",
 }
 
-toolchain(
-    name = "built_cmake_toolchain",
-    toolchain = "@rules_foreign_cc//tools/build_defs/native_tools:built_cmake",
-    toolchain_type = "@rules_foreign_cc//tools/build_defs:cmake_toolchain",
+string_setting(
+    name = "gotags",
+    build_setting_default = "",
+    values = [
+        "",
+        "libfuzzer",
+    ],
+)
+
+sh_binary(
+    name = "prysm_sh",
+    srcs = ["prysm.sh"],
+    visibility = ["//visibility:public"],
 )

CONTRIBUTING.md

@@ -1,8 +1,10 @@
 # Contribution Guidelines
 
-Excited by our work and want to get involved in building out our sharding releases? Or maybe you haven't learned as much about the Ethereum protocol but are a savvy developer? Our [READINGS.md](https://github.com/prysmaticlabs/prysm/blob/master/docs/READINGS.md) doc includes comprehensive information on Ethereum and sharding for both part-time and core contributors to the project.
+Note: The latest and most up to date documenation can be found on our [docs portal](https://docs.prylabs.network/docs/contribute/contribution-guidelines).
 
-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!
+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!
 
 ## Contribution Steps
 
@@ -60,12 +62,6 @@ 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.**
 
 ```
@@ -179,7 +175,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 sharding. The responsibilities of a part-time contributor include:
+Anyone can become a part-time contributor and help out on implementing Ethereum consensus. 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
@@ -190,8 +186,6 @@ Anyone can become a part-time contributor and help out on implementing sharding.
 -   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:

DEPENDENCIES.md

@@ -0,0 +1,80 @@
+# 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,6 +1,6 @@
 # Prysm Client Interoperability Guide
 
-This README details how to setup Prysm for interop testing for usage with other Ethereum 2.0 clients.
+This README details how to setup Prysm for interop testing for usage with other Ethereum consensus clients.
 
 ## Installation & Setup
 

PULL_REQUEST_TEMPLATE.md

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

README.md

@@ -1,20 +1,35 @@
-# Prysm: An Ethereum 2.0 Client Written in Go
+# Prysm: An Ethereum Consensus Implementation Written in Go
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
-[![ETH2.0_Spec_Version 0.11.1](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v0.11.1-blue.svg)](https://github.com/ethereum/eth2.0-specs/tree/v0.11.1)
-[![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)
+[![Go Report Card](https://goreportcard.com/badge/github.com/prysmaticlabs/prysm)](https://goreportcard.com/report/github.com/prysmaticlabs/prysm)
+[![ETH2.0_Spec_Version 1.0.0](https://img.shields.io/badge/ETH2.0%20Spec%20Version-v1.0.0-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.0.0)
+[![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
 
-This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the Ethereum 2.0 client specifications developed by [Prysmatic Labs](https://prysmaticlabs.com).
+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.
 
 ### Getting Started
-A detailed set of installation and usage instructions as well as breakdowns of each individual component are available in the [official documentation portal](https://docs.prylabs.network). If you still have questions, feel free to stop by either our [Discord](https://discord.gg/KSA7rPr) or [Gitter](https://gitter.im/prysmaticlabs/geth-sharding?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) and a member of the team or our community will be happy to assist you.
 
-### Come join the testnet!
-Participation is now open to the public for our Ethereum 2.0 phase 0 testnet release. Visit [prylabs.net](https://prylabs.net) for more information on the project or to sign up as a validator on the network. You can visualize the nodes in the network on [eth2stats.io](https://eth2stats.io), explore validator rewards/penalties via Bitfly's block explorer: [beaconcha.in](https://beaconcha.in), and follow the latest blocks added to the chain on [Etherscan](https://beacon.etherscan.io).
+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).
+
+### Staking on Mainnet
+
+To participate in staking, you can join the [official eth2 launchpad](https://launchpad.ethereum.org). The launchpad is the only recommended way to become a validator on mainnet. You can explore validator rewards/penalties via Bitfly's block explorer: [beaconcha.in](https://beaconcha.in), and follow the latest blocks added to the chain on [beaconscan](https://beaconscan.com).
+
 
 ## Contributing
+### Branches
+Prysm maintains two permanent branches:
+
+* [master](https://github.com/prysmaticlabs/prysm/tree/master): This points to the latest stable release. It is ideal for most users.
+* [develop](https://github.com/prysmaticlabs/prysm/tree/develop): This is used for development, it contains the latest PRs. Developers should base their PRs on this branch.
+
+### Guide
 Want to get involved? Check out our [Contribution Guide](https://docs.prylabs.network/docs/contribute/contribution-guidelines/) to learn more!
 
 ## License
+
 [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

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

@@ -0,0 +1,45 @@
+## Terms of Use
+
+Effective as of Oct 14, 2020
+
+By downloading, accessing or using the Prysm implementation (“Prysm”), you (referenced herein as “you” or the “user”) certify that you have read and agreed to the terms and conditions below (the “Terms”) which form a binding contract between you and Prysmatic Labs (referenced herein as “we” or “us”). If you do not agree to the Terms, do not download or use Prysm.
+
+### About Prysm
+Prysm is a client implementation for Ethereum 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.

TESTNET.md

@@ -1,43 +0,0 @@
-# Testnet 
-
-The Prysmatic Labs test network is available for anyone to join. The easiest way to participate is by joining through the website, https://prylabs.net.
-
-## Interop
-
-For developers looking to connect a client other than Prysm to the test network, here is the relevant information for compatability. 
-
-
-**Spec version** - [v0.8.3](https://github.com/ethereum/eth2.0-specs/tree/v0.8.3)
-
-**ETH 1 Deposit Contract Address** - See https://prylabs.net/contract. This contract is deployed on the [goerli](https://goerli.net/) network. 
-
-**Genesis time** - The ETH1 block time in which the 64th deposit to start ETH2 was included. This is NOT midnight of the next day as required by spec.
-
-### ETH 2 Configuration
-
-Use the [minimal config](https://github.com/ethereum/eth2.0-specs/blob/v0.8.3/configs/minimal.yaml) with the following changes.
-
-| field | value |
-|-------|-------|
-| MIN_DEPOSIT_AMOUNT | 100 |
-| MAX_EFFECTIVE_BALANCE | 3.2 * 1e9 |
-| EJECTION_BALANCE | 1.6 * 1e9 |
-| EFFECTIVE_BALANCE_INCREMENT | 0.1 * 1e9 |
-| ETH1_FOLLOW_DISTANCE | 16 | 
-| GENESIS_FORK_VERSION | See [latest code](https://github.com/prysmaticlabs/prysm/blob/master/shared/params/config.go#L236) |
-
-These parameters reduce the minimal config to 1/10 of the required ETH.
-
-We have a genesis.ssz file available for download [here](https://prysmaticlabs.com/uploads/genesis.ssz)
-
-### Connecting to the network
-
-We have a libp2p bootstrap node available at `/dns4/prylabs.net/tcp/30001/p2p/16Uiu2HAm7Qwe19vz9WzD2Mxn7fXd1vgHHp4iccuyq7TxwRXoAGfc`.
-
-Some of the Prysmatic Labs hosted nodes are behind a libp2p relay, so your libp2p implementation protocol should understand this functionality.
-
-### Other
-
-Undoubtably, you will have bugs. Reach out to us on [Discord](https://discord.gg/KSA7rPr) and be sure to capture issues on Github at https://github.com/prysmaticlabs/prysm/issues. 
-
-If you have instructions for you client, we would love to attempt this on your behalf. Kindly send over the instructions via github issue, PR, email to team@prysmaticlabs.com, or discord.

VERSION

@@ -1 +0,0 @@
-0.2.0

api/client/openapi/BUILD.bazel

@@ -0,0 +1,13 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["client.go"],
+    importpath = "github.com/prysmaticlabs/prysm/api/client/openapi",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)

api/client/openapi/client.go

@@ -0,0 +1,278 @@
+package openapi
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"path"
+	"strconv"
+	"time"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	log "github.com/sirupsen/logrus"
+)
+
+const GET_WEAK_SUBJECTIVITY_CHECKPOINT_EPOCH_PATH = "/eth/v1alpha1/beacon/weak_subjectivity_checkpoint_epoch"
+const GET_WEAK_SUBJECTIVITY_CHECKPOINT_PATH = "/eth/v1alpha1/beacon/weak_subjectivity_checkpoint"
+const GET_SIGNED_BLOCK_PATH = "/eth/v2/beacon/blocks"
+const GET_STATE_PATH = "/eth/v2/debug/beacon/states"
+
+// 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.c.Timeout = timeout
+	}
+}
+
+// Client provides a collection of helper methods for calling the beacon node OpenAPI endpoints
+type Client struct {
+	c      *http.Client
+	host   string
+	scheme 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
+}
+
+// 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{
+		c:      &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
+}
+
+type checkpointEpochResponse struct {
+	Epoch string
+}
+
+// GetWeakSubjectivityCheckpointEpoch retrieves the epoch for a finalized block within the weak subjectivity period.
+// The main use case for method is to find the slot that can be used to fetch a block within the subjectivity period
+// which can be used to sync (as an alternative to syncing from genesis).
+func (c *Client) GetWeakSubjectivityCheckpointEpoch() (uint64, error) {
+	u := c.urlForPath(GET_WEAK_SUBJECTIVITY_CHECKPOINT_EPOCH_PATH)
+	r, err := c.c.Get(u.String())
+	if err != nil {
+		return 0, err
+	}
+	if r.StatusCode != http.StatusOK {
+		return 0, non200Err(r)
+	}
+	jsonr := &checkpointEpochResponse{}
+	err = json.NewDecoder(r.Body).Decode(jsonr)
+	if err != nil {
+		return 0, err
+	}
+	return strconv.ParseUint(jsonr.Epoch, 10, 64)
+}
+
+type wscResponse struct {
+	BlockRoot string
+	StateRoot string
+	Epoch     string
+}
+
+// GetWeakSubjectivityCheckpoint calls an entirely different rpc method than GetWeakSubjectivityCheckpointEpoch
+// This endpoint is much slower, because it uses stategen to generate the BeaconState at the beginning of the
+// weak subjectivity epoch. This also results in a different set of state+block roots, because this endpoint currently
+// uses the state's latest_block_header for the block hash, while the checkpoint sync code assumes that the block
+// is from the first slot in the epoch and the state is from the subesequent slot.
+func (c *Client) GetWeakSubjectivityCheckpoint() (*ethpb.WeakSubjectivityCheckpoint, error) {
+	u := c.urlForPath(GET_WEAK_SUBJECTIVITY_CHECKPOINT_PATH)
+	r, err := c.c.Get(u.String())
+	if err != nil {
+		return nil, err
+	}
+	if r.StatusCode != http.StatusOK {
+		return nil, non200Err(r)
+	}
+	v := &wscResponse{}
+	b := bytes.NewBuffer(nil)
+	bodyReader := io.TeeReader(r.Body, b)
+	err = json.NewDecoder(bodyReader).Decode(v)
+	if err != nil {
+		return nil, err
+	}
+	epoch, err := strconv.ParseUint(v.Epoch, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	blockRoot, err := base64.StdEncoding.DecodeString(v.BlockRoot)
+	if err != nil {
+		return nil, err
+	}
+	stateRoot, err := base64.StdEncoding.DecodeString(v.StateRoot)
+	if err != nil {
+		return nil, err
+	}
+	return &ethpb.WeakSubjectivityCheckpoint{
+		Epoch:     types.Epoch(epoch),
+		BlockRoot: blockRoot,
+		StateRoot: stateRoot,
+	}, nil
+}
+
+// TODO: fix hardcoded pb type using sniff code
+// GetBlockBySlot queries the beacon node API for the SignedBeaconBlockAltair for the given slot
+func (c *Client) GetBlockBySlot(slot uint64) (*ethpb.SignedBeaconBlockAltair, error) {
+	blockPath := path.Join(GET_SIGNED_BLOCK_PATH, strconv.FormatUint(slot, 10))
+	u := c.urlForPath(blockPath)
+	log.Printf("requesting %s", u.String())
+	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/octet-stream")
+	r, err := c.c.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if r.StatusCode != http.StatusOK {
+		return nil, non200Err(r)
+	}
+
+	v := &ethpb.SignedBeaconBlockAltair{}
+	b := new(bytes.Buffer)
+	_, err = b.ReadFrom(r.Body)
+	if err != nil {
+		return nil, err
+	}
+	err = v.UnmarshalSSZ(b.Bytes())
+	return v, err
+}
+
+// GetBlockByRoot retrieves a SignedBeaconBlockAltair with the given root via the beacon node API
+func (c *Client) GetBlockByRoot(blockHex string) (*ethpb.SignedBeaconBlockAltair, error) {
+	blockPath := path.Join(GET_SIGNED_BLOCK_PATH, blockHex)
+	u := c.urlForPath(blockPath)
+	log.Printf("requesting %s", u.String())
+	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/octet-stream")
+	r, err := c.c.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if r.StatusCode != http.StatusOK {
+		return nil, non200Err(r)
+	}
+
+	v := &ethpb.SignedBeaconBlockAltair{}
+	b := new(bytes.Buffer)
+	_, err = b.ReadFrom(r.Body)
+	if err != nil {
+		return nil, err
+	}
+	err = v.UnmarshalSSZ(b.Bytes())
+	return v, err
+}
+
+// GetStateByRoot retrieves a BeaconStateAltair with the given root via the beacon node API
+func (c *Client) GetStateByRoot(stateHex string) (*ethpb.BeaconStateAltair, error) {
+	statePath := path.Join(GET_STATE_PATH, stateHex)
+	u := c.urlForPath(statePath)
+	log.Printf("requesting %s", u.String())
+	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/octet-stream")
+	r, err := c.c.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if r.StatusCode != http.StatusOK {
+		return nil, non200Err(r)
+	}
+
+	v := &ethpb.BeaconStateAltair{}
+	b := new(bytes.Buffer)
+	_, err = b.ReadFrom(r.Body)
+	if err != nil {
+		return nil, err
+	}
+	err = v.UnmarshalSSZ(b.Bytes())
+	return v, err
+}
+
+// GetStateBySlot retrieves a BeaconStateAltair at the given slot via the beacon node API
+func (c *Client) GetStateBySlot(slot uint64) (*ethpb.BeaconStateAltair, error) {
+	statePath := path.Join(GET_STATE_PATH, strconv.FormatUint(slot, 10))
+	u := c.urlForPath(statePath)
+	log.Printf("requesting %s", u.String())
+	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/octet-stream")
+	r, err := c.c.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if r.StatusCode != http.StatusOK {
+		return nil, non200Err(r)
+	}
+
+	v := &ethpb.BeaconStateAltair{}
+	b := new(bytes.Buffer)
+	_, err = b.ReadFrom(r.Body)
+	if err != nil {
+		return nil, err
+	}
+	err = v.UnmarshalSSZ(b.Bytes())
+	return v, err
+}
+
+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)
+	}
+	return fmt.Errorf("Got non-200 status code = %d requesting %s. %s", response.StatusCode, response.Request.URL, body)
+}

api/gateway/BUILD.bazel

@@ -0,0 +1,41 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "gateway.go",
+        "log.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

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

@@ -0,0 +1,233 @@
+package apimiddleware
+
+import (
+	"net/http"
+	"reflect"
+
+	"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
+}
+
+// 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.
+	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() {
+		m.handleApiPath(gatewayRouter, path, m.EndpointCreator)
+	}
+}
+
+func (m *ApiProxyMiddleware) handleApiPath(gatewayRouter *mux.Router, path string, endpointFactory EndpointFactory) {
+	gatewayRouter.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) {
+		endpoint, err := endpointFactory.Create(path)
+		if err != nil {
+			errJson := InternalServerErrorWithMessage(err, "could not create endpoint")
+			WriteError(w, errJson, nil)
+		}
+
+		for _, handler := range endpoint.CustomHandlers {
+			if handler(m, *endpoint, w, req) {
+				return
+			}
+		}
+
+		if req.Method == "POST" {
+			if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
+				WriteError(w, errJson, nil)
+				return
+			}
+
+			if errJson := ProcessRequestContainerFields(endpoint.PostRequest); errJson != nil {
+				WriteError(w, errJson, nil)
+				return
+			}
+			if errJson := SetRequestBodyToRequestContainer(endpoint.PostRequest, req); errJson != nil {
+				WriteError(w, errJson, nil)
+				return
+			}
+		}
+
+		if errJson := m.PrepareRequestForProxying(*endpoint, req); errJson != nil {
+			WriteError(w, errJson, nil)
+			return
+		}
+		grpcResp, errJson := 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 {
+				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 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

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

api/gateway/apimiddleware/param_handling.go

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

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

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

@@ -0,0 +1,267 @@
+package apimiddleware
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"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
+}
+
+type ClientOption func(*http.Client)
+
+func WithTimeout(t time.Duration) ClientOption {
+	return func(c *http.Client) {
+		c.Timeout = t
+	}
+}
+
+// ProxyRequest proxies the request to grpc-gateway.
+func ProxyRequest(req *http.Request, opts ...ClientOption) (*http.Response, ErrorJson) {
+	// We do not use http.DefaultClient because it does not have any timeout.
+	// TODO: think about exposing this as a flag, or based on endpoint
+	netClient := &http.Client{Timeout: time.Minute * 2}
+	for _, o := range opts {
+		o(netClient)
+	}
+	grpcResp, err := netClient.Do(req)
+	if err != nil {
+		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)
+			}
+		}
+		// 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

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

@@ -0,0 +1,62 @@
+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,
+	}
+}
+
+// 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

@@ -0,0 +1,281 @@
+// 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(http.Handler, http.ResponseWriter, *http.Request)
+
+// Gateway is the gRPC gateway to serve HTTP JSON traffic as a proxy and forward it to the gRPC server.
+type Gateway struct {
+	conn                         *grpc.ClientConn
+	pbHandlers                   []*PbMux
+	muxHandler                   MuxHandler
+	maxCallRecvMsgSize           uint64
+	router                       *mux.Router
+	server                       *http.Server
+	cancel                       context.CancelFunc
+	remoteCert                   string
+	gatewayAddr                  string
+	apiMiddlewareEndpointFactory apimiddleware.EndpointFactory
+	ctx                          context.Context
+	startFailure                 error
+	remoteAddr                   string
+	allowedOrigins               []string
+}
+
+// New returns a new instance of the Gateway.
+func New(
+	ctx context.Context,
+	pbHandlers []*PbMux,
+	muxHandler MuxHandler,
+	remoteAddr,
+	gatewayAddress string,
+) *Gateway {
+	g := &Gateway{
+		pbHandlers:     pbHandlers,
+		muxHandler:     muxHandler,
+		router:         mux.NewRouter(),
+		gatewayAddr:    gatewayAddress,
+		ctx:            ctx,
+		remoteAddr:     remoteAddr,
+		allowedOrigins: []string{},
+	}
+	return g
+}
+
+// WithRouter allows adding a custom mux router to the gateway.
+func (g *Gateway) WithRouter(r *mux.Router) *Gateway {
+	g.router = r
+	return g
+}
+
+// WithAllowedOrigins allows adding a set of allowed origins to the gateway.
+func (g *Gateway) WithAllowedOrigins(origins []string) *Gateway {
+	g.allowedOrigins = origins
+	return g
+}
+
+// WithRemoteCert allows adding a custom certificate to the gateway,
+func (g *Gateway) WithRemoteCert(cert string) *Gateway {
+	g.remoteCert = cert
+	return g
+}
+
+// WithMaxCallRecvMsgSize allows specifying the maximum allowed gRPC message size.
+func (g *Gateway) WithMaxCallRecvMsgSize(size uint64) *Gateway {
+	g.maxCallRecvMsgSize = size
+	return g
+}
+
+// WithApiMiddleware allows adding API Middleware proxy to the gateway.
+func (g *Gateway) WithApiMiddleware(endpointFactory apimiddleware.EndpointFactory) *Gateway {
+	g.apiMiddlewareEndpointFactory = endpointFactory
+	return g
+}
+
+// Start the gateway service.
+func (g *Gateway) Start() {
+	ctx, cancel := context.WithCancel(g.ctx)
+	g.cancel = cancel
+
+	conn, err := g.dial(ctx, "tcp", g.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.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.router.PathPrefix(p).Handler(h.Mux)
+		}
+	}
+
+	corsMux := g.corsMiddleware(g.router)
+
+	if g.muxHandler != nil {
+		g.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			g.muxHandler(corsMux, w, r)
+		})
+	}
+
+	if g.apiMiddlewareEndpointFactory != nil && !g.apiMiddlewareEndpointFactory.IsNil() {
+		go g.registerApiMiddleware()
+	}
+
+	g.server = &http.Server{
+		Addr:    g.gatewayAddr,
+		Handler: g.router,
+	}
+
+	go func() {
+		log.WithField("address", g.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.allowedOrigins,
+		AllowedMethods:   []string{http.MethodPost, http.MethodGet, 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.remoteCert) > 0 {
+		creds, err := credentials.NewClientTLSFromFile(g.remoteCert, "")
+		if err != nil {
+			return nil, err
+		}
+		security = grpc.WithTransportCredentials(creds)
+	}
+	opts := []grpc.DialOption{
+		security,
+		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.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.maxCallRecvMsgSize))),
+	}
+	return grpc.DialContext(ctx, addr, opts...)
+}
+
+func (g *Gateway) registerApiMiddleware() {
+	proxy := &apimiddleware.ApiProxyMiddleware{
+		GatewayAddress:  g.gatewayAddr,
+		EndpointCreator: g.apiMiddlewareEndpointFactory,
+	}
+	log.Info("Starting API middleware")
+	proxy.Run(g.router)
+}

api/gateway/gateway_test.go

@@ -0,0 +1,120 @@
+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{}
+
+	g := New(
+		context.Background(),
+		[]*PbMux{},
+		func(handler http.Handler, writer http.ResponseWriter, request *http.Request) {
+
+		},
+		"",
+		"",
+	).WithRouter(r).
+		WithRemoteCert(cert).
+		WithAllowedOrigins(origins).
+		WithMaxCallRecvMsgSize(size).
+		WithApiMiddleware(endpointFactory)
+
+	assert.Equal(t, r, g.router)
+	assert.Equal(t, cert, g.remoteCert)
+	require.Equal(t, 1, len(g.allowedOrigins))
+	assert.Equal(t, origins[0], g.allowedOrigins[0])
+	assert.Equal(t, size, g.maxCallRecvMsgSize)
+	assert.Equal(t, endpointFactory, g.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)
+
+	g := New(
+		ctx.Context,
+		[]*PbMux{},
+		func(handler http.Handler, writer http.ResponseWriter, request *http.Request) {
+
+		},
+		selfAddress,
+		gatewayAddress,
+	)
+
+	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)
+
+	g := New(
+		ctx.Context,
+		[]*PbMux{},
+		/* muxHandler */ nil,
+		selfAddress,
+		gatewayAddress,
+	)
+
+	writer := httptest.NewRecorder()
+	g.router.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
+	assert.Equal(t, http.StatusNotFound, writer.Code)
+}

api/grpc/BUILD.bazel

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

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

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

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

@@ -0,0 +1,22 @@
+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,3 +1,4 @@
+// Package pagination contains useful pagination-related helpers.
 package pagination
 
 import (
@@ -5,12 +6,12 @@ import (
 	"strconv"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"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 int, totalSize int) (int, int, string, error) {
+func StartAndEndPage(pageToken string, pageSize, totalSize int) (int, int, string, error) {
 	if pageToken == "" {
 		pageToken = "0"
 	}
@@ -33,7 +34,7 @@ func StartAndEndPage(pageToken string, pageSize int, totalSize int) (int, int, s
 	end := start + pageSize
 	nextPageToken := strconv.Itoa(token + 1)
 
-	if end > totalSize {
+	if end >= totalSize {
 		end = totalSize
 		nextPageToken = "" // Return an empty next page token for the last page of a set
 	}

api/pagination/pagination_test.go

@@ -1,10 +1,11 @@
 package pagination_test
 
 import (
-	"strings"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/pagination"
+	"github.com/prysmaticlabs/prysm/api/pagination"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestStartAndEndPage(t *testing.T) {
@@ -48,13 +49,19 @@ func TestStartAndEndPage(t *testing.T) {
 			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)
-		if err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, err)
 		if test.start != start {
 			t.Errorf("expected start and computed start are not equal %d, %d", test.start, start)
 		}
@@ -69,14 +76,12 @@ func TestStartAndEndPage(t *testing.T) {
 
 func TestStartAndEndPage_CannotConvertPage(t *testing.T) {
 	wanted := "could not convert page token: strconv.Atoi: parsing"
-	if _, _, _, err := pagination.StartAndEndPage("bad", 0, 0); !strings.Contains(err.Error(), wanted) {
-		t.Fatalf("wanted error: %v, got error: %v", wanted, err.Error())
-	}
+	_, _, _, err := pagination.StartAndEndPage("bad", 0, 0)
+	assert.ErrorContains(t, wanted, err)
 }
 
 func TestStartAndEndPage_ExceedsMaxPage(t *testing.T) {
 	wanted := "page start 0 >= list 0"
-	if _, _, _, err := pagination.StartAndEndPage("", 0, 0); !strings.Contains(err.Error(), wanted) {
-		t.Fatalf("wanted error: %v, got error: %v", wanted, err.Error())
-	}
+	_, _, _, err := pagination.StartAndEndPage("", 0, 0)
+	assert.ErrorContains(t, wanted, err)
 }

async/BUILD.bazel

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

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

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

@@ -0,0 +1,298 @@
+// 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,4 +1,4 @@
-package mputil_test
+package async_test
 
 import (
 	"crypto/rand"
@@ -6,7 +6,8 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/mputil"
+	"github.com/prysmaticlabs/prysm/async"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -51,12 +52,10 @@ func BenchmarkHash(b *testing.B) {
 func BenchmarkHashMP(b *testing.B) {
 	output := make([][]byte, len(input))
 	for i := 0; i < b.N; i++ {
-		workerResults, err := mputil.Scatter(len(input), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
+		workerResults, err := async.Scatter(len(input), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
 			return hash(input[offset : offset+entries]), nil
 		})
-		if err != nil {
-			b.Error(err)
-		}
+		require.NoError(b, err)
 		for _, result := range workerResults {
 			copy(output[result.Offset:], result.Extent.([][]byte))
 		}

async/debounce.go

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

@@ -0,0 +1,116 @@
+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,4 +1,4 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
@@ -6,9 +6,9 @@ go_library(
         "feed.go",
         "subscription.go",
     ],
-    importpath = "github.com/prysmaticlabs/prysm/shared/event",
+    importpath = "github.com/prysmaticlabs/prysm/async/event",
     visibility = ["//visibility:public"],
-    deps = ["//shared/mclockutil:go_default_library"],
+    deps = ["//time/mclock:go_default_library"],
 )
 
 go_test(
@@ -22,4 +22,8 @@ go_test(
         "subscription_test.go",
     ],
     embed = [":go_default_library"],
+    deps = [
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+    ],
 )

async/event/example_feed_test.go

@@ -19,7 +19,7 @@ package event_test
 import (
 	"fmt"
 
-	"github.com/prysmaticlabs/prysm/shared/event"
+	"github.com/prysmaticlabs/prysm/async/event"
 )
 
 func ExampleFeed_acknowledgedEvents() {

async/event/example_scope_test.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/prysmaticlabs/prysm/shared/event"
+	"github.com/prysmaticlabs/prysm/async/event"
 )
 
 // This example demonstrates how SubscriptionScope can be used to control the lifetime of

async/event/example_subscription_test.go

@@ -19,7 +19,7 @@ package event_test
 import (
 	"fmt"
 
-	"github.com/prysmaticlabs/prysm/shared/event"
+	"github.com/prysmaticlabs/prysm/async/event"
 )
 
 func ExampleNewSubscription() {

async/event/feed.go

@@ -14,6 +14,7 @@
 // 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 (
@@ -97,6 +98,11 @@ func (f *Feed) typecheck(typ reflect.Type) bool {
 		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
 }
 
@@ -195,6 +201,7 @@ type feedSub struct {
 	err     chan error
 }
 
+// Unsubscribe remove feed subscription.
 func (sub *feedSub) Unsubscribe() {
 	sub.errOnce.Do(func() {
 		sub.feed.remove(sub)
@@ -202,6 +209,7 @@ func (sub *feedSub) Unsubscribe() {
 	})
 }
 
+// Err returns error channel.
 func (sub *feedSub) Err() <-chan error {
 	return sub.err
 }

async/event/feed_test.go

@@ -22,6 +22,8 @@ import (
 	"sync"
 	"testing"
 	"time"
+
+	"github.com/prysmaticlabs/prysm/testing/assert"
 )
 
 func TestFeedPanics(t *testing.T) {
@@ -29,48 +31,38 @@ func TestFeedPanics(t *testing.T) {
 		var f Feed
 		f.Send(2)
 		want := feedTypeError{op: "Send", got: reflect.TypeOf(uint64(0)), want: reflect.TypeOf(0)}
-		if err := checkPanic(want, func() { f.Send(uint64(2)) }); err != nil {
-			t.Error(err)
-		}
+		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)}
-		if err := checkPanic(want, func() { f.Send(uint64(2)) }); err != nil {
-			t.Error(err)
-		}
+		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))}
-		if err := checkPanic(want, func() { f.Subscribe(make(chan uint64)) }); err != nil {
-			t.Error(err)
-		}
+		assert.NoError(t, checkPanic(want, func() { f.Subscribe(make(chan uint64)) }))
 	}
 	{
 		var f Feed
-		if err := checkPanic(errBadChannel, func() { f.Subscribe(make(<-chan int)) }); err != nil {
-			t.Error(err)
-		}
+		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(make(<-chan int)) }))
 	}
 	{
 		var f Feed
-		if err := checkPanic(errBadChannel, func() { f.Subscribe(0) }); err != nil {
-			t.Error(err)
-		}
+		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(0) }))
 	}
 }
 
 func checkPanic(want error, fn func()) (err error) {
 	defer func() {
-		panic := recover()
-		if panic == nil {
+		panicResult := recover()
+		if panicResult == nil {
 			err = fmt.Errorf("didn't panic")
-		} else if !reflect.DeepEqual(panic, want) {
-			err = fmt.Errorf("panicked with wrong error: got %q, want %q", panic, want)
+		} else if !reflect.DeepEqual(panicResult, want) {
+			err = fmt.Errorf("panicked with wrong error: got %q, want %q", panicResult, want)
 		}
 	}()
 	fn()
@@ -167,7 +159,7 @@ func TestFeedSubscribeSameChannel(t *testing.T) {
 	done.Wait()
 }
 
-func TestFeedSubscribeBlockedPost(t *testing.T) {
+func TestFeedSubscribeBlockedPost(_ *testing.T) {
 	var (
 		feed   Feed
 		nsends = 2000
@@ -200,7 +192,7 @@ func TestFeedSubscribeBlockedPost(t *testing.T) {
 	}
 }
 
-func TestFeedUnsubscribeBlockedPost(t *testing.T) {
+func TestFeedUnsubscribeBlockedPost(_ *testing.T) {
 	var (
 		feed   Feed
 		nsends = 200
@@ -237,7 +229,7 @@ func TestFeedUnsubscribeBlockedPost(t *testing.T) {
 
 // Checks that unsubscribing a channel during Send works even if that
 // channel has already been sent on.
-func TestFeedUnsubscribeSentChan(t *testing.T) {
+func TestFeedUnsubscribeSentChan(_ *testing.T) {
 	var (
 		feed Feed
 		ch1  = make(chan int)
@@ -283,22 +275,14 @@ func TestFeedUnsubscribeFromInbox(t *testing.T) {
 		sub2 = feed.Subscribe(ch1)
 		sub3 = feed.Subscribe(ch2)
 	)
-	if len(feed.inbox) != 3 {
-		t.Errorf("inbox length != 3 after subscribe")
-	}
-	if len(feed.sendCases) != 1 {
-		t.Errorf("sendCases is non-empty after unsubscribe")
-	}
+	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()
-	if len(feed.inbox) != 0 {
-		t.Errorf("inbox is non-empty after unsubscribe")
-	}
-	if len(feed.sendCases) != 1 {
-		t.Errorf("sendCases is non-empty after 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) {
@@ -331,3 +315,193 @@ func BenchmarkFeedSend1000(b *testing.B) {
 	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/event/subscription.go

@@ -21,9 +21,13 @@ import (
 	"sync"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/shared/mclockutil"
+	"github.com/prysmaticlabs/prysm/time/mclock"
 )
 
+// waitQuotient is divided against the max backoff time, in order to have N requests based on the full
+// request backoff time.
+const waitQuotient = 10
+
 // Subscription represents a stream of events. The carrier of the events is typically a
 // channel, but isn't part of the interface.
 //
@@ -70,6 +74,7 @@ type funcSub struct {
 	unsubscribed bool
 }
 
+// Unsubscribe unsubscribes from subscription.
 func (s *funcSub) Unsubscribe() {
 	s.mu.Lock()
 	if s.unsubscribed {
@@ -83,6 +88,7 @@ func (s *funcSub) Unsubscribe() {
 	<-s.err
 }
 
+// Err exposes error channel.
 func (s *funcSub) Err() <-chan error {
 	return s.err
 }
@@ -96,7 +102,7 @@ func (s *funcSub) Err() <-chan error {
 // based on the error rate, but will never exceed backoffMax.
 func Resubscribe(backoffMax time.Duration, fn ResubscribeFunc) Subscription {
 	s := &resubscribeSub{
-		waitTime:   backoffMax / 10,
+		waitTime:   backoffMax / waitQuotient,
 		backoffMax: backoffMax,
 		fn:         fn,
 		err:        make(chan error),
@@ -114,10 +120,11 @@ type resubscribeSub struct {
 	err                  chan error
 	unsub                chan struct{}
 	unsubOnce            sync.Once
-	lastTry              mclockutil.AbsTime
+	lastTry              mclock.AbsTime
 	waitTime, backoffMax time.Duration
 }
 
+// Unsubscribe unsubscribes from subscription.
 func (s *resubscribeSub) Unsubscribe() {
 	s.unsubOnce.Do(func() {
 		s.unsub <- struct{}{}
@@ -125,6 +132,7 @@ func (s *resubscribeSub) Unsubscribe() {
 	})
 }
 
+// Err exposes error channel.
 func (s *resubscribeSub) Err() <-chan error {
 	return s.err
 }
@@ -143,12 +151,12 @@ func (s *resubscribeSub) loop() {
 }
 
 func (s *resubscribeSub) subscribe() Subscription {
-	subscribed := make(chan error)
+	subscribed := make(chan error, 1)
 	var sub Subscription
 retry:
 	for {
-		s.lastTry = mclockutil.Now()
-		ctx, cancel := context.WithCancel(context.Background())
+		s.lastTry = mclock.Now()
+		ctx, cancel := context.WithCancel(context.TODO())
 		go func() {
 			rsub, err := s.fn(ctx)
 			sub = rsub
@@ -186,8 +194,8 @@ func (s *resubscribeSub) waitForError(sub Subscription) bool {
 }
 
 func (s *resubscribeSub) backoffWait() bool {
-	if time.Duration(mclockutil.Now()-s.lastTry) > s.backoffMax {
-		s.waitTime = s.backoffMax / 10
+	if time.Duration(mclock.Now()-s.lastTry) > s.backoffMax {
+		s.waitTime = s.backoffMax / waitQuotient
 	} else {
 		s.waitTime *= 2
 		if s.waitTime > s.backoffMax {
@@ -263,6 +271,7 @@ func (sc *SubscriptionScope) Count() int {
 	return len(sc.subs)
 }
 
+// Unsubscribe unsubscribes from subscription.
 func (s *scopeSub) Unsubscribe() {
 	s.s.Unsubscribe()
 	s.sc.mu.Lock()
@@ -270,6 +279,7 @@ func (s *scopeSub) Unsubscribe() {
 	delete(s.sc.subs, s)
 }
 
+// Err exposes error channel.
 func (s *scopeSub) Err() <-chan error {
 	return s.s.Err()
 }

async/event/subscription_test.go

@@ -19,8 +19,11 @@ package event
 import (
 	"context"
 	"errors"
+	"runtime"
 	"testing"
 	"time"
+
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 var errInts = errors.New("error in subscribeInts")
@@ -50,25 +53,17 @@ loop:
 	for want := 0; want < 10; want++ {
 		select {
 		case got := <-channel:
-			if got != want {
-				t.Fatalf("wrong int %d, want %d", got, want)
-			}
+			require.Equal(t, want, got)
 		case err := <-sub.Err():
-			if err != errInts {
-				t.Fatalf("wrong error: got %q, want %q", err, errInts)
-			}
-			if want != 2 {
-				t.Fatalf("got errInts at int %d, should be received at 2", want)
-			}
+			require.Equal(t, errInts, err)
+			require.Equal(t, 2, want)
 			break loop
 		}
 	}
 	sub.Unsubscribe()
 
 	err, ok := <-sub.Err()
-	if err != nil {
-		t.Fatal("got non-nil error after Unsubscribe")
-	}
+	require.NoError(t, err)
 	if ok {
 		t.Fatal("channel still open after Unsubscribe")
 	}
@@ -94,9 +89,7 @@ func TestResubscribe(t *testing.T) {
 	})
 
 	<-sub.Err()
-	if i != nfails {
-		t.Fatalf("resubscribe function called %d times, want %d times", i, nfails)
-	}
+	require.Equal(t, nfails, i)
 }
 
 func TestResubscribeAbort(t *testing.T) {
@@ -114,7 +107,20 @@ func TestResubscribeAbort(t *testing.T) {
 	})
 
 	sub.Unsubscribe()
-	if err := <-done; err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, <-done)
+}
+
+func TestResubscribeNonBlocking(t *testing.T) {
+	done := make(chan struct{})
+	sub := Resubscribe(0, func(ctx context.Context) (Subscription, error) {
+		<-done
+		return nil, nil
+	})
+
+	resub, ok := sub.(*resubscribeSub)
+	require.Equal(t, true, ok)
+	currNum := runtime.NumGoroutine()
+	resub.unsub <- struct{}{}
+	done <- struct{}{}
+	require.Equal(t, currNum-1, runtime.NumGoroutine())
 }

async/every.go

@@ -1,4 +1,5 @@
-package runutil
+// Package async includes helpers for scheduling runnable, periodic functions and contains useful helpers for converting multi-processor computation.
+package async
 
 import (
 	"context"

async/every_test.go

@@ -1,18 +1,18 @@
-package runutil_test
+package async_test
 
 import (
 	"context"
 	"testing"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/shared/runutil"
+	"github.com/prysmaticlabs/prysm/async"
 )
 
 func TestEveryRuns(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 
 	i := 0
-	runutil.RunEvery(ctx, 100*time.Millisecond, func() {
+	async.RunEvery(ctx, 100*time.Millisecond, func() {
 		i++
 	})
 

async/multilock.go

@@ -0,0 +1,139 @@
+/*
+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

@@ -0,0 +1,342 @@
+/*
+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))
+		defer lock.Unlock()
+
+		<-time.After(100 * time.Millisecond)
+		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,4 +1,4 @@
-package mputil
+package async
 
 import (
 	"errors"

async/scatter_test.go

@@ -1,11 +1,13 @@
-package mputil_test
+package async_test
 
 import (
 	"errors"
 	"sync"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/mputil"
+	"github.com/prysmaticlabs/prysm/async"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestDouble(t *testing.T) {
@@ -44,7 +46,7 @@ func TestDouble(t *testing.T) {
 				inValues[i] = i
 			}
 			outValues := make([]int, test.inValues)
-			workerResults, err := mputil.Scatter(len(inValues), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
+			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
@@ -52,25 +54,15 @@ func TestDouble(t *testing.T) {
 				return extent, nil
 			})
 			if test.err != nil {
-				if err == nil {
-					t.Fatalf("Missing expected error %v", test.err)
-				}
-				if test.err.Error() != err.Error() {
-					t.Fatalf("Unexpected error value: expected \"%v\", found \"%v\"", test.err, err)
-				}
+				assert.ErrorContains(t, test.err.Error(), err)
 			} else {
-				if err != nil {
-					t.Fatalf("Unexpected error %v", test.err)
-				}
-
+				require.NoError(t, err)
 				for _, result := range workerResults {
 					copy(outValues[result.Offset:], result.Extent.([]int))
 				}
 
 				for i := 0; i < test.inValues; i++ {
-					if outValues[i] != inValues[i]*2 {
-						t.Fatalf("Outvalue at %d mismatch: expected %d, found %d", i, inValues[i]*2, outValues[i])
-					}
+					require.Equal(t, inValues[i]*2, outValues[i], "Outvalue at %d mismatch", i)
 				}
 			}
 		})
@@ -80,7 +72,7 @@ func TestDouble(t *testing.T) {
 func TestMutex(t *testing.T) {
 	totalRuns := 1048576
 	val := 0
-	_, err := mputil.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
+	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
 		for i := 0; i < entries; i++ {
 			mu.Lock()
 			val++
@@ -88,9 +80,7 @@ func TestMutex(t *testing.T) {
 		}
 		return nil, nil
 	})
-	if err != nil {
-		t.Fatalf("Unexpected error %v", err)
-	}
+	require.NoError(t, err)
 
 	if val != totalRuns {
 		t.Fatalf("Unexpected value: expected \"%v\", found \"%v\"", totalRuns, val)
@@ -100,7 +90,7 @@ func TestMutex(t *testing.T) {
 func TestError(t *testing.T) {
 	totalRuns := 1024
 	val := 0
-	_, err := mputil.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
+	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
 		for i := 0; i < entries; i++ {
 			mu.Lock()
 			val++

bazel.sh

@@ -6,6 +6,6 @@
 
 env -i \
  PATH=/usr/bin:/bin \
- HOME=$HOME \
- GOOGLE_APPLICATION_CREDENTIALS=$GOOGLE_APPLICATION_CREDENTIALS \
+ HOME="$HOME" \
+ GOOGLE_APPLICATION_CREDENTIALS="$GOOGLE_APPLICATION_CREDENTIALS" \
  bazel "$@"

beacon-chain/BUILD.bazel

@@ -1,146 +1,19 @@
-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_bundle")
-load("//tools:go_image.bzl", "go_image_alpine", "go_image_debug")
-load("@io_bazel_rules_docker//contrib:push-all.bzl", "docker_push")
+load("//tools:target_migration.bzl", "moved_targets")
 
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "main.go",
-        "usage.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain",
-    visibility = ["//beacon-chain:__subpackages__"],
-    deps = [
-        "//beacon-chain/flags:go_default_library",
-        "//beacon-chain/node:go_default_library",
-        "//shared/cmd:go_default_library",
-        "//shared/debug:go_default_library",
-        "//shared/featureconfig:go_default_library",
-        "//shared/logutil:go_default_library",
-        "//shared/version:go_default_library",
-        "@com_github_ipfs_go_log//:go_default_library",
-        "@com_github_joonix_log//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_whyrusleeping_go_logging//:go_default_library",
-        "@com_github_x_cray_logrus_prefixed_formatter//:go_default_library",
-        "@in_gopkg_urfave_cli_v2//:go_default_library",
-        "@in_gopkg_urfave_cli_v2//altsrc:go_default_library",
-        "@org_uber_go_automaxprocs//:go_default_library",
-    ],
-)
-
-go_image(
-    name = "image",
-    srcs = [
-        "main.go",
-        "usage.go",
-    ],
-    base = select({
-        "//tools:base_image_alpine": "//tools:alpine_cc_image",
-        "//tools:base_image_cc": "//tools:cc_image",
-        "//conditions:default": "//tools:cc_image",
-    }),
-    goarch = "amd64",
-    goos = "linux",
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain",
-    race = "off",
-    static = "off",  # Static enabled binary seems to cause issues with DNS lookup with cgo.
-    tags = ["manual"],
-    visibility = ["//visibility:private"],
-    deps = [
-        "//beacon-chain/flags:go_default_library",
-        "//beacon-chain/node:go_default_library",
-        "//shared/cmd:go_default_library",
-        "//shared/debug:go_default_library",
-        "//shared/featureconfig:go_default_library",
-        "//shared/logutil:go_default_library",
-        "//shared/version:go_default_library",
-        "@com_github_ipfs_go_log//:go_default_library",
-        "@com_github_joonix_log//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_whyrusleeping_go_logging//:go_default_library",
-        "@com_github_x_cray_logrus_prefixed_formatter//:go_default_library",
-        "@in_gopkg_urfave_cli_v2//:go_default_library",
-        "@in_gopkg_urfave_cli_v2//altsrc:go_default_library",
-        "@org_uber_go_automaxprocs//:go_default_library",
-    ],
-)
-
-container_bundle(
-    name = "image_bundle",
-    images = {
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:latest": ":image",
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:{DOCKER_TAG}": ":image",
-    },
-    tags = ["manual"],
-)
-
-go_image_debug(
-    name = "image_debug",
-    image = ":image",
-    tags = ["manual"],
-)
-
-container_bundle(
-    name = "image_bundle_debug",
-    images = {
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:latest-debug": ":image_debug",
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:{DOCKER_TAG}-debug": ":image_debug",
-    },
-    tags = ["manual"],
-)
-
-go_image_alpine(
-    name = "image_alpine",
-    image = ":image",
-    tags = ["manual"],
-)
-
-container_bundle(
-    name = "image_bundle_alpine",
-    images = {
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:latest-alpine": ":image_alpine",
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:{DOCKER_TAG}-alpine": ":image_alpine",
-    },
-    tags = ["manual"],
-)
-
-docker_push(
-    name = "push_images",
-    bundle = ":image_bundle",
-    tags = ["manual"],
-)
-
-docker_push(
-    name = "push_images_debug",
-    bundle = ":image_bundle_debug",
-    tags = ["manual"],
-)
-
-docker_push(
-    name = "push_images_alpine",
-    bundle = ":image_bundle_alpine",
-    tags = ["manual"],
-)
-
-go_binary(
-    name = "beacon-chain",
-    embed = [":go_default_library"],
-    visibility = [
-        "//beacon-chain:__subpackages__",
-        "//endtoend:__pkg__",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    size = "small",
-    srcs = ["usage_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//shared/featureconfig:go_default_library",
-        "@in_gopkg_urfave_cli_v2//:go_default_library",
+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",
     ],
+    "//cmd/beacon-chain",
 )

beacon-chain/README.md

@@ -1,10 +1,9 @@
 # Prysmatic Labs Beacon Chain Implementation
 
-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:
+This is the main project folder for the beacon chain implementation of Ethereum written in Go by [Prysmatic Labs](https://prysmaticlabs.com).
 
-[![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)
+You can also read our main [README](https://github.com/prysmaticlabs/prysm/blob/master/README.md) and join our active chat room on Discord.
 
-Also, read the latest beacon chain [design spec](https://github.com/ethereum/eth2.0-specs/blob/dev/specs/phase0/beacon-chain.md), this design spec serves as a source of truth for the beacon chain implementation we follow at prysmatic labs.
-Check out the [FAQs](https://notes.ethereum.org/9MMuzWeFTTSg-3Tz_YeiBA?view). Refer this page on [why](http://email.mg2.substack.com/c/eJwlj9GOhCAMRb9G3jRQQPGBh5mM8xsbhKrsDGIAM9m_X9xN2qZtbpt7rCm4xvSjj5gLOTOmL-809CMbKXFaOKakIl4DZYr2AGyQIGjHOnWH22OiYnoIxmDijaBhhS6fcy7GvjobA9m0mSXOcnZq5GBqLkilXBZhBsus5ZK89VbKkRt-a-BZI6DzZ7iur1lQ953KJ9bemnxgahuQU9XJu6pFPdu8meT8vragzEjpMCwMGLlgLo6h5z1JumQTu4IJd4v15xqMf_8ZLP_Y1bSLdbnrD-LL71i2Kj7DLxaWWF4)
-we are combining sharding and casper together.
+[![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.

beacon-chain/archiver/BUILD.bazel

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

beacon-chain/archiver/service.go

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

beacon-chain/archiver/service_test.go

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

beacon-chain/blockchain/BUILD.bazel

@@ -1,14 +1,16 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
     srcs = [
         "chain_info.go",
         "head.go",
+        "head_sync_committee_info.go",
         "info.go",
         "init_sync_process_block.go",
         "log.go",
         "metrics.go",
+        "options.go",
         "process_attestation.go",
         "process_attestation_helpers.go",
         "process_block.go",
@@ -16,21 +18,31 @@ go_library(
         "receive_attestation.go",
         "receive_block.go",
         "service.go",
+        "state_balance_cache.go",
+        "weak_subjectivity_checks.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain",
-    visibility = ["//beacon-chain:__subpackages__"],
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//cmd/beacon-chain:__subpackages__",
+        "//testing/fuzz:__pkg__",
+        "//testing/slasher/simulator:__pkg__",
+    ],
     deps = [
+        "//async:go_default_library",
+        "//async/event:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
+        "//beacon-chain/core/altair: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/state: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/db:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
-        "//beacon-chain/flags:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
@@ -40,21 +52,24 @@ go_library(
         "//beacon-chain/powchain:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
-        "//beacon-chain/state/stateutil:go_default_library",
-        "//proto/beacon/p2p/v1:go_default_library",
-        "//shared/attestationutil:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/featureconfig:go_default_library",
-        "//shared/params:go_default_library",
-        "//shared/roughtime:go_default_library",
-        "//shared/slotutil:go_default_library",
-        "//shared/traceutil:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
+        "//config/features:go_default_library",
+        "//config/params:go_default_library",
+        "//crypto/bls:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//monitoring/tracing: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_emicklei_dot//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
-        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -72,40 +87,52 @@ go_test(
     name = "go_raceoff_test",
     size = "medium",
     srcs = [
+        "blockchain_test.go",
         "chain_info_test.go",
+        "checktags_test.go",
+        "head_sync_committee_info_test.go",
         "head_test.go",
-        "init_sync_process_block_test.go",
+        "info_test.go",
+        "init_test.go",
+        "log_test.go",
+        "metrics_test.go",
+        "mock_test.go",
         "process_attestation_test.go",
         "process_block_test.go",
         "receive_attestation_test.go",
+        "receive_block_test.go",
         "service_test.go",
+        "weak_subjectivity_checks_test.go",
     ],
     embed = [":go_default_library"],
+    gotags = ["develop"],
     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/state: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/state/stateutil:go_default_library",
-        "//proto/beacon/db:go_default_library",
-        "//proto/beacon/p2p/v1:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/event:go_default_library",
-        "//shared/params:go_default_library",
-        "//shared/testutil:go_default_library",
+        "//beacon-chain/state/v1: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_gogo_protobuf//proto:go_default_library",
-        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
         "@org_golang_x_net//context:go_default_library",
     ],
 )
@@ -114,6 +141,10 @@ 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"],
@@ -124,30 +155,33 @@ go_test(
         # 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/state: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",
-        "//proto/beacon/p2p/v1:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/event:go_default_library",
-        "//shared/params:go_default_library",
-        "//shared/testutil: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_gogo_protobuf//proto:go_default_library",
-        "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
-        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
         "@org_golang_x_net//context:go_default_library",
     ],
 )

beacon-chain/blockchain/blockchain_test.go

@@ -0,0 +1,15 @@
+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,17 +1,18 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"time"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
@@ -19,28 +20,52 @@ import (
 type ChainInfoFetcher interface {
 	HeadFetcher
 	FinalizationFetcher
+	GenesisFetcher
+	CanonicalFetcher
+	ForkFetcher
+	TimeFetcher
+	HeadDomainFetcher
 }
 
-// TimeFetcher retrieves the Eth2 data that's related to time.
+// TimeFetcher retrieves the Ethereum consensus data that's related to time.
 type TimeFetcher interface {
 	GenesisTime() time.Time
-	CurrentSlot() uint64
+	CurrentSlot() types.Slot
+}
+
+// GenesisFetcher retrieves the Ethereum consensus data related to its genesis.
+type GenesisFetcher interface {
+	GenesisValidatorRoot() [32]byte
 }
 
 // HeadFetcher defines a common interface for methods in blockchain service which
 // directly retrieves head related data.
 type HeadFetcher interface {
-	HeadSlot() uint64
+	HeadSlot() types.Slot
 	HeadRoot(ctx context.Context) ([]byte, error)
-	HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, error)
-	HeadState(ctx context.Context) (*state.BeaconState, error)
-	HeadValidatorsIndices(epoch uint64) ([]uint64, error)
-	HeadSeed(epoch uint64) ([32]byte, error)
+	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)
+	HeadGenesisValidatorRoot() [32]byte
+	HeadETH1Data() *ethpb.Eth1Data
+	HeadPublicKeyToValidatorIndex(ctx context.Context, pubKey [48]byte) (types.ValidatorIndex, bool)
+	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([48]byte, error)
+	ProtoArrayStore() *protoarray.Store
+	ChainHeads() ([][32]byte, []types.Slot)
+	HeadSyncCommitteeFetcher
+	HeadDomainFetcher
 }
 
 // ForkFetcher retrieves the current fork information of the Ethereum beacon chain.
 type ForkFetcher interface {
-	CurrentFork() *pb.Fork
+	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
@@ -51,25 +76,13 @@ type FinalizationFetcher interface {
 	PreviousJustifiedCheckpt() *ethpb.Checkpoint
 }
 
-// ParticipationFetcher defines a common interface for methods in blockchain service which
-// directly retrieves validator participation related data.
-type ParticipationFetcher interface {
-	Participation(epoch uint64) *precompute.Balance
-}
-
 // FinalizedCheckpt returns the latest finalized checkpoint from head state.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 	if s.finalizedCheckpt == nil {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	// If head state exists but there hasn't been a finalized check point,
-	// the check point's root should refer to genesis block root.
-	if bytes.Equal(s.finalizedCheckpt.Root, params.BeaconConfig().ZeroHash[:]) {
-		return &ethpb.Checkpoint{Root: s.genesisRoot[:]}
-	}
-
-	return state.CopyCheckpoint(s.finalizedCheckpt)
+	return ethpb.CopyCheckpoint(s.finalizedCheckpt)
 }
 
 // CurrentJustifiedCheckpt returns the current justified checkpoint from head state.
@@ -78,13 +91,7 @@ func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	// If head state exists but there hasn't been a justified check point,
-	// the check point root should refer to genesis block root.
-	if bytes.Equal(s.justifiedCheckpt.Root, params.BeaconConfig().ZeroHash[:]) {
-		return &ethpb.Checkpoint{Root: s.genesisRoot[:]}
-	}
-
-	return state.CopyCheckpoint(s.justifiedCheckpt)
+	return ethpb.CopyCheckpoint(s.justifiedCheckpt)
 }
 
 // PreviousJustifiedCheckpt returns the previous justified checkpoint from head state.
@@ -93,17 +100,14 @@ func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	// If head state exists but there hasn't been a justified check point,
-	// the check point root should refer to genesis block root.
-	if bytes.Equal(s.prevJustifiedCheckpt.Root, params.BeaconConfig().ZeroHash[:]) {
-		return &ethpb.Checkpoint{Root: s.genesisRoot[:]}
-	}
-
-	return state.CopyCheckpoint(s.prevJustifiedCheckpt)
+	return ethpb.CopyCheckpoint(s.prevJustifiedCheckpt)
 }
 
 // HeadSlot returns the slot of the head of the chain.
-func (s *Service) HeadSlot() uint64 {
+func (s *Service) HeadSlot() types.Slot {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return 0
 	}
@@ -113,20 +117,23 @@ func (s *Service) HeadSlot() uint64 {
 
 // HeadRoot returns the root of the head of the chain.
 func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if s.headRoot() != params.BeaconConfig().ZeroHash {
 		r := s.headRoot()
 		return r[:], nil
 	}
 
-	b, err := s.beaconDB.HeadBlock(ctx)
+	b, err := s.cfg.BeaconDB.HeadBlock(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if b == nil {
+	if b == nil || b.IsNil() {
 		return params.BeaconConfig().ZeroHash[:], nil
 	}
 
-	r, err := ssz.HashTreeRoot(b.Block)
+	r, err := b.Block().HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
@@ -135,42 +142,87 @@ func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
 }
 
 // HeadBlock returns the head block of the chain.
-// If the head state is nil from service struct,
+// If the head is nil from service struct,
 // it will attempt to get the head block from DB.
-func (s *Service) HeadBlock(ctx context.Context) (*ethpb.SignedBeaconBlock, error) {
+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.beaconDB.HeadBlock(ctx)
+	return s.cfg.BeaconDB.HeadBlock(ctx)
 }
 
 // HeadState returns the head state of the chain.
-// If the head state is nil from service struct,
+// If the head is nil from service struct,
 // it will attempt to get the head state from DB.
-func (s *Service) HeadState(ctx context.Context) (*state.BeaconState, error) {
-	if s.hasHeadState() {
-		return s.headState(), nil
+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.beaconDB.HeadState(ctx)
+	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(epoch uint64) ([]uint64, error) {
+func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
-		return []uint64{}, nil
+		return []types.ValidatorIndex{}, nil
 	}
-	return helpers.ActiveValidatorIndices(s.headState(), epoch)
+	return helpers.ActiveValidatorIndices(ctx, s.headState(ctx), epoch)
 }
 
 // HeadSeed returns the seed from the head view of a given epoch.
-func (s *Service) HeadSeed(epoch uint64) ([32]byte, error) {
+func (s *Service) HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
 		return [32]byte{}, nil
 	}
 
-	return helpers.Seed(s.headState(), epoch, params.BeaconConfig().DomainBeaconAttester)
+	return helpers.Seed(s.headState(ctx), epoch, params.BeaconConfig().DomainBeaconAttester)
+}
+
+// HeadGenesisValidatorRoot returns genesis validator root of the head state.
+func (s *Service) HeadGenesisValidatorRoot() [32]byte {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
+	if !s.hasHeadState() {
+		return [32]byte{}
+	}
+
+	return s.headGenesisValidatorRoot()
+}
+
+// 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()
+}
+
+// ProtoArrayStore returns the proto array store object.
+func (s *Service) ProtoArrayStore() *protoarray.Store {
+	return s.cfg.ForkChoiceStore.Store()
 }
 
 // GenesisTime returns the genesis time of beacon chain.
@@ -178,10 +230,25 @@ func (s *Service) GenesisTime() time.Time {
 	return s.genesisTime
 }
 
-// CurrentFork retrieves the latest fork information of the beacon chain.
-func (s *Service) CurrentFork() *pb.Fork {
+// GenesisValidatorRoot returns the genesis validator
+// root of the chain.
+func (s *Service) GenesisValidatorRoot() [32]byte {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
 	if !s.hasHeadState() {
-		return &pb.Fork{
+		return [32]byte{}
+	}
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
+}
+
+// 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,
 		}
@@ -189,10 +256,59 @@ func (s *Service) CurrentFork() *pb.Fork {
 	return s.head.state.Fork()
 }
 
-// Participation returns the participation stats of a given epoch.
-func (s *Service) Participation(epoch uint64) *precompute.Balance {
-	s.epochParticipationLock.RLock()
-	defer s.epochParticipationLock.RUnlock()
+// IsCanonical returns true if the input block root is part of the canonical chain.
+func (s *Service) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error) {
+	// If the block has been finalized, the block will always be part of the canonical chain.
+	if s.cfg.BeaconDB.IsFinalizedBlock(ctx, blockRoot) {
+		return true, nil
+	}
 
-	return s.epochParticipation[epoch]
+	// If the block has not been finalized, check fork choice store to see if the block is canonical
+	return s.cfg.ForkChoiceStore.IsCanonical(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) {
+	nodes := s.ProtoArrayStore().Nodes()
+
+	// Deliberate choice to not preallocate space for below.
+	// Heads cant be more than 2-3 in the worst case where pre-allocation will be 64 to begin with.
+	headsRoots := make([][32]byte, 0)
+	headsSlots := make([]types.Slot, 0)
+
+	nonExistentNode := ^uint64(0)
+	for _, node := range nodes {
+		// Possible heads have no children.
+		if node.BestDescendant() == nonExistentNode && node.BestChild() == nonExistentNode {
+			headsRoots = append(headsRoots, node.Root())
+			headsSlots = append(headsSlots, node.Slot())
+		}
+	}
+
+	return headsRoots, headsSlots
+}
+
+// HeadPublicKeyToValidatorIndex returns the validator index of the `pubkey` in current head state.
+func (s *Service) HeadPublicKeyToValidatorIndex(ctx context.Context, pubKey [48]byte) (types.ValidatorIndex, bool) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+	if !s.hasHeadState() {
+		return 0, false
+	}
+	return s.headState(ctx).ValidatorIndexByPubkey(pubKey)
+}
+
+// HeadValidatorIndexToPublicKey returns the pubkey of the validator `index`  in current head state.
+func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.ValidatorIndex) ([48]byte, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+	if !s.hasHeadState() {
+		return [48]byte{}, nil
+	}
+	v, err := s.headValidatorAtIndex(index)
+	if err != nil {
+		return [48]byte{}, err
+	}
+	return v.PublicKey(), nil
 }

beacon-chain/blockchain/chain_info_norace_test.go

@@ -4,75 +4,58 @@ import (
 	"context"
 	"testing"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"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"
 )
 
 func TestHeadSlot_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB: db,
+		cfg: &config{BeaconDB: beaconDB},
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}, ); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
 	s.HeadSlot()
 }
 
 func TestHeadRoot_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB: db,
-		head:     &head{root: [32]byte{'A'}},
-		stateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
+		head: &head{root: [32]byte{'A'}},
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}, ); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	if _, err := s.HeadRoot(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := s.HeadRoot(context.Background())
+	require.NoError(t, err)
 }
 
 func TestHeadBlock_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB: db,
-		head:     &head{block: &ethpb.SignedBeaconBlock{}},
-		stateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
+		head: &head{block: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{})},
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}, ); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	if _, err := s.HeadBlock(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := s.HeadBlock(context.Background())
+	require.NoError(t, err)
 }
 
 func TestHeadState_DataRace(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		beaconDB: db,
-		stateGen: stategen.New(db, cache.NewStateSummaryCache()),
+		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 	}
 	go func() {
-		if err := s.saveHead(context.Background(), [32]byte{}, ); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	if _, err := s.HeadState(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := s.HeadState(context.Background())
+	require.NoError(t, err)
 }

beacon-chain/blockchain/chain_info_test.go

@@ -1,203 +1,356 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
-	"reflect"
 	"testing"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	"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{})
-var _ = TimeFetcher(&Service{})
-var _ = ForkFetcher(&Service{})
+var _ ChainInfoFetcher = (*Service)(nil)
+var _ TimeFetcher = (*Service)(nil)
+var _ ForkFetcher = (*Service)(nil)
 
 func TestFinalizedCheckpt_Nil(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	c := setupBeaconChain(t, db)
-	if !bytes.Equal(c.FinalizedCheckpt().Root, params.BeaconConfig().ZeroHash[:]) {
-		t.Error("Incorrect pre chain start value")
-	}
+	beaconDB := testDB.SetupDB(t)
+	c := setupBeaconChain(t, beaconDB)
+	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], c.FinalizedCheckpt().Root, "Incorrect pre chain start value")
 }
 
 func TestHeadRoot_Nil(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	c := setupBeaconChain(t, db)
+	beaconDB := testDB.SetupDB(t)
+	c := setupBeaconChain(t, beaconDB)
 	headRoot, err := c.HeadRoot(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(headRoot, params.BeaconConfig().ZeroHash[:]) {
-		t.Error("Incorrect pre chain start value")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
 }
 
 func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 5, Root: []byte("foo")}
-	c := setupBeaconChain(t, db)
+	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
+	c := setupBeaconChain(t, beaconDB)
 	c.finalizedCheckpt = cp
 
-	if c.FinalizedCheckpt().Epoch != cp.Epoch {
-		t.Errorf("Finalized epoch at genesis should be %d, got: %d", cp.Epoch, c.FinalizedCheckpt().Epoch)
-	}
+	assert.Equal(t, cp.Epoch, c.FinalizedCheckpt().Epoch, "Unexpected finalized epoch")
 }
 
 func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 
 	genesisRoot := [32]byte{'A'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db)
+	c := setupBeaconChain(t, beaconDB)
 	c.finalizedCheckpt = cp
-	c.genesisRoot = genesisRoot
-
-	if !bytes.Equal(c.FinalizedCheckpt().Root, c.genesisRoot[:]) {
-		t.Errorf("Got: %v, wanted: %v", c.FinalizedCheckpt().Root, c.genesisRoot[:])
-	}
+	c.originRoot = genesisRoot
+	assert.DeepEqual(t, c.originRoot[:], c.FinalizedCheckpt().Root)
 }
 
 func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 6, Root: []byte("foo")}
-	c := setupBeaconChain(t, db)
+	c := setupBeaconChain(t, beaconDB)
+	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
+	cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
 	c.justifiedCheckpt = cp
-
-	if c.CurrentJustifiedCheckpt().Epoch != cp.Epoch {
-		t.Errorf("Current Justifiied epoch at genesis should be %d, got: %d", cp.Epoch, c.CurrentJustifiedCheckpt().Epoch)
-	}
+	assert.Equal(t, cp.Epoch, c.CurrentJustifiedCheckpt().Epoch, "Unexpected justified epoch")
 }
 
 func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 
+	c := setupBeaconChain(t, beaconDB)
 	genesisRoot := [32]byte{'B'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db)
 	c.justifiedCheckpt = cp
-	c.genesisRoot = genesisRoot
-
-	if !bytes.Equal(c.CurrentJustifiedCheckpt().Root, c.genesisRoot[:]) {
-		t.Errorf("Got: %v, wanted: %v", c.CurrentJustifiedCheckpt().Root, c.genesisRoot[:])
-	}
+	c.originRoot = genesisRoot
+	assert.DeepEqual(t, c.originRoot[:], c.CurrentJustifiedCheckpt().Root)
 }
 
 func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 
-	cp := &ethpb.Checkpoint{Epoch: 7, Root: []byte("foo")}
-	c := setupBeaconChain(t, db)
+	cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
+	c := setupBeaconChain(t, beaconDB)
+	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
 	c.prevJustifiedCheckpt = cp
-
-	if c.PreviousJustifiedCheckpt().Epoch != cp.Epoch {
-		t.Errorf("Previous Justifiied epoch at genesis should be %d, got: %d", cp.Epoch, c.PreviousJustifiedCheckpt().Epoch)
-	}
+	assert.Equal(t, cp.Epoch, c.PreviousJustifiedCheckpt().Epoch, "Unexpected previous justified epoch")
 }
 
 func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
+	beaconDB := testDB.SetupDB(t)
 
 	genesisRoot := [32]byte{'C'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c := setupBeaconChain(t, db)
+	c := setupBeaconChain(t, beaconDB)
 	c.prevJustifiedCheckpt = cp
-	c.genesisRoot = genesisRoot
-
-	if !bytes.Equal(c.PreviousJustifiedCheckpt().Root, c.genesisRoot[:]) {
-		t.Errorf("Got: %v, wanted: %v", c.PreviousJustifiedCheckpt().Root, c.genesisRoot[:])
-	}
+	c.originRoot = genesisRoot
+	assert.DeepEqual(t, c.originRoot[:], c.PreviousJustifiedCheckpt().Root)
 }
 
 func TestHeadSlot_CanRetrieve(t *testing.T) {
 	c := &Service{}
-	s, err := state.InitializeFromProto(&pb.BeaconState{})
-	if err != nil {
-		t.Fatal(err)
-	}
+	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	c.head = &head{slot: 100, state: s}
-	if c.HeadSlot() != 100 {
-		t.Errorf("Wanted head slot: %d, got: %d", 100, c.HeadSlot())
-	}
+	assert.Equal(t, types.Slot(100), c.HeadSlot())
 }
 
 func TestHeadRoot_CanRetrieve(t *testing.T) {
 	c := &Service{}
 	c.head = &head{root: [32]byte{'A'}}
-	if [32]byte{'A'} != c.headRoot() {
-		t.Errorf("Wanted head root: %v, got: %d", []byte{'A'}, c.headRoot())
-	}
+	r, err := c.HeadRoot(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, [32]byte{'A'}, bytesutil.ToBytes32(r))
+}
+
+func 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)
+	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	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 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
-	s, err := state.InitializeFromProto(&pb.BeaconState{})
-	if err != nil {
-		t.Fatal(err)
-	}
+	b := util.NewBeaconBlock()
+	b.Block.Slot = 1
+	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	c := &Service{}
-	c.head = &head{block: b, state: s}
+	c.head = &head{block: wrapper.WrappedPhase0SignedBeaconBlock(b), state: s}
 
 	recevied, err := c.HeadBlock(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(b, recevied) {
-		t.Error("incorrect head block received")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, b, recevied.Proto(), "Incorrect head block received")
 }
 
 func TestHeadState_CanRetrieve(t *testing.T) {
-	s, err := state.InitializeFromProto(&pb.BeaconState{Slot: 2, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
-	if err != nil {
-		t.Fatal(err)
-	}
+	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())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !proto.Equal(s.InnerStateUnsafe(), headState.InnerStateUnsafe()) {
-		t.Error("incorrect head state received")
-	}
+	require.NoError(t, err)
+	assert.DeepEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Incorrect head state received")
 }
 
 func TestGenesisTime_CanRetrieve(t *testing.T) {
 	c := &Service{genesisTime: time.Unix(999, 0)}
 	wanted := time.Unix(999, 0)
-	if c.GenesisTime() != wanted {
-		t.Error("Did not get wanted genesis time")
-	}
+	assert.Equal(t, wanted, c.GenesisTime(), "Did not get wanted genesis time")
 }
 
 func TestCurrentFork_CanRetrieve(t *testing.T) {
-	f := &pb.Fork{Epoch: 999}
-	s, err := state.InitializeFromProto(&pb.BeaconState{Fork: f})
-	if err != nil {
-		t.Fatal(err)
-	}
+	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 TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
+	// Should not panic if head state is nil.
+	c := &Service{}
+	assert.Equal(t, [32]byte{}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+
+	s, err := v1.InitializeFromProto(&ethpb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
+	require.NoError(t, err)
+	c.head = &head{state: s}
+	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+}
+
+func TestHeadETH1Data_Nil(t *testing.T) {
+	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)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
+	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_HeadGenesisValidatorRoot(t *testing.T) {
+	s, _ := util.DeterministicGenesisState(t, 1)
+	c := &Service{}
+
+	c.head = &head{}
+	root := c.HeadGenesisValidatorRoot()
+	require.Equal(t, [32]byte{}, root)
+
+	c.head = &head{state: s}
+	root = c.HeadGenesisValidatorRoot()
+	require.DeepEqual(t, root[:], s.GenesisValidatorRoot())
+}
+
+func TestService_ProtoArrayStore(t *testing.T) {
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}}
+	p := c.ProtoArrayStore()
+	require.Equal(t, 0, int(p.FinalizedEpoch()))
+}
+
+func TestService_ChainHeads(t *testing.T) {
+	ctx := context.Background()
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}}
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, [32]byte{}, 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_HeadPublicKeyToValidatorIndex(t *testing.T) {
+	s, _ := util.DeterministicGenesisState(t, 10)
+	c := &Service{}
+	c.head = &head{state: s}
+
+	_, e := c.HeadPublicKeyToValidatorIndex(context.Background(), [48]byte{})
+	require.Equal(t, false, e)
+
+	v, err := s.ValidatorAtIndex(0)
+	require.NoError(t, err)
+
+	i, e := c.HeadPublicKeyToValidatorIndex(context.Background(), 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(context.Background(), [48]byte{})
+	require.Equal(t, false, e)
+	require.Equal(t, types.ValidatorIndex(0), idx)
+
+	c.head = &head{state: nil}
+	i, e := c.HeadPublicKeyToValidatorIndex(context.Background(), [48]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, [48]byte{}, p)
+
+	c.head = &head{state: nil}
+	p, err = c.HeadValidatorIndexToPublicKey(context.Background(), 0)
+	require.NoError(t, err)
+	require.Equal(t, [48]byte{}, p)
+}

beacon-chain/blockchain/checktags_test.go

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

beacon-chain/blockchain/head.go

@@ -1,30 +1,39 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
+	"fmt"
 
 	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	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"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/config/features"
+	"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"
 )
 
 // This defines the current chain service's view of head.
 type head struct {
-	slot  uint64                   // current head slot.
-	root  [32]byte                 // current head root.
-	block *ethpb.SignedBeaconBlock // current head block.
-	state *state.BeaconState       // current head state.
+	slot  types.Slot              // current head slot.
+	root  [32]byte                // current head root.
+	block block.SignedBeaconBlock // current head block.
+	state state.BeaconState       // current head state.
 }
 
-// This gets head from the fork choice service and saves head related items
-// (ie root, block, state) to the local service cache.
+// Determined the head from the fork choice service and saves its new data
+// (head root, head block, and head state) to the local service cache.
 func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
-	ctx, span := trace.StartSpan(ctx, "blockchain.updateHead")
+	ctx, span := trace.StartSpan(ctx, "blockChain.updateHead")
 	defer span.End()
 
 	// To get the proper head update, a node first checks its best justified
@@ -37,7 +46,29 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 	// Get head from the fork choice service.
 	f := s.finalizedCheckpt
 	j := s.justifiedCheckpt
-	headRoot, err := s.forkChoiceStore.Head(ctx, j.Epoch, bytesutil.ToBytes32(j.Root), balances, f.Epoch)
+	// 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.originRoot
+	}
+
+	// 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 err
+		}
+		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 err
+		}
+	}
+
+	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx, j.Epoch, headStartRoot, balances, f.Epoch)
 	if err != nil {
 		return err
 	}
@@ -49,163 +80,278 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 // This saves head info to the local service cache, it also saves the
 // new head root to the DB.
 func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockchain.saveHead")
+	ctx, span := trace.StartSpan(ctx, "blockChain.saveHead")
 	defer span.End()
 
 	// Do nothing if head hasn't changed.
-	if headRoot == s.headRoot() {
+	r, err := s.HeadRoot(ctx)
+	if err != nil {
+		return err
+	}
+	if headRoot == bytesutil.ToBytes32(r) {
 		return nil
 	}
 
 	// If the head state is not available, just return nil.
 	// There's nothing to cache
-	if !featureconfig.Get().DisableNewStateMgmt {
-		if !s.stateGen.StateSummaryExists(ctx, headRoot) {
-			return nil
-		}
-	} else {
-		_, cached := s.initSyncState[headRoot]
-		if !cached && !s.beaconDB.HasState(ctx, headRoot) {
-			return nil
-		}
+	if !s.cfg.BeaconDB.HasStateSummary(ctx, headRoot) {
+		return nil
 	}
 
 	// Get the new head block from DB.
-	newHeadBlock, err := s.beaconDB.Block(ctx, headRoot)
+	newHeadBlock, err := s.cfg.BeaconDB.Block(ctx, headRoot)
 	if err != nil {
 		return err
 	}
-	if newHeadBlock == nil || newHeadBlock.Block == nil {
-		return errors.New("cannot save nil head block")
+	if err := helpers.BeaconBlockIsNil(newHeadBlock); err != nil {
+		return err
 	}
 
 	// Get the new head state from cached state or DB.
-	var newHeadState *state.BeaconState
-	if !featureconfig.Get().DisableNewStateMgmt {
-		newHeadState, err = s.stateGen.StateByRoot(ctx, headRoot)
-		if err != nil {
-			return errors.Wrap(err, "could not retrieve head state in DB")
-		}
-	} else {
-		var exists bool
-		newHeadState, exists = s.initSyncState[headRoot]
-		if !exists {
-			newHeadState, err = s.beaconDB.State(ctx, headRoot)
-			if err != nil {
-				return errors.Wrap(err, "could not retrieve head state in DB")
-			}
-		}
+	newHeadState, err := s.cfg.StateGen.StateByRoot(ctx, headRoot)
+	if err != nil {
+		return errors.Wrap(err, "could not retrieve head state in DB")
 	}
-	if newHeadState == nil {
+	if newHeadState == nil || newHeadState.IsNil() {
 		return errors.New("cannot save nil head state")
 	}
 
+	// A chain re-org occurred, so we fire an event notifying the rest of the services.
+	headSlot := s.HeadSlot()
+	newHeadSlot := newHeadBlock.Block().Slot()
+	oldHeadRoot := s.headRoot()
+	oldStateRoot := s.headBlock().Block().StateRoot()
+	newStateRoot := newHeadBlock.Block().StateRoot()
+	if bytesutil.ToBytes32(newHeadBlock.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)
+		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),
+			},
+		})
+
+		if err := s.saveOrphanedAtts(ctx, bytesutil.ToBytes32(r)); err != nil {
+			return err
+		}
+
+		reorgCount.Inc()
+	}
+
 	// Cache the new head info.
 	s.setHead(headRoot, newHeadBlock, newHeadState)
 
 	// Save the new head root to DB.
-	if err := s.beaconDB.SaveHeadBlockRoot(ctx, headRoot); err != nil {
+	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(newHeadSlot, newHeadState, 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 inital-sync-cache-state flag, it uses finalized
+// root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
 // check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
-func (s *Service) saveHeadNoDB(ctx context.Context, b *ethpb.SignedBeaconBlock, r [32]byte) error {
-	if b == nil || b.Block == nil {
-		return errors.New("cannot save nil head block")
+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
 	}
 
-	var headState *state.BeaconState
-	var err error
-	if !featureconfig.Get().DisableNewStateMgmt {
-		headState, err = s.stateGen.StateByRoot(ctx, r)
-		if err != nil {
-			return errors.Wrap(err, "could not retrieve head state in DB")
-		}
-	} else {
-		headState, err = s.beaconDB.State(ctx, r)
-		if err != nil {
-			return errors.Wrap(err, "could not retrieve head state in DB")
-		}
-		if headState == nil {
-			s.initSyncStateLock.RLock()
-			cachedHeadState, ok := s.initSyncState[r]
-			if ok {
-				headState = cachedHeadState
-			}
-			s.initSyncStateLock.RUnlock()
-		}
-	}
-	if headState == nil {
-		return errors.New("nil head state")
-	}
-
-	s.setHead(r, stateTrie.CopySignedBeaconBlock(b), headState)
-
+	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 *ethpb.SignedBeaconBlock, state *state.BeaconState) {
+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,
+		slot:  block.Block().Slot(),
 		root:  root,
-		block: stateTrie.CopySignedBeaconBlock(block),
+		block: block.Copy(),
 		state: state.Copy(),
 	}
 }
 
-// This returns the head slot.
-func (s *Service) headSlot() uint64 {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
+// 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
 	}
 
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
 	return s.head.root
 }
 
 // This returns the head block.
 // It does a full copy on head block for immutability.
-func (s *Service) headBlock() *ethpb.SignedBeaconBlock {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-
-	return stateTrie.CopySignedBeaconBlock(s.head.block)
+// This 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.
-func (s *Service) headState() *state.BeaconState {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
+// This is a lock free version.
+func (s *Service) headState(ctx context.Context) state.BeaconState {
+	ctx, span := trace.StartSpan(ctx, "blockChain.headState")
+	defer span.End()
 
 	return s.head.state.Copy()
 }
 
-// Returns true if head state exists.
-func (s *Service) hasHeadState() bool {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
+// This returns the genesis validator root of the head state.
+// This is a lock free version.
+func (s *Service) headGenesisValidatorRoot() [32]byte {
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
+}
 
+// 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)
+}
+
+// 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(
+	newHeadSlot types.Slot,
+	newHeadState state.BeaconState,
+	newHeadStateRoot,
+	newHeadRoot []byte,
+) error {
+	previousDutyDependentRoot := s.originRoot[:]
+	currentDutyDependentRoot := s.originRoot[:]
+
+	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")
+		}
+	}
+	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,
+		},
+	})
+	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

@@ -0,0 +1,174 @@
+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.GenesisValidatorRoot())
+}
+
+// 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")
+		}
+		if slot > headState.Slot() {
+			headState, err = transition.ProcessSlots(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

@@ -0,0 +1,176 @@
+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.GenesisValidatorRoot())
+	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.GenesisValidatorRoot())
+	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.GenesisValidatorRoot())
+	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)
+}

beacon-chain/blockchain/head_test.go

@@ -3,84 +3,267 @@ package blockchain
 import (
 	"bytes"
 	"context"
-	"reflect"
 	"testing"
+	"time"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
+	types "github.com/prysmaticlabs/eth2-types"
+	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
+	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
+	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"
+	"github.com/prysmaticlabs/prysm/time/slots"
+	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 func TestSaveHead_Same(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	service := setupBeaconChain(t, db)
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
 
 	r := [32]byte{'A'}
 	service.head = &head{slot: 0, root: r}
 
-	if err := service.saveHead(context.Background(), r); err != nil {
-		t.Fatal(err)
-	}
-
-	if service.headSlot() != 0 {
-		t.Error("Head did not stay the same")
-	}
-
-	if service.headRoot() != r {
-		t.Error("Head did not stay the same")
-	}
+	require.NoError(t, service.saveHead(context.Background(), r))
+	assert.Equal(t, types.Slot(0), service.headSlot(), "Head did not stay the same")
+	assert.Equal(t, r, service.headRoot(), "Head did not stay the same")
 }
 
 func TestSaveHead_Different(t *testing.T) {
-	db := testDB.SetupDB(t)
-	defer testDB.TeardownDB(t, db)
-	service := setupBeaconChain(t, db)
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
 
-	oldRoot := [32]byte{'A'}
-	service.head = &head{slot: 0, root: oldRoot}
-
-	newHeadBlock := &ethpb.BeaconBlock{Slot: 1}
-	newHeadSignedBlock := &ethpb.SignedBeaconBlock{Block: newHeadBlock}
-
-	if err := service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock); err != nil {
-		t.Fatal(err)
-	}
-	newRoot, err := ssz.HashTreeRoot(newHeadBlock)
-	if err != nil {
-		t.Fatal(err)
-	}
-	headState := testutil.NewBeaconState()
-	if err := headState.SetSlot(1); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.beaconDB.SaveState(context.Background(), headState, newRoot); err != nil {
-		t.Fatal(err)
-	}
-	if err := service.saveHead(context.Background(), newRoot); err != nil {
-		t.Fatal(err)
+	util.NewBeaconBlock()
+	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
+		util.NewBeaconBlock(),
+	)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
+	oldRoot, err := oldBlock.Block().HashTreeRoot()
+	require.NoError(t, err)
+	service.head = &head{
+		slot:  0,
+		root:  oldRoot,
+		block: oldBlock,
 	}
 
-	if service.HeadSlot() != 1 {
-		t.Error("Head did not change")
-	}
+	newHeadSignedBlock := util.NewBeaconBlock()
+	newHeadSignedBlock.Block.Slot = 1
+	newHeadBlock := newHeadSignedBlock.Block
+
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
+	newRoot, err := newHeadBlock.HashTreeRoot()
+	require.NoError(t, err)
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, headState.SetSlot(1))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), headState, newRoot))
+	require.NoError(t, service.saveHead(context.Background(), newRoot))
+
+	assert.Equal(t, types.Slot(1), service.HeadSlot(), "Head did not change")
 
 	cachedRoot, err := service.HeadRoot(context.Background())
-	if err != nil {
-		t.Fatal(err)
+	require.NoError(t, err)
+	assert.DeepEqual(t, cachedRoot, newRoot[:], "Head did not change")
+	assert.DeepEqual(t, newHeadSignedBlock, service.headBlock().Proto(), "Head did not change")
+	assert.DeepSSZEqual(t, headState.CloneInnerState(), service.headState(ctx).CloneInnerState(), "Head did not change")
+}
+
+func TestSaveHead_Different_Reorg(t *testing.T) {
+	ctx := context.Background()
+	hook := logTest.NewGlobal()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+
+	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
+		util.NewBeaconBlock(),
+	)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
+	oldRoot, err := oldBlock.Block().HashTreeRoot()
+	require.NoError(t, err)
+	service.head = &head{
+		slot:  0,
+		root:  oldRoot,
+		block: oldBlock,
 	}
+
+	reorgChainParent := [32]byte{'B'}
+	newHeadSignedBlock := util.NewBeaconBlock()
+	newHeadSignedBlock.Block.Slot = 1
+	newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
+	newHeadBlock := newHeadSignedBlock.Block
+
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
+	newRoot, err := newHeadBlock.HashTreeRoot()
+	require.NoError(t, err)
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, headState.SetSlot(1))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), headState, newRoot))
+	require.NoError(t, service.saveHead(context.Background(), newRoot))
+
+	assert.Equal(t, types.Slot(1), service.HeadSlot(), "Head did not change")
+
+	cachedRoot, err := service.HeadRoot(context.Background())
+	require.NoError(t, err)
 	if !bytes.Equal(cachedRoot, newRoot[:]) {
 		t.Error("Head did not change")
 	}
-	if !reflect.DeepEqual(service.headBlock(), newHeadSignedBlock) {
-		t.Error("Head did not change")
-	}
-	if !reflect.DeepEqual(service.headState().CloneInnerState(), headState.CloneInnerState()) {
-		t.Error("Head did not change")
-	}
+	assert.DeepEqual(t, newHeadSignedBlock, service.headBlock().Proto(), "Head did not change")
+	assert.DeepSSZEqual(t, headState.CloneInnerState(), service.headState(ctx).CloneInnerState(), "Head did not change")
+	require.LogsContain(t, hook, "Chain reorg occurred")
+}
+
+func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+	ctx := context.Background()
+
+	state, _ := util.DeterministicGenesisState(t, 100)
+	r := [32]byte{'a'}
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: r[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), state, r))
+	balances, err := service.justifiedBalances.get(ctx, r)
+	require.NoError(t, err)
+	require.DeepEqual(t, balances, state.Balances(), "Incorrect justified balances")
+}
+
+func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+
+	b := util.NewBeaconBlock()
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.finalizedCheckpt = &ethpb.Checkpoint{}
+	service.bestJustifiedCheckpt = &ethpb.Checkpoint{}
+
+	require.NoError(t, service.updateHead(context.Background(), []uint64{}))
+}
+
+func Test_notifyNewHeadEvent(t *testing.T) {
+	t.Run("genesis_state_root", func(t *testing.T) {
+		bState, _ := util.DeterministicGenesisState(t, 10)
+		notifier := &mock.MockStateNotifier{RecordEvents: true}
+		srv := &Service{
+			cfg: &config{
+				StateNotifier: notifier,
+			},
+			originRoot: [32]byte{1},
+		}
+		newHeadStateRoot := [32]byte{2}
+		newHeadRoot := [32]byte{3}
+		err := srv.notifyNewHeadEvent(1, bState, newHeadStateRoot[:], newHeadRoot[:])
+		require.NoError(t, err)
+		events := notifier.ReceivedEvents()
+		require.Equal(t, 1, len(events))
+
+		eventHead, ok := events[0].Data.(*ethpbv1.EventHead)
+		require.Equal(t, true, ok)
+		wanted := &ethpbv1.EventHead{
+			Slot:                      1,
+			Block:                     newHeadRoot[:],
+			State:                     newHeadStateRoot[:],
+			EpochTransition:           false,
+			PreviousDutyDependentRoot: srv.originRoot[:],
+			CurrentDutyDependentRoot:  srv.originRoot[:],
+		}
+		require.DeepSSZEqual(t, wanted, eventHead)
+	})
+	t.Run("non_genesis_values", func(t *testing.T) {
+		bState, _ := util.DeterministicGenesisState(t, 10)
+		notifier := &mock.MockStateNotifier{RecordEvents: true}
+		genesisRoot := [32]byte{1}
+		srv := &Service{
+			cfg: &config{
+				StateNotifier: notifier,
+			},
+			originRoot: genesisRoot,
+		}
+		epoch1Start, err := slots.EpochStart(1)
+		require.NoError(t, err)
+		epoch2Start, err := slots.EpochStart(1)
+		require.NoError(t, err)
+		require.NoError(t, bState.SetSlot(epoch1Start))
+
+		newHeadStateRoot := [32]byte{2}
+		newHeadRoot := [32]byte{3}
+		err = srv.notifyNewHeadEvent(epoch2Start, bState, newHeadStateRoot[:], newHeadRoot[:])
+		require.NoError(t, err)
+		events := notifier.ReceivedEvents()
+		require.Equal(t, 1, len(events))
+
+		eventHead, ok := events[0].Data.(*ethpbv1.EventHead)
+		require.Equal(t, true, ok)
+		wanted := &ethpbv1.EventHead{
+			Slot:                      epoch2Start,
+			Block:                     newHeadRoot[:],
+			State:                     newHeadStateRoot[:],
+			EpochTransition:           true,
+			PreviousDutyDependentRoot: genesisRoot[:],
+			CurrentDutyDependentRoot:  make([]byte, 32),
+		}
+		require.DeepSSZEqual(t, wanted, eventHead)
+	})
+}
+
+func TestSaveOrphanedAtts(t *testing.T) {
+	resetCfg := features.InitWithReset(&features.Flags{
+		CorrectlyInsertOrphanedAtts: true,
+	})
+	defer resetCfg()
+
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
+	assert.NoError(t, err)
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+	service.genesisTime = time.Now()
+
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	require.NoError(t, service.saveOrphanedAtts(ctx, r))
+
+	require.Equal(t, len(b.Block.Body.Attestations), service.cfg.AttPool.AggregatedAttestationCount())
+	savedAtts := service.cfg.AttPool.AggregatedAttestations()
+	atts := b.Block.Body.Attestations
+	require.DeepSSZEqual(t, atts, savedAtts)
+}
+
+func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
+	resetCfg := features.InitWithReset(&features.Flags{
+		CorrectlyInsertOrphanedAtts: true,
+	})
+	defer resetCfg()
+
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
+	assert.NoError(t, err)
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
+
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	require.NoError(t, service.saveOrphanedAtts(ctx, r))
+
+	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
+	savedAtts := service.cfg.AttPool.AggregatedAttestations()
+	atts := b.Block.Body.Attestations
+	require.DeepNotSSZEqual(t, atts, savedAtts)
 }

beacon-chain/blockchain/info.go

@@ -1,11 +1,12 @@
 package blockchain
 
 import (
+	"encoding/hex"
 	"fmt"
 	"net/http"
-	"strconv"
 
 	"github.com/emicklei/dot"
+	"github.com/prysmaticlabs/prysm/config/params"
 )
 
 const template = `<html>
@@ -32,37 +33,44 @@ const template = `<html>
 </html>`
 
 // TreeHandler is a handler to serve /tree page in metrics.
-func (s *Service) TreeHandler(w http.ResponseWriter, _ *http.Request) {
-	if s.headState() == nil {
+func (s *Service) TreeHandler(w http.ResponseWriter, r *http.Request) {
+	headState, err := s.HeadState(r.Context())
+	if err != nil {
+		log.WithError(err).Error("Could not get head state")
+		return
+	}
+	if headState == nil || headState.IsNil() {
 		if _, err := w.Write([]byte("Unavailable during initial syncing")); err != nil {
 			log.WithError(err).Error("Failed to render p2p info page")
 		}
 	}
 
-	nodes := s.forkChoiceStore.Nodes()
+	nodes := s.cfg.ForkChoiceStore.Nodes()
 
 	graph := dot.NewGraph(dot.Directed)
 	graph.Attr("rankdir", "RL")
 	graph.Attr("labeljust", "l")
 
 	dotNodes := make([]*dot.Node, len(nodes))
-	avgBalance := uint64(averageBalance(s.headState().Balances()))
+	avgBalance := uint64(averageBalance(headState.Balances()))
 
 	for i := len(nodes) - 1; i >= 0; i-- {
 		// Construct label for each node.
-		slot := strconv.Itoa(int(nodes[i].Slot))
-		weight := strconv.Itoa(int(nodes[i].Weight / 1e9)) // Convert unit Gwei to unit ETH.
-		votes := strconv.Itoa(int(nodes[i].Weight / 1e9 / avgBalance))
-		bestDescendent := strconv.Itoa(int(nodes[i].BestDescendent))
-		index := strconv.Itoa(int(i))
-		label := "slot: " + slot + "\n index: " + index + "\n bestDescendent: " + bestDescendent + "\n votes: " + votes + "\n weight: " + weight
+		slot := fmt.Sprintf("%d", nodes[i].Slot())
+		weight := fmt.Sprintf("%d", nodes[i].Weight()/1e9) // Convert unit Gwei to unit ETH.
+		votes := fmt.Sprintf("%d", nodes[i].Weight()/1e9/avgBalance)
+		index := fmt.Sprintf("%d", i)
+		g := nodes[i].Graffiti()
+		graffiti := hex.EncodeToString(g[:8])
+		label := "slot: " + slot + "\n votes: " + votes + "\n weight: " + weight + "\n graffiti: " + graffiti
 		var dotN dot.Node
-		if nodes[i].Parent != ^uint64(0) {
+		if nodes[i].Parent() != ^uint64(0) {
 			dotN = graph.Node(index).Box().Attr("label", label)
 		}
 
-		if nodes[i].Slot == s.headSlot() &&
-			nodes[i].BestDescendent == ^uint64(0) {
+		if nodes[i].Slot() == s.HeadSlot() &&
+			nodes[i].BestDescendant() == ^uint64(0) &&
+			nodes[i].Parent() != ^uint64(0) {
 			dotN = dotN.Attr("color", "green")
 		}
 
@@ -70,8 +78,8 @@ func (s *Service) TreeHandler(w http.ResponseWriter, _ *http.Request) {
 	}
 
 	for i := len(nodes) - 1; i >= 0; i-- {
-		if nodes[i].Parent != ^uint64(0) && nodes[i].Parent < uint64(len(dotNodes)) {
-			graph.Edge(*dotNodes[i], *dotNodes[nodes[i].Parent])
+		if nodes[i].Parent() != ^uint64(0) && nodes[i].Parent() < uint64(len(dotNodes)) {
+			graph.Edge(*dotNodes[i], *dotNodes[nodes[i].Parent()])
 		}
 	}
 
@@ -81,3 +89,11 @@ func (s *Service) TreeHandler(w http.ResponseWriter, _ *http.Request) {
 		log.WithError(err).Error("Failed to render p2p info page")
 	}
 }
+
+func averageBalance(balances []uint64) float64 {
+	total := uint64(0)
+	for i := 0; i < len(balances); i++ {
+		total += balances[i]
+	}
+	return float64(total) / float64(len(balances)) / float64(params.BeaconConfig().GweiPerEth)
+}

beacon-chain/blockchain/info_test.go

@@ -0,0 +1,50 @@
+package blockchain
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"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"
+)
+
+func TestService_TreeHandler(t *testing.T) {
+	req, err := http.NewRequest("GET", "/tree", nil)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, headState.SetBalances([]uint64{params.BeaconConfig().GweiPerEth}))
+	fcs := protoarray.New(
+		0, // justifiedEpoch
+		0, // finalizedEpoch
+		[32]byte{'a'},
+	)
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	s, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, [32]byte{'a'}, [32]byte{'g'}, [32]byte{'c'}, 0, 0))
+	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'c'}, 0, 0))
+	s.setHead([32]byte{'a'}, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), headState)
+
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(s.TreeHandler)
+
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+}

beacon-chain/blockchain/init_sync_process_block.go

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

beacon-chain/blockchain/init_sync_process_block_test.go

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

beacon-chain/blockchain/init_test.go

@@ -0,0 +1,12 @@
+package blockchain
+
+import (
+	"github.com/prysmaticlabs/prysm/config/params"
+)
+
+func init() {
+	// Override network name so that hardcoded genesis files are not loaded.
+	cfg := params.BeaconConfig()
+	cfg.ConfigName = "test"
+	params.OverrideBeaconConfig(cfg)
+}

beacon-chain/blockchain/log.go

@@ -1,52 +1,67 @@
 package blockchain
 
 import (
+	"encoding/hex"
 	"fmt"
+	"time"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/config/params"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/runtime/version"
+	prysmTime "github.com/prysmaticlabs/prysm/time"
+	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 )
 
 var log = logrus.WithField("prefix", "blockchain")
 
 // logs state transition related data every slot.
-func logStateTransitionData(b *ethpb.BeaconBlock) {
-	log.WithFields(logrus.Fields{
-		"slot":              b.Slot,
-		"attestations":      len(b.Body.Attestations),
-		"deposits":          len(b.Body.Deposits),
-		"attesterSlashings": len(b.Body.AttesterSlashings),
-		"proposerSlashings": len(b.Body.ProposerSlashings),
-		"voluntaryExits":    len(b.Body.VoluntaryExits),
-	}).Info("Finished applying state transition")
+func logStateTransitionData(b block.BeaconBlock) {
+	log := log.WithField("slot", b.Slot())
+	if len(b.Body().Attestations()) > 0 {
+		log = log.WithField("attestations", len(b.Body().Attestations()))
+	}
+	if len(b.Body().Deposits()) > 0 {
+		log = log.WithField("deposits", len(b.Body().Deposits()))
+	}
+	if len(b.Body().AttesterSlashings()) > 0 {
+		log = log.WithField("attesterSlashings", len(b.Body().AttesterSlashings()))
+	}
+	if len(b.Body().ProposerSlashings()) > 0 {
+		log = log.WithField("proposerSlashings", len(b.Body().ProposerSlashings()))
+	}
+	if len(b.Body().VoluntaryExits()) > 0 {
+		log = log.WithField("voluntaryExits", len(b.Body().VoluntaryExits()))
+	}
+	if b.Version() == version.Altair {
+		agg, err := b.Body().SyncAggregate()
+		if err == nil {
+			log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
+		}
+	}
+	log.Info("Finished applying state transition")
 }
 
-func logEpochData(beaconState *stateTrie.BeaconState) {
-	log.WithFields(logrus.Fields{
-		"epoch":                  helpers.CurrentEpoch(beaconState),
-		"finalizedEpoch":         beaconState.FinalizedCheckpointEpoch(),
-		"justifiedEpoch":         beaconState.CurrentJustifiedCheckpoint().Epoch,
-		"previousJustifiedEpoch": beaconState.PreviousJustifiedCheckpoint().Epoch,
-	}).Info("Starting next epoch")
-	activeVals, err := helpers.ActiveValidatorIndices(beaconState, helpers.CurrentEpoch(beaconState))
+func logBlockSyncStatus(block block.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint, receivedTime time.Time, genesisTime uint64) error {
+	startTime, err := slots.ToTime(genesisTime, block.Slot())
 	if err != nil {
-		log.WithError(err).Error("Could not get active validator indices")
-		return
+		return err
 	}
 	log.WithFields(logrus.Fields{
-		"totalValidators":  len(beaconState.Validators()),
-		"activeValidators": len(activeVals),
-		"averageBalance":   fmt.Sprintf("%.5f ETH", averageBalance(beaconState.Balances())),
-	}).Info("Validator registry information")
-}
-
-func averageBalance(balances []uint64) float64 {
-	total := uint64(0)
-	for i := 0; i < len(balances); i++ {
-		total += balances[i]
-	}
-	return float64(total) / float64(len(balances)) / float64(params.BeaconConfig().GweiPerEth)
+		"slot":           block.Slot(),
+		"slotInEpoch":    block.Slot() % params.BeaconConfig().SlotsPerEpoch,
+		"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+		"epoch":          slots.ToEpoch(block.Slot()),
+		"finalizedEpoch": finalized.Epoch,
+		"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
+		"parentRoot":     fmt.Sprintf("0x%s...", hex.EncodeToString(block.ParentRoot())[:8]),
+		"version":        version.String(block.Version()),
+	}).Info("Synced new block")
+	log.WithFields(logrus.Fields{
+		"slot":                      block.Slot,
+		"sinceSlotStartTime":        prysmTime.Now().Sub(startTime),
+		"chainServiceProcessedTime": prysmTime.Now().Sub(receivedTime),
+	}).Debug("Sync new block times")
+	return nil
 }

beacon-chain/blockchain/log_test.go

@@ -0,0 +1,66 @@
+package blockchain
+
+import (
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+)
+
+func Test_logStateTransitionData(t *testing.T) {
+	tests := []struct {
+		name string
+		b    block.BeaconBlock
+		want string
+	}{
+		{name: "empty block body",
+			b:    wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}),
+			want: "\"Finished applying state transition\" prefix=blockchain slot=0",
+		},
+		{name: "has attestation",
+			b:    wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Attestations: []*ethpb.Attestation{{}}}}),
+			want: "\"Finished applying state transition\" attestations=1 prefix=blockchain slot=0",
+		},
+		{name: "has deposit",
+			b: wrapper.WrappedPhase0BeaconBlock(
+				&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+					Attestations: []*ethpb.Attestation{{}},
+					Deposits:     []*ethpb.Deposit{{}}}}),
+			want: "\"Finished applying state transition\" attestations=1 deposits=1 prefix=blockchain slot=0",
+		},
+		{name: "has attester slashing",
+			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				AttesterSlashings: []*ethpb.AttesterSlashing{{}}}}),
+			want: "\"Finished applying state transition\" attesterSlashings=1 prefix=blockchain slot=0",
+		},
+		{name: "has proposer slashing",
+			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				ProposerSlashings: []*ethpb.ProposerSlashing{{}}}}),
+			want: "\"Finished applying state transition\" prefix=blockchain proposerSlashings=1 slot=0",
+		},
+		{name: "has exit",
+			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				VoluntaryExits: []*ethpb.SignedVoluntaryExit{{}}}}),
+			want: "\"Finished applying state transition\" prefix=blockchain slot=0 voluntaryExits=1",
+		},
+		{name: "has everything",
+			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				Attestations:      []*ethpb.Attestation{{}},
+				Deposits:          []*ethpb.Deposit{{}},
+				AttesterSlashings: []*ethpb.AttesterSlashing{{}},
+				ProposerSlashings: []*ethpb.ProposerSlashing{{}},
+				VoluntaryExits:    []*ethpb.SignedVoluntaryExit{{}}}}),
+			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 deposits=1 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
+		},
+	}
+	for _, tt := range tests {
+		hook := logTest.NewGlobal()
+		t.Run(tt.name, func(t *testing.T) {
+			logStateTransitionData(tt.b)
+			require.LogsContain(t, hook, tt.want)
+		})
+	}
+}