Add debug logging

.bazelrc

@@ -62,7 +62,20 @@ build:llvm-asan --config=llvm
 build:llvm-asan --config=asan
 build:llvm-asan --linkopt -fuse-ld=ld.lld
 
-build:fuzz --@io_bazel_rules_go//go/config:tags=fuzz
+build: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
@@ -217,6 +230,3 @@ build:remote --remote_local_fallback
 
 # Ignore GoStdLib with remote caching
 build --modify_execution_info='GoStdlib.*=+no-remote-cache'
-
-# Set bazel gotag
-build --define gotags=bazel

.bazelversion

@@ -1 +1 @@
-5.0.0
+4.2.1

.buildkite-bazelrc

@@ -14,33 +14,36 @@ 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
-build:remote-cache --experimental_remote_cache_async
-build:remote-cache --experimental_remote_merkle_tree_cache
-build:remote-cache --experimental_action_cache_store_output_metadata
-build:remote-cache --experimental_remote_cache_compression
 # Enforce stricter environment rules, which eliminates some non-hermetic
 # behavior and therefore improves both the remote cache hit rate and the
 # correctness and repeatability of the build.
 build:remote-cache --incompatible_strict_action_env=true
 
-build --experimental_use_hermetic_linux_sandbox
-
 # Import workspace options.
 import %workspace%/.bazelrc
 
-startup --host_jvm_args=-Xmx4g --host_jvm_args=-Xms2g
+startup --host_jvm_args=-Xmx2g --host_jvm_args=-Xms2g
+query --repository_cache=/tmp/repositorycache
+query --experimental_repository_cache_hardlinks
+build --repository_cache=/tmp/repositorycache
+build --experimental_repository_cache_hardlinks
 build --experimental_strict_action_env
+build --disk_cache=/tmp/bazelbuilds
+build --experimental_multi_threaded_digest
 build --sandbox_tmpfs_path=/tmp
 build --verbose_failures
 build --announce_rc
 build --show_progress_rate_limit=5
-build --curses=no --color=no
+build --curses=yes --color=no
 build --keep_going
 build --test_output=errors
 build --flaky_test_attempts=5
 # Disabled race detection due to unstable test results under constrained environment build kite
 # build --features=race
 
+# Disable flaky test detection for fuzzing.
+test:fuzz --flaky_test_attempts=1
+
 # Better caching
 build:nostamp --nostamp
 build:nostamp --workspace_status_command=./hack/workspace_status_ci.sh

.github/CODEOWNERS

@@ -6,11 +6,3 @@
 
 # Anyone on prylabs team can approve dependency updates.
 deps.bzl @prysmaticlabs/core-team
-
-# Radek and Nishant are responsible for changes that can affect the native state feature.
-# See https://www.notion.so/prysmaticlabs/Native-Beacon-State-Redesign-6cc9744b4ec1439bb34fa829b36a35c1
-/beacon-chain/state/fieldtrie/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/v1/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/v2/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/v3/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/state-native/ @rkapka @nisdas @rauljordan

.github/actions/gomodtidy/entrypoint.sh

@@ -1,13 +1,13 @@
 #!/bin/sh -l
 set -e
-export PATH="$PATH:/usr/local/go/bin"
+export PATH=$PATH:/usr/local/go/bin
 
-cd "$GITHUB_WORKSPACE"
+cd $GITHUB_WORKSPACE
 
 cp go.mod go.mod.orig
 cp go.sum go.sum.orig
 
-go mod tidy -compat=1.17
+go mod tidy
 
 echo "Checking go.mod and go.sum:"
 checks=0

.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

@@ -7,12 +7,13 @@ on:
     branches: [ '*' ]
 
 jobs:
-  formatting:
-    name: Formatting
+
+  check:
+    name: Check
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v1
 
       - name: Go mod tidy checker
         id: gomodtidy
@@ -30,42 +31,15 @@ jobs:
         with:
           goimports-path: ./
 
-  gosec:
-    name: Gosec scan
-    runs-on: ubuntu-latest
-    env:
-      GO111MODULE: on
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Set up Go 1.18
-        uses: actions/setup-go@v3
+      - name: Gosec security scanner
+        uses: securego/gosec@master
         with:
-          go-version: 1.18
-      - name: Run Gosec Security Scanner
-        run: | # https://github.com/securego/gosec/issues/469
-          export PATH=$PATH:$(go env GOPATH)/bin
-          go install github.com/securego/gosec/v2/cmd/gosec@latest
-          gosec -exclude=G307 -exclude-dir=crypto/bls/herumi ./...
-
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set up Go 1.18
-        uses: actions/setup-go@v3
-        with:
-          go-version: 1.18
-          id: go
+          args: '-exclude=G307 -exclude-dir=crypto/bls/herumi ./...'
 
       - name: Golangci-lint
         uses: golangci/golangci-lint-action@v2
         with:
-          version: v1.45.2
-          skip-go-installation: true
+          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
@@ -74,7 +48,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: 1.18
+          go-version: ^1.14
         id: go
 
       - name: Check out code into the Go module directory
@@ -87,14 +61,6 @@ jobs:
       - name: Build
         # Use blst tag to allow go and bazel builds for blst.
         run: go build -v ./...
-        env: 
-           CGO_CFLAGS: "-O -D__BLST_PORTABLE__"
-        # fuzz leverage go tag based stubs at compile time.
-        # Building and testing with these tags should be checked and enforced at pre-submit.
-      - name: Test for fuzzing
-        run: go test  -tags=fuzz,develop ./...  -test.run=^Fuzz
-        env: 
-           CGO_CFLAGS: "-O -D__BLST_PORTABLE__"
 
 # Tests run via Bazel for now...
 #      - name: Test

.github/workflows/horusec.yaml

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

.gitignore

@@ -30,11 +30,9 @@ password.txt
 # Dist files
 dist
 
+# libfuzzer
+oom-*
+crash-*
+
 # deepsource cli
 bin
-
-# p2p metaData
-metaData
-
-# execution API authentication
-jwt.hex

.golangci.yml

@@ -1,26 +1,69 @@
-run:
-  skip-files:
-    - validator/web/site_data.go
-    - .*_test.go
-  skip-dirs:
-    - proto
-    - tools/analyzers
-  timeout: 10m
-  go: '1.18'
+linters-settings:
+  govet:
+    check-shadowing: true
+    settings:
+      printf:
+        funcs:
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Infof
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Warnf
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Errorf
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Fatalf
+  golint:
+    min-confidence: 0
+  gocyclo:
+    min-complexity: 10
+  maligned:
+    suggest-new: true
+  dupl:
+    threshold: 100
+  goconst:
+    min-len: 2
+    min-occurrences: 2
+  depguard:
+    list-type: blacklist
+    packages:
+      # logging is allowed only by logutils.Log, logrus
+      # is allowed to use only in logutils package
+      - github.com/sirupsen/logrus
+  misspell:
+    locale: US
+  lll:
+    line-length: 140
+  goimports:
+    local-prefixes: github.com/golangci/golangci-lint
+  gocritic:
+    enabled-tags:
+      - performance
+      - style
+      - experimental
+    disabled-checks:
+      - wrapperFunc
 
 linters:
-  disable-all: true
   enable:
     - deadcode
-    - errcheck
-    - gosimple
-    - gocognit
+    - goconst
+    - goimports
+    - golint
+    - gosec
+    - misspell
+    - structcheck
+    - typecheck
+    - unparam
+    - varcheck
+    - gofmt
+    - unused
+  disable-all: true
 
-linters-settings:
-  gocognit:
-    # TODO: We should target for < 50
-    min-complexity: 65
+run:
+  skip-dirs:
+    - proto/
+    - ^contracts/
+  deadline: 10m
 
-output:
-  print-issued-lines: true
-  sort-results: true
+# golangci.com configuration
+# https://github.com/golangci/golangci/wiki/Configuration
+service:
+  golangci-lint-version: 1.15.0 # use the fixed version to not introduce new linters unexpectedly
+  prepare:
+    - echo "here I can run custom commands, but no preparation needed for this repo"

.well-known/security.txt

@@ -5,22 +5,21 @@ Contact: mailto:security@prysmaticlabs.com
 Encryption: openpgp4fpr:0AE0051D647BA3C1A917AF4072E33E4DF1A5036E
 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+TfGlA24FAmGOfiYACgkQcuM+TfGl
-A24YwRAAiQk3w6yzqSEggrOlNoNn04iu/rWZdn5ihkQgzACXy8XH2D1gdKLChE/X
-7e5bUtgE2aCuHryQjwoKxqZakviBJFstVmHgF64rXv2zKhpqA30Mj4fI+T3zn8I+
-+FpFV0TTsxNLDx+AcR1eQ1nSayO7ImUDIfOQNDDnSZZy42Bc+F+QIGKB3aH/8bpG
-kT+bDTZrXvX+TE1gZTbAtZG8sH8g/zadoWEHIhfXUuYb0kTz+DRzAxoqU4j4Z4ee
-1zSfFAgfJwxJP4kWD7s4xkE1sBbCgGBeD6cW/C2lbcfIei+XSizLpHW3jD9dNqh4
-fLkmEspSa/LV/iXFq8nFzu/GLww4q+sQZDzzDKZyws54CrATinRitZMhzoIL0bTn
-yFZVOGHosFAMEVZ36dl1Aw2+B2W6tr2CVr9c5zfV+kup5/KZH1EmT5nYY/zFwfg2
-jYCFB5wmYeiyWZvuprgJXRArgVZLZaJxwWazlPVk4i/4vPvRgvfHqOwHCBe8DXy0
-VHPhpewwb/ECYek1KoaNQflgR8iH2GMHkC5RjhGDAt1S0AQDtite5m4ZYt1kvO9E
-k/znkv89dduhL9CKDvZvnI+DICwsTrf//4KJ8PM/qaPAJa4GvtiUU/eS/jKBivtv
-OP5dZQtX6KPc9ewqqZgn622uHSezoBidgeTkdZsJ6tw2eIu0lsY=
-=V7L0
+iQIzBAEBCgAdFiEECuAFHWR7o8GpF69AcuM+TfGlA24FAl++klgACgkQcuM+TfGl
+A27rQw/6A29p1W20J0v+h218p8XWLSUpTIGLnZTxw6KqdyVXMzlsQK0YG4G2s2AB
+0LKh7Ae/Di5E0U+Z4AjUW5nc5eaCxK36GMscH9Ah0rgJwNYxEJw7/2o8ZqVT/Ip2
++56rFihRqxFZfaCNKFVuZFaL9jKewV9FKYP38ID6/SnTcrOHiu2AoAlyZGmB03p+
+iT57SPRHatygeY4xb/gwcfREFWEv+VHGyBTv8A+6ABZDxyurboCFMERHzFICrbmk
+8UdHxxlWZDnHAbAUyAwpERC5znx6IHXQJwF8TMtu6XY6a6axT2XBOyJDF9/mZOz+
+kdkz6loX5uxaQBGLtTv6Kqf1yUGANOZ16VhHvWwL209LmHmigIVQ+qSM6c79PsW/
+vrsqdz3GBsiMC5Fq2vYgnbgzpfE8Atjn0y7E+j4R7IvwOAE/Ro/b++nqnc4YqhME
+P/yTcfGftaCrdSNnQCXeoV9JxpFM5Xy8KV3eexvNKbcgA/9DtgxL5i+s5ZJkUT9A
++qJvoRrRyIym32ghkHgtFJKB3PLCdobeoOVRk6EnMo9zKSiSK2rZEJW8Ccbo515D
+W9qUOn3GF7lNVuUFAU/YKEdmDp/AVaViZ7vH+8aq0LC0HBkZ8XlzWnWoArS8sMhw
+fX0R9g/HMgrwNte/d0mwim5lJ2Plgv60Bh4grJqwZJeWbU0zi1U=
+=uW+X
 -----END PGP SIGNATURE-----

BUILD.bazel

@@ -3,7 +3,7 @@ load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
-load("@vaticle_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
+load("@graknlabs_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
 load("@bazel_skylib//rules:common_settings.bzl", "string_setting")
 
 prefix = "github.com/prysmaticlabs/prysm"
@@ -16,8 +16,6 @@ exports_files([
 # gazelle:map_kind go_library go_library @prysm//tools/go:def.bzl
 # gazelle:map_kind go_test go_test @prysm//tools/go:def.bzl
 # gazelle:map_kind go_repository go_repository @prysm//tools/go:def.bzl
-# gazelle:build_tags bazel
-# gazelle:exclude tools/analyzers/**/testdata/**
 gazelle(
     name = "gazelle",
     prefix = prefix,
@@ -88,53 +86,50 @@ nogo(
     config = "nogo_config.json",
     visibility = ["//visibility:public"],
     deps = [
-        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unreachable:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/tests:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/structtag:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/shift:go_default_library",
-        # "@org_golang_x_tools//go/analysis/passes/shadow:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/printf:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/pkgfact:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/nilness:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/nilfunc:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/loopclosure:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/httpresponse:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/findcall:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/copylock:go_default_library",
-        #  "@org_golang_x_tools//go/analysis/passes/cgocall:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/buildtag:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/buildssa:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/bools:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/atomic:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/assign:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/inspect:go_default_library",
-        "@org_golang_x_tools//go/analysis/passes/asmdecl:go_default_library",
-        "//tools/analyzers/comparesame:go_default_library",
-        "//tools/analyzers/cryptorand:go_default_library",
-        "//tools/analyzers/errcheck:go_default_library",
-        "//tools/analyzers/featureconfig:go_default_library",
-        "//tools/analyzers/gocognit:go_default_library",
-        "//tools/analyzers/ineffassign:go_default_library",
-        "//tools/analyzers/interfacechecker:go_default_library",
-        "//tools/analyzers/maligned:go_default_library",
-        "//tools/analyzers/nop:go_default_library",
-        "//tools/analyzers/properpermissions:go_default_library",
-        "//tools/analyzers/recursivelock:go_default_library",
-        "//tools/analyzers/shadowpredecl:go_default_library",
-        "//tools/analyzers/slicedirect:go_default_library",
-        "//tools/analyzers/uintcast:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/unreachable:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/tests:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/structtag:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/shift:go_tool_library",
+        # "@org_golang_x_tools//go/analysis/passes/shadow:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/printf:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/pkgfact:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/nilness:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/nilfunc:go_tool_library",
+        "@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/cgocall:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/buildtag:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/buildssa:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/bools:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/atomic:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/assign:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/inspect:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/asmdecl:go_tool_library",
+        "//tools/analyzers/maligned: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_default_library",
-            "@org_golang_x_tools//go/analysis/passes/composite:go_default_library",
+            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_tool_library",
+            "@org_golang_x_tools//go/analysis/passes/composite:go_tool_library",
         ],
     }),
 )
@@ -149,6 +144,15 @@ common_files = {
     "//:README.md": "README.md",
 }
 
+string_setting(
+    name = "gotags",
+    build_setting_default = "",
+    values = [
+        "",
+        "libfuzzer",
+    ],
+)
+
 sh_binary(
     name = "prysm_sh",
     srcs = ["prysm.sh"],

CONTRIBUTING.md

@@ -190,7 +190,7 @@ Anyone can become a part-time contributor and help out on implementing Ethereum
 
 Core contributors are remote contractors of Prysmatic Labs, LLC. and are considered critical team members of our organization. Core devs have all of the responsibilities of part-time contributors plus the majority of the following:
 
--   Stay up to date on the latest beacon chain specification
+-   Stay up to date on the latest beacon chain sepcification
 -   Monitor github issues and PR’s to make sure owner, labels, descriptions are correct
 -   Formulate independent ideas, suggest new work to do, point out improvements to existing approaches
 -   Participate in code review, ensure code quality is excellent, and have ensure high code coverage

INTEROP.md

@@ -26,18 +26,15 @@ You can use `bazel run //tools/genesis-state-gen` to create a deterministic gene
 ### Usage
 
 - **--genesis-time** uint: Unix timestamp used as the genesis time in the generated genesis state (defaults to now)
+- **--mainnet-config** bool: Select whether genesis state should be generated with mainnet or minimal (default) params
 - **--num-validators** int: Number of validators to deterministically include in the generated genesis state
 - **--output-ssz** string: Output filename of the SSZ marshaling of the generated genesis state
-- **--config-name=interop** string: name of the beacon chain config to use when generating the state. ex mainnet|minimal|interop
-
-**deprecated flag: use --config-name instead**
-- **--mainnet-config** bool: Select whether genesis state should be generated with mainnet or minimal (default) params
 
 The example below creates 64 validator keys, instantiates a genesis state with those 64 validators and with genesis unix timestamp 1567542540,
-and finally writes a ssz encoded output to ~/Desktop/genesis.ssz. This file can be used to kickstart the beacon chain in the next section. When using the `--interop-*` flags, the beacon node will assume the `interop` config should be used, unless a different config is specified on the command line.
+and finally writes a ssz encoded output to ~/Desktop/genesis.ssz. This file can be used to kickstart the beacon chain in the next section.
 
 ```
-bazel run //tools/genesis-state-gen -- --config-name interop --output-ssz ~/Desktop/genesis.ssz --num-validators 64 --genesis-time 1567542540
+bazel run //tools/genesis-state-gen -- --output-ssz ~/Desktop/genesis.ssz --num-validators 64 --genesis-time 1567542540
 ```
 
 ## Launching a Beacon Node + Validator Client
@@ -49,10 +46,8 @@ Open up two terminal windows, run:
 ```
 bazel run //beacon-chain -- \
 --bootstrap-node= \
---deposit-contract 0x8A04d14125D0FDCDc742F4A05C051De07232EDa4 \
---datadir=/tmp/beacon-chain-interop \
+--deposit-contract $(curl -s https://prylabs.net/contract) \
 --force-clear-db \
---min-sync-peers=0 \
 --interop-num-validators 64 \
 --interop-eth1data-votes
 ```
@@ -74,10 +69,8 @@ Assuming you generated a `genesis.ssz` file with 64 validators, open up two term
 ```
  bazel run //beacon-chain -- \
 --bootstrap-node= \
---deposit-contract 0x8A04d14125D0FDCDc742F4A05C051De07232EDa4 \
---datadir=/tmp/beacon-chain-interop \
+--deposit-contract $(curl -s https://prylabs.net/contract) \
 --force-clear-db \
---min-sync-peers=0 \
 --interop-genesis-state /path/to/genesis.ssz \
 --interop-eth1data-votes
 ```

README.md

@@ -2,8 +2,7 @@
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
 [![Go Report Card](https://goreportcard.com/badge/github.com/prysmaticlabs/prysm)](https://goreportcard.com/report/github.com/prysmaticlabs/prysm)
-[![Consensus_Spec_Version 1.2.0-rc.1](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.2.0.rc.1-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.2.0-rc.1)
-[![Execution_API_Version 1.0.0-alpha.9](https://img.shields.io/badge/Execution%20API%20Version-v1.0.0.alpha.9-blue.svg)](https://github.com/ethereum/execution-apis/tree/v1.0.0-alpha.9/src/engine)
+[![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 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.

WORKSPACE

@@ -60,10 +60,10 @@ bazel_skylib_workspace()
 
 http_archive(
     name = "bazel_gazelle",
-    sha256 = "5982e5463f171da99e3bdaeff8c0f48283a7a5f396ec5282910b9e8a49c0dd7e",
+    sha256 = "62ca106be173579c0a167deb23358fdfe71ffa1e4cfdddf5582af26520f1c66f",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.25.0/bazel-gazelle-v0.25.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.25.0/bazel-gazelle-v0.25.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.23.0/bazel-gazelle-v0.23.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.23.0/bazel-gazelle-v0.23.0.tar.gz",
     ],
 )
 
@@ -85,13 +85,16 @@ http_archive(
     name = "io_bazel_rules_go",
     patch_args = ["-p1"],
     patches = [
+        # Required until https://github.com/bazelbuild/rules_go/pull/2450 merges otherwise nilness
+        # nogo check fails for certain third_party dependencies.
+        "//third_party:io_bazel_rules_go.patch",
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "f2dcd210c7095febe54b804bb1cd3a58fe8435a909db2ec04e31542631cf715c",
+    sha256 = "7c10271940c6bce577d51a075ae77728964db285dac0a46614a7934dc34303e6",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.31.0/rules_go-v0.31.0.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.31.0/rules_go-v0.31.0.zip",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.26.0/rules_go-v0.26.0.tar.gz",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.26.0/rules_go-v0.26.0.tar.gz",
     ],
 )
 
@@ -117,6 +120,13 @@ http_archive(
     urls = ["https://github.com/fuzzitdev/fuzzit/releases/download/v2.4.76/fuzzit_Linux_x86_64.zip"],
 )
 
+git_repository(
+    name = "graknlabs_bazel_distribution",
+    commit = "962f3a7e56942430c0ec120c24f9e9f2a9c2ce1a",
+    remote = "https://github.com/graknlabs/bazel-distribution",
+    shallow_since = "1569509514 +0300",
+)
+
 load(
     "@io_bazel_rules_docker//repositories:repositories.bzl",
     container_repositories = "repositories",
@@ -176,7 +186,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.18.1",
+    go_version = "1.16.4",
     nogo = "@//:nogo",
 )
 
@@ -212,10 +222,10 @@ filegroup(
 )
     """,
     sha256 = "91434d5fd5e1c6eb7b0174fed2afe25e09bddf00e1e4c431db931b2cee4e7773",
-    url = "https://github.com/eth-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
+    url = "https://github.com/eth2-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
-consensus_spec_version = "v1.2.0-rc.1"
+consensus_spec_version = "v1.1.5"
 
 bls_test_version = "v0.1.1"
 
@@ -231,7 +241,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "9c93f87378aaa6d6fe1c67b396eac2aacc9594af2a83f028cb99c95dea5b81df",
+    sha256 = "a7d7173d953494c0dfde432c9fc064c25d46d666b024749b3474ae0cdfc50050",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -247,7 +257,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "52f2c52415228cee8a4de5a09abff785f439a77dfef8f03e834e4e16857673c1",
+    sha256 = "f86872061588c0197516b23025d39e9365b4716c112218a618739dc0d6f4666a",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -263,7 +273,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "022dcc0d6de7dd27b337a0d1b945077eaf5ee47000700395a693fc25e12f96df",
+    sha256 = "7a06975360fd37fbb4694d0e06abb78d2a0835146c1d9b26d33569edff8b98f0",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -278,7 +288,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "0a9c110305cbd6ebbe0d942f0f33e6ce22dd484ce4ceed277bf185a091941cde",
+    sha256 = "87d8089200163340484d61212fbdffbb5d9d03e1244622761dcb91e641a65761",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -309,9 +319,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "4e8a18b21d056c4032605621b1a6632198eabab57cb90c61e273f344c287f1b2",
-    strip_prefix = "eth2-networks-791a5369c5981e829698b17fbcdcdacbdaba97c8",
-    url = "https://github.com/eth-clients/eth2-networks/archive/791a5369c5981e829698b17fbcdcdacbdaba97c8.tar.gz",
+    sha256 = "9dc47bf6b14aed7fac8833e35ab83a69131b43fa5789b3256bf1ac3d4861aeb8",
+    strip_prefix = "eth2-networks-7fa1b868985ee24aad65567f9250cf7fa86f97b1",
+    url = "https://github.com/eth2-clients/eth2-networks/archive/7fa1b868985ee24aad65567f9250cf7fa86f97b1.tar.gz",
 )
 
 http_archive(
@@ -331,6 +341,16 @@ git_repository(
 # Group the sources of the library so that CMake rule have access to it
 all_content = """filegroup(name = "all", srcs = glob(["**"]), visibility = ["//visibility:public"])"""
 
+http_archive(
+    name = "sigp_beacon_fuzz_corpora",
+    build_file = "//third_party:beacon-fuzz/corpora.BUILD",
+    sha256 = "42993d0901a316afda45b4ba6d53c7c21f30c551dcec290a4ca131c24453d1ef",
+    strip_prefix = "beacon-fuzz-corpora-bac24ad78d45cc3664c0172241feac969c1ac29b",
+    urls = [
+        "https://github.com/sigp/beacon-fuzz-corpora/archive/bac24ad78d45cc3664c0172241feac969c1ac29b.tar.gz",
+    ],
+)
+
 # External dependencies
 
 http_archive(
@@ -342,9 +362,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "4797a7e594a5b1f4c1c8080701613f3ee451b01ec0861499ea7d9b60877a6b23",
+    sha256 = "54ce527b83d092da01127f2e3816f4d5cfbab69354caba8537f1ea55889b6d7c",
     urls = [
-        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.3/prysm-web-ui.tar.gz",
+        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.0-beta.4/prysm-web-ui.tar.gz",
     ],
 )
 
@@ -357,10 +377,6 @@ load("@prysm//third_party/herumi:herumi.bzl", "bls_dependencies")
 
 bls_dependencies()
 
-load("@prysm//testing/endtoend:deps.bzl", "e2e_deps")
-
-e2e_deps()
-
 load(
     "@io_bazel_rules_docker//go:image.bzl",
     _go_image_repos = "repositories",

api/client/beacon/BUILD.bazel

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

api/client/beacon/checkpoint.go

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

api/client/beacon/checkpoint_test.go

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

api/client/beacon/client.go

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

api/client/beacon/client_test.go

@@ -1,138 +0,0 @@
-package beacon
-
-import (
-	"net/url"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestParseNodeVersion(t *testing.T) {
-	cases := []struct {
-		name string
-		v    string
-		err  error
-		nv   *NodeVersion
-	}{
-		{
-			name: "empty string",
-			v:    "",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "Prysm as the version string",
-			v:    "Prysm",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "semver only",
-			v:    "v2.0.6",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "complete version",
-			v:    "Prysm/v2.0.6 (linux amd64)",
-			nv: &NodeVersion{
-				implementation: "Prysm",
-				semver:         "v2.0.6",
-				systemInfo:     "(linux amd64)",
-			},
-		},
-		{
-			name: "nimbus version",
-			v:    "Nimbus/v22.4.0-039bec-stateofus",
-			nv: &NodeVersion{
-				implementation: "Nimbus",
-				semver:         "v22.4.0-039bec-stateofus",
-				systemInfo:     "",
-			},
-		},
-		{
-			name: "teku version",
-			v:    "teku/v22.3.2/linux-x86_64/oracle-java-11",
-			nv: &NodeVersion{
-				implementation: "teku",
-				semver:         "v22.3.2",
-				systemInfo:     "linux-x86_64/oracle-java-11",
-			},
-		},
-		{
-			name: "lighthouse version",
-			v:    "Lighthouse/v2.1.1-5f628a7/x86_64-linux",
-			nv: &NodeVersion{
-				implementation: "Lighthouse",
-				semver:         "v2.1.1-5f628a7",
-				systemInfo:     "x86_64-linux",
-			},
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			nv, err := parseNodeVersion(c.v)
-			if c.err != nil {
-				require.ErrorIs(t, err, c.err)
-			} else {
-				require.NoError(t, err)
-				require.DeepEqual(t, c.nv, nv)
-			}
-		})
-	}
-}
-
-func TestValidHostname(t *testing.T) {
-	cases := []struct {
-		name    string
-		hostArg string
-		path    string
-		joined  string
-		err     error
-	}{
-		{
-			name:    "hostname without port",
-			hostArg: "mydomain.org",
-			err:     ErrMalformedHostname,
-		},
-		{
-			name:    "hostname with port",
-			hostArg: "mydomain.org:3500",
-			path:    getNodeVersionPath,
-			joined:  "http://mydomain.org:3500/eth/v1/node/version",
-		},
-		{
-			name:    "https scheme, hostname with port",
-			hostArg: "https://mydomain.org:3500",
-			path:    getNodeVersionPath,
-			joined:  "https://mydomain.org:3500/eth/v1/node/version",
-		},
-		{
-			name:    "http scheme, hostname without port",
-			hostArg: "http://mydomain.org",
-			path:    getNodeVersionPath,
-			joined:  "http://mydomain.org/eth/v1/node/version",
-		},
-		{
-			name:    "http scheme, trailing slash, hostname without port",
-			hostArg: "http://mydomain.org/",
-			path:    getNodeVersionPath,
-			joined:  "http://mydomain.org/eth/v1/node/version",
-		},
-		{
-			name:    "http scheme, hostname with basic auth creds and no port",
-			hostArg: "http://username:pass@mydomain.org/",
-			path:    getNodeVersionPath,
-			joined:  "http://username:pass@mydomain.org/eth/v1/node/version",
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			cl, err := NewClient(c.hostArg)
-			if c.err != nil {
-				require.ErrorIs(t, err, c.err)
-				return
-			}
-			require.NoError(t, err)
-			require.Equal(t, c.joined, cl.baseURL.ResolveReference(&url.URL{Path: c.path}).String())
-		})
-	}
-}

api/client/beacon/doc.go

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

api/client/beacon/errors.go

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

api/client/builder/BUILD.bazel

@@ -1,41 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "client.go",
-        "errors.go",
-        "types.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/client/builder",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//consensus-types/primitives:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "client_test.go",
-        "types_test.go",
-    ],
-    data = glob(["testdata/**"]),
-    embed = [":go_default_library"],
-    deps = [
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-    ],
-)

api/client/builder/client.go

@@ -1,261 +0,0 @@
-package builder
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/url"
-	"text/template"
-	"time"
-
-	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	getExecHeaderPath          = "/eth/v1/builder/header/{{.Slot}}/{{.ParentHash}}/{{.Pubkey}}"
-	getStatus                  = "/eth/v1/builder/status"
-	postBlindedBeaconBlockPath = "/eth/v1/builder/blinded_blocks"
-	postRegisterValidatorPath  = "/eth/v1/builder/validators"
-)
-
-var errMalformedHostname = errors.New("hostname must include port, separated by one colon, like example.com:3500")
-var errMalformedRequest = errors.New("required request data are missing")
-
-// ClientOpt is a functional option for the Client type (http.Client wrapper)
-type ClientOpt func(*Client)
-
-// WithTimeout sets the .Timeout attribute of the wrapped http.Client.
-func WithTimeout(timeout time.Duration) ClientOpt {
-	return func(c *Client) {
-		c.hc.Timeout = timeout
-	}
-}
-
-type observer interface {
-	observe(r *http.Request) error
-}
-
-func WithObserver(m observer) ClientOpt {
-	return func(c *Client) {
-		c.obvs = append(c.obvs, m)
-	}
-}
-
-type requestLogger struct{}
-
-func (*requestLogger) observe(r *http.Request) (e error) {
-	b := bytes.NewBuffer(nil)
-	if r.Body == nil {
-		log.WithFields(log.Fields{
-			"body-base64": "(nil value)",
-			"url":         r.URL.String(),
-		}).Info("builder http request")
-		return nil
-	}
-	t := io.TeeReader(r.Body, b)
-	defer func() {
-		if r.Body != nil {
-			e = r.Body.Close()
-		}
-	}()
-	body, err := io.ReadAll(t)
-	if err != nil {
-		return err
-	}
-	r.Body = io.NopCloser(b)
-	log.WithFields(log.Fields{
-		"body-base64": string(body),
-		"url":         r.URL.String(),
-	}).Info("builder http request")
-
-	return nil
-}
-
-var _ observer = &requestLogger{}
-
-// Client provides a collection of helper methods for calling Builder API endpoints.
-type Client struct {
-	hc      *http.Client
-	baseURL *url.URL
-	obvs    []observer
-}
-
-// 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) {
-	u, err := urlForHost(host)
-	if err != nil {
-		return nil, err
-	}
-	c := &Client{
-		hc:      &http.Client{},
-		baseURL: u,
-	}
-	for _, o := range opts {
-		o(c)
-	}
-	return c, nil
-}
-
-func urlForHost(h string) (*url.URL, error) {
-	// try to parse as url (being permissive)
-	u, err := url.Parse(h)
-	if err == nil && u.Host != "" {
-		return u, nil
-	}
-	// try to parse as host:port
-	host, port, err := net.SplitHostPort(h)
-	if err != nil {
-		return nil, errMalformedHostname
-	}
-	return &url.URL{Host: net.JoinHostPort(host, port), Scheme: "http"}, nil
-}
-
-// NodeURL returns a human-readable string representation of the beacon node base url.
-func (c *Client) NodeURL() string {
-	return c.baseURL.String()
-}
-
-type reqOption func(*http.Request)
-
-// do is a generic, opinionated GET function to reduce boilerplate amongst the getters in this packageapi/client/builder/types.go.
-func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) ([]byte, error) {
-	u := c.baseURL.ResolveReference(&url.URL{Path: path})
-	log.Printf("requesting %s", u.String())
-	req, err := http.NewRequestWithContext(ctx, method, u.String(), body)
-	if err != nil {
-		return nil, err
-	}
-	for _, o := range opts {
-		o(req)
-	}
-	for _, o := range c.obvs {
-		if err := o.observe(req); err != nil {
-			return nil, err
-		}
-	}
-	r, err := c.hc.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	b, err := io.ReadAll(r.Body)
-	if err != nil {
-		return nil, errors.Wrap(err, "error reading http response body from GetBlock")
-	}
-	return b, nil
-}
-
-var execHeaderTemplate = template.Must(template.New("").Parse(getExecHeaderPath))
-
-func execHeaderPath(slot types.Slot, parentHash [32]byte, pubkey [48]byte) (string, error) {
-	v := struct {
-		Slot       types.Slot
-		ParentHash string
-		Pubkey     string
-	}{
-		Slot:       slot,
-		ParentHash: fmt.Sprintf("%#x", parentHash),
-		Pubkey:     fmt.Sprintf("%#x", pubkey),
-	}
-	b := bytes.NewBuffer(nil)
-	err := execHeaderTemplate.Execute(b, v)
-	if err != nil {
-		return "", errors.Wrapf(err, "error rendering exec header template with slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
-	}
-	return b.String(), nil
-}
-
-// GetHeader is used by a proposing validator to request an ExecutionPayloadHeader from the Builder node.
-func (c *Client) GetHeader(ctx context.Context, slot types.Slot, parentHash [32]byte, pubkey [48]byte) (*ethpb.SignedBuilderBid, error) {
-	path, err := execHeaderPath(slot, parentHash, pubkey)
-	if err != nil {
-		return nil, err
-	}
-	hb, err := c.do(ctx, http.MethodGet, path, nil)
-	if err != nil {
-		return nil, err
-	}
-	hr := &ExecHeaderResponse{}
-	if err := json.Unmarshal(hb, hr); err != nil {
-		return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
-	}
-	return hr.ToProto()
-}
-
-// RegisterValidator encodes the SignedValidatorRegistrationV1 message to json (including hex-encoding the byte
-// fields with 0x prefixes) and posts to the builder validator registration endpoint.
-func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValidatorRegistrationV1) error {
-	if len(svr) == 0 {
-		return errors.Wrap(errMalformedRequest, "empty validator registration list")
-	}
-	vs := make([]*SignedValidatorRegistration, len(svr))
-	for i := 0; i < len(svr); i++ {
-		vs[i] = &SignedValidatorRegistration{SignedValidatorRegistrationV1: svr[i]}
-	}
-	body, err := json.Marshal(vs)
-	if err != nil {
-		return errors.Wrap(err, "error encoding the SignedValidatorRegistration value body in RegisterValidator")
-	}
-	_, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body))
-	return err
-}
-
-// SubmitBlindedBlock calls the builder API endpoint that binds the validator to the builder and submits the block.
-// The response is the full ExecutionPayload used to create the blinded block.
-func (c *Client) SubmitBlindedBlock(ctx context.Context, sb *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error) {
-	v := &SignedBlindedBeaconBlockBellatrix{SignedBlindedBeaconBlockBellatrix: sb}
-	body, err := json.Marshal(v)
-	if err != nil {
-		return nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockBellatrix value body in SubmitBlindedBlock")
-	}
-	rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body))
-	if err != nil {
-		return nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockBellatrix to the builder api")
-	}
-	ep := &ExecPayloadResponse{}
-	if err := json.Unmarshal(rb, ep); err != nil {
-		return nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlock response")
-	}
-	return ep.ToProto()
-}
-
-// Status asks the remote builder server for a health check. A response of 200 with an empty body is the success/healthy
-// response, and an error response may have an error message. This method will return a nil value for error in the
-// happy path, and an error with information about the server response body for a non-200 response.
-func (c *Client) Status(ctx context.Context) error {
-	_, err := c.do(ctx, http.MethodGet, getStatus, nil)
-	return err
-}
-
-func non200Err(response *http.Response) error {
-	bodyBytes, err := io.ReadAll(response.Body)
-	var body string
-	if err != nil {
-		body = "(Unable to read response body.)"
-	} else {
-		body = "response body:\n" + string(bodyBytes)
-	}
-	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
-	switch response.StatusCode {
-	case 404:
-		return errors.Wrap(ErrNotFound, msg)
-	default:
-		return errors.Wrap(ErrNotOK, msg)
-	}
-}

api/client/builder/client_test.go

@@ -1,345 +0,0 @@
-package builder
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-type roundtrip func(*http.Request) (*http.Response, error)
-
-func (fn roundtrip) RoundTrip(r *http.Request) (*http.Response, error) {
-	return fn(r)
-}
-
-func TestClient_Status(t *testing.T) {
-	ctx := context.Background()
-	statusPath := "/eth/v1/builder/status"
-	hc := &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			defer func() {
-				if r.Body == nil {
-					return
-				}
-				require.NoError(t, r.Body.Close())
-			}()
-			require.Equal(t, statusPath, r.URL.Path)
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewBuffer(nil)),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c := &Client{
-		hc:      hc,
-		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-	}
-	require.NoError(t, c.Status(ctx))
-	hc = &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			defer func() {
-				if r.Body == nil {
-					return
-				}
-				require.NoError(t, r.Body.Close())
-			}()
-			require.Equal(t, statusPath, r.URL.Path)
-			return &http.Response{
-				StatusCode: http.StatusInternalServerError,
-				Body:       io.NopCloser(bytes.NewBuffer(nil)),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c = &Client{
-		hc:      hc,
-		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-	}
-	require.ErrorIs(t, c.Status(ctx), ErrNotOK)
-}
-
-func TestClient_RegisterValidator(t *testing.T) {
-	ctx := context.Background()
-	expectedBody := `[{"message":{"fee_recipient":"0x0000000000000000000000000000000000000000","gas_limit":"23","timestamp":"42","pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"}}]`
-	expectedPath := "/eth/v1/builder/validators"
-	hc := &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			body, err := io.ReadAll(r.Body)
-			defer func() {
-				require.NoError(t, r.Body.Close())
-			}()
-			require.NoError(t, err)
-			require.Equal(t, expectedBody, string(body))
-			require.Equal(t, expectedPath, r.URL.Path)
-			require.Equal(t, http.MethodPost, r.Method)
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewBuffer(nil)),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c := &Client{
-		hc:      hc,
-		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-	}
-	reg := &eth.SignedValidatorRegistrationV1{
-		Message: &eth.ValidatorRegistrationV1{
-			FeeRecipient: ezDecode(t, params.BeaconConfig().EthBurnAddressHex),
-			GasLimit:     23,
-			Timestamp:    42,
-			Pubkey:       ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
-		},
-	}
-	require.NoError(t, c.RegisterValidator(ctx, []*eth.SignedValidatorRegistrationV1{reg}))
-}
-
-func TestClient_GetHeader(t *testing.T) {
-	ctx := context.Background()
-	expectedPath := "/eth/v1/builder/header/23/0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2/0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
-	hc := &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			require.Equal(t, expectedPath, r.URL.Path)
-			return &http.Response{
-				StatusCode: http.StatusInternalServerError,
-				Body:       io.NopCloser(bytes.NewBuffer(nil)),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c := &Client{
-		hc:      hc,
-		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-	}
-	var slot types.Slot = 23
-	parentHash := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	pubkey := ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
-	_, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-	require.ErrorIs(t, err, ErrNotOK)
-
-	hc = &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			require.Equal(t, expectedPath, r.URL.Path)
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewBufferString(testExampleHeaderResponse)),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c = &Client{
-		hc:      hc,
-		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-	}
-	h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-	require.NoError(t, err)
-	expectedSig := ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505")
-	require.Equal(t, true, bytes.Equal(expectedSig, h.Signature))
-	expectedTxRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.Equal(t, true, bytes.Equal(expectedTxRoot, h.Message.Header.TransactionsRoot))
-	require.Equal(t, uint64(1), h.Message.Header.GasUsed)
-	value := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
-	require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", h.Message.Value))
-}
-
-func TestSubmitBlindedBlock(t *testing.T) {
-	ctx := context.Background()
-	hc := &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayload)),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c := &Client{
-		hc:      hc,
-		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-	}
-	sbbb := testSignedBlindedBeaconBlockBellatrix(t)
-	ep, err := c.SubmitBlindedBlock(ctx, sbbb)
-	require.NoError(t, err)
-	require.Equal(t, true, bytes.Equal(ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"), ep.ParentHash))
-	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
-	require.Equal(t, fmt.Sprintf("%#x", bfpg.SSZBytes()), fmt.Sprintf("%#x", ep.BaseFeePerGas))
-	require.Equal(t, uint64(1), ep.GasLimit)
-}
-
-func testSignedBlindedBeaconBlockBellatrix(t *testing.T) *eth.SignedBlindedBeaconBlockBellatrix {
-	return &eth.SignedBlindedBeaconBlockBellatrix{
-		Block: &eth.BlindedBeaconBlockBellatrix{
-			Slot:          1,
-			ProposerIndex: 1,
-			ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			Body: &eth.BlindedBeaconBlockBodyBellatrix{
-				RandaoReveal: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-				Eth1Data: &eth.Eth1Data{
-					DepositRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					DepositCount: 1,
-					BlockHash:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				},
-				Graffiti: ezDecode(t, "0xdeadbeefc0ffee"),
-				ProposerSlashings: []*eth.ProposerSlashing{
-					{
-						Header_1: &eth.SignedBeaconBlockHeader{
-							Header: &eth.BeaconBlockHeader{
-								Slot:          1,
-								ProposerIndex: 1,
-								ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-						Header_2: &eth.SignedBeaconBlockHeader{
-							Header: &eth.BeaconBlockHeader{
-								Slot:          1,
-								ProposerIndex: 1,
-								ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-					},
-				},
-				AttesterSlashings: []*eth.AttesterSlashing{
-					{
-						Attestation_1: &eth.IndexedAttestation{
-							AttestingIndices: []uint64{1},
-							Data: &eth.AttestationData{
-								Slot:            1,
-								CommitteeIndex:  1,
-								BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								Source: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-								Target: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-						Attestation_2: &eth.IndexedAttestation{
-							AttestingIndices: []uint64{1},
-							Data: &eth.AttestationData{
-								Slot:            1,
-								CommitteeIndex:  1,
-								BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								Source: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-								Target: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-					},
-				},
-				Attestations: []*eth.Attestation{
-					{
-						AggregationBits: bitfield.Bitlist{0x01},
-						Data: &eth.AttestationData{
-							Slot:            1,
-							CommitteeIndex:  1,
-							BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							Source: &eth.Checkpoint{
-								Epoch: 1,
-								Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-							Target: &eth.Checkpoint{
-								Epoch: 1,
-								Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-						},
-						Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-					},
-				},
-				Deposits: []*eth.Deposit{
-					{
-						Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
-						Data: &eth.Deposit_Data{
-							PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
-							WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							Amount:                1,
-							Signature:             ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-					},
-				},
-				VoluntaryExits: []*eth.SignedVoluntaryExit{
-					{
-						Exit: &eth.VoluntaryExit{
-							Epoch:          1,
-							ValidatorIndex: 1,
-						},
-						Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-					},
-				},
-				SyncAggregate: &eth.SyncAggregate{
-					SyncCommitteeSignature: make([]byte, 48),
-					SyncCommitteeBits:      bitfield.Bitvector512{0x01},
-				},
-				ExecutionPayloadHeader: &v1.ExecutionPayloadHeader{
-					ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					FeeRecipient:     ezDecode(t, "0xabcf8e0d4e9587369b2301d0790347320302cc09"),
-					StateRoot:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					ReceiptsRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					LogsBloom:        ezDecode(t, "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
-					PrevRandao:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					BlockNumber:      1,
-					GasLimit:         1,
-					GasUsed:          1,
-					Timestamp:        1,
-					ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					BaseFeePerGas:    []byte(strconv.FormatUint(1, 10)),
-					BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				},
-			},
-		},
-		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-	}
-}
-
-func TestRequestLogger(t *testing.T) {
-	wo := WithObserver(&requestLogger{})
-	c, err := NewClient("localhost:3500", wo)
-	require.NoError(t, err)
-
-	ctx := context.Background()
-	hc := &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			require.Equal(t, getStatus, r.URL.Path)
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayload)),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c.hc = hc
-	err = c.Status(ctx)
-	require.NoError(t, err)
-}

api/client/builder/errors.go

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

api/client/builder/testdata/execution-payload.json

@@ -1 +0,0 @@
-{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"14074904626401341155369551180448584754667373453244490859944217516317499064576","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}

api/client/builder/types.go

@@ -1,585 +0,0 @@
-package builder
-
-import (
-	"encoding/json"
-	"fmt"
-	"math/big"
-	"strconv"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-type SignedValidatorRegistration struct {
-	*eth.SignedValidatorRegistrationV1
-}
-
-type ValidatorRegistration struct {
-	*eth.ValidatorRegistrationV1
-}
-
-func (r *SignedValidatorRegistration) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Message   *ValidatorRegistration `json:"message,omitempty"`
-		Signature hexutil.Bytes          `json:"signature,omitempty"`
-	}{
-		Message:   &ValidatorRegistration{r.Message},
-		Signature: r.SignedValidatorRegistrationV1.Signature,
-	})
-}
-
-func (r *ValidatorRegistration) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		FeeRecipient hexutil.Bytes `json:"fee_recipient,omitempty"`
-		GasLimit     string        `json:"gas_limit,omitempty"`
-		Timestamp    string        `json:"timestamp,omitempty"`
-		Pubkey       hexutil.Bytes `json:"pubkey,omitempty"`
-	}{
-		FeeRecipient: r.FeeRecipient,
-		GasLimit:     fmt.Sprintf("%d", r.GasLimit),
-		Timestamp:    fmt.Sprintf("%d", r.Timestamp),
-		Pubkey:       r.Pubkey,
-	})
-}
-
-type Uint256 struct {
-	*big.Int
-}
-
-func stringToUint256(s string) Uint256 {
-	bi := new(big.Int)
-	bi.SetString(s, 10)
-	return Uint256{Int: bi}
-}
-
-// sszBytesToUint256 creates a Uint256 from a ssz-style (little-endian byte slice) representation.
-func sszBytesToUint256(b []byte) Uint256 {
-	bi := new(big.Int)
-	return Uint256{Int: bi.SetBytes(bytesutil.ReverseByteOrder(b))}
-}
-
-// SSZBytes creates an ssz-style (little-endian byte slice) representation of the Uint256
-func (s Uint256) SSZBytes() []byte {
-	return bytesutil.PadTo(bytesutil.ReverseByteOrder(s.Int.Bytes()), 32)
-}
-
-var errUnmarshalUint256Failed = errors.New("unable to UnmarshalText into a Uint256 value")
-
-func (s *Uint256) UnmarshalJSON(t []byte) error {
-	start := 0
-	end := len(t)
-	if t[0] == '"' {
-		start += 1
-	}
-	if t[end-1] == '"' {
-		end -= 1
-	}
-	return s.UnmarshalText(t[start:end])
-}
-
-func (s *Uint256) UnmarshalText(t []byte) error {
-	if s.Int == nil {
-		s.Int = big.NewInt(0)
-	}
-	z, ok := s.SetString(string(t), 10)
-	if !ok {
-		return errors.Wrapf(errUnmarshalUint256Failed, "value=%s", string(t))
-	}
-	s.Int = z
-	return nil
-}
-
-func (s Uint256) MarshalJSON() ([]byte, error) {
-	t, err := s.MarshalText()
-	if err != nil {
-		return nil, err
-	}
-	t = append([]byte{'"'}, t...)
-	t = append(t, '"')
-	return t, nil
-}
-
-func (s Uint256) MarshalText() ([]byte, error) {
-	return []byte(s.String()), nil
-}
-
-type Uint64String uint64
-
-func (s *Uint64String) UnmarshalText(t []byte) error {
-	u, err := strconv.ParseUint(string(t), 10, 64)
-	*s = Uint64String(u)
-	return err
-}
-
-func (s Uint64String) MarshalText() ([]byte, error) {
-	return []byte(fmt.Sprintf("%d", s)), nil
-}
-
-type ExecHeaderResponse struct {
-	Version string `json:"version,omitempty"`
-	Data    struct {
-		Signature hexutil.Bytes `json:"signature,omitempty"`
-		Message   *BuilderBid   `json:"message,omitempty"`
-	} `json:"data,omitempty"`
-}
-
-func (ehr *ExecHeaderResponse) ToProto() (*eth.SignedBuilderBid, error) {
-	bb, err := ehr.Data.Message.ToProto()
-	if err != nil {
-		return nil, err
-	}
-	return &eth.SignedBuilderBid{
-		Message:   bb,
-		Signature: ehr.Data.Signature,
-	}, nil
-}
-
-func (bb *BuilderBid) ToProto() (*eth.BuilderBid, error) {
-	header, err := bb.Header.ToProto()
-	if err != nil {
-		return nil, err
-	}
-	return &eth.BuilderBid{
-		Header: header,
-		Value:  bb.Value.SSZBytes(),
-		Pubkey: bb.Pubkey,
-	}, nil
-}
-
-func (h *ExecutionPayloadHeader) ToProto() (*v1.ExecutionPayloadHeader, error) {
-	return &v1.ExecutionPayloadHeader{
-		ParentHash:       h.ParentHash,
-		FeeRecipient:     h.FeeRecipient,
-		StateRoot:        h.StateRoot,
-		ReceiptsRoot:     h.ReceiptsRoot,
-		LogsBloom:        h.LogsBloom,
-		PrevRandao:       h.PrevRandao,
-		BlockNumber:      uint64(h.BlockNumber),
-		GasLimit:         uint64(h.GasLimit),
-		GasUsed:          uint64(h.GasUsed),
-		Timestamp:        uint64(h.Timestamp),
-		ExtraData:        h.ExtraData,
-		BaseFeePerGas:    h.BaseFeePerGas.SSZBytes(),
-		BlockHash:        h.BlockHash,
-		TransactionsRoot: h.TransactionsRoot,
-	}, nil
-}
-
-type BuilderBid struct {
-	Header *ExecutionPayloadHeader `json:"header,omitempty"`
-	Value  Uint256                 `json:"value,omitempty"`
-	Pubkey hexutil.Bytes           `json:"pubkey,omitempty"`
-}
-
-type ExecutionPayloadHeader struct {
-	ParentHash       hexutil.Bytes `json:"parent_hash,omitempty"`
-	FeeRecipient     hexutil.Bytes `json:"fee_recipient,omitempty"`
-	StateRoot        hexutil.Bytes `json:"state_root,omitempty"`
-	ReceiptsRoot     hexutil.Bytes `json:"receipts_root,omitempty"`
-	LogsBloom        hexutil.Bytes `json:"logs_bloom,omitempty"`
-	PrevRandao       hexutil.Bytes `json:"prev_randao,omitempty"`
-	BlockNumber      Uint64String  `json:"block_number,omitempty"`
-	GasLimit         Uint64String  `json:"gas_limit,omitempty"`
-	GasUsed          Uint64String  `json:"gas_used,omitempty"`
-	Timestamp        Uint64String  `json:"timestamp,omitempty"`
-	ExtraData        hexutil.Bytes `json:"extra_data,omitempty"`
-	BaseFeePerGas    Uint256       `json:"base_fee_per_gas,omitempty"`
-	BlockHash        hexutil.Bytes `json:"block_hash,omitempty"`
-	TransactionsRoot hexutil.Bytes `json:"transactions_root,omitempty"`
-	*v1.ExecutionPayloadHeader
-}
-
-func (h *ExecutionPayloadHeader) MarshalJSON() ([]byte, error) {
-	type MarshalCaller ExecutionPayloadHeader
-	return json.Marshal(&MarshalCaller{
-		ParentHash:       h.ExecutionPayloadHeader.ParentHash,
-		FeeRecipient:     h.ExecutionPayloadHeader.FeeRecipient,
-		StateRoot:        h.ExecutionPayloadHeader.StateRoot,
-		ReceiptsRoot:     h.ExecutionPayloadHeader.ReceiptsRoot,
-		LogsBloom:        h.ExecutionPayloadHeader.LogsBloom,
-		PrevRandao:       h.ExecutionPayloadHeader.PrevRandao,
-		BlockNumber:      Uint64String(h.ExecutionPayloadHeader.BlockNumber),
-		GasLimit:         Uint64String(h.ExecutionPayloadHeader.GasLimit),
-		GasUsed:          Uint64String(h.ExecutionPayloadHeader.GasUsed),
-		Timestamp:        Uint64String(h.ExecutionPayloadHeader.Timestamp),
-		ExtraData:        h.ExecutionPayloadHeader.ExtraData,
-		BaseFeePerGas:    sszBytesToUint256(h.ExecutionPayloadHeader.BaseFeePerGas),
-		BlockHash:        h.ExecutionPayloadHeader.BlockHash,
-		TransactionsRoot: h.ExecutionPayloadHeader.TransactionsRoot,
-	})
-}
-
-func (h *ExecutionPayloadHeader) UnmarshalJSON(b []byte) error {
-	type UnmarshalCaller ExecutionPayloadHeader
-	uc := &UnmarshalCaller{}
-	if err := json.Unmarshal(b, uc); err != nil {
-		return err
-	}
-	ep := ExecutionPayloadHeader(*uc)
-	*h = ep
-	var err error
-	h.ExecutionPayloadHeader, err = h.ToProto()
-	return err
-}
-
-type ExecPayloadResponse struct {
-	Version string           `json:"version,omitempty"`
-	Data    ExecutionPayload `json:"data,omitempty"`
-}
-
-type ExecutionPayload struct {
-	ParentHash    hexutil.Bytes   `json:"parent_hash,omitempty"`
-	FeeRecipient  hexutil.Bytes   `json:"fee_recipient,omitempty"`
-	StateRoot     hexutil.Bytes   `json:"state_root,omitempty"`
-	ReceiptsRoot  hexutil.Bytes   `json:"receipts_root,omitempty"`
-	LogsBloom     hexutil.Bytes   `json:"logs_bloom,omitempty"`
-	PrevRandao    hexutil.Bytes   `json:"prev_randao,omitempty"`
-	BlockNumber   Uint64String    `json:"block_number,omitempty"`
-	GasLimit      Uint64String    `json:"gas_limit,omitempty"`
-	GasUsed       Uint64String    `json:"gas_used,omitempty"`
-	Timestamp     Uint64String    `json:"timestamp,omitempty"`
-	ExtraData     hexutil.Bytes   `json:"extra_data,omitempty"`
-	BaseFeePerGas Uint256         `json:"base_fee_per_gas,omitempty"`
-	BlockHash     hexutil.Bytes   `json:"block_hash,omitempty"`
-	Transactions  []hexutil.Bytes `json:"transactions,omitempty"`
-}
-
-func (r *ExecPayloadResponse) ToProto() (*v1.ExecutionPayload, error) {
-	return r.Data.ToProto()
-}
-
-func (p *ExecutionPayload) ToProto() (*v1.ExecutionPayload, error) {
-	txs := make([][]byte, len(p.Transactions))
-	for i := range p.Transactions {
-		txs[i] = p.Transactions[i]
-	}
-	return &v1.ExecutionPayload{
-		ParentHash:    p.ParentHash,
-		FeeRecipient:  p.FeeRecipient,
-		StateRoot:     p.StateRoot,
-		ReceiptsRoot:  p.ReceiptsRoot,
-		LogsBloom:     p.LogsBloom,
-		PrevRandao:    p.PrevRandao,
-		BlockNumber:   uint64(p.BlockNumber),
-		GasLimit:      uint64(p.GasLimit),
-		GasUsed:       uint64(p.GasUsed),
-		Timestamp:     uint64(p.Timestamp),
-		ExtraData:     p.ExtraData,
-		BaseFeePerGas: p.BaseFeePerGas.SSZBytes(),
-		BlockHash:     p.BlockHash,
-		Transactions:  txs,
-	}, nil
-}
-
-type SignedBlindedBeaconBlockBellatrix struct {
-	*eth.SignedBlindedBeaconBlockBellatrix
-}
-
-type BlindedBeaconBlockBellatrix struct {
-	*eth.BlindedBeaconBlockBellatrix
-}
-
-type BlindedBeaconBlockBodyBellatrix struct {
-	*eth.BlindedBeaconBlockBodyBellatrix
-}
-
-func (r *SignedBlindedBeaconBlockBellatrix) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Message   *BlindedBeaconBlockBellatrix `json:"message,omitempty"`
-		Signature hexutil.Bytes                `json:"signature,omitempty"`
-	}{
-		Message:   &BlindedBeaconBlockBellatrix{r.SignedBlindedBeaconBlockBellatrix.Block},
-		Signature: r.SignedBlindedBeaconBlockBellatrix.Signature,
-	})
-}
-
-func (b *BlindedBeaconBlockBellatrix) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Slot          string                           `json:"slot"`
-		ProposerIndex string                           `json:"proposer_index,omitempty"`
-		ParentRoot    hexutil.Bytes                    `json:"parent_root,omitempty"`
-		StateRoot     hexutil.Bytes                    `json:"state_root,omitempty"`
-		Body          *BlindedBeaconBlockBodyBellatrix `json:"body,omitempty"`
-	}{
-		Slot:          fmt.Sprintf("%d", b.Slot),
-		ProposerIndex: fmt.Sprintf("%d", b.ProposerIndex),
-		ParentRoot:    b.ParentRoot,
-		StateRoot:     b.StateRoot,
-		Body:          &BlindedBeaconBlockBodyBellatrix{b.BlindedBeaconBlockBellatrix.Body},
-	})
-}
-
-type ProposerSlashing struct {
-	*eth.ProposerSlashing
-}
-
-func (s *ProposerSlashing) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		SignedHeader1 *SignedBeaconBlockHeader `json:"signed_header_1,omitempty"`
-		SignedHeader2 *SignedBeaconBlockHeader `json:"signed_header_2,omitempty"`
-	}{
-		SignedHeader1: &SignedBeaconBlockHeader{s.ProposerSlashing.Header_1},
-		SignedHeader2: &SignedBeaconBlockHeader{s.ProposerSlashing.Header_2},
-	})
-}
-
-type SignedBeaconBlockHeader struct {
-	*eth.SignedBeaconBlockHeader
-}
-
-func (h *SignedBeaconBlockHeader) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Header    *BeaconBlockHeader `json:"message,omitempty"`
-		Signature hexutil.Bytes      `json:"signature,omitempty"`
-	}{
-		Header:    &BeaconBlockHeader{h.SignedBeaconBlockHeader.Header},
-		Signature: h.SignedBeaconBlockHeader.Signature,
-	})
-}
-
-type BeaconBlockHeader struct {
-	*eth.BeaconBlockHeader
-}
-
-func (h *BeaconBlockHeader) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Slot          string        `json:"slot,omitempty"`
-		ProposerIndex string        `json:"proposer_index,omitempty"`
-		ParentRoot    hexutil.Bytes `json:"parent_root,omitempty"`
-		StateRoot     hexutil.Bytes `json:"state_root,omitempty"`
-		BodyRoot      hexutil.Bytes `json:"body_root,omitempty"`
-	}{
-		Slot:          fmt.Sprintf("%d", h.BeaconBlockHeader.Slot),
-		ProposerIndex: fmt.Sprintf("%d", h.BeaconBlockHeader.ProposerIndex),
-		ParentRoot:    h.BeaconBlockHeader.ParentRoot,
-		StateRoot:     h.BeaconBlockHeader.StateRoot,
-		BodyRoot:      h.BeaconBlockHeader.BodyRoot,
-	})
-}
-
-type IndexedAttestation struct {
-	*eth.IndexedAttestation
-}
-
-func (a *IndexedAttestation) MarshalJSON() ([]byte, error) {
-	indices := make([]string, len(a.IndexedAttestation.AttestingIndices))
-	for i := range a.IndexedAttestation.AttestingIndices {
-		indices[i] = fmt.Sprintf("%d", a.AttestingIndices[i])
-	}
-	return json.Marshal(struct {
-		AttestingIndices []string         `json:"attesting_indices,omitempty"`
-		Data             *AttestationData `json:"data,omitempty"`
-		Signature        hexutil.Bytes    `json:"signature,omitempty"`
-	}{
-		AttestingIndices: indices,
-		Data:             &AttestationData{a.IndexedAttestation.Data},
-		Signature:        a.IndexedAttestation.Signature,
-	})
-}
-
-type AttesterSlashing struct {
-	*eth.AttesterSlashing
-}
-
-func (s *AttesterSlashing) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Attestation1 *IndexedAttestation `json:"attestation_1,omitempty"`
-		Attestation2 *IndexedAttestation `json:"attestation_2,omitempty"`
-	}{
-		Attestation1: &IndexedAttestation{s.Attestation_1},
-		Attestation2: &IndexedAttestation{s.Attestation_2},
-	})
-}
-
-type Checkpoint struct {
-	*eth.Checkpoint
-}
-
-func (c *Checkpoint) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Epoch string        `json:"epoch,omitempty"`
-		Root  hexutil.Bytes `json:"root,omitempty"`
-	}{
-		Epoch: fmt.Sprintf("%d", c.Checkpoint.Epoch),
-		Root:  c.Checkpoint.Root,
-	})
-}
-
-type AttestationData struct {
-	*eth.AttestationData
-}
-
-func (a *AttestationData) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Slot            string        `json:"slot,omitempty"`
-		Index           string        `json:"index,omitempty"`
-		BeaconBlockRoot hexutil.Bytes `json:"beacon_block_root,omitempty"`
-		Source          *Checkpoint   `json:"source,omitempty"`
-		Target          *Checkpoint   `json:"target,omitempty"`
-	}{
-		Slot:            fmt.Sprintf("%d", a.AttestationData.Slot),
-		Index:           fmt.Sprintf("%d", a.AttestationData.CommitteeIndex),
-		BeaconBlockRoot: a.AttestationData.BeaconBlockRoot,
-		Source:          &Checkpoint{a.AttestationData.Source},
-		Target:          &Checkpoint{a.AttestationData.Target},
-	})
-}
-
-type Attestation struct {
-	*eth.Attestation
-}
-
-func (a *Attestation) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		AggregationBits hexutil.Bytes    `json:"aggregation_bits,omitempty"`
-		Data            *AttestationData `json:"data,omitempty"`
-		Signature       hexutil.Bytes    `json:"signature,omitempty" ssz-size:"96"`
-	}{
-		AggregationBits: hexutil.Bytes(a.Attestation.AggregationBits),
-		Data:            &AttestationData{a.Attestation.Data},
-		Signature:       a.Attestation.Signature,
-	})
-}
-
-type DepositData struct {
-	*eth.Deposit_Data
-}
-
-func (d *DepositData) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		PublicKey             hexutil.Bytes `json:"pubkey,omitempty"`
-		WithdrawalCredentials hexutil.Bytes `json:"withdrawal_credentials,omitempty"`
-		Amount                string        `json:"amount,omitempty"`
-		Signature             hexutil.Bytes `json:"signature,omitempty"`
-	}{
-		PublicKey:             d.PublicKey,
-		WithdrawalCredentials: d.WithdrawalCredentials,
-		Amount:                fmt.Sprintf("%d", d.Amount),
-		Signature:             d.Signature,
-	})
-}
-
-type Deposit struct {
-	*eth.Deposit
-}
-
-func (d *Deposit) MarshalJSON() ([]byte, error) {
-	proof := make([]hexutil.Bytes, len(d.Proof))
-	for i := range d.Proof {
-		proof[i] = d.Proof[i]
-	}
-	return json.Marshal(struct {
-		Proof []hexutil.Bytes `json:"proof"`
-		Data  *DepositData    `json:"data"`
-	}{
-		Proof: proof,
-		Data:  &DepositData{Deposit_Data: d.Deposit.Data},
-	})
-}
-
-type SignedVoluntaryExit struct {
-	*eth.SignedVoluntaryExit
-}
-
-func (sve *SignedVoluntaryExit) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Message   *VoluntaryExit `json:"message,omitempty"`
-		Signature hexutil.Bytes  `json:"signature,omitempty"`
-	}{
-		Signature: sve.SignedVoluntaryExit.Signature,
-		Message:   &VoluntaryExit{sve.SignedVoluntaryExit.Exit},
-	})
-}
-
-type VoluntaryExit struct {
-	*eth.VoluntaryExit
-}
-
-func (ve *VoluntaryExit) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Epoch          string `json:"epoch,omitempty"`
-		ValidatorIndex string `json:"validator_index,omitempty"`
-	}{
-		Epoch:          fmt.Sprintf("%d", ve.Epoch),
-		ValidatorIndex: fmt.Sprintf("%d", ve.ValidatorIndex),
-	})
-}
-
-type SyncAggregate struct {
-	*eth.SyncAggregate
-}
-
-func (s *SyncAggregate) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		SyncCommitteeBits      hexutil.Bytes `json:"sync_committee_bits,omitempty"`
-		SyncCommitteeSignature hexutil.Bytes `json:"sync_committee_signature,omitempty"`
-	}{
-		SyncCommitteeBits:      hexutil.Bytes(s.SyncAggregate.SyncCommitteeBits),
-		SyncCommitteeSignature: s.SyncAggregate.SyncCommitteeSignature,
-	})
-}
-
-type Eth1Data struct {
-	*eth.Eth1Data
-}
-
-func (e *Eth1Data) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		DepositRoot  hexutil.Bytes `json:"deposit_root,omitempty"`
-		DepositCount string        `json:"deposit_count,omitempty"`
-		BlockHash    hexutil.Bytes `json:"block_hash,omitempty"`
-	}{
-		DepositRoot:  e.DepositRoot,
-		DepositCount: fmt.Sprintf("%d", e.DepositCount),
-		BlockHash:    e.BlockHash,
-	})
-}
-
-func (b *BlindedBeaconBlockBodyBellatrix) MarshalJSON() ([]byte, error) {
-	sve := make([]*SignedVoluntaryExit, len(b.BlindedBeaconBlockBodyBellatrix.VoluntaryExits))
-	for i := range b.BlindedBeaconBlockBodyBellatrix.VoluntaryExits {
-		sve[i] = &SignedVoluntaryExit{SignedVoluntaryExit: b.BlindedBeaconBlockBodyBellatrix.VoluntaryExits[i]}
-	}
-	deps := make([]*Deposit, len(b.BlindedBeaconBlockBodyBellatrix.Deposits))
-	for i := range b.BlindedBeaconBlockBodyBellatrix.Deposits {
-		deps[i] = &Deposit{Deposit: b.BlindedBeaconBlockBodyBellatrix.Deposits[i]}
-	}
-	atts := make([]*Attestation, len(b.BlindedBeaconBlockBodyBellatrix.Attestations))
-	for i := range b.BlindedBeaconBlockBodyBellatrix.Attestations {
-		atts[i] = &Attestation{Attestation: b.BlindedBeaconBlockBodyBellatrix.Attestations[i]}
-	}
-	atsl := make([]*AttesterSlashing, len(b.BlindedBeaconBlockBodyBellatrix.AttesterSlashings))
-	for i := range b.BlindedBeaconBlockBodyBellatrix.AttesterSlashings {
-		atsl[i] = &AttesterSlashing{AttesterSlashing: b.BlindedBeaconBlockBodyBellatrix.AttesterSlashings[i]}
-	}
-	pros := make([]*ProposerSlashing, len(b.BlindedBeaconBlockBodyBellatrix.ProposerSlashings))
-	for i := range b.BlindedBeaconBlockBodyBellatrix.ProposerSlashings {
-		pros[i] = &ProposerSlashing{ProposerSlashing: b.BlindedBeaconBlockBodyBellatrix.ProposerSlashings[i]}
-	}
-	return json.Marshal(struct {
-		RandaoReveal           hexutil.Bytes           `json:"randao_reveal,omitempty"`
-		Eth1Data               *Eth1Data               `json:"eth1_data,omitempty"`
-		Graffiti               hexutil.Bytes           `json:"graffiti,omitempty"`
-		ProposerSlashings      []*ProposerSlashing     `json:"proposer_slashings,omitempty"`
-		AttesterSlashings      []*AttesterSlashing     `json:"attester_slashings,omitempty"`
-		Attestations           []*Attestation          `json:"attestations,omitempty"`
-		Deposits               []*Deposit              `json:"deposits,omitempty"`
-		VoluntaryExits         []*SignedVoluntaryExit  `json:"voluntary_exits,omitempty"`
-		SyncAggregate          *SyncAggregate          `json:"sync_aggregate,omitempty"`
-		ExecutionPayloadHeader *ExecutionPayloadHeader `json:"execution_payload_header,omitempty"`
-	}{
-		RandaoReveal:           b.RandaoReveal,
-		Eth1Data:               &Eth1Data{b.BlindedBeaconBlockBodyBellatrix.Eth1Data},
-		Graffiti:               b.BlindedBeaconBlockBodyBellatrix.Graffiti,
-		ProposerSlashings:      pros,
-		AttesterSlashings:      atsl,
-		Attestations:           atts,
-		Deposits:               deps,
-		VoluntaryExits:         sve,
-		SyncAggregate:          &SyncAggregate{b.BlindedBeaconBlockBodyBellatrix.SyncAggregate},
-		ExecutionPayloadHeader: &ExecutionPayloadHeader{ExecutionPayloadHeader: b.BlindedBeaconBlockBodyBellatrix.ExecutionPayloadHeader},
-	})
-}

api/client/builder/types_test.go

@@ -1,727 +0,0 @@
-package builder
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"math/big"
-	"os"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/prysmaticlabs/go-bitfield"
-	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func ezDecode(t *testing.T, s string) []byte {
-	v, err := hexutil.Decode(s)
-	require.NoError(t, err)
-	return v
-}
-
-func TestSignedValidatorRegistration_MarshalJSON(t *testing.T) {
-	svr := &eth.SignedValidatorRegistrationV1{
-		Message: &eth.ValidatorRegistrationV1{
-			FeeRecipient: make([]byte, 20),
-			GasLimit:     0,
-			Timestamp:    0,
-			Pubkey:       make([]byte, 48),
-		},
-		Signature: make([]byte, 96),
-	}
-	je, err := json.Marshal(&SignedValidatorRegistration{SignedValidatorRegistrationV1: svr})
-	require.NoError(t, err)
-	// decode with a struct w/ plain strings so we can check the string encoding of the hex fields
-	un := struct {
-		Message struct {
-			FeeRecipient string `json:"fee_recipient"`
-			Pubkey       string `json:"pubkey"`
-		} `json:"message"`
-		Signature string `json:"signature"`
-	}{}
-	require.NoError(t, json.Unmarshal(je, &un))
-	require.Equal(t, "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", un.Signature)
-	require.Equal(t, "0x0000000000000000000000000000000000000000", un.Message.FeeRecipient)
-	require.Equal(t, "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", un.Message.Pubkey)
-}
-
-var testExampleHeaderResponse = `{
-  "version": "bellatrix",
-  "data": {
-    "message": {
-      "header": {
-        "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-        "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-        "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-        "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-        "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-        "block_number": "1",
-        "gas_limit": "1",
-        "gas_used": "1",
-        "timestamp": "1",
-        "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-        "base_fee_per_gas": "452312848583266388373324160190187140051835877600158453279131187530910662656",
-        "block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-        "transactions_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
-      },
-      "value": "652312848583266388373324160190187140051835877600158453279131187530910662656",
-      "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
-    },
-    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
-  }
-}`
-
-func TestExecutionHeaderResponseUnmarshal(t *testing.T) {
-	hr := &ExecHeaderResponse{}
-	require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponse), hr))
-	cases := []struct {
-		expected string
-		actual   string
-		name     string
-	}{
-		{
-			expected: "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
-			actual:   hexutil.Encode(hr.Data.Signature),
-			name:     "Signature",
-		},
-		{
-			expected: "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
-			actual:   hexutil.Encode(hr.Data.Message.Pubkey),
-			name:     "ExecHeaderResponse.Pubkey",
-		},
-		{
-			expected: "652312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   hr.Data.Message.Value.String(),
-			name:     "ExecHeaderResponse.Value",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ParentHash),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ParentHash",
-		},
-		{
-			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-			actual:   hexutil.Encode(hr.Data.Message.Header.FeeRecipient),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.FeeRecipient",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.StateRoot),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.StateRoot",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ReceiptsRoot),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ReceiptsRoot",
-		},
-		{
-			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-			actual:   hexutil.Encode(hr.Data.Message.Header.LogsBloom),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.LogsBloom",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.PrevRandao),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.PrevRandao",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BlockNumber),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockNumber",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasLimit),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasLimit",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasUsed),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasUsed",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.Timestamp),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.Timestamp",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ExtraData),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ExtraData",
-		},
-		{
-			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BaseFeePerGas),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BaseFeePerGas",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.BlockHash),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockHash",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.TransactionsRoot),
-			name:     "ExecHeaderResponse.ExecutionPayloadHeader.TransactionsRoot",
-		},
-	}
-	for _, c := range cases {
-		require.Equal(t, c.expected, c.actual, fmt.Sprintf("unexpected value for field %s", c.name))
-	}
-}
-
-func TestExecutionHeaderResponseToProto(t *testing.T) {
-	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
-	v := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
-	hr := &ExecHeaderResponse{}
-	require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponse), hr))
-	p, err := hr.ToProto()
-	require.NoError(t, err)
-	signature, err := hexutil.Decode("0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505")
-	require.NoError(t, err)
-	pubkey, err := hexutil.Decode("0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
-	require.NoError(t, err)
-	parentHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	feeRecipient, err := hexutil.Decode("0xabcf8e0d4e9587369b2301d0790347320302cc09")
-	require.NoError(t, err)
-	stateRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	receiptsRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	logsBloom, err := hexutil.Decode("0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
-	require.NoError(t, err)
-	prevRandao, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	extraData, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	blockHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	txRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-
-	expected := &eth.SignedBuilderBid{
-		Message: &eth.BuilderBid{
-			Header: &v1.ExecutionPayloadHeader{
-				ParentHash:       parentHash,
-				FeeRecipient:     feeRecipient,
-				StateRoot:        stateRoot,
-				ReceiptsRoot:     receiptsRoot,
-				LogsBloom:        logsBloom,
-				PrevRandao:       prevRandao,
-				BlockNumber:      1,
-				GasLimit:         1,
-				GasUsed:          1,
-				Timestamp:        1,
-				ExtraData:        extraData,
-				BaseFeePerGas:    bfpg.SSZBytes(),
-				BlockHash:        blockHash,
-				TransactionsRoot: txRoot,
-			},
-			Value:  v.SSZBytes(),
-			Pubkey: pubkey,
-		},
-		Signature: signature,
-	}
-	require.DeepEqual(t, expected, p)
-}
-
-var testExampleExecutionPayload = `{
-  "version": "bellatrix",
-  "data": {
-    "parent_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-    "fee_recipient": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-    "state_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-    "receipts_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-    "logs_bloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "prev_randao": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-    "block_number": "1",
-    "gas_limit": "1",
-    "gas_used": "1",
-    "timestamp": "1",
-    "extra_data": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-    "base_fee_per_gas": "452312848583266388373324160190187140051835877600158453279131187530910662656",
-    "block_hash": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-    "transactions": [
-      "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
-    ]
-  }
-}`
-
-func TestExecutionPayloadResponseUnmarshal(t *testing.T) {
-	epr := &ExecPayloadResponse{}
-	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), epr))
-	cases := []struct {
-		expected string
-		actual   string
-		name     string
-	}{
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ParentHash),
-			name:     "ExecPayloadResponse.ExecutionPayload.ParentHash",
-		},
-		{
-			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-			actual:   hexutil.Encode(epr.Data.FeeRecipient),
-			name:     "ExecPayloadResponse.ExecutionPayload.FeeRecipient",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.StateRoot),
-			name:     "ExecPayloadResponse.ExecutionPayload.StateRoot",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ReceiptsRoot),
-			name:     "ExecPayloadResponse.ExecutionPayload.ReceiptsRoot",
-		},
-		{
-			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-			actual:   hexutil.Encode(epr.Data.LogsBloom),
-			name:     "ExecPayloadResponse.ExecutionPayload.LogsBloom",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.PrevRandao),
-			name:     "ExecPayloadResponse.ExecutionPayload.PrevRandao",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.BlockNumber),
-			name:     "ExecPayloadResponse.ExecutionPayload.BlockNumber",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.GasLimit),
-			name:     "ExecPayloadResponse.ExecutionPayload.GasLimit",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.GasUsed),
-			name:     "ExecPayloadResponse.ExecutionPayload.GasUsed",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.Timestamp),
-			name:     "ExecPayloadResponse.ExecutionPayload.Timestamp",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExtraData),
-			name:     "ExecPayloadResponse.ExecutionPayload.ExtraData",
-		},
-		{
-			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   fmt.Sprintf("%d", epr.Data.BaseFeePerGas),
-			name:     "ExecPayloadResponse.ExecutionPayload.BaseFeePerGas",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.BlockHash),
-			name:     "ExecPayloadResponse.ExecutionPayload.BlockHash",
-		},
-	}
-	for _, c := range cases {
-		require.Equal(t, c.expected, c.actual, fmt.Sprintf("unexpected value for field %s", c.name))
-	}
-	require.Equal(t, 1, len(epr.Data.Transactions))
-	txHash := "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
-	require.Equal(t, txHash, hexutil.Encode(epr.Data.Transactions[0]))
-}
-
-func TestExecutionPayloadResponseToProto(t *testing.T) {
-	hr := &ExecPayloadResponse{}
-	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), hr))
-	p, err := hr.ToProto()
-	require.NoError(t, err)
-
-	parentHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	feeRecipient, err := hexutil.Decode("0xabcf8e0d4e9587369b2301d0790347320302cc09")
-	require.NoError(t, err)
-	stateRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	receiptsRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	logsBloom, err := hexutil.Decode("0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
-	require.NoError(t, err)
-	prevRandao, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	extraData, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	blockHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-
-	tx, err := hexutil.Decode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")
-	require.NoError(t, err)
-	txList := [][]byte{tx}
-
-	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
-	expected := &v1.ExecutionPayload{
-		ParentHash:    parentHash,
-		FeeRecipient:  feeRecipient,
-		StateRoot:     stateRoot,
-		ReceiptsRoot:  receiptsRoot,
-		LogsBloom:     logsBloom,
-		PrevRandao:    prevRandao,
-		BlockNumber:   1,
-		GasLimit:      1,
-		GasUsed:       1,
-		Timestamp:     1,
-		ExtraData:     extraData,
-		BaseFeePerGas: bfpg.SSZBytes(),
-		BlockHash:     blockHash,
-		Transactions:  txList,
-	}
-	require.DeepEqual(t, expected, p)
-}
-
-func pbEth1Data() *eth.Eth1Data {
-	return &eth.Eth1Data{
-		DepositRoot:  make([]byte, 32),
-		DepositCount: 23,
-		BlockHash:    make([]byte, 32),
-	}
-}
-
-func TestEth1DataMarshal(t *testing.T) {
-	ed := &Eth1Data{
-		Eth1Data: pbEth1Data(),
-	}
-	b, err := json.Marshal(ed)
-	require.NoError(t, err)
-	expected := `{"deposit_root":"0x0000000000000000000000000000000000000000000000000000000000000000","deposit_count":"23","block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`
-	require.Equal(t, expected, string(b))
-}
-
-func pbSyncAggregate() *eth.SyncAggregate {
-	return &eth.SyncAggregate{
-		SyncCommitteeSignature: make([]byte, 48),
-		SyncCommitteeBits:      bitfield.Bitvector512{0x01},
-	}
-}
-
-func TestSyncAggregate_MarshalJSON(t *testing.T) {
-	sa := &SyncAggregate{pbSyncAggregate()}
-	b, err := json.Marshal(sa)
-	require.NoError(t, err)
-	expected := `{"sync_committee_bits":"0x01","sync_committee_signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}`
-	require.Equal(t, expected, string(b))
-}
-
-func pbDeposit(t *testing.T) *eth.Deposit {
-	return &eth.Deposit{
-		Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
-		Data: &eth.Deposit_Data{
-			PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
-			WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			Amount:                1,
-			Signature:             ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-		},
-	}
-}
-
-func TestDeposit_MarshalJSON(t *testing.T) {
-	d := &Deposit{
-		Deposit: pbDeposit(t),
-	}
-	b, err := json.Marshal(d)
-	require.NoError(t, err)
-	expected := `{"proof":["0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"],"data":{"pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a","withdrawal_credentials":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","amount":"1","signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
-	require.Equal(t, expected, string(b))
-}
-
-func pbSignedVoluntaryExit(t *testing.T) *eth.SignedVoluntaryExit {
-	return &eth.SignedVoluntaryExit{
-		Exit: &eth.VoluntaryExit{
-			Epoch:          1,
-			ValidatorIndex: 1,
-		},
-		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-	}
-}
-
-func TestVoluntaryExit(t *testing.T) {
-	ve := &SignedVoluntaryExit{
-		SignedVoluntaryExit: pbSignedVoluntaryExit(t),
-	}
-	b, err := json.Marshal(ve)
-	require.NoError(t, err)
-	expected := `{"message":{"epoch":"1","validator_index":"1"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}`
-	require.Equal(t, expected, string(b))
-}
-
-func pbAttestation(t *testing.T) *eth.Attestation {
-	return &eth.Attestation{
-		AggregationBits: bitfield.Bitlist{0x01},
-		Data: &eth.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  1,
-			BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			Source: &eth.Checkpoint{
-				Epoch: 1,
-				Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			},
-			Target: &eth.Checkpoint{
-				Epoch: 1,
-				Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			},
-		},
-		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-	}
-}
-
-func TestAttestationMarshal(t *testing.T) {
-	a := &Attestation{
-		Attestation: pbAttestation(t),
-	}
-	b, err := json.Marshal(a)
-	require.NoError(t, err)
-	expected := `{"aggregation_bits":"0x01","data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}`
-	require.Equal(t, expected, string(b))
-}
-
-func pbAttesterSlashing(t *testing.T) *eth.AttesterSlashing {
-	return &eth.AttesterSlashing{
-		Attestation_1: &eth.IndexedAttestation{
-			AttestingIndices: []uint64{1},
-			Signature:        ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-			Data: &eth.AttestationData{
-				Slot:            1,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				Source: &eth.Checkpoint{
-					Epoch: 1,
-					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				},
-				Target: &eth.Checkpoint{
-					Epoch: 1,
-					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				},
-			},
-		},
-		Attestation_2: &eth.IndexedAttestation{
-			AttestingIndices: []uint64{1},
-			Signature:        ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-			Data: &eth.AttestationData{
-				Slot:            1,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				Source: &eth.Checkpoint{
-					Epoch: 1,
-					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				},
-				Target: &eth.Checkpoint{
-					Epoch: 1,
-					Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				},
-			},
-		},
-	}
-}
-
-func TestAttesterSlashing_MarshalJSON(t *testing.T) {
-	as := &AttesterSlashing{
-		AttesterSlashing: pbAttesterSlashing(t),
-	}
-	b, err := json.Marshal(as)
-	require.NoError(t, err)
-	expected := `{"attestation_1":{"attesting_indices":["1"],"data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"},"attestation_2":{"attesting_indices":["1"],"data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
-	require.Equal(t, expected, string(b))
-}
-
-func pbProposerSlashing(t *testing.T) *eth.ProposerSlashing {
-	return &eth.ProposerSlashing{
-		Header_1: &eth.SignedBeaconBlockHeader{
-			Header: &eth.BeaconBlockHeader{
-				Slot:          1,
-				ProposerIndex: 1,
-				ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			},
-			Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-		},
-		Header_2: &eth.SignedBeaconBlockHeader{
-			Header: &eth.BeaconBlockHeader{
-				Slot:          1,
-				ProposerIndex: 1,
-				ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			},
-			Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-		},
-	}
-}
-
-func TestProposerSlashings(t *testing.T) {
-	ps := &ProposerSlashing{ProposerSlashing: pbProposerSlashing(t)}
-	b, err := json.Marshal(ps)
-	require.NoError(t, err)
-	expected := `{"signed_header_1":{"message":{"slot":"1","proposer_index":"1","parent_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","body_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"},"signed_header_2":{"message":{"slot":"1","proposer_index":"1","parent_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","body_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
-	require.Equal(t, expected, string(b))
-}
-
-func pbExecutionPayloadHeader(t *testing.T) *v1.ExecutionPayloadHeader {
-	bfpg := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
-	return &v1.ExecutionPayloadHeader{
-		ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		FeeRecipient:     ezDecode(t, "0xabcf8e0d4e9587369b2301d0790347320302cc09"),
-		StateRoot:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		ReceiptsRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		LogsBloom:        ezDecode(t, "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
-		PrevRandao:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		BlockNumber:      1,
-		GasLimit:         1,
-		GasUsed:          1,
-		Timestamp:        1,
-		ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		BaseFeePerGas:    bfpg.SSZBytes(),
-		BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-	}
-}
-
-func TestExecutionPayloadHeader_MarshalJSON(t *testing.T) {
-	h := &ExecutionPayloadHeader{
-		ExecutionPayloadHeader: pbExecutionPayloadHeader(t),
-	}
-	b, err := json.Marshal(h)
-	require.NoError(t, err)
-	expected := `{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"452312848583266388373324160190187140051835877600158453279131187530910662656","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}`
-	require.Equal(t, expected, string(b))
-}
-
-var testBuilderBid = `{
-    "version":"bellatrix",
-	"data":{
-		"message":{
-			"header":{
-				"parent_hash":"0xa0513a503d5bd6e89a144c3268e5b7e9da9dbf63df125a360e3950a7d0d67131",
-				"fee_recipient":"0xdfb434922631787e43725c6b926e989875125751",
-				"state_root":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45",
-				"receipts_root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-				"logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-				"prev_randao":"0xc2fa210081542a87f334b7b14a2da3275e4b281dd77b007bcfcb10e34c42052e",
-				"block_number":"1",
-				"gas_limit":"10000000",
-				"gas_used":"0",
-				"timestamp":"4660",
-				"extra_data":"0x",
-				"base_fee_per_gas":"7",
-				"block_hash":"0x10746fa06c248e7eacd4ff8ad8b48a826c227387ee31a6aa5eb4d83ddad34f07",
-				"transactions_root":"0x7ffe241ea60187fdb0187bfa22de35d1f9bed7ab061d9401fd47e34a54fbede1"
-			},
-			"value":"452312848583266388373324160190187140051835877600158453279131187530910662656",
-			"pubkey":"0x8645866c95cbc2e08bc77ccad473540eddf4a1f51a2a8edc8d7a673824218f7f68fe565f1ab38dadd5c855b45bbcec95"
-		},
-		"signature":"0x9183ebc1edf9c3ab2bbd7abdc3b59c6b249d6647b5289a97eea36d9d61c47f12e283f64d928b1e7f5b8a5182b714fa921954678ea28ca574f5f232b2f78cf8900915a2993b396e3471e0655291fec143a300d41408f66478c8208e0f9be851dc"
-	}
-}`
-
-func TestBuilderBidUnmarshalUint256(t *testing.T) {
-	base10 := "452312848583266388373324160190187140051835877600158453279131187530910662656"
-	var expectedValue big.Int
-	require.NoError(t, expectedValue.UnmarshalText([]byte(base10)))
-	r := &ExecHeaderResponse{}
-	require.NoError(t, json.Unmarshal([]byte(testBuilderBid), r))
-	//require.Equal(t, expectedValue, r.Data.Message.Value)
-	marshaled := r.Data.Message.Value.String()
-	require.Equal(t, base10, marshaled)
-	require.Equal(t, 0, expectedValue.Cmp(r.Data.Message.Value.Int))
-}
-
-func TestMathBigUnmarshal(t *testing.T) {
-	base10 := "452312848583266388373324160190187140051835877600158453279131187530910662656"
-	var expectedValue big.Int
-	require.NoError(t, expectedValue.UnmarshalText([]byte(base10)))
-	marshaled, err := expectedValue.MarshalText()
-	require.NoError(t, err)
-	require.Equal(t, base10, string(marshaled))
-
-	var u256 Uint256
-	require.NoError(t, u256.UnmarshalText([]byte("452312848583266388373324160190187140051835877600158453279131187530910662656")))
-}
-
-func TestUint256Unmarshal(t *testing.T) {
-	base10 := "452312848583266388373324160190187140051835877600158453279131187530910662656"
-	bi := new(big.Int)
-	bi, ok := bi.SetString(base10, 10)
-	require.Equal(t, true, ok)
-	s := struct {
-		BigNumber Uint256 `json:"big_number"`
-	}{
-		BigNumber: Uint256{Int: bi},
-	}
-	m, err := json.Marshal(s)
-	require.NoError(t, err)
-	expected := `{"big_number":"452312848583266388373324160190187140051835877600158453279131187530910662656"}`
-	require.Equal(t, expected, string(m))
-}
-
-func TestMarshalBlindedBeaconBlockBodyBellatrix(t *testing.T) {
-	expected, err := os.ReadFile("testdata/blinded-block.json")
-	require.NoError(t, err)
-	b := &BlindedBeaconBlockBellatrix{BlindedBeaconBlockBellatrix: &eth.BlindedBeaconBlockBellatrix{
-		Slot:          1,
-		ProposerIndex: 1,
-		ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-		Body: &eth.BlindedBeaconBlockBodyBellatrix{
-			RandaoReveal:           ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-			Eth1Data:               pbEth1Data(),
-			Graffiti:               ezDecode(t, "0xdeadbeefc0ffee"),
-			ProposerSlashings:      []*eth.ProposerSlashing{pbProposerSlashing(t)},
-			AttesterSlashings:      []*eth.AttesterSlashing{pbAttesterSlashing(t)},
-			Attestations:           []*eth.Attestation{pbAttestation(t)},
-			Deposits:               []*eth.Deposit{pbDeposit(t)},
-			VoluntaryExits:         []*eth.SignedVoluntaryExit{pbSignedVoluntaryExit(t)},
-			SyncAggregate:          pbSyncAggregate(),
-			ExecutionPayloadHeader: pbExecutionPayloadHeader(t),
-		},
-	}}
-	m, err := json.Marshal(b)
-	require.NoError(t, err)
-	// string error output is easier to deal with
-	// -1 end slice index on expected is to get rid of trailing newline
-	// if you update this fixture and this test breaks, you probably removed the trailing newline
-	require.Equal(t, string(expected[0:len(expected)-1]), string(m))
-}
-
-func TestRoundTripUint256(t *testing.T) {
-	vs := "4523128485832663883733241601901871400518358776001584532791311875309106626"
-	u := stringToUint256(vs)
-	sb := u.SSZBytes()
-	require.Equal(t, 32, len(sb))
-	uu := sszBytesToUint256(sb)
-	require.Equal(t, true, bytes.Equal(u.SSZBytes(), uu.SSZBytes()))
-	require.Equal(t, vs, uu.String())
-}
-
-func TestRoundTripProtoUint256(t *testing.T) {
-	h := pbExecutionPayloadHeader(t)
-	h.BaseFeePerGas = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
-	hm := &ExecutionPayloadHeader{ExecutionPayloadHeader: h}
-	m, err := json.Marshal(hm)
-	require.NoError(t, err)
-	hu := &ExecutionPayloadHeader{}
-	require.NoError(t, json.Unmarshal(m, hu))
-	hp, err := hu.ToProto()
-	require.NoError(t, err)
-	require.DeepEqual(t, h.BaseFeePerGas, hp.BaseFeePerGas)
-}
-
-func TestExecutionPayloadHeaderRoundtrip(t *testing.T) {
-	expected, err := os.ReadFile("testdata/execution-payload.json")
-	require.NoError(t, err)
-	hu := &ExecutionPayloadHeader{}
-	require.NoError(t, json.Unmarshal(expected, hu))
-	m, err := json.Marshal(hu)
-	require.NoError(t, err)
-	require.DeepEqual(t, string(expected[0:len(expected)-1]), string(m))
-}

api/gateway/BUILD.bazel

@@ -5,8 +5,6 @@ go_library(
     srcs = [
         "gateway.go",
         "log.go",
-        "modifiers.go",
-        "options.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/api/gateway",
     visibility = [
@@ -24,7 +22,6 @@ go_library(
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//connectivity:go_default_library",
         "@org_golang_google_grpc//credentials:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
 

api/gateway/apimiddleware/BUILD.bazel

@@ -15,7 +15,6 @@ go_library(
     deps = [
         "//api/grpc:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common: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",

api/gateway/apimiddleware/api_middleware.go

@@ -3,7 +3,6 @@ package apimiddleware
 import (
 	"net/http"
 	"reflect"
-	"time"
 
 	"github.com/gorilla/mux"
 )
@@ -15,8 +14,6 @@ import (
 type ApiProxyMiddleware struct {
 	GatewayAddress  string
 	EndpointCreator EndpointFactory
-	Timeout         time.Duration
-	router          *mux.Router
 }
 
 // EndpointFactory is responsible for creating new instances of Endpoint values.
@@ -32,8 +29,6 @@ type Endpoint struct {
 	GetResponse        interface{}     // The struct corresponding to the JSON structure used in a GET response.
 	PostRequest        interface{}     // The struct corresponding to the JSON structure used in a POST request.
 	PostResponse       interface{}     // The struct corresponding to the JSON structure used in a POST response.
-	DeleteRequest      interface{}     // The struct corresponding to the JSON structure used in a DELETE request.
-	DeleteResponse     interface{}     // The struct corresponding to the JSON structure used in a DELETE response.
 	RequestURLLiterals []string        // Names of URL parameters that should not be base64-encoded.
 	RequestQueryParams []QueryParam    // Query parameters of the request.
 	Err                ErrorJson       // The struct corresponding to the error that should be returned in case of a request failure.
@@ -79,23 +74,16 @@ type fieldProcessor struct {
 // Run starts the proxy, registering all proxy endpoints.
 func (m *ApiProxyMiddleware) Run(gatewayRouter *mux.Router) {
 	for _, path := range m.EndpointCreator.Paths() {
-		gatewayRouter.HandleFunc(path, m.WithMiddleware(path))
+		m.handleApiPath(gatewayRouter, path, m.EndpointCreator)
 	}
-	m.router = gatewayRouter
 }
 
-// ServeHTTP for the proxy middleware.
-func (m *ApiProxyMiddleware) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	m.router.ServeHTTP(w, req)
-}
-
-// WithMiddleware wraps the given endpoint handler with the middleware logic.
-func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		endpoint, err := m.EndpointCreator.Create(path)
+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 {
-			log.WithError(err).Errorf("Could not create endpoint for path: %s", path)
-			return
+			errJson := InternalServerErrorWithMessage(err, "could not create endpoint")
+			WriteError(w, errJson, nil)
 		}
 
 		for _, handler := range endpoint.CustomHandlers {
@@ -105,14 +93,16 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 		}
 
 		if req.Method == "POST" {
-			if errJson := handlePostRequestForEndpoint(endpoint, w, req); errJson != nil {
+			if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
 				WriteError(w, errJson, nil)
 				return
 			}
-		}
 
-		if req.Method == "DELETE" && req.Body != http.NoBody {
-			if errJson := handleDeleteRequestForEndpoint(endpoint, req); errJson != nil {
+			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
 			}
@@ -122,7 +112,7 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 			WriteError(w, errJson, nil)
 			return
 		}
-		grpcResp, errJson := m.ProxyRequest(req)
+		grpcResp, errJson := ProxyRequest(req)
 		if errJson != nil {
 			WriteError(w, errJson, nil)
 			return
@@ -147,8 +137,6 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 			var resp interface{}
 			if req.Method == "GET" {
 				resp = endpoint.GetResponse
-			} else if req.Method == "DELETE" {
-				resp = endpoint.DeleteResponse
 			} else {
 				resp = endpoint.PostResponse
 			}
@@ -176,27 +164,7 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 			WriteError(w, errJson, nil)
 			return
 		}
-	}
-}
-
-func handlePostRequestForEndpoint(endpoint *Endpoint, w http.ResponseWriter, req *http.Request) ErrorJson {
-	if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
-		return errJson
-	}
-	if errJson := ProcessRequestContainerFields(endpoint.PostRequest); errJson != nil {
-		return errJson
-	}
-	return SetRequestBodyToRequestContainer(endpoint.PostRequest, req)
-}
-
-func handleDeleteRequestForEndpoint(endpoint *Endpoint, req *http.Request) ErrorJson {
-	if errJson := DeserializeRequestBodyIntoContainer(req.Body, endpoint.DeleteRequest); errJson != nil {
-		return errJson
-	}
-	if errJson := ProcessRequestContainerFields(endpoint.DeleteRequest); errJson != nil {
-		return errJson
-	}
-	return SetRequestBodyToRequestContainer(endpoint.DeleteRequest, req)
+	})
 }
 
 func deserializeRequestBodyIntoContainerWrapped(endpoint *Endpoint, req *http.Request, w http.ResponseWriter) ErrorJson {

api/gateway/apimiddleware/process_field.go

@@ -3,13 +3,11 @@ package apimiddleware
 import (
 	"encoding/base64"
 	"fmt"
-	"math/big"
 	"reflect"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/go-bytesutil"
@@ -32,26 +30,26 @@ func processField(s interface{}, processors []fieldProcessor) error {
 			sliceElem := t.Field(i).Type.Elem()
 			kind := sliceElem.Kind()
 			// Recursively process slices to struct pointers.
-			switch {
-			case kind == reflect.Ptr && sliceElem.Elem().Kind() == reflect.Struct:
+			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.
-			case kind == reflect.String:
+			if kind == reflect.String {
 				for _, proc := range processors {
 					_, hasTag := t.Field(i).Tag.Lookup(proc.tag)
-					if !hasTag {
-						continue
-					}
-					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)
+					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:
@@ -75,10 +73,6 @@ func processField(s interface{}, processors []fieldProcessor) error {
 }
 
 func hexToBase64Processor(v reflect.Value) error {
-	if v.String() == "0x" {
-		v.SetString("")
-		return nil
-	}
 	b, err := bytesutil.FromHexString(v.String())
 	if err != nil {
 		return err
@@ -89,8 +83,6 @@ func hexToBase64Processor(v reflect.Value) error {
 
 func base64ToHexProcessor(v reflect.Value) error {
 	if v.String() == "" {
-		// Empty hex values are represented as "0x".
-		v.SetString("0x")
 		return nil
 	}
 	b, err := base64.StdEncoding.DecodeString(v.String())
@@ -101,69 +93,6 @@ func base64ToHexProcessor(v reflect.Value) error {
 	return nil
 }
 
-func base64ToChecksumAddressProcessor(v reflect.Value) error {
-	if v.String() == "" {
-		// Empty hex values are represented as "0x".
-		v.SetString("0x")
-		return nil
-	}
-	b, err := base64.StdEncoding.DecodeString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(common.BytesToAddress(b).Hex())
-	return nil
-}
-
-func base64ToUint256Processor(v reflect.Value) error {
-	if v.String() == "" {
-		return nil
-	}
-	littleEndian, err := base64.StdEncoding.DecodeString(v.String())
-	if err != nil {
-		return err
-	}
-	if len(littleEndian) != 32 {
-		return errors.New("invalid length for Uint256")
-	}
-
-	// Integers are stored as little-endian, but
-	// big.Int expects big-endian. So we need to reverse
-	// the byte order before decoding.
-	var bigEndian [32]byte
-	for i := 0; i < len(littleEndian); i++ {
-		bigEndian[i] = littleEndian[len(littleEndian)-1-i]
-	}
-	var uint256 big.Int
-	uint256.SetBytes(bigEndian[:])
-	v.SetString(uint256.String())
-	return nil
-}
-
-func uint256ToBase64Processor(v reflect.Value) error {
-	if v.String() == "" {
-		return nil
-	}
-	uint256, ok := new(big.Int).SetString(v.String(), 10)
-	if !ok {
-		return fmt.Errorf("could not parse Uint256")
-	}
-	bigEndian := uint256.Bytes()
-	if len(bigEndian) > 32 {
-		return fmt.Errorf("number too big for Uint256")
-	}
-
-	// Integers are stored as little-endian, but
-	// big.Int gives big-endian. So we need to reverse
-	// the byte order before encoding.
-	var littleEndian [32]byte
-	for i := 0; i < len(bigEndian); i++ {
-		littleEndian[i] = bigEndian[len(bigEndian)-1-i]
-	}
-	v.SetString(base64.StdEncoding.EncodeToString(littleEndian[:]))
-	return nil
-}
-
 func enumToLowercaseProcessor(v reflect.Value) error {
 	v.SetString(strings.ToLower(v.String()))
 	return nil

api/gateway/apimiddleware/process_request.go

@@ -4,10 +4,11 @@ import (
 	"bytes"
 	"encoding/json"
 	"io"
-	"net"
+	"io/ioutil"
 	"net/http"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/api/grpc"
@@ -37,10 +38,6 @@ func ProcessRequestContainerFields(requestContainer interface{}) ErrorJson {
 			tag: "hex",
 			f:   hexToBase64Processor,
 		},
-		{
-			tag: "uint256",
-			f:   uint256ToBase64Processor,
-		},
 	}); err != nil {
 		return InternalServerErrorWithMessage(err, "could not process request data")
 	}
@@ -55,7 +52,7 @@ func SetRequestBodyToRequestContainer(requestContainer interface{}, req *http.Re
 		return InternalServerErrorWithMessage(err, "could not marshal request")
 	}
 	// Set the body to the new JSON.
-	req.Body = io.NopCloser(bytes.NewReader(j))
+	req.Body = ioutil.NopCloser(bytes.NewReader(j))
 	req.Header.Set("Content-Length", strconv.Itoa(len(j)))
 	req.ContentLength = int64(len(j))
 	return nil
@@ -78,14 +75,11 @@ func (m *ApiProxyMiddleware) PrepareRequestForProxying(endpoint Endpoint, req *h
 }
 
 // ProxyRequest proxies the request to grpc-gateway.
-func (m *ApiProxyMiddleware) ProxyRequest(req *http.Request) (*http.Response, ErrorJson) {
+func ProxyRequest(req *http.Request) (*http.Response, ErrorJson) {
 	// We do not use http.DefaultClient because it does not have any timeout.
-	netClient := &http.Client{Timeout: m.Timeout}
+	netClient := &http.Client{Timeout: time.Minute * 2}
 	grpcResp, err := netClient.Do(req)
 	if err != nil {
-		if err, ok := err.(net.Error); ok && err.Timeout() {
-			return nil, TimeoutError()
-		}
 		return nil, InternalServerErrorWithMessage(err, "could not proxy request")
 	}
 	if grpcResp == nil {
@@ -96,7 +90,7 @@ func (m *ApiProxyMiddleware) ProxyRequest(req *http.Request) (*http.Response, Er
 
 // ReadGrpcResponseBody reads the body from the grpc-gateway's response.
 func ReadGrpcResponseBody(r io.Reader) ([]byte, ErrorJson) {
-	body, err := io.ReadAll(r)
+	body, err := ioutil.ReadAll(r)
 	if err != nil {
 		return nil, InternalServerErrorWithMessage(err, "could not read response body")
 	}
@@ -104,8 +98,6 @@ func ReadGrpcResponseBody(r io.Reader) ([]byte, ErrorJson) {
 }
 
 // HandleGrpcResponseError acts on an error that resulted from a grpc-gateway's response.
-// Whether there was an error is indicated by the bool return value. In case of an error,
-// there is no need to write to the response because it's taken care of by the function.
 func HandleGrpcResponseError(errJson ErrorJson, resp *http.Response, respBody []byte, w http.ResponseWriter) (bool, ErrorJson) {
 	responseHasError := false
 	if err := json.Unmarshal(respBody, errJson); err != nil {
@@ -119,14 +111,9 @@ func HandleGrpcResponseError(errJson ErrorJson, resp *http.Response, respBody []
 				w.Header().Set(h, v)
 			}
 		}
-		// Handle gRPC timeout.
-		if resp.StatusCode == http.StatusGatewayTimeout {
-			WriteError(w, TimeoutError(), resp.Header)
-		} else {
-			// Set code to HTTP code because unmarshalled body contained gRPC code.
-			errJson.SetCode(resp.StatusCode)
-			WriteError(w, errJson, resp.Header)
-		}
+		// Set code to HTTP code because unmarshalled body contained gRPC code.
+		errJson.SetCode(resp.StatusCode)
+		WriteError(w, errJson, resp.Header)
 	}
 	return responseHasError, nil
 }
@@ -151,10 +138,6 @@ func ProcessMiddlewareResponseFields(responseContainer interface{}) ErrorJson {
 			tag: "hex",
 			f:   base64ToHexProcessor,
 		},
-		{
-			tag: "address",
-			f:   base64ToChecksumAddressProcessor,
-		},
 		{
 			tag: "enum",
 			f:   enumToLowercaseProcessor,
@@ -163,10 +146,6 @@ func ProcessMiddlewareResponseFields(responseContainer interface{}) ErrorJson {
 			tag: "time",
 			f:   timeToUnixProcessor,
 		},
-		{
-			tag: "uint256",
-			f:   base64ToUint256Processor,
-		},
 	}); err != nil {
 		return InternalServerErrorWithMessage(err, "could not process response data")
 	}
@@ -208,7 +187,7 @@ func WriteMiddlewareResponseHeadersAndBody(grpcResp *http.Response, responseJson
 		} else {
 			w.WriteHeader(grpcResp.StatusCode)
 		}
-		if _, err := io.Copy(w, io.NopCloser(bytes.NewReader(responseJson))); err != nil {
+		if _, err := io.Copy(w, ioutil.NopCloser(bytes.NewReader(responseJson))); err != nil {
 			return InternalServerErrorWithMessage(err, "could not write response message")
 		}
 	} else {
@@ -262,7 +241,7 @@ func WriteError(w http.ResponseWriter, errJson ErrorJson, responseHeader http.He
 	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, io.NopCloser(bytes.NewReader(j))); err != nil {
+	if _, err := io.Copy(w, ioutil.NopCloser(bytes.NewReader(j))); err != nil {
 		log.WithError(err).Error("Could not write error message")
 	}
 }

api/gateway/apimiddleware/process_request_test.go

@@ -15,44 +15,30 @@ import (
 )
 
 type testRequestContainer struct {
-	TestString         string
-	TestHexString      string `hex:"true"`
-	TestEmptyHexString string `hex:"true"`
-	TestUint256String  string `uint256:"true"`
+	TestString    string
+	TestHexString string `hex:"true"`
 }
 
 func defaultRequestContainer() *testRequestContainer {
 	return &testRequestContainer{
-		TestString:         "test string",
-		TestHexString:      "0x666F6F", // hex encoding of "foo"
-		TestEmptyHexString: "0x",
-		TestUint256String:  "4196",
+		TestString:    "test string",
+		TestHexString: "0x666F6F", // hex encoding of "foo"
 	}
 }
 
 type testResponseContainer struct {
-	TestString       string
-	TestHex          string `hex:"true"`
-	TestEmptyHex     string `hex:"true"`
-	TestAddress      string `address:"true"`
-	TestEmptyAddress string `address:"true"`
-	TestUint256      string `uint256:"true"`
-	TestEnum         string `enum:"true"`
-	TestTime         string `time:"true"`
+	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"
-		TestEmptyHex:     "",
-		TestAddress:      "Zm9v",
-		TestEmptyAddress: "",
-		TestEnum:         "Test Enum",
-		TestTime:         "2006-01-02T15:04:05Z",
-
-		// base64 encoding of 4196 in little-endian
-		TestUint256: "ZBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
+		TestString: "test string",
+		TestHex:    "Zm9v", // base64 encoding of "foo"
+		TestEnum:   "Test Enum",
+		TestTime:   "2006-01-02T15:04:05Z",
 	}
 }
 
@@ -120,8 +106,6 @@ func TestProcessRequestContainerFields(t *testing.T) {
 		errJson := ProcessRequestContainerFields(container)
 		require.Equal(t, true, errJson == nil)
 		assert.Equal(t, "Zm9v", container.TestHexString)
-		assert.Equal(t, "", container.TestEmptyHexString)
-		assert.Equal(t, "ZBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", container.TestUint256String)
 	})
 
 	t.Run("error", func(t *testing.T) {
@@ -144,8 +128,8 @@ func TestSetRequestBodyToRequestContainer(t *testing.T) {
 	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, "108", contentLengthHeader[0])
-	assert.Equal(t, int64(108), request.ContentLength)
+	assert.Equal(t, "55", contentLengthHeader[0])
+	assert.Equal(t, int64(55), request.ContentLength)
 }
 
 func TestPrepareRequestForProxying(t *testing.T) {
@@ -250,10 +234,6 @@ func TestProcessMiddlewareResponseFields(t *testing.T) {
 		errJson := ProcessMiddlewareResponseFields(container)
 		require.Equal(t, true, errJson == nil)
 		assert.Equal(t, "0x666f6f", container.TestHex)
-		assert.Equal(t, "0x", container.TestEmptyHex)
-		assert.Equal(t, "0x0000000000000000000000000000000000666F6f", container.TestAddress)
-		assert.Equal(t, "0x", container.TestEmptyAddress)
-		assert.Equal(t, "4196", container.TestUint256)
 		assert.Equal(t, "test enum", container.TestEnum)
 		assert.Equal(t, "1136214245", container.TestTime)
 	})
@@ -298,7 +278,7 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		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, "224", v[0])
+		assert.Equal(t, "102", v[0])
 		assert.Equal(t, 204, writer.Code)
 		assert.DeepEqual(t, responseJson, writer.Body.Bytes())
 	})

api/gateway/apimiddleware/structs.go

@@ -41,13 +41,6 @@ func InternalServerError(err error) *DefaultErrorJson {
 	}
 }
 
-func TimeoutError() *DefaultErrorJson {
-	return &DefaultErrorJson{
-		Message: "Request timeout",
-		Code:    http.StatusRequestTimeout,
-	}
-}
-
 // StatusCode returns the error's underlying error code.
 func (e *DefaultErrorJson) StatusCode() int {
 	return e.Code

api/gateway/gateway.go

@@ -34,52 +34,74 @@ type PbMux struct {
 type PbHandlerRegistration func(context.Context, *gwruntime.ServeMux, *grpc.ClientConn) error
 
 // MuxHandler is a function that implements the mux handler functionality.
-type MuxHandler func(
-	apiMiddlewareHandler *apimiddleware.ApiProxyMiddleware,
-	h http.HandlerFunc,
-	w http.ResponseWriter,
-	req *http.Request,
-)
-
-// Config parameters for setting up the gateway service.
-type config struct {
-	maxCallRecvMsgSize           uint64
-	remoteCert                   string
-	gatewayAddr                  string
-	remoteAddr                   string
-	allowedOrigins               []string
-	apiMiddlewareEndpointFactory apimiddleware.EndpointFactory
-	muxHandler                   MuxHandler
-	pbHandlers                   []*PbMux
-	router                       *mux.Router
-	timeout                      time.Duration
-}
+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 {
-	cfg          *config
-	conn         *grpc.ClientConn
-	server       *http.Server
-	cancel       context.CancelFunc
-	proxy        *apimiddleware.ApiProxyMiddleware
-	ctx          context.Context
-	startFailure error
+	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, opts ...Option) (*Gateway, error) {
+func New(
+	ctx context.Context,
+	pbHandlers []*PbMux,
+	muxHandler MuxHandler,
+	remoteAddr,
+	gatewayAddress string,
+) *Gateway {
 	g := &Gateway{
-		ctx: ctx,
-		cfg: &config{
-			router: mux.NewRouter(),
-		},
+		pbHandlers:     pbHandlers,
+		muxHandler:     muxHandler,
+		router:         mux.NewRouter(),
+		gatewayAddr:    gatewayAddress,
+		ctx:            ctx,
+		remoteAddr:     remoteAddr,
+		allowedOrigins: []string{},
 	}
-	for _, opt := range opts {
-		if err := opt(g); err != nil {
-			return nil, err
-		}
-	}
-	return g, nil
+	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.
@@ -87,7 +109,7 @@ func (g *Gateway) Start() {
 	ctx, cancel := context.WithCancel(g.ctx)
 	g.cancel = cancel
 
-	conn, err := g.dial(ctx, "tcp", g.cfg.remoteAddr)
+	conn, err := g.dial(ctx, "tcp", g.remoteAddr)
 	if err != nil {
 		log.WithError(err).Error("Failed to connect to gRPC server")
 		g.startFailure = err
@@ -95,7 +117,7 @@ func (g *Gateway) Start() {
 	}
 	g.conn = conn
 
-	for _, h := range g.cfg.pbHandlers {
+	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")
@@ -104,30 +126,29 @@ func (g *Gateway) Start() {
 			}
 		}
 		for _, p := range h.Patterns {
-			g.cfg.router.PathPrefix(p).Handler(h.Mux)
+			g.router.PathPrefix(p).Handler(h.Mux)
 		}
 	}
 
-	corsMux := g.corsMiddleware(g.cfg.router)
+	corsMux := g.corsMiddleware(g.router)
 
-	if g.cfg.apiMiddlewareEndpointFactory != nil && !g.cfg.apiMiddlewareEndpointFactory.IsNil() {
-		g.registerApiMiddleware()
-	}
-
-	if g.cfg.muxHandler != nil {
-		g.cfg.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			g.cfg.muxHandler(g.proxy, corsMux.ServeHTTP, w, r)
+	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.cfg.gatewayAddr,
-		Handler:           corsMux,
-		ReadHeaderTimeout: time.Second,
+		Addr:    g.gatewayAddr,
+		Handler: g.router,
 	}
 
 	go func() {
-		log.WithField("address", g.cfg.gatewayAddr).Info("Starting gRPC gateway")
+		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
@@ -141,9 +162,11 @@ 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
 }
 
@@ -160,16 +183,18 @@ func (g *Gateway) Stop() error {
 			}
 		}
 	}
+
 	if g.cancel != nil {
 		g.cancel()
 	}
+
 	return nil
 }
 
 func (g *Gateway) corsMiddleware(h http.Handler) http.Handler {
 	c := cors.New(cors.Options{
-		AllowedOrigins:   g.cfg.allowedOrigins,
-		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
+		AllowedOrigins:   g.allowedOrigins,
+		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodOptions},
 		AllowCredentials: true,
 		MaxAge:           600,
 		AllowedHeaders:   []string{"*"},
@@ -211,8 +236,8 @@ func (g *Gateway) dial(ctx context.Context, network, addr string) (*grpc.ClientC
 // "addr" must be a valid TCP address with a port number.
 func (g *Gateway) dialTCP(ctx context.Context, addr string) (*grpc.ClientConn, error) {
 	security := grpc.WithInsecure()
-	if len(g.cfg.remoteCert) > 0 {
-		creds, err := credentials.NewClientTLSFromFile(g.cfg.remoteCert, "")
+	if len(g.remoteCert) > 0 {
+		creds, err := credentials.NewClientTLSFromFile(g.remoteCert, "")
 		if err != nil {
 			return nil, err
 		}
@@ -220,7 +245,7 @@ func (g *Gateway) dialTCP(ctx context.Context, addr string) (*grpc.ClientConn, e
 	}
 	opts := []grpc.DialOption{
 		security,
-		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
+		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.maxCallRecvMsgSize))),
 	}
 
 	return grpc.DialContext(ctx, addr, opts...)
@@ -241,17 +266,16 @@ func (g *Gateway) dialUnix(ctx context.Context, addr string) (*grpc.ClientConn,
 	opts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithContextDialer(f),
-		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
+		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.maxCallRecvMsgSize))),
 	}
 	return grpc.DialContext(ctx, addr, opts...)
 }
 
 func (g *Gateway) registerApiMiddleware() {
-	g.proxy = &apimiddleware.ApiProxyMiddleware{
-		GatewayAddress:  g.cfg.gatewayAddr,
-		EndpointCreator: g.cfg.apiMiddlewareEndpointFactory,
-		Timeout:         g.cfg.timeout,
+	proxy := &apimiddleware.ApiProxyMiddleware{
+		GatewayAddress:  g.gatewayAddr,
+		EndpointCreator: g.apiMiddlewareEndpointFactory,
 	}
 	log.Info("Starting API middleware")
-	g.proxy.Run(g.cfg.router)
+	proxy.Run(g.router)
 }

api/gateway/gateway_test.go

@@ -40,30 +40,26 @@ func TestGateway_Customized(t *testing.T) {
 	size := uint64(100)
 	endpointFactory := &mockEndpointFactory{}
 
-	opts := []Option{
-		WithRouter(r),
-		WithRemoteCert(cert),
-		WithAllowedOrigins(origins),
-		WithMaxCallRecvMsgSize(size),
-		WithApiMiddleware(endpointFactory),
-		WithMuxHandler(func(
-			_ *apimiddleware.ApiProxyMiddleware,
-			_ http.HandlerFunc,
-			_ http.ResponseWriter,
-			_ *http.Request,
-		) {
-		}),
-	}
+	g := New(
+		context.Background(),
+		[]*PbMux{},
+		func(handler http.Handler, writer http.ResponseWriter, request *http.Request) {
 
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
+		},
+		"",
+		"",
+	).WithRouter(r).
+		WithRemoteCert(cert).
+		WithAllowedOrigins(origins).
+		WithMaxCallRecvMsgSize(size).
+		WithApiMiddleware(endpointFactory)
 
-	assert.Equal(t, r, g.cfg.router)
-	assert.Equal(t, cert, g.cfg.remoteCert)
-	require.Equal(t, 1, len(g.cfg.allowedOrigins))
-	assert.Equal(t, origins[0], g.cfg.allowedOrigins[0])
-	assert.Equal(t, size, g.cfg.maxCallRecvMsgSize)
-	assert.Equal(t, endpointFactory, g.cfg.apiMiddlewareEndpointFactory)
+	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) {
@@ -79,27 +75,23 @@ func TestGateway_StartStop(t *testing.T) {
 	selfAddress := fmt.Sprintf("%s:%d", rpcHost, ctx.Int(flags.RPCPort.Name))
 	gatewayAddress := fmt.Sprintf("%s:%d", gatewayHost, gatewayPort)
 
-	opts := []Option{
-		WithGatewayAddr(gatewayAddress),
-		WithRemoteAddr(selfAddress),
-		WithMuxHandler(func(
-			_ *apimiddleware.ApiProxyMiddleware,
-			_ http.HandlerFunc,
-			_ http.ResponseWriter,
-			_ *http.Request,
-		) {
-		}),
-	}
+	g := New(
+		ctx.Context,
+		[]*PbMux{},
+		func(handler http.Handler, writer http.ResponseWriter, request *http.Request) {
 
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
+		},
+		selfAddress,
+		gatewayAddress,
+	)
 
 	g.Start()
 	go func() {
 		require.LogsContain(t, hook, "Starting gRPC gateway")
 		require.LogsDoNotContain(t, hook, "Starting API middleware")
 	}()
-	err = g.Stop()
+
+	err := g.Stop()
 	require.NoError(t, err)
 }
 
@@ -114,15 +106,15 @@ func TestGateway_NilHandler_NotFoundHandlerRegistered(t *testing.T) {
 	selfAddress := fmt.Sprintf("%s:%d", rpcHost, ctx.Int(flags.RPCPort.Name))
 	gatewayAddress := fmt.Sprintf("%s:%d", gatewayHost, gatewayPort)
 
-	opts := []Option{
-		WithGatewayAddr(gatewayAddress),
-		WithRemoteAddr(selfAddress),
-	}
-
-	g, err := New(context.Background(), opts...)
-	require.NoError(t, err)
+	g := New(
+		ctx.Context,
+		[]*PbMux{},
+		/* muxHandler */ nil,
+		selfAddress,
+		gatewayAddress,
+	)
 
 	writer := httptest.NewRecorder()
-	g.cfg.router.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
+	g.router.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
 	assert.Equal(t, http.StatusNotFound, writer.Code)
 }

api/gateway/modifiers.go

@@ -1,30 +0,0 @@
-package gateway
-
-import (
-	"context"
-	"net/http"
-	"strconv"
-
-	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"google.golang.org/protobuf/proto"
-)
-
-func HttpResponseModifier(ctx context.Context, w http.ResponseWriter, _ proto.Message) error {
-	md, ok := gwruntime.ServerMetadataFromContext(ctx)
-	if !ok {
-		return nil
-	}
-	// set http status code
-	if vals := md.HeaderMD.Get("x-http-code"); len(vals) > 0 {
-		code, err := strconv.Atoi(vals[0])
-		if err != nil {
-			return err
-		}
-		// delete the headers to not expose any grpc-metadata in http response
-		delete(md.HeaderMD, "x-http-code")
-		delete(w.Header(), "Grpc-Metadata-X-Http-Code")
-		w.WriteHeader(code)
-	}
-
-	return nil
-}

api/gateway/options.go

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

async/multilock.go

@@ -49,7 +49,7 @@ func (lk *Lock) Lock() {
 	lk.unlock <- 1
 }
 
-// Unlock unlocks this lock. Must be called after Lock.
+// 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
@@ -65,14 +65,14 @@ func (lk *Lock) Unlock() {
 	<-lk.lock
 }
 
-// Yield temporarily unlocks, gives up the cpu time to other goroutine, and attempts to lock again.
+// 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()
 }
 
-// NewMultilock creates a new multilock for the specified keys
+// Creates a new multilock for the specified keys
 func NewMultilock(locks ...string) *Lock {
 	if len(locks) == 0 {
 		return nil
@@ -87,7 +87,7 @@ func NewMultilock(locks ...string) *Lock {
 	}
 }
 
-// Clean cleans old unused locks. Returns removed keys.
+// Cleans old unused locks. Returns removed keys.
 func Clean() []string {
 	locks.lock <- 1
 	defer func() { <-locks.lock }()

async/multilock_test.go

@@ -22,22 +22,22 @@ import (
 
 func TestUnique(t *testing.T) {
 	var arr []string
-	a := assert.New(t)
+	assert := assert.New(t)
 
 	arr = []string{"a", "b", "c"}
-	a.Equal(arr, unique(arr))
+	assert.Equal(arr, unique(arr))
 
 	arr = []string{"a", "a", "a"}
-	a.Equal([]string{"a"}, unique(arr))
+	assert.Equal([]string{"a"}, unique(arr))
 
 	arr = []string{"a", "a", "b"}
-	a.Equal([]string{"a", "b"}, unique(arr))
+	assert.Equal([]string{"a", "b"}, unique(arr))
 
 	arr = []string{"a", "b", "a"}
-	a.Equal([]string{"a", "b"}, unique(arr))
+	assert.Equal([]string{"a", "b"}, unique(arr))
 
 	arr = []string{"a", "b", "c", "b", "d"}
-	a.Equal([]string{"a", "b", "c", "d"}, unique(arr))
+	assert.Equal([]string{"a", "b", "c", "d"}, unique(arr))
 }
 
 func TestGetChan(t *testing.T) {
@@ -45,9 +45,9 @@ func TestGetChan(t *testing.T) {
 	ch2 := getChan("aa")
 	ch3 := getChan("a")
 
-	a := assert.New(t)
-	a.NotEqual(ch1, ch2)
-	a.Equal(ch1, ch3)
+	assert := assert.New(t)
+	assert.NotEqual(ch1, ch2)
+	assert.Equal(ch1, ch3)
 }
 
 func TestLockUnlock(_ *testing.T) {
@@ -110,8 +110,9 @@ func TestLockUnlock_CleansUnused(t *testing.T) {
 		lock := NewMultilock("dog", "cat", "owl")
 		lock.Lock()
 		assert.Equal(t, 3, len(locks.list))
-		lock.Unlock()
+		defer lock.Unlock()
 
+		<-time.After(100 * time.Millisecond)
 		wg.Done()
 	}()
 	wg.Wait()

beacon-chain/blockchain/BUILD.bazel

@@ -4,16 +4,13 @@ go_library(
     name = "go_default_library",
     srcs = [
         "chain_info.go",
-        "error.go",
-        "execution_engine.go",
         "head.go",
         "head_sync_committee_info.go",
+        "info.go",
         "init_sync_process_block.go",
         "log.go",
-        "merge_ascii_art.go",
         "metrics.go",
         "options.go",
-        "pow_block.go",
         "process_attestation.go",
         "process_attestation_helpers.go",
         "process_block.go",
@@ -21,15 +18,14 @@ 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__",
         "//cmd/beacon-chain:__subpackages__",
+        "//testing/fuzz:__pkg__",
         "//testing/slasher/simulator:__pkg__",
-        "//testing/spectest:__subpackages__",
     ],
     deps = [
         "//async:go_default_library",
@@ -37,8 +33,8 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
+        "//beacon-chain/core/execution: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",
@@ -47,11 +43,8 @@ go_library(
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
-        "//beacon-chain/db/kv:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
-        "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
@@ -61,29 +54,25 @@ go_library(
         "//beacon-chain/state/stategen:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/forks/bellatrix:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//consensus-types/wrapper:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
+        "//proto/prysm/v1alpha1/block:go_default_library",
         "//runtime/version:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_emicklei_dot//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//eth/catalyst:go_default_library",
         "@com_github_holiman_uint256//: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_eth2_types//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -104,14 +93,12 @@ go_test(
         "blockchain_test.go",
         "chain_info_test.go",
         "checktags_test.go",
-        "execution_engine_test.go",
         "head_sync_committee_info_test.go",
         "head_test.go",
+        "info_test.go",
         "init_test.go",
         "log_test.go",
         "metrics_test.go",
-        "mock_test.go",
-        "pow_block_test.go",
         "process_attestation_test.go",
         "process_block_test.go",
         "receive_attestation_test.go",
@@ -130,19 +117,14 @@ go_test(
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/powchain/testing:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
-        "//beacon-chain/state/v3:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/wrapper:go_default_library",
-        "//container/trie: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",
@@ -163,7 +145,6 @@ go_test(
         "chain_info_norace_test.go",
         "checktags_test.go",
         "init_test.go",
-        "mock_test.go",
         "receive_block_test.go",
         "service_norace_test.go",
     ],
@@ -187,15 +168,12 @@ go_test(
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/powchain/testing:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/wrapper:go_default_library",
-        "//container/trie: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",

beacon-chain/blockchain/blockchain_test.go

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

beacon-chain/blockchain/chain_info.go

@@ -4,23 +4,19 @@ import (
 	"context"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
-// directly retrieve chain info related data.
+// directly retrieves chain info related data.
 type ChainInfoFetcher interface {
 	HeadFetcher
 	FinalizationFetcher
@@ -31,12 +27,6 @@ type ChainInfoFetcher interface {
 	HeadDomainFetcher
 }
 
-// HeadUpdater defines a common interface for methods in blockchain service
-// which allow to update the head info
-type HeadUpdater interface {
-	UpdateHead(context.Context) error
-}
-
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
 type TimeFetcher interface {
 	GenesisTime() time.Time
@@ -45,21 +35,23 @@ type TimeFetcher interface {
 
 // GenesisFetcher retrieves the Ethereum consensus data related to its genesis.
 type GenesisFetcher interface {
-	GenesisValidatorsRoot() [32]byte
+	GenesisValidatorRoot() [32]byte
 }
 
 // HeadFetcher defines a common interface for methods in blockchain service which
-// directly retrieve head related data.
+// directly retrieves head related data.
 type HeadFetcher interface {
 	HeadSlot() types.Slot
 	HeadRoot(ctx context.Context) ([]byte, error)
-	HeadBlock(ctx context.Context) (interfaces.SignedBeaconBlock, 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)
-	HeadGenesisValidatorsRoot() [32]byte
+	HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error)
+	HeadGenesisValidatorRoot() [32]byte
 	HeadETH1Data() *ethpb.Eth1Data
-	HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool)
-	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error)
+	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
@@ -67,52 +59,48 @@ type HeadFetcher interface {
 
 // ForkFetcher retrieves the current fork information of the Ethereum beacon chain.
 type ForkFetcher interface {
-	ForkChoicer() forkchoice.ForkChoicer
 	CurrentFork() *ethpb.Fork
 }
 
 // CanonicalFetcher retrieves the current chain's canonical information.
 type CanonicalFetcher interface {
 	IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error)
+	VerifyBlkDescendant(ctx context.Context, blockRoot [32]byte) error
 }
 
 // FinalizationFetcher defines a common interface for methods in blockchain service which
-// directly retrieve finalization and justification related data.
+// directly retrieves finalization and justification related data.
 type FinalizationFetcher interface {
 	FinalizedCheckpt() *ethpb.Checkpoint
 	CurrentJustifiedCheckpt() *ethpb.Checkpoint
 	PreviousJustifiedCheckpt() *ethpb.Checkpoint
-	VerifyFinalizedBlkDescendant(ctx context.Context, blockRoot [32]byte) error
 }
 
-// OptimisticModeFetcher retrieves information about optimistic status of the node.
-type OptimisticModeFetcher interface {
-	IsOptimistic(ctx context.Context) (bool, error)
-	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
-}
-
-// FinalizedCheckpt returns the latest finalized checkpoint from chain store.
+// FinalizedCheckpt returns the latest finalized checkpoint from head state.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
-	cp := s.ForkChoicer().FinalizedCheckpoint()
-	return &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
+	if s.finalizedCheckpt == nil {
+		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
+	}
+
+	return ethpb.CopyCheckpoint(s.finalizedCheckpt)
 }
 
-// PreviousJustifiedCheckpt returns the current justified checkpoint from chain store.
-func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
-	cp := s.ForkChoicer().PreviousJustifiedCheckpoint()
-	return &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-}
-
-// CurrentJustifiedCheckpt returns the current justified checkpoint from chain store.
+// CurrentJustifiedCheckpt returns the current justified checkpoint from head state.
 func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
-	cp := s.ForkChoicer().JustifiedCheckpoint()
-	return &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
+	if s.justifiedCheckpt == nil {
+		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
+	}
+
+	return ethpb.CopyCheckpoint(s.justifiedCheckpt)
 }
 
-// BestJustifiedCheckpt returns the best justified checkpoint from store.
-func (s *Service) BestJustifiedCheckpt() *ethpb.Checkpoint {
-	cp := s.ForkChoicer().BestJustifiedCheckpoint()
-	return &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
+// PreviousJustifiedCheckpt returns the previous justified checkpoint from head state.
+func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
+	if s.prevJustifiedCheckpt == nil {
+		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
+	}
+
+	return ethpb.CopyCheckpoint(s.prevJustifiedCheckpt)
 }
 
 // HeadSlot returns the slot of the head of the chain.
@@ -132,8 +120,9 @@ func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
-	if s.head != nil && s.head.root != params.BeaconConfig().ZeroHash {
-		return bytesutil.SafeCopyBytes(s.head.root[:]), nil
+	if s.headRoot() != params.BeaconConfig().ZeroHash {
+		r := s.headRoot()
+		return r[:], nil
 	}
 
 	b, err := s.cfg.BeaconDB.HeadBlock(ctx)
@@ -155,7 +144,7 @@ func (s *Service) HeadRoot(ctx context.Context) ([]byte, error) {
 // HeadBlock returns the head block of the chain.
 // If the head is nil from service struct,
 // it will attempt to get the head block from DB.
-func (s *Service) HeadBlock(ctx context.Context) (interfaces.SignedBeaconBlock, error) {
+func (s *Service) HeadBlock(ctx context.Context) (block.SignedBeaconBlock, error) {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
@@ -196,8 +185,20 @@ func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch types.Epoch)
 	return helpers.ActiveValidatorIndices(ctx, s.headState(ctx), epoch)
 }
 
-// HeadGenesisValidatorsRoot returns genesis validators root of the head state.
-func (s *Service) HeadGenesisValidatorsRoot() [32]byte {
+// HeadSeed returns the seed from the head view of a given epoch.
+func (s *Service) HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+
+	if !s.hasHeadState() {
+		return [32]byte{}, nil
+	}
+
+	return helpers.Seed(s.headState(ctx), epoch, params.BeaconConfig().DomainBeaconAttester)
+}
+
+// HeadGenesisValidatorRoot returns genesis validator root of the head state.
+func (s *Service) HeadGenesisValidatorRoot() [32]byte {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
@@ -205,7 +206,7 @@ func (s *Service) HeadGenesisValidatorsRoot() [32]byte {
 		return [32]byte{}
 	}
 
-	return s.headGenesisValidatorsRoot()
+	return s.headGenesisValidatorRoot()
 }
 
 // HeadETH1Data returns the eth1data of the current head state.
@@ -219,21 +220,26 @@ func (s *Service) HeadETH1Data() *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.
 func (s *Service) GenesisTime() time.Time {
 	return s.genesisTime
 }
 
-// GenesisValidatorsRoot returns the genesis validators
+// GenesisValidatorRoot returns the genesis validator
 // root of the chain.
-func (s *Service) GenesisValidatorsRoot() [32]byte {
+func (s *Service) GenesisValidatorRoot() [32]byte {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
 	if !s.hasHeadState() {
 		return [32]byte{}
 	}
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
 }
 
 // CurrentFork retrieves the latest fork information of the beacon chain.
@@ -252,119 +258,57 @@ func (s *Service) CurrentFork() *ethpb.Fork {
 
 // IsCanonical returns true if the input block root is part of the canonical chain.
 func (s *Service) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error) {
-	// If the block has not been finalized, check fork choice store to see if the block is canonical
-	if s.cfg.ForkChoiceStore.HasNode(blockRoot) {
-		return s.cfg.ForkChoiceStore.IsCanonical(blockRoot), nil
+	// If the block has been finalized, the block will always be part of the canonical chain.
+	if s.cfg.BeaconDB.IsFinalizedBlock(ctx, blockRoot) {
+		return true, nil
 	}
 
-	// If the block has been finalized, the block will always be part of the canonical chain.
-	return s.cfg.BeaconDB.IsFinalizedBlock(ctx, blockRoot), nil
+	// 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) {
-	return s.cfg.ForkChoiceStore.Tips()
+	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(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool) {
+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.headValidatorIndexAtPubkey(pubKey)
+	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) ([fieldparams.BLSPubkeyLength]byte, error) {
+func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.ValidatorIndex) ([48]byte, error) {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 	if !s.hasHeadState() {
-		return [fieldparams.BLSPubkeyLength]byte{}, nil
+		return [48]byte{}, nil
 	}
 	v, err := s.headValidatorAtIndex(index)
 	if err != nil {
-		return [fieldparams.BLSPubkeyLength]byte{}, err
+		return [48]byte{}, err
 	}
 	return v.PublicKey(), nil
 }
-
-// ForkChoicer returns the forkchoice interface.
-func (s *Service) ForkChoicer() forkchoice.ForkChoicer {
-	return s.cfg.ForkChoiceStore
-}
-
-// IsOptimistic returns true if the current head is optimistic.
-func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-	if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {
-		return false, nil
-	}
-
-	return s.IsOptimisticForRoot(ctx, s.head.root)
-}
-
-// IsOptimisticForRoot takes the root as argument instead of the current head
-// and returns true if it is optimistic.
-func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(root)
-	if err == nil {
-		return optimistic, nil
-	}
-	if err != protoarray.ErrUnknownNodeRoot && err != doublylinkedtree.ErrNilNode {
-		return false, err
-	}
-	ss, err := s.cfg.BeaconDB.StateSummary(ctx, root)
-	if err != nil {
-		return false, err
-	}
-	if ss == nil {
-		return false, errInvalidNilSummary
-	}
-
-	validatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	if err != nil {
-		return false, err
-	}
-	if slots.ToEpoch(ss.Slot) > validatedCheckpoint.Epoch {
-		return true, nil
-	}
-
-	if slots.ToEpoch(ss.Slot)+1 < validatedCheckpoint.Epoch {
-		return false, nil
-	}
-
-	// Checkpoint root could be zeros before the first finalized epoch. Use genesis root if the case.
-	lastValidated, err := s.cfg.BeaconDB.StateSummary(ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(validatedCheckpoint.Root)))
-	if err != nil {
-		return false, err
-	}
-	if lastValidated == nil {
-		return false, errInvalidNilSummary
-	}
-
-	if ss.Slot > lastValidated.Slot {
-		return true, nil
-	}
-
-	isCanonical, err := s.IsCanonical(ctx, root)
-	if err != nil {
-		return false, err
-	}
-
-	// Historical non-canonical blocks here are returned as optimistic for safety.
-	return !isCanonical, nil
-}
-
-// SetGenesisTime sets the genesis time of beacon chain.
-func (s *Service) SetGenesisTime(t time.Time) {
-	s.genesisTime = t
-}
-
-// ForkChoiceStore returns the fork choice store in the service.
-func (s *Service) ForkChoiceStore() forkchoice.ForkChoicer {
-	return s.cfg.ForkChoiceStore
-}

beacon-chain/blockchain/chain_info_norace_test.go

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

beacon-chain/blockchain/chain_info_test.go

@@ -5,21 +5,15 @@ import (
 	"testing"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/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"
@@ -31,38 +25,10 @@ var _ ChainInfoFetcher = (*Service)(nil)
 var _ TimeFetcher = (*Service)(nil)
 var _ ForkFetcher = (*Service)(nil)
 
-// prepareForkchoiceState prepares a beacon state with the given data to mock
-// insert into forkchoice
-func prepareForkchoiceState(
-	_ context.Context,
-	slot types.Slot,
-	blockRoot [32]byte,
-	parentRoot [32]byte,
-	payloadHash [32]byte,
-	justified *ethpb.Checkpoint,
-	finalized *ethpb.Checkpoint,
-) (state.BeaconState, [32]byte, error) {
-	blockHeader := &ethpb.BeaconBlockHeader{
-		ParentRoot: parentRoot[:],
-	}
-
-	executionHeader := &enginev1.ExecutionPayloadHeader{
-		BlockHash: payloadHash[:],
-	}
-
-	base := &ethpb.BeaconStateBellatrix{
-		Slot:                         slot,
-		RandaoMixes:                  make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		BlockRoots:                   make([][]byte, 1),
-		CurrentJustifiedCheckpoint:   justified,
-		FinalizedCheckpoint:          finalized,
-		LatestExecutionPayloadHeader: executionHeader,
-		LatestBlockHeader:            blockHeader,
-	}
-
-	base.BlockRoots[0] = append(base.BlockRoots[0], blockRoot[:]...)
-	st, err := v3.InitializeFromProto(base)
-	return st, blockRoot, err
+func TestFinalizedCheckpt_Nil(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	c := setupBeaconChain(t, beaconDB)
+	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], c.FinalizedCheckpt().Root, "Incorrect pre chain start value")
 }
 
 func TestHeadRoot_Nil(t *testing.T) {
@@ -73,54 +39,67 @@ func TestHeadRoot_Nil(t *testing.T) {
 	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
 }
 
-func TestService_ForkChoiceStore(t *testing.T) {
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
-	p := c.ForkChoiceStore()
-	require.Equal(t, types.Epoch(0), p.FinalizedCheckpoint().Epoch)
+func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+
+	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
+	c := setupBeaconChain(t, beaconDB)
+	c.finalizedCheckpt = cp
+
+	assert.Equal(t, cp.Epoch, c.FinalizedCheckpt().Epoch, "Unexpected finalized epoch")
 }
 
 func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
-	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(fcs),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	gs, _ := util.DeterministicGenesisState(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-	cp := service.FinalizedCheckpt()
-	assert.DeepEqual(t, [32]byte{}, bytesutil.ToBytes32(cp.Root))
-	cp = service.CurrentJustifiedCheckpt()
-	assert.DeepEqual(t, [32]byte{}, bytesutil.ToBytes32(cp.Root))
-	// check that forkchoice has the right genesis root as the node root
-	root, err := fcs.Head(ctx, []uint64{})
-	require.NoError(t, err)
-	require.Equal(t, service.originBlockRoot, root)
 
+	genesisRoot := [32]byte{'A'}
+	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
+	c := setupBeaconChain(t, beaconDB)
+	c.finalizedCheckpt = cp
+	c.genesisRoot = genesisRoot
+	assert.DeepEqual(t, c.genesisRoot[:], c.FinalizedCheckpt().Root)
 }
 
 func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
-	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(fcs),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
 
-	cp := &forkchoicetypes.Checkpoint{Epoch: 6, Root: [32]byte{'j'}}
-	require.NoError(t, fcs.UpdateJustifiedCheckpoint(cp))
-	jp := service.CurrentJustifiedCheckpt()
-	assert.Equal(t, cp.Epoch, jp.Epoch, "Unexpected justified epoch")
-	require.Equal(t, cp.Root, bytesutil.ToBytes32(jp.Root))
+	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
+	assert.Equal(t, cp.Epoch, c.CurrentJustifiedCheckpt().Epoch, "Unexpected justified epoch")
+}
+
+func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+
+	c := setupBeaconChain(t, beaconDB)
+	genesisRoot := [32]byte{'B'}
+	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
+	c.justifiedCheckpt = cp
+	c.genesisRoot = genesisRoot
+	assert.DeepEqual(t, c.genesisRoot[:], c.CurrentJustifiedCheckpt().Root)
+}
+
+func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+
+	cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
+	c := setupBeaconChain(t, beaconDB)
+	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
+	c.prevJustifiedCheckpt = cp
+	assert.Equal(t, cp.Epoch, c.PreviousJustifiedCheckpt().Epoch, "Unexpected previous justified epoch")
+}
+
+func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+
+	genesisRoot := [32]byte{'C'}
+	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
+	c := setupBeaconChain(t, beaconDB)
+	c.prevJustifiedCheckpt = cp
+	c.genesisRoot = genesisRoot
+	assert.DeepEqual(t, c.genesisRoot[:], c.PreviousJustifiedCheckpt().Root)
 }
 
 func TestHeadSlot_CanRetrieve(t *testing.T) {
@@ -132,46 +111,24 @@ func TestHeadSlot_CanRetrieve(t *testing.T) {
 }
 
 func TestHeadRoot_CanRetrieve(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(fcs),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
+	c := &Service{}
+	c.head = &head{root: [32]byte{'A'}}
+	r, err := c.HeadRoot(context.Background())
 	require.NoError(t, err)
-	gs, _ := util.DeterministicGenesisState(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-
-	r, err := service.HeadRoot(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, service.originBlockRoot, bytesutil.ToBytes32(r))
+	assert.Equal(t, [32]byte{'A'}, bytesutil.ToBytes32(r))
 }
 
 func TestHeadRoot_UseDB(t *testing.T) {
-	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(fcs),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	service.head = &head{root: params.BeaconConfig().ZeroHash}
+	c := &Service{cfg: &config{BeaconDB: beaconDB}}
+	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: br[:]}))
-	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, br))
-	r, err := service.HeadRoot(ctx)
+	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))
 }
@@ -181,10 +138,8 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
 	b.Block.Slot = 1
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
 	c := &Service{}
-	c.head = &head{block: wsb, state: s}
+	c.head = &head{block: wrapper.WrappedPhase0SignedBeaconBlock(b), state: s}
 
 	recevied, err := c.HeadBlock(context.Background())
 	require.NoError(t, err)
@@ -229,15 +184,15 @@ func TestCurrentFork_NilHeadSTate(t *testing.T) {
 	}
 }
 
-func TestGenesisValidatorsRoot_CanRetrieve(t *testing.T) {
+func TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
 	// Should not panic if head state is nil.
 	c := &Service{}
-	assert.Equal(t, [32]byte{}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
+	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.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
+	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
 }
 
 func TestHeadETH1Data_Nil(t *testing.T) {
@@ -266,7 +221,7 @@ func TestIsCanonical_Ok(t *testing.T) {
 	blk.Block.Slot = 0
 	root, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, blk)
+	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)
@@ -292,96 +247,68 @@ func TestService_HeadValidatorsIndices(t *testing.T) {
 	require.Equal(t, 10, len(indices))
 }
 
-func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
+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.HeadGenesisValidatorsRoot()
+	root := c.HeadGenesisValidatorRoot()
 	require.Equal(t, [32]byte{}, root)
 
 	c.head = &head{state: s}
-	root = c.HeadGenesisValidatorsRoot()
-	require.DeepEqual(t, root[:], s.GenesisValidatorsRoot())
+	root = c.HeadGenesisValidatorRoot()
+	require.DeepEqual(t, root[:], s.GenesisValidatorRoot())
 }
-func TestService_ChainHeads_ProtoArray(t *testing.T) {
+
+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()}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	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)
 }
 
-//
-//  A <- B <- C
-//   \    \
-//    \    ---------- E
-//     ---------- D
-
-func TestService_ChainHeads_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-
-	roots, slots := c.ChainHeads()
-	require.Equal(t, 3, len(roots))
-	rootMap := map[[32]byte]types.Slot{[32]byte{'c'}: 102, [32]byte{'d'}: 103, [32]byte{'e'}: 104}
-	for i, root := range roots {
-		slot, ok := rootMap[root]
-		require.Equal(t, true, ok)
-		require.Equal(t, slot, slots[i])
-	}
-}
-
 func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 10)
 	c := &Service{}
 	c.head = &head{state: s}
 
-	_, e := c.HeadPublicKeyToValidatorIndex([fieldparams.BLSPubkeyLength]byte{})
+	_, 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(bytesutil.ToBytes48(v.PublicKey))
+	i, e := c.HeadPublicKeyToValidatorIndex(context.Background(), bytesutil.ToBytes48(v.PublicKey))
 	require.Equal(t, true, e)
 	require.Equal(t, types.ValidatorIndex(0), i)
 }
@@ -390,12 +317,12 @@ func TestService_HeadPublicKeyToValidatorIndexNil(t *testing.T) {
 	c := &Service{}
 	c.head = nil
 
-	idx, e := c.HeadPublicKeyToValidatorIndex([fieldparams.BLSPubkeyLength]byte{})
+	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([fieldparams.BLSPubkeyLength]byte{})
+	i, e := c.HeadPublicKeyToValidatorIndex(context.Background(), [48]byte{})
 	require.Equal(t, false, e)
 	require.Equal(t, types.ValidatorIndex(0), i)
 }
@@ -420,252 +347,10 @@ func TestService_HeadValidatorIndexToPublicKeyNil(t *testing.T) {
 
 	p, err := c.HeadValidatorIndexToPublicKey(context.Background(), 0)
 	require.NoError(t, err)
-	require.Equal(t, [fieldparams.BLSPubkeyLength]byte{}, p)
+	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, [fieldparams.BLSPubkeyLength]byte{}, p)
-}
-
-func TestService_IsOptimistic_ProtoArray(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.BellatrixForkEpoch = 0
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-
-	opt, err := c.IsOptimistic(ctx)
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimistic_DoublyLinkedTree(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.BellatrixForkEpoch = 0
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-
-	opt, err := c.IsOptimistic(ctx)
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{genesisTime: time.Now()}
-	opt, err := c.IsOptimistic(ctx)
-	require.NoError(t, err)
-	require.Equal(t, false, opt)
-}
-
-func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-
-	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
-
-	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, b)
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 97
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, optimisticBlock)
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, validatedBlock)
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	_, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.ErrorContains(t, "nil summary returned from the DB", err)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	cp := &ethpb.Checkpoint{
-		Epoch: 1,
-		Root:  validatedRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, validatedRoot))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, cp))
-
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, validated)
-
-	// Before the first finalized epoch, finalized root could be zeros.
-	validatedCheckpoint = &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, br))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:], Slot: 10}))
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-}
-
-func TestService_IsOptimisticForRoot_DB_DoublyLinkedTree(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, b)
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 97
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, optimisticBlock)
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, validatedBlock)
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	_, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.ErrorContains(t, "nil summary returned from the DB", err)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	cp := &ethpb.Checkpoint{
-		Epoch: 1,
-		Root:  validatedRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, validatedRoot))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, cp))
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, validated)
-
-	// Before the first finalized epoch, finalized root could be zeros.
-	validatedCheckpoint = &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, br))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:], Slot: 10}))
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-}
-
-func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, b)
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 97
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, optimisticBlock)
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, context.Background(), beaconDB, validatedBlock)
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, validated)
-
+	require.Equal(t, [48]byte{}, p)
 }

beacon-chain/blockchain/checktags_test.go

@@ -1,4 +1,4 @@
-//go:build !develop
+// +build !develop
 
 package blockchain
 

beacon-chain/blockchain/error.go

@@ -1,64 +0,0 @@
-package blockchain
-
-import "github.com/pkg/errors"
-
-var (
-	// ErrInvalidPayload is returned when the payload is invalid
-	ErrInvalidPayload = errors.New("recevied an INVALID payload from execution engine")
-	// ErrUndefinedExecutionEngineError is returned when the execution engine returns an error that is not defined
-	ErrUndefinedExecutionEngineError = errors.New("received an undefined ee error")
-	// errNilFinalizedInStore is returned when a nil finalized checkpt is returned from store.
-	errNilFinalizedInStore = errors.New("nil finalized checkpoint returned from store")
-	// errNilFinalizedCheckpoint is returned when a nil finalized checkpt is returned from a state.
-	errNilFinalizedCheckpoint = errors.New("nil finalized checkpoint returned from state")
-	// errNilJustifiedCheckpoint is returned when a nil justified checkpt is returned from a state.
-	errNilJustifiedCheckpoint = errors.New("nil finalized checkpoint returned from state")
-	// errInvalidNilSummary is returned when a nil summary is returned from the DB.
-	errInvalidNilSummary = errors.New("nil summary returned from the DB")
-	// errWrongBlockCount is returned when the wrong number of blocks or block roots is used
-	errWrongBlockCount = errors.New("wrong number of blocks or block roots")
-	// block is not a valid optimistic candidate block
-	errNotOptimisticCandidate = errors.New("block is not suitable for optimistic sync")
-	// errBlockNotFoundInCacheOrDB is returned when a block is not found in the cache or DB.
-	errBlockNotFoundInCacheOrDB = errors.New("block not found in cache or db")
-	// errNilStateFromStategen is returned when a nil state is returned from the state generator.
-	errNilStateFromStategen = errors.New("justified state can't be nil")
-	// errWSBlockNotFound is returned when a block is not found in the WS cache or DB.
-	errWSBlockNotFound = errors.New("weak subjectivity root not found in db")
-	// errWSBlockNotFoundInEpoch is returned when a block is not found in the WS cache or DB within epoch.
-	errWSBlockNotFoundInEpoch = errors.New("weak subjectivity root not found in db within epoch")
-	// errNotDescendantOfFinalized is returned when a block is not a descendant of the finalized checkpoint
-	errNotDescendantOfFinalized = invalidBlock{errors.New("not descendant of finalized checkpoint")}
-)
-
-// An invalid block is the block that fails state transition based on the core protocol rules.
-// The beacon node shall not be accepting nor building blocks that branch off from an invalid block.
-// Some examples of invalid blocks are:
-// The block violates state transition rules.
-// The block is deemed invalid according to execution layer client.
-// The block violates certain fork choice rules (before finalized slot, not finalized ancestor)
-type invalidBlock struct {
-	error
-}
-
-type invalidBlockError interface {
-	Error() string
-	InvalidBlock() bool
-}
-
-// InvalidBlock returns true for `invalidBlock`.
-func (e invalidBlock) InvalidBlock() bool {
-	return true
-}
-
-// IsInvalidBlock returns true if the error has `invalidBlock`.
-func IsInvalidBlock(e error) bool {
-	if e == nil {
-		return false
-	}
-	d, ok := e.(invalidBlockError)
-	if !ok {
-		return IsInvalidBlock(errors.Unwrap(e))
-	}
-	return d.InvalidBlock()
-}

beacon-chain/blockchain/error_test.go

@@ -1,17 +0,0 @@
-package blockchain
-
-import (
-	"testing"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestIsInvalidBlock(t *testing.T) {
-	require.Equal(t, false, IsInvalidBlock(ErrInvalidPayload))
-	err := invalidBlock{ErrInvalidPayload}
-	require.Equal(t, true, IsInvalidBlock(err))
-
-	newErr := errors.Wrap(err, "wrap me")
-	require.Equal(t, true, IsInvalidBlock(newErr))
-}

beacon-chain/blockchain/execution_engine.go

@@ -1,314 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
-	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-)
-
-// notifyForkchoiceUpdateArg is the argument for the forkchoice update notification `notifyForkchoiceUpdate`.
-type notifyForkchoiceUpdateArg struct {
-	headState state.BeaconState
-	headRoot  [32]byte
-	headBlock interfaces.BeaconBlock
-}
-
-// notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
-// 1. Re-organizes the execution payload chain and corresponding state to make head_block_hash the head.
-// 2. Applies finality to the execution state: it irreversibly persists the chain of all execution payloads and corresponding state, up to and including finalized_block_hash.
-func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkchoiceUpdateArg) (*enginev1.PayloadIDBytes, error) {
-	ctx, span := trace.StartSpan(ctx, "blockChain.notifyForkchoiceUpdate")
-	defer span.End()
-
-	headBlk := arg.headBlock
-	if headBlk == nil || headBlk.IsNil() || headBlk.Body().IsNil() {
-		return nil, errors.New("nil head block")
-	}
-	// Must not call fork choice updated until the transition conditions are met on the Pow network.
-	isExecutionBlk, err := blocks.IsExecutionBlock(headBlk.Body())
-	if err != nil {
-		return nil, errors.Wrap(err, "could not determine if block is execution block")
-	}
-	if !isExecutionBlk {
-		return nil, nil
-	}
-	headPayload, err := headBlk.Body().ExecutionPayload()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution payload")
-	}
-	finalizedHash := s.ForkChoicer().FinalizedPayloadBlockHash()
-	justifiedHash := s.ForkChoicer().JustifiedPayloadBlockHash()
-	fcs := &enginev1.ForkchoiceState{
-		HeadBlockHash:      headPayload.BlockHash,
-		SafeBlockHash:      justifiedHash[:],
-		FinalizedBlockHash: finalizedHash[:],
-	}
-
-	nextSlot := s.CurrentSlot() + 1 // Cache payload ID for next slot proposer.
-	hasAttr, attr, proposerId, err := s.getPayloadAttribute(ctx, arg.headState, nextSlot)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get payload attribute")
-	}
-
-	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, attr)
-	if err != nil {
-		switch err {
-		case powchain.ErrAcceptedSyncingPayloadStatus:
-			forkchoiceUpdatedOptimisticNodeCount.Inc()
-			log.WithFields(logrus.Fields{
-				"headSlot":                  headBlk.Slot(),
-				"headPayloadBlockHash":      fmt.Sprintf("%#x", bytesutil.Trunc(headPayload.BlockHash)),
-				"finalizedPayloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash[:])),
-			}).Info("Called fork choice updated with optimistic block")
-			return payloadID, s.optimisticCandidateBlock(ctx, headBlk)
-		case powchain.ErrInvalidPayloadStatus:
-			newPayloadInvalidNodeCount.Inc()
-			headRoot := arg.headRoot
-			invalidRoots, err := s.ForkChoicer().SetOptimisticToInvalid(ctx, headRoot, bytesutil.ToBytes32(headBlk.ParentRoot()), bytesutil.ToBytes32(lastValidHash))
-			if err != nil {
-				return nil, err
-			}
-			if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
-				return nil, err
-			}
-
-			r, err := s.cfg.ForkChoiceStore.Head(ctx, s.justifiedBalances.balances)
-			if err != nil {
-				return nil, err
-			}
-			b, err := s.getBlock(ctx, r)
-			if err != nil {
-				return nil, err
-			}
-			st, err := s.cfg.StateGen.StateByRoot(ctx, r)
-			if err != nil {
-				return nil, err
-			}
-			pid, err := s.notifyForkchoiceUpdate(ctx, &notifyForkchoiceUpdateArg{
-				headState: st,
-				headRoot:  r,
-				headBlock: b.Block(),
-			})
-			if err != nil {
-				return nil, err
-			}
-
-			log.WithFields(logrus.Fields{
-				"slot":         headBlk.Slot(),
-				"blockRoot":    fmt.Sprintf("%#x", headRoot),
-				"invalidCount": len(invalidRoots),
-			}).Warn("Pruned invalid blocks")
-			return pid, ErrInvalidPayload
-
-		default:
-			return nil, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
-		}
-	}
-	forkchoiceUpdatedValidNodeCount.Inc()
-	if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, arg.headRoot); err != nil {
-		return nil, errors.Wrap(err, "could not set block to valid")
-	}
-	if hasAttr { // If the forkchoice update call has an attribute, update the proposer payload ID cache.
-		var pId [8]byte
-		copy(pId[:], payloadID[:])
-		s.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(nextSlot, proposerId, pId)
-	}
-	return payloadID, nil
-}
-
-// getPayloadHash returns the payload hash given the block root.
-// if the block is before bellatrix fork epoch, it returns the zero hash.
-func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, error) {
-	blk, err := s.getBlock(ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(root)))
-	if err != nil {
-		return [32]byte{}, err
-	}
-	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
-		return params.BeaconConfig().ZeroHash, nil
-	}
-	payload, err := blk.Block().Body().ExecutionPayload()
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not get execution payload")
-	}
-	return bytesutil.ToBytes32(payload.BlockHash), nil
-}
-
-// notifyForkchoiceUpdate signals execution engine on a new payload.
-// It returns true if the EL has returned VALID for the block
-func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
-	postStateHeader *enginev1.ExecutionPayloadHeader, blk interfaces.SignedBeaconBlock) (bool, error) {
-	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
-	defer span.End()
-
-	// Execution payload is only supported in Bellatrix and beyond. Pre
-	// merge blocks are never optimistic
-	if blocks.IsPreBellatrixVersion(postStateVersion) {
-		return true, nil
-	}
-	if err := wrapper.BeaconBlockIsNil(blk); err != nil {
-		return false, err
-	}
-	body := blk.Block().Body()
-	enabled, err := blocks.IsExecutionEnabledUsingHeader(postStateHeader, body)
-	if err != nil {
-		return false, errors.Wrap(invalidBlock{err}, "could not determine if execution is enabled")
-	}
-	if !enabled {
-		return true, nil
-	}
-	payload, err := body.ExecutionPayload()
-	if err != nil {
-		return false, errors.Wrap(invalidBlock{err}, "could not get execution payload")
-	}
-	lastValidHash, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload)
-	switch err {
-	case nil:
-		newPayloadValidNodeCount.Inc()
-		return true, nil
-	case powchain.ErrAcceptedSyncingPayloadStatus:
-		newPayloadOptimisticNodeCount.Inc()
-		log.WithFields(logrus.Fields{
-			"slot":             blk.Block().Slot(),
-			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
-		}).Info("Called new payload with optimistic block")
-		return false, s.optimisticCandidateBlock(ctx, blk.Block())
-	case powchain.ErrInvalidPayloadStatus:
-		newPayloadInvalidNodeCount.Inc()
-		root, err := blk.Block().HashTreeRoot()
-		if err != nil {
-			return false, err
-		}
-		invalidRoots, err := s.ForkChoicer().SetOptimisticToInvalid(ctx, root, bytesutil.ToBytes32(blk.Block().ParentRoot()), bytesutil.ToBytes32(lastValidHash))
-		if err != nil {
-			return false, err
-		}
-		if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
-			return false, err
-		}
-		log.WithFields(logrus.Fields{
-			"slot":         blk.Block().Slot(),
-			"blockRoot":    fmt.Sprintf("%#x", root),
-			"invalidCount": len(invalidRoots),
-		}).Warn("Pruned invalid blocks")
-		return false, invalidBlock{ErrInvalidPayload}
-	default:
-		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
-	}
-}
-
-// optimisticCandidateBlock returns an error if this block can't be optimistically synced.
-// It replaces boolean in spec code with `errNotOptimisticCandidate`.
-//
-// Spec pseudocode definition:
-// def is_optimistic_candidate_block(opt_store: OptimisticStore, current_slot: Slot, block: BeaconBlock) -> bool:
-//    if is_execution_block(opt_store.blocks[block.parent_root]):
-//        return True
-//
-//    if block.slot + SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY <= current_slot:
-//        return True
-//
-//    return False
-func (s *Service) optimisticCandidateBlock(ctx context.Context, blk interfaces.BeaconBlock) error {
-	if blk.Slot()+params.BeaconConfig().SafeSlotsToImportOptimistically <= s.CurrentSlot() {
-		return nil
-	}
-	parent, err := s.getBlock(ctx, bytesutil.ToBytes32(blk.ParentRoot()))
-	if err != nil {
-		return err
-	}
-	parentIsExecutionBlock, err := blocks.IsExecutionBlock(parent.Block().Body())
-	if err != nil {
-		return err
-	}
-	if parentIsExecutionBlock {
-		return nil
-	}
-
-	return errNotOptimisticCandidate
-}
-
-// getPayloadAttributes returns the payload attributes for the given state and slot.
-// The attribute is required to initiate a payload build process in the context of an `engine_forkchoiceUpdated` call.
-func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState, slot types.Slot) (bool, *enginev1.PayloadAttributes, types.ValidatorIndex, error) {
-	proposerID, _, ok := s.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(slot)
-	if !ok { // There's no need to build attribute if there is no proposer for slot.
-		return false, nil, 0, nil
-	}
-
-	// Get previous randao.
-	st = st.Copy()
-	st, err := transition.ProcessSlotsIfPossible(ctx, st, slot)
-	if err != nil {
-		return false, nil, 0, err
-	}
-	prevRando, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
-	if err != nil {
-		return false, nil, 0, nil
-	}
-
-	// Get fee recipient.
-	feeRecipient := params.BeaconConfig().DefaultFeeRecipient
-	recipient, err := s.cfg.BeaconDB.FeeRecipientByValidatorID(ctx, proposerID)
-	switch {
-	case errors.Is(err, kv.ErrNotFoundFeeRecipient):
-		if feeRecipient.String() == params.BeaconConfig().EthBurnAddressHex {
-			logrus.WithFields(logrus.Fields{
-				"validatorIndex": proposerID,
-				"burnAddress":    params.BeaconConfig().EthBurnAddressHex,
-			}).Warn("Fee recipient is currently using the burn address, " +
-				"you will not be rewarded transaction fees on this setting. " +
-				"Please set a different eth address as the fee recipient. " +
-				"Please refer to our documentation for instructions")
-		}
-	case err != nil:
-		return false, nil, 0, errors.Wrap(err, "could not get fee recipient in db")
-	default:
-		feeRecipient = recipient
-	}
-
-	// Get timestamp.
-	t, err := slots.ToTime(uint64(s.genesisTime.Unix()), slot)
-	if err != nil {
-		return false, nil, 0, err
-	}
-	attr := &enginev1.PayloadAttributes{
-		Timestamp:             uint64(t.Unix()),
-		PrevRandao:            prevRando,
-		SuggestedFeeRecipient: feeRecipient.Bytes(),
-	}
-	return true, attr, proposerID, nil
-}
-
-// removeInvalidBlockAndState removes the invalid block and its corresponding state from the cache and DB.
-func (s *Service) removeInvalidBlockAndState(ctx context.Context, blkRoots [][32]byte) error {
-	for _, root := range blkRoots {
-		if err := s.cfg.StateGen.DeleteStateFromCaches(ctx, root); err != nil {
-			return err
-		}
-
-		// Delete block also deletes the state as well.
-		if err := s.cfg.BeaconDB.DeleteBlock(ctx, root); err != nil {
-			// TODO(10487): If a caller requests to delete a root that's justified and finalized. We should gracefully shutdown.
-			// This is an irreparable condition, it would me a justified or finalized block has become invalid.
-			return err
-		}
-	}
-	return nil
-}

beacon-chain/blockchain/execution_engine_test.go

@@ -1,992 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
-	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
-	bstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-)
-
-func Test_NotifyForkchoiceUpdate(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	altairBlk := util.SaveBlock(t, ctx, beaconDB, util.NewBeaconBlockAltair())
-	altairBlkRoot, err := altairBlk.Block().HashTreeRoot()
-	require.NoError(t, err)
-	bellatrixBlk := util.SaveBlock(t, ctx, beaconDB, util.NewBeaconBlockBellatrix())
-	bellatrixBlkRoot, err := bellatrixBlk.Block().HashTreeRoot()
-	require.NoError(t, err)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-		WithProposerIdsCache(cache.NewProposerPayloadIDsCache()),
-	}
-	service, err := NewService(ctx, opts...)
-	st, _ := util.DeterministicGenesisState(t, 10)
-	service.head = &head{
-		state: st,
-	}
-	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-
-	tests := []struct {
-		name             string
-		blk              interfaces.BeaconBlock
-		headRoot         [32]byte
-		finalizedRoot    [32]byte
-		justifiedRoot    [32]byte
-		newForkchoiceErr error
-		errString        string
-	}{
-		{
-			name:      "nil block",
-			errString: "nil head block",
-		},
-		{
-			name: "phase0 block",
-			blk: func() interfaces.BeaconBlock {
-				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}})
-				require.NoError(t, err)
-				return b
-			}(),
-		},
-		{
-			name: "altair block",
-			blk: func() interfaces.BeaconBlock {
-				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{Body: &ethpb.BeaconBlockBodyAltair{}})
-				require.NoError(t, err)
-				return b
-			}(),
-		},
-		{
-			name: "not execution block",
-			blk: func() interfaces.BeaconBlock {
-				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
-					Body: &ethpb.BeaconBlockBodyBellatrix{
-						ExecutionPayload: &v1.ExecutionPayload{
-							ParentHash:    make([]byte, fieldparams.RootLength),
-							FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
-							StateRoot:     make([]byte, fieldparams.RootLength),
-							ReceiptsRoot:  make([]byte, fieldparams.RootLength),
-							LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
-							PrevRandao:    make([]byte, fieldparams.RootLength),
-							BaseFeePerGas: make([]byte, fieldparams.RootLength),
-							BlockHash:     make([]byte, fieldparams.RootLength),
-						},
-					},
-				})
-				require.NoError(t, err)
-				return b
-			}(),
-		},
-		{
-			name: "happy case: finalized root is altair block",
-			blk: func() interfaces.BeaconBlock {
-				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
-					Body: &ethpb.BeaconBlockBodyBellatrix{
-						ExecutionPayload: &v1.ExecutionPayload{},
-					},
-				})
-				require.NoError(t, err)
-				return b
-			}(),
-			finalizedRoot: altairBlkRoot,
-			justifiedRoot: altairBlkRoot,
-		},
-		{
-			name: "happy case: finalized root is bellatrix block",
-			blk: func() interfaces.BeaconBlock {
-				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
-					Body: &ethpb.BeaconBlockBodyBellatrix{
-						ExecutionPayload: &v1.ExecutionPayload{},
-					},
-				})
-				require.NoError(t, err)
-				return b
-			}(),
-			finalizedRoot: bellatrixBlkRoot,
-			justifiedRoot: bellatrixBlkRoot,
-		},
-		{
-			name: "forkchoice updated with optimistic block",
-			blk: func() interfaces.BeaconBlock {
-				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
-					Body: &ethpb.BeaconBlockBodyBellatrix{
-						ExecutionPayload: &v1.ExecutionPayload{},
-					},
-				})
-				require.NoError(t, err)
-				return b
-			}(),
-			newForkchoiceErr: powchain.ErrAcceptedSyncingPayloadStatus,
-			finalizedRoot:    bellatrixBlkRoot,
-			justifiedRoot:    bellatrixBlkRoot,
-		},
-		{
-			name: "forkchoice updated with invalid block",
-			blk: func() interfaces.BeaconBlock {
-				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
-					Body: &ethpb.BeaconBlockBodyBellatrix{
-						ExecutionPayload: &v1.ExecutionPayload{},
-					},
-				})
-				require.NoError(t, err)
-				return b
-			}(),
-			newForkchoiceErr: powchain.ErrInvalidPayloadStatus,
-			finalizedRoot:    bellatrixBlkRoot,
-			justifiedRoot:    bellatrixBlkRoot,
-			headRoot:         [32]byte{'a'},
-			errString:        ErrInvalidPayload.Error(),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			service.cfg.ExecutionEngineCaller = &mockPOW.EngineClient{ErrForkchoiceUpdated: tt.newForkchoiceErr}
-			st, _ := util.DeterministicGenesisState(t, 1)
-			require.NoError(t, beaconDB.SaveState(ctx, st, tt.finalizedRoot))
-			require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, tt.finalizedRoot))
-			arg := &notifyForkchoiceUpdateArg{
-				headState: st,
-				headRoot:  tt.headRoot,
-				headBlock: tt.blk,
-			}
-			_, err = service.notifyForkchoiceUpdate(ctx, arg)
-			if tt.errString != "" {
-				require.ErrorContains(t, tt.errString, err)
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}
-
-//
-//
-//  A <- B <- C <- D
-//       \
-//         ---------- E <- F
-//                     \
-//                       ------ G
-// D is the current head, attestations for F and G come late, both are invalid.
-// We switch recursively to F then G and finally to D.
-//
-// We test:
-// 1. forkchoice removes blocks F and G from the forkchoice implementation
-// 2. forkchoice removes the weights of these blocks
-// 3. the blockchain package calls fcu to obtain heads G -> F -> D.
-
-func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	// Prepare blocks
-	ba := util.NewBeaconBlockBellatrix()
-	ba.Block.Body.ExecutionPayload.BlockNumber = 1
-	wba := util.SaveBlock(t, ctx, beaconDB, ba)
-	bra, err := wba.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bb := util.NewBeaconBlockBellatrix()
-	bb.Block.Body.ExecutionPayload.BlockNumber = 2
-	wbb := util.SaveBlock(t, ctx, beaconDB, bb)
-	brb, err := wbb.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bc := util.NewBeaconBlockBellatrix()
-	bc.Block.Body.ExecutionPayload.BlockNumber = 3
-	wbc := util.SaveBlock(t, ctx, beaconDB, bc)
-	brc, err := wbc.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bd := util.NewBeaconBlockBellatrix()
-	pd := [32]byte{'D'}
-	bd.Block.Body.ExecutionPayload.BlockHash = pd[:]
-	bd.Block.Body.ExecutionPayload.BlockNumber = 4
-	wbd := util.SaveBlock(t, ctx, beaconDB, bd)
-	brd, err := wbd.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	be := util.NewBeaconBlockBellatrix()
-	pe := [32]byte{'E'}
-	be.Block.Body.ExecutionPayload.BlockHash = pe[:]
-	be.Block.Body.ExecutionPayload.BlockNumber = 5
-	wbe := util.SaveBlock(t, ctx, beaconDB, be)
-	bre, err := wbe.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bf := util.NewBeaconBlockBellatrix()
-	pf := [32]byte{'F'}
-	bf.Block.Body.ExecutionPayload.BlockHash = pf[:]
-	bf.Block.Body.ExecutionPayload.BlockNumber = 6
-	bf.Block.ParentRoot = bre[:]
-	wbf := util.SaveBlock(t, ctx, beaconDB, bf)
-	brf, err := wbf.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bg := util.NewBeaconBlockBellatrix()
-	bg.Block.Body.ExecutionPayload.BlockNumber = 7
-	pg := [32]byte{'G'}
-	bg.Block.Body.ExecutionPayload.BlockHash = pg[:]
-	bg.Block.ParentRoot = bre[:]
-	wbg := util.SaveBlock(t, ctx, beaconDB, bg)
-	brg, err := wbg.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	// Insert blocks into forkchoice
-	fcs := doublylinkedtree.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-		WithProposerIdsCache(cache.NewProposerPayloadIDsCache()),
-	}
-	service, err := NewService(ctx, opts...)
-	service.justifiedBalances.balances = []uint64{50, 100, 200}
-	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-
-	// Insert Attestations to D, F and G so that they have higher weight than D
-	// Ensure G is head
-	fcs.ProcessAttestation(ctx, []uint64{0}, brd, 1)
-	fcs.ProcessAttestation(ctx, []uint64{1}, brf, 1)
-	fcs.ProcessAttestation(ctx, []uint64{2}, brg, 1)
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: bra}
-	require.NoError(t, fcs.UpdateJustifiedCheckpoint(jc))
-	headRoot, err := fcs.Head(ctx, []uint64{50, 100, 200})
-	require.NoError(t, err)
-	require.Equal(t, brg, headRoot)
-
-	// Prepare Engine Mock to return invalid unless head is D, LVH =  E
-	service.cfg.ExecutionEngineCaller = &mockPOW.EngineClient{ErrForkchoiceUpdated: powchain.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: pe[:], OverrideValidHash: [32]byte{'D'}}
-	st, _ := util.DeterministicGenesisState(t, 1)
-
-	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
-	a := &notifyForkchoiceUpdateArg{
-		headState: st,
-		headBlock: wbg.Block(),
-		headRoot:  brg,
-	}
-	_, err = service.notifyForkchoiceUpdate(ctx, a)
-	require.ErrorIs(t, ErrInvalidPayload, err)
-	// Ensure Head is D
-	headRoot, err = fcs.Head(ctx, service.justifiedBalances.balances)
-	require.NoError(t, err)
-	require.Equal(t, brd, headRoot)
-
-	// Ensure F and G where removed but their parent E wasn't
-	require.Equal(t, false, fcs.HasNode(brf))
-	require.Equal(t, false, fcs.HasNode(brg))
-	require.Equal(t, true, fcs.HasNode(bre))
-}
-
-func Test_NotifyNewPayload(t *testing.T) {
-	cfg := params.BeaconConfig()
-	cfg.TerminalTotalDifficulty = "2"
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	phase0State, _ := util.DeterministicGenesisState(t, 1)
-	altairState, _ := util.DeterministicGenesisStateAltair(t, 1)
-	bellatrixState, _ := util.DeterministicGenesisStateBellatrix(t, 2)
-	a := &ethpb.SignedBeaconBlockAltair{
-		Block: &ethpb.BeaconBlockAltair{
-			Body: &ethpb.BeaconBlockBodyAltair{},
-		},
-	}
-	altairBlk, err := wrapper.WrappedSignedBeaconBlock(a)
-	require.NoError(t, err)
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Slot: 1,
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &v1.ExecutionPayload{
-					BlockNumber:   1,
-					ParentHash:    make([]byte, fieldparams.RootLength),
-					FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
-					StateRoot:     make([]byte, fieldparams.RootLength),
-					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
-					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
-					PrevRandao:    make([]byte, fieldparams.RootLength),
-					BaseFeePerGas: make([]byte, fieldparams.RootLength),
-					BlockHash:     make([]byte, fieldparams.RootLength),
-				},
-			},
-		},
-	}
-	bellatrixBlk, err := wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(blk))
-	require.NoError(t, err)
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
-	service.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-	r, err := bellatrixBlk.Block().HashTreeRoot()
-	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, r, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-
-	tests := []struct {
-		postState      bstate.BeaconState
-		invalidBlock   bool
-		isValidPayload bool
-		blk            interfaces.SignedBeaconBlock
-		newPayloadErr  error
-		errString      string
-		name           string
-	}{
-		{
-			name:           "phase 0 post state",
-			postState:      phase0State,
-			isValidPayload: true,
-		},
-		{
-			name:           "altair post state",
-			postState:      altairState,
-			isValidPayload: true,
-		},
-		{
-			name:           "nil beacon block",
-			postState:      bellatrixState,
-			errString:      "signed beacon block can't be nil",
-			isValidPayload: false,
-		},
-		{
-			name:           "new payload with optimistic block",
-			postState:      bellatrixState,
-			blk:            bellatrixBlk,
-			newPayloadErr:  powchain.ErrAcceptedSyncingPayloadStatus,
-			isValidPayload: false,
-		},
-		{
-			name:           "new payload with invalid block",
-			postState:      bellatrixState,
-			blk:            bellatrixBlk,
-			newPayloadErr:  powchain.ErrInvalidPayloadStatus,
-			errString:      ErrInvalidPayload.Error(),
-			isValidPayload: false,
-			invalidBlock:   true,
-		},
-		{
-			name:           "altair pre state, altair block",
-			postState:      bellatrixState,
-			blk:            altairBlk,
-			isValidPayload: true,
-		},
-		{
-			name:      "altair pre state, happy case",
-			postState: bellatrixState,
-			blk: func() interfaces.SignedBeaconBlock {
-				blk := &ethpb.SignedBeaconBlockBellatrix{
-					Block: &ethpb.BeaconBlockBellatrix{
-						Body: &ethpb.BeaconBlockBodyBellatrix{
-							ExecutionPayload: &v1.ExecutionPayload{
-								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-							},
-						},
-					},
-				}
-				b, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(t, err)
-				return b
-			}(),
-			isValidPayload: true,
-		},
-		{
-			name:      "not at merge transition",
-			postState: bellatrixState,
-			blk: func() interfaces.SignedBeaconBlock {
-				blk := &ethpb.SignedBeaconBlockBellatrix{
-					Block: &ethpb.BeaconBlockBellatrix{
-						Body: &ethpb.BeaconBlockBodyBellatrix{
-							ExecutionPayload: &v1.ExecutionPayload{
-								ParentHash:    make([]byte, fieldparams.RootLength),
-								FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
-								StateRoot:     make([]byte, fieldparams.RootLength),
-								ReceiptsRoot:  make([]byte, fieldparams.RootLength),
-								LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
-								PrevRandao:    make([]byte, fieldparams.RootLength),
-								BaseFeePerGas: make([]byte, fieldparams.RootLength),
-								BlockHash:     make([]byte, fieldparams.RootLength),
-							},
-						},
-					},
-				}
-				b, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(t, err)
-				return b
-			}(),
-			isValidPayload: true,
-		},
-		{
-			name:      "happy case",
-			postState: bellatrixState,
-			blk: func() interfaces.SignedBeaconBlock {
-				blk := &ethpb.SignedBeaconBlockBellatrix{
-					Block: &ethpb.BeaconBlockBellatrix{
-						Body: &ethpb.BeaconBlockBodyBellatrix{
-							ExecutionPayload: &v1.ExecutionPayload{
-								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-							},
-						},
-					},
-				}
-				b, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(t, err)
-				return b
-			}(),
-			isValidPayload: true,
-		},
-		{
-			name:      "undefined error from ee",
-			postState: bellatrixState,
-			blk: func() interfaces.SignedBeaconBlock {
-				blk := &ethpb.SignedBeaconBlockBellatrix{
-					Block: &ethpb.BeaconBlockBellatrix{
-						Body: &ethpb.BeaconBlockBodyBellatrix{
-							ExecutionPayload: &v1.ExecutionPayload{
-								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-							},
-						},
-					},
-				}
-				b, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(t, err)
-				return b
-			}(),
-			newPayloadErr: ErrUndefinedExecutionEngineError,
-			errString:     ErrUndefinedExecutionEngineError.Error(),
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			e := &mockPOW.EngineClient{ErrNewPayload: tt.newPayloadErr, BlockByHashMap: map[[32]byte]*v1.ExecutionBlock{}}
-			e.BlockByHashMap[[32]byte{'a'}] = &v1.ExecutionBlock{
-				ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
-				TotalDifficulty: "0x2",
-			}
-			e.BlockByHashMap[[32]byte{'b'}] = &v1.ExecutionBlock{
-				ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
-				TotalDifficulty: "0x1",
-			}
-			service.cfg.ExecutionEngineCaller = e
-			root := [32]byte{'a'}
-			state, blkRoot, err := prepareForkchoiceState(ctx, 0, root, root, params.BeaconConfig().ZeroHash, ojc, ofc)
-			require.NoError(t, err)
-			require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-			postVersion, postHeader, err := getStateVersionAndPayload(tt.postState)
-			require.NoError(t, err)
-			isValidPayload, err := service.notifyNewPayload(ctx, postVersion, postHeader, tt.blk)
-			if tt.errString != "" {
-				require.ErrorContains(t, tt.errString, err)
-				if tt.invalidBlock {
-					require.Equal(t, true, IsInvalidBlock(err))
-				}
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, tt.isValidPayload, isValidPayload)
-				require.Equal(t, false, IsInvalidBlock(err))
-			}
-		})
-	}
-}
-
-func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
-	cfg := params.BeaconConfig()
-	cfg.TerminalTotalDifficulty = "2"
-	params.OverrideBeaconConfig(cfg)
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	bellatrixState, _ := util.DeterministicGenesisStateBellatrix(t, 2)
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &v1.ExecutionPayload{
-					ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-				},
-			},
-		},
-	}
-	bellatrixBlk, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	e := &mockPOW.EngineClient{BlockByHashMap: map[[32]byte]*v1.ExecutionBlock{}}
-	e.BlockByHashMap[[32]byte{'a'}] = &v1.ExecutionBlock{
-		ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
-		TotalDifficulty: "0x2",
-	}
-	e.BlockByHashMap[[32]byte{'b'}] = &v1.ExecutionBlock{
-		ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
-		TotalDifficulty: "0x1",
-	}
-	service.cfg.ExecutionEngineCaller = e
-	postVersion, postHeader, err := getStateVersionAndPayload(bellatrixState)
-	require.NoError(t, err)
-	validated, err := service.notifyNewPayload(ctx, postVersion, postHeader, bellatrixBlk)
-	require.NoError(t, err)
-	require.Equal(t, true, validated)
-}
-
-func Test_IsOptimisticCandidateBlock(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MainnetConfig())
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	params.BeaconConfig().SafeSlotsToImportOptimistically = 128
-	service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
-
-	parentBlk := util.NewBeaconBlockBellatrix()
-	wrappedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlk)
-	require.NoError(t, err)
-	parentRoot, err := wrappedParentBlock.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	tests := []struct {
-		name      string
-		blk       interfaces.BeaconBlock
-		justified interfaces.SignedBeaconBlock
-		err       error
-	}{
-		{
-			name: "deep block",
-			blk: func(tt *testing.T) interfaces.BeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Slot = 1
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedBeaconBlock(blk.Block)
-				require.NoError(tt, err)
-				return wr
-			}(t),
-			justified: func(tt *testing.T) interfaces.SignedBeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Slot = 32
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(tt, err)
-				return wr
-			}(t),
-			err: nil,
-		},
-		{
-			name: "shallow block, Altair justified chkpt",
-			blk: func(tt *testing.T) interfaces.BeaconBlock {
-				blk := util.NewBeaconBlockAltair()
-				blk.Block.Slot = 200
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedBeaconBlock(blk.Block)
-				require.NoError(tt, err)
-				return wr
-			}(t),
-			justified: func(tt *testing.T) interfaces.SignedBeaconBlock {
-				blk := util.NewBeaconBlockAltair()
-				blk.Block.Slot = 32
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(tt, err)
-				return wr
-			}(t),
-			err: errNotOptimisticCandidate,
-		},
-		{
-			name: "shallow block, Bellatrix justified chkpt without execution",
-			blk: func(tt *testing.T) interfaces.BeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Slot = 200
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedBeaconBlock(blk.Block)
-				require.NoError(tt, err)
-				return wr
-			}(t),
-			justified: func(tt *testing.T) interfaces.SignedBeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Slot = 32
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(tt, err)
-				return wr
-			}(t),
-			err: errNotOptimisticCandidate,
-		},
-	}
-	for _, tt := range tests {
-		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, tt.justified))
-		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrappedParentBlock))
-
-		err = service.optimisticCandidateBlock(ctx, tt.blk)
-		if tt.err != nil {
-			require.Equal(t, tt.err.Error(), err.Error())
-		} else {
-			require.NoError(t, err)
-		}
-	}
-}
-
-func Test_IsOptimisticShallowExecutionParent(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MainnetConfig())
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	params.BeaconConfig().SafeSlotsToImportOptimistically = 128
-	service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
-	payload := &v1.ExecutionPayload{
-		ParentHash:    make([]byte, 32),
-		FeeRecipient:  make([]byte, 20),
-		StateRoot:     make([]byte, 32),
-		ReceiptsRoot:  make([]byte, 32),
-		LogsBloom:     make([]byte, 256),
-		PrevRandao:    make([]byte, 32),
-		BaseFeePerGas: bytesutil.PadTo([]byte{1, 2, 3, 4}, fieldparams.RootLength),
-		BlockHash:     make([]byte, 32),
-		BlockNumber:   100,
-	}
-	body := &ethpb.BeaconBlockBodyBellatrix{ExecutionPayload: payload}
-	b := &ethpb.BeaconBlockBellatrix{Body: body, Slot: 200}
-	rawSigned := &ethpb.SignedBeaconBlockBellatrix{Block: b}
-	blk := util.HydrateSignedBeaconBlockBellatrix(rawSigned)
-	wr := util.SaveBlock(t, ctx, service.cfg.BeaconDB, blk)
-	blkRoot, err := wr.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	childBlock := util.NewBeaconBlockBellatrix()
-	childBlock.Block.ParentRoot = blkRoot[:]
-	// shallow block
-	childBlock.Block.Slot = 201
-	wrappedChild := util.SaveBlock(t, ctx, service.cfg.BeaconDB, childBlock)
-	err = service.optimisticCandidateBlock(ctx, wrappedChild.Block())
-	require.NoError(t, err)
-}
-
-func Test_GetPayloadAttribute(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithProposerIdsCache(cache.NewProposerPayloadIDsCache()),
-	}
-
-	// Cache miss
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	hasPayload, _, vId, err := service.getPayloadAttribute(ctx, nil, 0)
-	require.NoError(t, err)
-	require.Equal(t, false, hasPayload)
-	require.Equal(t, types.ValidatorIndex(0), vId)
-
-	// Cache hit, advance state, no fee recipient
-	suggestedVid := types.ValidatorIndex(1)
-	slot := types.Slot(1)
-	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(slot, suggestedVid, [8]byte{})
-	st, _ := util.DeterministicGenesisState(t, 1)
-	hook := logTest.NewGlobal()
-	hasPayload, attr, vId, err := service.getPayloadAttribute(ctx, st, slot)
-	require.NoError(t, err)
-	require.Equal(t, true, hasPayload)
-	require.Equal(t, suggestedVid, vId)
-	require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient).String())
-	require.LogsContain(t, hook, "Fee recipient is currently using the burn address")
-
-	// Cache hit, advance state, has fee recipient
-	suggestedAddr := common.HexToAddress("123")
-	require.NoError(t, service.cfg.BeaconDB.SaveFeeRecipientsByValidatorIDs(ctx, []types.ValidatorIndex{suggestedVid}, []common.Address{suggestedAddr}))
-	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(slot, suggestedVid, [8]byte{})
-	hasPayload, attr, vId, err = service.getPayloadAttribute(ctx, st, slot)
-	require.NoError(t, err)
-	require.Equal(t, true, hasPayload)
-	require.Equal(t, suggestedVid, vId)
-	require.Equal(t, suggestedAddr, common.BytesToAddress(attr.SuggestedFeeRecipient))
-}
-
-func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MainnetConfig())
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	stateGen := stategen.New(beaconDB)
-	fcs := doublylinkedtree.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stateGen),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	genesisStateRoot := [32]byte{}
-	genesisBlk := blocks.NewGenesisBlock(genesisStateRoot[:])
-	util.SaveBlock(t, ctx, beaconDB, genesisBlk)
-	genesisRoot, err := genesisBlk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	fjc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash}
-	require.NoError(t, fcs.UpdateJustifiedCheckpoint(fjc))
-	require.NoError(t, fcs.UpdateFinalizedCheckpoint(fjc))
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	fcs.SetOriginRoot(genesisRoot)
-	genesisSummary := &ethpb.StateSummary{
-		Root: genesisStateRoot[:],
-		Slot: 0,
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, genesisSummary))
-
-	// Get last validated checkpoint
-	origCheckpoint, err := service.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, origCheckpoint))
-
-	// Optimistic finalized checkpoint
-	blk := util.NewBeaconBlock()
-	blk.Block.Slot = 320
-	blk.Block.ParentRoot = genesisRoot[:]
-	util.SaveBlock(t, ctx, beaconDB, blk)
-	opRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	opCheckpoint := &ethpb.Checkpoint{
-		Root:  opRoot[:],
-		Epoch: 10,
-	}
-	opStateSummary := &ethpb.StateSummary{
-		Root: opRoot[:],
-		Slot: 320,
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, opStateSummary))
-	tenjc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
-	tenfc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 320, opRoot, genesisRoot, params.BeaconConfig().ZeroHash, tenjc, tenfc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, opRoot))
-	require.NoError(t, service.updateFinalized(ctx, opCheckpoint))
-	cp, err := service.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-	require.DeepEqual(t, origCheckpoint.Root, cp.Root)
-	require.Equal(t, origCheckpoint.Epoch, cp.Epoch)
-
-	// Validated finalized checkpoint
-	blk = util.NewBeaconBlock()
-	blk.Block.Slot = 640
-	blk.Block.ParentRoot = opRoot[:]
-	util.SaveBlock(t, ctx, beaconDB, blk)
-	validRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	validCheckpoint := &ethpb.Checkpoint{
-		Root:  validRoot[:],
-		Epoch: 20,
-	}
-	validSummary := &ethpb.StateSummary{
-		Root: validRoot[:],
-		Slot: 640,
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, validSummary))
-	twentyjc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
-	twentyfc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 640, validRoot, genesisRoot, params.BeaconConfig().ZeroHash, twentyjc, twentyfc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, fcs.SetOptimisticToValid(ctx, validRoot))
-	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, validRoot))
-	require.NoError(t, service.updateFinalized(ctx, validCheckpoint))
-	cp, err = service.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-
-	optimistic, err := service.IsOptimisticForRoot(ctx, validRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, optimistic)
-	require.DeepEqual(t, validCheckpoint.Root, cp.Root)
-	require.Equal(t, validCheckpoint.Epoch, cp.Epoch)
-}
-
-func TestService_removeInvalidBlockAndState(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	// Deleting unknown block should not error.
-	require.NoError(t, service.removeInvalidBlockAndState(ctx, [][32]byte{{'a'}, {'b'}, {'c'}}))
-
-	// Happy case
-	b1 := util.NewBeaconBlock()
-	b1.Block.Slot = 1
-	blk1 := util.SaveBlock(t, ctx, service.cfg.BeaconDB, b1)
-	r1, err := blk1.Block().HashTreeRoot()
-	require.NoError(t, err)
-	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
-		Slot: 1,
-		Root: r1[:],
-	}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, r1))
-
-	b2 := util.NewBeaconBlock()
-	b2.Block.Slot = 2
-	blk2 := util.SaveBlock(t, ctx, service.cfg.BeaconDB, b2)
-	r2, err := blk2.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
-		Slot: 2,
-		Root: r2[:],
-	}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, r2))
-
-	require.NoError(t, service.removeInvalidBlockAndState(ctx, [][32]byte{r1, r2}))
-
-	require.Equal(t, false, service.hasBlock(ctx, r1))
-	require.Equal(t, false, service.hasBlock(ctx, r2))
-	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r1))
-	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r2))
-	has, err := service.cfg.StateGen.HasState(ctx, r1)
-	require.NoError(t, err)
-	require.Equal(t, false, has)
-	has, err = service.cfg.StateGen.HasState(ctx, r2)
-	require.NoError(t, err)
-	require.Equal(t, false, has)
-}
-
-func TestService_getPayloadHash(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	_, err = service.getPayloadHash(ctx, []byte{})
-	require.ErrorIs(t, errBlockNotFoundInCacheOrDB, err)
-
-	b := util.NewBeaconBlock()
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.saveInitSyncBlock(ctx, r, wsb))
-
-	h, err := service.getPayloadHash(ctx, r[:])
-	require.NoError(t, err)
-	require.DeepEqual(t, params.BeaconConfig().ZeroHash, h)
-
-	bb := util.NewBeaconBlockBellatrix()
-	h = [32]byte{'a'}
-	bb.Block.Body.ExecutionPayload.BlockHash = h[:]
-	r, err = b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(bb)
-	require.NoError(t, err)
-	require.NoError(t, service.saveInitSyncBlock(ctx, r, wsb))
-
-	h, err = service.getPayloadHash(ctx, r[:])
-	require.NoError(t, err)
-	require.DeepEqual(t, [32]byte{'a'}, h)
-}

beacon-chain/blockchain/head.go

@@ -6,136 +6,164 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
-// UpdateAndSaveHeadWithBalances updates the beacon state head after getting justified balanced from cache.
-// This function is only used in spec-tests, it does save the head after updating it.
-func (s *Service) UpdateAndSaveHeadWithBalances(ctx context.Context) error {
-	jp := s.CurrentJustifiedCheckpt()
+// This defines the current chain service's view of head.
+type head struct {
+	slot  types.Slot              // current head slot.
+	root  [32]byte                // current head root.
+	block block.SignedBeaconBlock // current head block.
+	state state.BeaconState       // current head state.
+}
 
-	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(jp.Root))
-	if err != nil {
-		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", jp.Root)
-		return errors.Wrap(err, msg)
+// Determined the head from the fork choice service and saves its new data
+// (head root, head block, and head state) to the local service cache.
+func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.updateHead")
+	defer span.End()
+
+	// To get the proper head update, a node first checks its best justified
+	// can become justified. This is designed to prevent bounce attack and
+	// ensure head gets its best justified info.
+	if s.bestJustifiedCheckpt.Epoch > s.justifiedCheckpt.Epoch {
+		s.justifiedCheckpt = s.bestJustifiedCheckpt
+		if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+			return err
+		}
 	}
-	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
-	if err != nil {
-		return errors.Wrap(err, "could not update head")
+
+	// Get head from the fork choice service.
+	f := s.finalizedCheckpt
+	j := s.justifiedCheckpt
+	// To get head before the first justified epoch, the fork choice will start with genesis root
+	// instead of zero hashes.
+	headStartRoot := bytesutil.ToBytes32(j.Root)
+	if headStartRoot == params.BeaconConfig().ZeroHash {
+		headStartRoot = s.genesisRoot
 	}
-	headBlock, err := s.getBlock(ctx, headRoot)
+
+	// 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
 	}
-	headState, err := s.cfg.StateGen.StateByRoot(ctx, headRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not retrieve head state in DB")
-	}
-	return s.saveHead(ctx, headRoot, headBlock, headState)
-}
 
-// This defines the current chain service's view of head.
-type head struct {
-	slot  types.Slot                   // current head slot.
-	root  [32]byte                     // current head root.
-	block interfaces.SignedBeaconBlock // current head block.
-	state state.BeaconState            // current head state.
+	// Save head to the local service cache.
+	return s.saveHead(ctx, headRoot)
 }
 
 // This saves head info to the local service cache, it also saves the
 // new head root to the DB.
-func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock interfaces.SignedBeaconBlock, headState state.BeaconState) error {
+func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.saveHead")
 	defer span.End()
 
 	// Do nothing if head hasn't changed.
-	var oldHeadRoot [32]byte
-	s.headLock.RLock()
-	if s.head == nil {
-		oldHeadRoot = s.originBlockRoot
-	} else {
-		oldHeadRoot = s.head.root
-	}
-	s.headLock.RUnlock()
-	if newHeadRoot == oldHeadRoot {
-		return nil
-	}
-	if err := wrapper.BeaconBlockIsNil(headBlock); err != nil {
+	r, err := s.HeadRoot(ctx)
+	if err != nil {
 		return err
 	}
-	if headState == nil || headState.IsNil() {
-		return errors.New("cannot save nil head state")
+	if headRoot == bytesutil.ToBytes32(r) {
+		return nil
 	}
 
 	// If the head state is not available, just return nil.
 	// There's nothing to cache
-	if !s.cfg.BeaconDB.HasStateSummary(ctx, newHeadRoot) {
+	if !s.cfg.BeaconDB.HasStateSummary(ctx, headRoot) {
 		return nil
 	}
 
+	// Get the new head block from DB.
+	newHeadBlock, err := s.cfg.BeaconDB.Block(ctx, headRoot)
+	if err != nil {
+		return err
+	}
+	if err := helpers.BeaconBlockIsNil(newHeadBlock); err != nil {
+		return err
+	}
+
+	// Get the new head state from cached state or 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 || 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.
-	s.headLock.RLock()
-	oldStateRoot := s.headBlock().Block().StateRoot()
-	s.headLock.RUnlock()
 	headSlot := s.HeadSlot()
-	newHeadSlot := headBlock.Block().Slot()
-	newStateRoot := headBlock.Block().StateRoot()
-	if bytesutil.ToBytes32(headBlock.Block().ParentRoot()) != oldHeadRoot {
+	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)
-		isOptimistic, err := s.IsOptimistic(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not check if node is optimistically synced")
-		}
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Reorg,
 			Data: &ethpbv1.EventChainReorg{
-				Slot:                newHeadSlot,
-				Depth:               absoluteSlotDifference,
-				OldHeadBlock:        oldHeadRoot[:],
-				NewHeadBlock:        newHeadRoot[:],
-				OldHeadState:        oldStateRoot,
-				NewHeadState:        newStateRoot,
-				Epoch:               slots.ToEpoch(newHeadSlot),
-				ExecutionOptimistic: isOptimistic,
+				Slot:         newHeadSlot,
+				Depth:        absoluteSlotDifference,
+				OldHeadBlock: oldHeadRoot[:],
+				NewHeadBlock: headRoot[:],
+				OldHeadState: oldStateRoot,
+				NewHeadState: newStateRoot,
+				Epoch:        slots.ToEpoch(newHeadSlot),
 			},
 		})
 
-		if err := s.saveOrphanedAtts(ctx, oldHeadRoot, newHeadRoot); err != nil {
+		if err := s.saveOrphanedAtts(ctx, bytesutil.ToBytes32(r)); err != nil {
 			return err
 		}
+
 		reorgCount.Inc()
 	}
 
 	// Cache the new head info.
-	s.setHead(newHeadRoot, headBlock, headState)
+	s.setHead(headRoot, newHeadBlock, newHeadState)
 
 	// Save the new head root to DB.
-	if err := s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, newHeadRoot); 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(ctx, newHeadSlot, headState, newStateRoot, newHeadRoot[:]); err != nil {
+		if err := s.notifyNewHeadEvent(newHeadSlot, newHeadState, newStateRoot, headRoot[:]); err != nil {
 			log.WithError(err).Error("Could not notify event feed of new chain head")
 		}
 	}()
@@ -146,8 +174,8 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 // This gets called to update canonical root mapping. It does not save head block
 // root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
 // check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
-func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.SignedBeaconBlock, r [32]byte, hs state.BeaconState) error {
-	if err := wrapper.BeaconBlockIsNil(b); err != nil {
+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)
@@ -163,7 +191,7 @@ func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.SignedBeaconBlo
 }
 
 // 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 interfaces.SignedBeaconBlock, state state.BeaconState) {
+func (s *Service) setHead(root [32]byte, block block.SignedBeaconBlock, state state.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
@@ -179,7 +207,7 @@ func (s *Service) setHead(root [32]byte, block interfaces.SignedBeaconBlock, sta
 // 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 interfaces.SignedBeaconBlock, state state.BeaconState) {
+func (s *Service) setHeadInitialSync(root [32]byte, block block.SignedBeaconBlock, state state.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
@@ -212,7 +240,7 @@ func (s *Service) headRoot() [32]byte {
 // This returns the head block.
 // It does a full copy on head block for immutability.
 // This is a lock free version.
-func (s *Service) headBlock() interfaces.SignedBeaconBlock {
+func (s *Service) headBlock() block.SignedBeaconBlock {
 	return s.head.block.Copy()
 }
 
@@ -220,16 +248,16 @@ func (s *Service) headBlock() interfaces.SignedBeaconBlock {
 // It does a full copy on head state for immutability.
 // This is a lock free version.
 func (s *Service) headState(ctx context.Context) state.BeaconState {
-	_, span := trace.StartSpan(ctx, "blockChain.headState")
+	ctx, span := trace.StartSpan(ctx, "blockChain.headState")
 	defer span.End()
 
 	return s.head.state.Copy()
 }
 
-// This returns the genesis validators root of the head state.
+// This returns the genesis validator root of the head state.
 // This is a lock free version.
-func (s *Service) headGenesisValidatorsRoot() [32]byte {
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
+func (s *Service) headGenesisValidatorRoot() [32]byte {
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
 }
 
 // This returns the validator referenced by the provided index in
@@ -239,30 +267,73 @@ func (s *Service) headValidatorAtIndex(index types.ValidatorIndex) (state.ReadOn
 	return s.head.state.ValidatorAtIndexReadOnly(index)
 }
 
-// This returns the validator index referenced by the provided pubkey in
-// the head state.
-// This is a lock free version.
-func (s *Service) headValidatorIndexAtPubkey(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool) {
-	return s.head.state.ValidatorIndexByPubkey(pubKey)
-}
-
 // Returns true if head state exists.
 // This is the lock free version.
 func (s *Service) hasHeadState() bool {
 	return s.head != nil && s.head.state != nil
 }
 
+// This caches justified state balances to be used for fork choice.
+func (s *Service) cacheJustifiedStateBalances(ctx context.Context, justifiedRoot [32]byte) error {
+	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+		return err
+	}
+
+	s.clearInitSyncBlocks()
+
+	var justifiedState state.BeaconState
+	var err error
+	if justifiedRoot == s.genesisRoot {
+		justifiedState, err = s.cfg.BeaconDB.GenesisState(ctx)
+		if err != nil {
+			return err
+		}
+	} else {
+		justifiedState, err = s.cfg.StateGen.StateByRoot(ctx, justifiedRoot)
+		if err != nil {
+			return err
+		}
+	}
+	if justifiedState == nil || justifiedState.IsNil() {
+		return errors.New("justified state can't be nil")
+	}
+
+	epoch := time.CurrentEpoch(justifiedState)
+
+	justifiedBalances := make([]uint64, justifiedState.NumValidators())
+	if err := justifiedState.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
+		if helpers.IsActiveValidatorUsingTrie(val, epoch) {
+			justifiedBalances[idx] = val.EffectiveBalance()
+		} else {
+			justifiedBalances[idx] = 0
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	s.justifiedBalancesLock.Lock()
+	defer s.justifiedBalancesLock.Unlock()
+	s.justifiedBalances = justifiedBalances
+	return nil
+}
+
+func (s *Service) getJustifiedBalances() []uint64 {
+	s.justifiedBalancesLock.RLock()
+	defer s.justifiedBalancesLock.RUnlock()
+	return s.justifiedBalances
+}
+
 // Notifies a common event feed of a new chain head event. Called right after a new
 // chain head is determined, set, and saved to disk.
 func (s *Service) notifyNewHeadEvent(
-	ctx context.Context,
 	newHeadSlot types.Slot,
 	newHeadState state.BeaconState,
 	newHeadStateRoot,
 	newHeadRoot []byte,
 ) error {
-	previousDutyDependentRoot := s.originBlockRoot[:]
-	currentDutyDependentRoot := s.originBlockRoot[:]
+	previousDutyDependentRoot := s.genesisRoot[:]
+	currentDutyDependentRoot := s.genesisRoot[:]
 
 	var previousDutyEpoch types.Epoch
 	currentDutyEpoch := slots.ToEpoch(newHeadSlot)
@@ -289,10 +360,6 @@ func (s *Service) notifyNewHeadEvent(
 			return errors.Wrap(err, "could not get duty dependent root")
 		}
 	}
-	isOptimistic, err := s.IsOptimistic(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not check if node is optimistically synced")
-	}
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.NewHead,
 		Data: &ethpbv1.EventHead{
@@ -302,54 +369,44 @@ func (s *Service) notifyNewHeadEvent(
 			EpochTransition:           slots.IsEpochStart(newHeadSlot),
 			PreviousDutyDependentRoot: previousDutyDependentRoot,
 			CurrentDutyDependentRoot:  currentDutyDependentRoot,
-			ExecutionOptimistic:       isOptimistic,
 		},
 	})
 	return nil
 }
 
-// This saves the attestations between `orphanedRoot` and the common ancestor root that is derived using `newHeadRoot`.
-// 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, newHeadRoot [32]byte) error {
-	commonAncestorRoot, err := s.ForkChoicer().CommonAncestorRoot(ctx, newHeadRoot, orphanedRoot)
-	switch {
-	// Exit early if there's no common ancestor and root doesn't exist, there would be nothing to save.
-	case errors.Is(err, forkchoice.ErrUnknownCommonAncestor):
+// 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
-	case err != nil:
+	}
+
+	orphanedBlk, err := s.cfg.BeaconDB.Block(ctx, orphanedRoot)
+	if err != nil {
 		return err
 	}
-	for orphanedRoot != commonAncestorRoot {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
 
-		orphanedBlk, err := s.getBlock(ctx, orphanedRoot)
-		if err != nil {
-			return err
-		}
-		// If the block is an epoch older, break out of the loop since we can't include atts anyway.
-		// This prevents stuck within this for loop longer than necessary.
-		if orphanedBlk.Block().Slot()+params.BeaconConfig().SlotsPerEpoch <= s.CurrentSlot() {
-			break
-		}
-		for _, a := range orphanedBlk.Block().Body().Attestations() {
-			// if the attestation is one epoch older, it wouldn't been useful to save it.
-			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()
-		}
-		orphanedRoot = bytesutil.ToBytes32(orphanedBlk.Block().ParentRoot())
+	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

@@ -5,6 +5,7 @@ import (
 	"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"
@@ -13,7 +14,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
@@ -130,7 +130,7 @@ func (s *Service) domainWithHeadState(ctx context.Context, slot types.Slot, doma
 	if err != nil {
 		return nil, err
 	}
-	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorsRoot())
+	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.
@@ -157,9 +157,11 @@ func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot types.Slot
 		if headState == nil || headState.IsNil() {
 			return nil, errors.New("nil state")
 		}
-		headState, err = transition.ProcessSlotsIfPossible(ctx, headState, slot)
-		if err != nil {
-			return nil, err
+		if slot > headState.Slot() {
+			headState, err = transition.ProcessSlots(ctx, headState, slot)
+			if err != nil {
+				return nil, err
+			}
 		}
 		syncHeadStateMiss.Inc()
 		err = syncCommitteeHeadStateCache.Put(slot, headState)

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -4,12 +4,12 @@ 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"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -122,7 +122,7 @@ func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
+	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)
@@ -136,7 +136,7 @@ func TestService_HeadSyncContributionProofDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorsRoot())
+	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)
@@ -150,7 +150,7 @@ func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorsRoot())
+	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)

beacon-chain/blockchain/head_test.go

@@ -3,21 +3,17 @@ package blockchain
 import (
 	"bytes"
 	"context"
-	"sort"
 	"testing"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	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"
@@ -31,10 +27,8 @@ func TestSaveHead_Same(t *testing.T) {
 
 	r := [32]byte{'A'}
 	service.head = &head{slot: 0, root: r}
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	st, _ := util.DeterministicGenesisState(t, 1)
-	require.NoError(t, service.saveHead(context.Background(), r, b, st))
+
+	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")
 }
@@ -44,14 +38,13 @@ func TestSaveHead_Different(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldBlock := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, util.NewBeaconBlock())
+	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)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, bytesutil.ToBytes32(oldBlock.Block().ParentRoot()), [32]byte{}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
 		slot:  0,
 		root:  oldRoot,
@@ -62,18 +55,15 @@ func TestSaveHead_Different(t *testing.T) {
 	newHeadSignedBlock.Block.Slot = 1
 	newHeadBlock := newHeadSignedBlock.Block
 
-	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, bytesutil.ToBytes32(wsb.Block().ParentRoot()), [32]byte{}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	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, wsb, headState))
+	require.NoError(t, service.saveHead(context.Background(), newRoot))
 
 	assert.Equal(t, types.Slot(1), service.HeadSlot(), "Head did not change")
 
@@ -90,14 +80,12 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldBlock := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, 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)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, bytesutil.ToBytes32(oldBlock.Block().ParentRoot()), [32]byte{}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
 		slot:  0,
 		root:  oldRoot,
@@ -110,18 +98,15 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
 	newHeadBlock := newHeadSignedBlock.Block
 
-	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, bytesutil.ToBytes32(wsb.Block().ParentRoot()), [32]byte{}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	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, wsb, headState))
+	require.NoError(t, service.saveHead(context.Background(), newRoot))
 
 	assert.Equal(t, types.Slot(1), service.HeadSlot(), "Head did not change")
 
@@ -138,15 +123,29 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 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, service.cacheJustifiedStateBalances(context.Background(), r))
+	require.DeepEqual(t, service.getJustifiedBalances(), 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)
-	require.DeepEqual(t, balances, state.Balances(), "Incorrect justified balances")
+
+	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) {
@@ -157,11 +156,11 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			cfg: &config{
 				StateNotifier: notifier,
 			},
-			originBlockRoot: [32]byte{1},
+			genesisRoot: [32]byte{1},
 		}
 		newHeadStateRoot := [32]byte{2}
 		newHeadRoot := [32]byte{3}
-		err := srv.notifyNewHeadEvent(context.Background(), 1, bState, newHeadStateRoot[:], newHeadRoot[:])
+		err := srv.notifyNewHeadEvent(1, bState, newHeadStateRoot[:], newHeadRoot[:])
 		require.NoError(t, err)
 		events := notifier.ReceivedEvents()
 		require.Equal(t, 1, len(events))
@@ -173,8 +172,8 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			Block:                     newHeadRoot[:],
 			State:                     newHeadStateRoot[:],
 			EpochTransition:           false,
-			PreviousDutyDependentRoot: srv.originBlockRoot[:],
-			CurrentDutyDependentRoot:  srv.originBlockRoot[:],
+			PreviousDutyDependentRoot: srv.genesisRoot[:],
+			CurrentDutyDependentRoot:  srv.genesisRoot[:],
 		}
 		require.DeepSSZEqual(t, wanted, eventHead)
 	})
@@ -186,7 +185,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			cfg: &config{
 				StateNotifier: notifier,
 			},
-			originBlockRoot: genesisRoot,
+			genesisRoot: genesisRoot,
 		}
 		epoch1Start, err := slots.EpochStart(1)
 		require.NoError(t, err)
@@ -196,7 +195,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 
 		newHeadStateRoot := [32]byte{2}
 		newHeadRoot := [32]byte{3}
-		err = srv.notifyNewHeadEvent(context.Background(), epoch2Start, bState, newHeadStateRoot[:], newHeadRoot[:])
+		err = srv.notifyNewHeadEvent(epoch2Start, bState, newHeadStateRoot[:], newHeadRoot[:])
 		require.NoError(t, err)
 		events := notifier.ReceivedEvents()
 		require.Equal(t, 1, len(events))
@@ -215,397 +214,54 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 	})
 }
 
-func TestSaveOrphanedAtts_NoCommonAncestor(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	service := setupBeaconChain(t, beaconDB)
-	service.genesisTime = time.Now().Add(time.Duration(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-
-	// Chain setup
-	// 0 -- 1 -- 2 -- 3
-	//    -4
-	st, keys := util.DeterministicGenesisState(t, 64)
-	blkG, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 0)
-	assert.NoError(t, err)
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, blkG)
-	rG, err := blkG.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk1, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	blk1.Block.ParentRoot = rG[:]
-	r1, err := blk1.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk2, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
-	assert.NoError(t, err)
-	blk2.Block.ParentRoot = r1[:]
-	r2, err := blk2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk3, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 3)
-	assert.NoError(t, err)
-	blk3.Block.ParentRoot = r2[:]
-	r3, err := blk3.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk4 := util.NewBeaconBlock()
-	blk4.Block.Slot = 4
-	r4, err := blk4.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
-		r, err := blk.Block.HashTreeRoot()
-		require.NoError(t, err)
-		ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-		ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
-		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
-		util.SaveBlock(t, ctx, beaconDB, blk)
-	}
-
-	require.NoError(t, service.saveOrphanedAtts(ctx, r3, r4))
-	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
-}
-
 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().Add(time.Duration(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
+	service.genesisTime = time.Now()
 
-	// Chain setup
-	// 0 -- 1 -- 2 -- 3
-	//  \-4
-	st, keys := util.DeterministicGenesisState(t, 64)
-	blkG, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 0)
-	assert.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	require.NoError(t, service.saveOrphanedAtts(ctx, r))
 
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, blkG)
-	rG, err := blkG.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk1, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	blk1.Block.ParentRoot = rG[:]
-	r1, err := blk1.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk2, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
-	assert.NoError(t, err)
-	blk2.Block.ParentRoot = r1[:]
-	r2, err := blk2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk3, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 3)
-	assert.NoError(t, err)
-	blk3.Block.ParentRoot = r2[:]
-	r3, err := blk3.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk4 := util.NewBeaconBlock()
-	blk4.Block.Slot = 4
-	blk4.Block.ParentRoot = rG[:]
-	r4, err := blk4.Block.HashTreeRoot()
-	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-
-	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
-		r, err := blk.Block.HashTreeRoot()
-		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
-		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
-		util.SaveBlock(t, ctx, beaconDB, blk)
-	}
-
-	require.NoError(t, service.saveOrphanedAtts(ctx, r3, r4))
-	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
-		blk3.Block.Body.Attestations[0],
-		blk2.Block.Body.Attestations[0],
-		blk1.Block.Body.Attestations[0],
-	}
-	atts := service.cfg.AttPool.AggregatedAttestations()
-	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
-	})
-	require.DeepEqual(t, wantAtts, atts)
+	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) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	service := setupBeaconChain(t, beaconDB)
-	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+2)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-
-	// Chain setup
-	// 0 -- 1 -- 2
-	//  \-4
-	st, keys := util.DeterministicGenesisState(t, 64)
-	blkG, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 0)
-	assert.NoError(t, err)
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, blkG)
-	rG, err := blkG.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk1, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	blk1.Block.ParentRoot = rG[:]
-	r1, err := blk1.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk2, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
-	assert.NoError(t, err)
-	blk2.Block.ParentRoot = r1[:]
-	r2, err := blk2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk4 := util.NewBeaconBlock()
-	blk4.Block.Slot = 4
-	blk4.Block.ParentRoot = rG[:]
-	r4, err := blk4.Block.HashTreeRoot()
-	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-
-	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk4} {
-		r, err := blk.Block.HashTreeRoot()
-		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
-		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
-		util.SaveBlock(t, ctx, beaconDB, blk)
-	}
-
-	require.NoError(t, service.saveOrphanedAtts(ctx, r2, r4))
-	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
-}
-
-func TestSaveOrphanedAtts_NoCommonAncestor_DoublyLinkedTrie(t *testing.T) {
 	resetCfg := features.InitWithReset(&features.Flags{
-		EnableForkChoiceDoublyLinkedTree: true,
+		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(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
+	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
 
-	// Chain setup
-	// 0 -- 1 -- 2 -- 3
-	//    -4
-	st, keys := util.DeterministicGenesisState(t, 64)
-	blkG, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 0)
-	assert.NoError(t, err)
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, blkG)
-	rG, err := blkG.Block.HashTreeRoot()
-	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	require.NoError(t, service.saveOrphanedAtts(ctx, r))
 
-	blk1, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	blk1.Block.ParentRoot = rG[:]
-	r1, err := blk1.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk2, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
-	assert.NoError(t, err)
-	blk2.Block.ParentRoot = r1[:]
-	r2, err := blk2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk3, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 3)
-	assert.NoError(t, err)
-	blk3.Block.ParentRoot = r2[:]
-	r3, err := blk3.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk4 := util.NewBeaconBlock()
-	blk4.Block.Slot = 4
-	r4, err := blk4.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
-		r, err := blk.Block.HashTreeRoot()
-		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
-		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
-		util.SaveBlock(t, ctx, beaconDB, blk)
-	}
-
-	require.NoError(t, service.saveOrphanedAtts(ctx, r3, r4))
 	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
-}
-
-func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnableForkChoiceDoublyLinkedTree: true,
-	})
-	defer resetCfg()
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	service := setupBeaconChain(t, beaconDB)
-	service.genesisTime = time.Now().Add(time.Duration(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-
-	// Chain setup
-	// 0 -- 1 -- 2 -- 3
-	//  \-4
-	st, keys := util.DeterministicGenesisState(t, 64)
-	blkG, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 0)
-	assert.NoError(t, err)
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, blkG)
-	rG, err := blkG.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk1, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	blk1.Block.ParentRoot = rG[:]
-	r1, err := blk1.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk2, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
-	assert.NoError(t, err)
-	blk2.Block.ParentRoot = r1[:]
-	r2, err := blk2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk3, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 3)
-	assert.NoError(t, err)
-	blk3.Block.ParentRoot = r2[:]
-	r3, err := blk3.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk4 := util.NewBeaconBlock()
-	blk4.Block.Slot = 4
-	blk4.Block.ParentRoot = rG[:]
-	r4, err := blk4.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
-		r, err := blk.Block.HashTreeRoot()
-		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
-		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
-		util.SaveBlock(t, ctx, beaconDB, blk)
-	}
-
-	require.NoError(t, service.saveOrphanedAtts(ctx, r3, r4))
-	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
-		blk3.Block.Body.Attestations[0],
-		blk2.Block.Body.Attestations[0],
-		blk1.Block.Body.Attestations[0],
-	}
-	atts := service.cfg.AttPool.AggregatedAttestations()
-	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
-	})
-	require.DeepEqual(t, wantAtts, atts)
-}
-
-func TestSaveOrphanedAtts_CanFilter_DoublyLinkedTrie(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnableForkChoiceDoublyLinkedTree: true,
-	})
-	defer resetCfg()
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	service := setupBeaconChain(t, beaconDB)
-	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+2)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-
-	// Chain setup
-	// 0 -- 1 -- 2
-	//  \-4
-	st, keys := util.DeterministicGenesisState(t, 64)
-	blkG, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 0)
-	assert.NoError(t, err)
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, blkG)
-	rG, err := blkG.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk1, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	blk1.Block.ParentRoot = rG[:]
-	r1, err := blk1.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk2, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 2)
-	assert.NoError(t, err)
-	blk2.Block.ParentRoot = r1[:]
-	r2, err := blk2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blk4 := util.NewBeaconBlock()
-	blk4.Block.Slot = 4
-	blk4.Block.ParentRoot = rG[:]
-	r4, err := blk4.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk4} {
-		r, err := blk.Block.HashTreeRoot()
-		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
-		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
-		util.SaveBlock(t, ctx, beaconDB, blk)
-	}
-
-	require.NoError(t, service.saveOrphanedAtts(ctx, r2, r4))
-	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
-}
-
-func TestUpdateHead_noSavedChanges(t *testing.T) {
-	ctx := context.Background()
-
-	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	ojp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, ojp, ojp)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
-
-	bellatrixBlk := util.SaveBlock(t, ctx, beaconDB, util.NewBeaconBlockBellatrix())
-	bellatrixBlkRoot, err := bellatrixBlk.Block().HashTreeRoot()
-	require.NoError(t, err)
-	fcp := &ethpb.Checkpoint{
-		Root:  bellatrixBlkRoot[:],
-		Epoch: 0,
-	}
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bellatrixBlkRoot))
-
-	bellatrixState, _ := util.DeterministicGenesisStateBellatrix(t, 2)
-	require.NoError(t, beaconDB.SaveState(ctx, bellatrixState, bellatrixBlkRoot))
-	service.cfg.StateGen.SaveFinalizedState(0, bellatrixBlkRoot, bellatrixState)
-
-	headRoot := service.headRoot()
-	require.Equal(t, [32]byte{}, headRoot)
-
-	st, blkRoot, err = prepareForkchoiceState(ctx, 0, bellatrixBlkRoot, [32]byte{}, [32]byte{}, fcp, fcp)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
-	newRoot, err := service.cfg.ForkChoiceStore.Head(ctx, []uint64{1, 2})
-	require.NoError(t, err)
-	require.NotEqual(t, headRoot, newRoot)
-	require.Equal(t, headRoot, service.headRoot())
+	savedAtts := service.cfg.AttPool.AggregatedAttestations()
+	atts := b.Block.Body.Attestations
+	require.DeepNotSSZEqual(t, atts, savedAtts)
 }

beacon-chain/blockchain/info.go

@@ -0,0 +1,99 @@
+package blockchain
+
+import (
+	"encoding/hex"
+	"fmt"
+	"net/http"
+
+	"github.com/emicklei/dot"
+	"github.com/prysmaticlabs/prysm/config/params"
+)
+
+const template = `<html>
+<head>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/viz.js/2.1.2/viz.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/viz.js/2.1.2/full.render.js"></script>
+<body>
+    <script type="application/javascript">
+        var graph = ` + "`%s`;" + `
+        var viz = new Viz();
+        viz.renderSVGElement(graph) // reading the graph.
+            .then(function(element) {
+                document.body.appendChild(element); // appends to document.
+            })
+            .catch(error => {
+                // Create a new Viz instance (@see Caveats page for more info)
+                viz = new Viz();
+                // Possibly display the error
+                console.error(error);
+            });
+    </script>
+</head>
+</body>
+</html>`
+
+// TreeHandler is a handler to serve /tree page in metrics.
+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.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(headState.Balances()))
+
+	for i := len(nodes) - 1; i >= 0; i-- {
+		// Construct label for each node.
+		slot := fmt.Sprintf("%d", nodes[i].Slot())
+		weight := fmt.Sprintf("%d", nodes[i].Weight()/1e9) // Convert unit Gwei to unit ETH.
+		votes := fmt.Sprintf("%d", nodes[i].Weight()/1e9/avgBalance)
+		index := fmt.Sprintf("%d", i)
+		g := nodes[i].Graffiti()
+		graffiti := hex.EncodeToString(g[:8])
+		label := "slot: " + slot + "\n votes: " + votes + "\n weight: " + weight + "\n graffiti: " + graffiti
+		var dotN dot.Node
+		if nodes[i].Parent() != ^uint64(0) {
+			dotN = graph.Node(index).Box().Attr("label", label)
+		}
+
+		if nodes[i].Slot() == s.HeadSlot() &&
+			nodes[i].BestDescendant() == ^uint64(0) &&
+			nodes[i].Parent() != ^uint64(0) {
+			dotN = dotN.Attr("color", "green")
+		}
+
+		dotNodes[i] = &dotN
+	}
+
+	for i := len(nodes) - 1; i >= 0; i-- {
+		if nodes[i].Parent() != ^uint64(0) && nodes[i].Parent() < uint64(len(dotNodes)) {
+			graph.Edge(*dotNodes[i], *dotNodes[nodes[i].Parent()])
+		}
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Header().Set("Content-Type", "text/html")
+	if _, err := fmt.Fprintf(w, template, graph.String()); err != nil {
+		log.WithError(err).Error("Failed to render p2p info page")
+	}
+}
+
+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}))
+	cfg := &config{
+		BeaconDB: beaconDB,
+		ForkChoiceStore: protoarray.New(
+			0, // justifiedEpoch
+			0, // finalizedEpoch
+			[32]byte{'a'},
+		),
+		StateGen: stategen.New(beaconDB),
+	}
+	s, err := NewService(ctx)
+	require.NoError(t, err)
+	s.cfg = cfg
+	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,27 +1,14 @@
 package blockchain
 
 import (
-	"context"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 )
 
-// This saves a beacon block to the initial sync blocks cache. It rate limits how many blocks
-// the cache keeps in memory (2 epochs worth of blocks) and saves them to DB when it hits this limit.
-func (s *Service) saveInitSyncBlock(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock) error {
+// This saves a beacon block to the initial sync blocks cache.
+func (s *Service) saveInitSyncBlock(r [32]byte, b block.SignedBeaconBlock) {
 	s.initSyncBlocksLock.Lock()
+	defer s.initSyncBlocksLock.Unlock()
 	s.initSyncBlocks[r] = b
-	numBlocks := len(s.initSyncBlocks)
-	s.initSyncBlocksLock.Unlock()
-	if uint64(numBlocks) > initialSyncBlockCacheSize {
-		if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-			return err
-		}
-		s.clearInitSyncBlocks()
-	}
-	return nil
 }
 
 // This checks if a beacon block exists in the initial sync blocks cache using the root
@@ -33,42 +20,22 @@ func (s *Service) hasInitSyncBlock(r [32]byte) bool {
 	return ok
 }
 
-// Returns true if a block for root `r` exists in the initial sync blocks cache or the DB.
-func (s *Service) hasBlockInInitSyncOrDB(ctx context.Context, r [32]byte) bool {
-	if s.hasInitSyncBlock(r) {
-		return true
-	}
-	return s.cfg.BeaconDB.HasBlock(ctx, r)
-}
-
-// Returns block for a given root `r` from either the initial sync blocks cache or the DB.
-// Error is returned if the block is not found in either cache or DB.
-func (s *Service) getBlock(ctx context.Context, r [32]byte) (interfaces.SignedBeaconBlock, error) {
+// This retrieves a beacon block from the initial sync blocks cache using the root of
+// the block.
+func (s *Service) getInitSyncBlock(r [32]byte) block.SignedBeaconBlock {
 	s.initSyncBlocksLock.RLock()
-
-	// Check cache first because it's faster.
-	b, ok := s.initSyncBlocks[r]
-	s.initSyncBlocksLock.RUnlock()
-	var err error
-	if !ok {
-		b, err = s.cfg.BeaconDB.Block(ctx, r)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not retrieve block from db")
-		}
-	}
-	if err := wrapper.BeaconBlockIsNil(b); err != nil {
-		return nil, errBlockNotFoundInCacheOrDB
-	}
-	return b, nil
+	defer s.initSyncBlocksLock.RUnlock()
+	b := s.initSyncBlocks[r]
+	return b
 }
 
 // This retrieves all the beacon blocks from the initial sync blocks cache, the returned
 // blocks are unordered.
-func (s *Service) getInitSyncBlocks() []interfaces.SignedBeaconBlock {
+func (s *Service) getInitSyncBlocks() []block.SignedBeaconBlock {
 	s.initSyncBlocksLock.RLock()
 	defer s.initSyncBlocksLock.RUnlock()
 
-	blks := make([]interfaces.SignedBeaconBlock, 0, len(s.initSyncBlocks))
+	blks := make([]block.SignedBeaconBlock, 0, len(s.initSyncBlocks))
 	for _, b := range s.initSyncBlocks {
 		blks = append(blks, b)
 	}
@@ -79,5 +46,5 @@ func (s *Service) getInitSyncBlocks() []interfaces.SignedBeaconBlock {
 func (s *Service) clearInitSyncBlocks() {
 	s.initSyncBlocksLock.Lock()
 	defer s.initSyncBlocksLock.Unlock()
-	s.initSyncBlocks = make(map[[32]byte]interfaces.SignedBeaconBlock)
+	s.initSyncBlocks = make(map[[32]byte]block.SignedBeaconBlock)
 }

beacon-chain/blockchain/init_sync_process_block_test.go

@@ -1,68 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestService_getBlock(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	s := setupBeaconChain(t, beaconDB)
-	b1 := util.NewBeaconBlock()
-	r1, err := b1.Block.HashTreeRoot()
-	require.NoError(t, err)
-	b2 := util.NewBeaconBlock()
-	b2.Block.Slot = 100
-	r2, err := b2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// block not found
-	_, err = s.getBlock(ctx, [32]byte{})
-	require.ErrorIs(t, err, errBlockNotFoundInCacheOrDB)
-
-	// block in cache
-	b, err := wrapper.WrappedSignedBeaconBlock(b1)
-	require.NoError(t, err)
-	s.saveInitSyncBlock(ctx, r1, b)
-	got, err := s.getBlock(ctx, r1)
-	require.NoError(t, err)
-	require.DeepEqual(t, b, got)
-
-	// block in db
-	b = util.SaveBlock(t, ctx, s.cfg.BeaconDB, b2)
-	got, err = s.getBlock(ctx, r2)
-	require.NoError(t, err)
-	require.DeepEqual(t, b, got)
-}
-
-func TestService_hasBlockInInitSyncOrDB(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	s := setupBeaconChain(t, beaconDB)
-	b1 := util.NewBeaconBlock()
-	r1, err := b1.Block.HashTreeRoot()
-	require.NoError(t, err)
-	b2 := util.NewBeaconBlock()
-	b2.Block.Slot = 100
-	r2, err := b2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// block not found
-	require.Equal(t, false, s.hasBlockInInitSyncOrDB(ctx, [32]byte{}))
-
-	// block in cache
-	b, err := wrapper.WrappedSignedBeaconBlock(b1)
-	require.NoError(t, err)
-	s.saveInitSyncBlock(ctx, r1, b)
-	require.Equal(t, true, s.hasBlockInInitSyncOrDB(ctx, r1))
-
-	// block in db
-	util.SaveBlock(t, ctx, s.cfg.BeaconDB, b2)
-	require.Equal(t, true, s.hasBlockInInitSyncOrDB(ctx, r2))
-}

beacon-chain/blockchain/init_test.go

@@ -6,7 +6,7 @@ import (
 
 func init() {
 	// Override network name so that hardcoded genesis files are not loaded.
-	if err := params.SetActive(params.MainnetTestConfig()); err != nil {
-		panic(err)
-	}
+	cfg := params.BeaconConfig()
+	cfg.ConfigName = "test"
+	params.OverrideBeaconConfig(cfg)
 }

beacon-chain/blockchain/log.go

@@ -5,12 +5,9 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -20,7 +17,7 @@ import (
 var log = logrus.WithField("prefix", "blockchain")
 
 // logs state transition related data every slot.
-func logStateTransitionData(b interfaces.BeaconBlock) error {
+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()))
@@ -37,75 +34,35 @@ func logStateTransitionData(b interfaces.BeaconBlock) error {
 	if len(b.Body().VoluntaryExits()) > 0 {
 		log = log.WithField("voluntaryExits", len(b.Body().VoluntaryExits()))
 	}
-	if b.Version() == version.Altair || b.Version() == version.Bellatrix {
+	if b.Version() == version.Altair {
 		agg, err := b.Body().SyncAggregate()
-		if err != nil {
-			return err
+		if err == nil {
+			log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
 		}
-		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
-	}
-	if b.Version() == version.Bellatrix {
-		p, err := b.Body().ExecutionPayload()
-		if err != nil {
-			return err
-		}
-		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash)))
-		log = log.WithField("txCount", len(p.Transactions))
 	}
+	// TODO_MERGE: Add payload logging here
 	log.Info("Finished applying state transition")
-	return nil
 }
 
-func logBlockSyncStatus(block interfaces.BeaconBlock, blockRoot [32]byte, justified, finalized *ethpb.Checkpoint, receivedTime time.Time, genesisTime uint64) error {
+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 {
 		return err
 	}
-	level := log.Logger.GetLevel()
-
-	log = log.WithField("slot", block.Slot())
-	if level >= logrus.DebugLevel {
-		log = log.WithField("slotInEpoch", block.Slot()%params.BeaconConfig().SlotsPerEpoch)
-		log = log.WithField("justifiedEpoch", justified.Epoch)
-		log = log.WithField("justifiedRoot", fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]))
-		log = log.WithField("parentRoot", fmt.Sprintf("0x%s...", hex.EncodeToString(block.ParentRoot())[:8]))
-		log = log.WithField("version", version.String(block.Version()))
-		log = log.WithField("sinceSlotStartTime", prysmTime.Now().Sub(startTime))
-		log = log.WithField("chainServiceProcessedTime", prysmTime.Now().Sub(receivedTime))
-	}
-
 	log.WithFields(logrus.Fields{
-		"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+		"slot":           block.Slot(),
+		"slotInEpoch":    block.Slot() % params.BeaconConfig().SlotsPerEpoch,
+		"blockRoot":      fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+		"parentRoot":     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]),
+		"version":        version.String(block.Version()),
 	}).Info("Synced new block")
-	return nil
-}
-
-// logs payload related data every slot.
-func logPayload(block interfaces.BeaconBlock) error {
-	isExecutionBlk, err := blocks.IsExecutionBlock(block.Body())
-	if err != nil {
-		return errors.Wrap(err, "could not determine if block is execution block")
-	}
-	if !isExecutionBlk {
-		return nil
-	}
-	payload, err := block.Body().ExecutionPayload()
-	if err != nil {
-		return err
-	}
-	if payload.GasLimit == 0 {
-		return errors.New("gas limit should not be 0")
-	}
-	gasUtilized := float64(payload.GasUsed) / float64(payload.GasLimit)
-
 	log.WithFields(logrus.Fields{
-		"blockHash":   fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
-		"parentHash":  fmt.Sprintf("%#x", bytesutil.Trunc(payload.ParentHash)),
-		"blockNumber": payload.BlockNumber,
-		"gasUtilized": fmt.Sprintf("%.2f", gasUtilized),
-	}).Debug("Synced new payload")
+		"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

@@ -3,107 +3,63 @@ package blockchain
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	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) {
-	payloadBlk := &ethpb.BeaconBlockBellatrix{
-		Body: &ethpb.BeaconBlockBodyBellatrix{
-			SyncAggregate: &ethpb.SyncAggregate{},
-			ExecutionPayload: &enginev1.ExecutionPayload{
-				BlockHash:    []byte{1, 2, 3},
-				Transactions: [][]byte{{}, {}},
-			},
-		},
-	}
-	wrappedPayloadBlk, err := wrapper.WrappedBeaconBlock(payloadBlk)
-	require.NoError(t, err)
 	tests := []struct {
 		name string
-		b    func() interfaces.BeaconBlock
+		b    block.BeaconBlock
 		want string
 	}{
 		{name: "empty block body",
-			b: func() interfaces.BeaconBlock {
-				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}})
-				require.NoError(t, err)
-				return wb
-			},
+			b:    wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}),
 			want: "\"Finished applying state transition\" prefix=blockchain slot=0",
 		},
 		{name: "has attestation",
-			b: func() interfaces.BeaconBlock {
-				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Attestations: []*ethpb.Attestation{{}}}})
-				require.NoError(t, err)
-				return wb
-			},
+			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: func() interfaces.BeaconBlock {
-				wb, err := wrapper.WrappedBeaconBlock(
-					&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-						Attestations: []*ethpb.Attestation{{}},
-						Deposits:     []*ethpb.Deposit{{}}}})
-				require.NoError(t, err)
-				return wb
-			},
+			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: func() interfaces.BeaconBlock {
-				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-					AttesterSlashings: []*ethpb.AttesterSlashing{{}}}})
-				require.NoError(t, err)
-				return wb
-			},
+			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: func() interfaces.BeaconBlock {
-				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-					ProposerSlashings: []*ethpb.ProposerSlashing{{}}}})
-				require.NoError(t, err)
-				return wb
-			},
+			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: func() interfaces.BeaconBlock {
-				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-					VoluntaryExits: []*ethpb.SignedVoluntaryExit{{}}}})
-				require.NoError(t, err)
-				return wb
-			},
+			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: func() interfaces.BeaconBlock {
-				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-					Attestations:      []*ethpb.Attestation{{}},
-					Deposits:          []*ethpb.Deposit{{}},
-					AttesterSlashings: []*ethpb.AttesterSlashing{{}},
-					ProposerSlashings: []*ethpb.ProposerSlashing{{}},
-					VoluntaryExits:    []*ethpb.SignedVoluntaryExit{{}}}})
-				require.NoError(t, err)
-				return wb
-			},
+			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",
 		},
-		{name: "has payload",
-			b:    func() interfaces.BeaconBlock { return wrappedPayloadBlk },
-			want: "\"Finished applying state transition\" payloadHash=0x010203 prefix=blockchain slot=0 syncBitsCount=0 txCount=2",
-		},
 	}
 	for _, tt := range tests {
 		hook := logTest.NewGlobal()
 		t.Run(tt.name, func(t *testing.T) {
-			require.NoError(t, logStateTransitionData(tt.b()))
+			logStateTransitionData(tt.b)
 			require.LogsContain(t, hook, tt.want)
 		})
 	}

beacon-chain/blockchain/merge_ascii_art.go

@@ -1,81 +0,0 @@
-package blockchain
-
-var mergeAsciiArt = `                                                                                                                                                  	                                                                                                                                                      
-		                                                                                                                                                      
-		                                 +?$$$$$$?*;                         ;*?$$$$?*;                         +!$$$$$$?!;                                   
-		                                 !##$???$@##$+                      !&#@$??$&#@*                      +@#&$????$##+                                   
-		                                 !##;     +@#&;                    !##*     ;$##*                     @#$      ;&#+                                   
-		                                 !##;      !##+                   ;##$        @#@                     $#&*      ++;                                   
-		                                 !##;     ;@#&;                   *##*        ?##;                    ;$##&$!+;                                       
-		                                 !##?!!!?$##$+                    !##+        !##+                      ;!$@##&$!;                                    
-		                                 !##@@@@$$!+                      *##*        ?##;                          ;*?@#&!                                   
-		                                 !##;                             ;##$        @#@                    ;?$;       ?##+                                  
-		                                 !##;                              ?##!     ;?##+                    ;##+      ;$#&;                                  
-		                                 !##;                               !&#&$??$&#@*                     ;&#&$$??$$&#@+                                   
-		                                 +??;                                ;*?$$$$?+                        ;+!?$$$$$!+                                     
-		                                                                                                ;;;;                                                  
-		                                      ;+!??$$$?!*+;                                       ;*?$@&&&&&@@$!*;                                            
-		                                   *?@############&$?+                                 ;!@###############&$!;                                         
-		                                ;!@####&@$????$$@#####@!                             ;?&####$?*++;++*!?@####&?;                                       
-		                               *@###&$*;         ;*$&###@*                          *&###@!;            ;!@###&!                                      
-		                              !###&!;               ;?&###?                        *####!                  *&###?                                     
-		                             !###@+                   ;$###$                      +###&+                    ;$###?                                    
-		                            ;###&;                      $###?   ;;+*!??$$$$$$$$??!$###*                      ;@###*                                   
-		                            !###!                        &###?$@&#####################@$?!+;                  +###$                                   
-		                            $###+                     ;*?&#################################&$?*;               &##&;                                  
-		                            $###+                  ;!$&########################################&$!;            &###;                                  
-		                            *###?               ;!$################################################$*;        +###@                                   
-		                            ;@###+            +$&####################################################&?;      $###!                                   
-		                             +###&+         *$##########################################################$+  ;$###$;                                   
-		                              *&###?;     +$##############################################################?*@###$;                                    
-		                               +$###&?+ ;$#####################################################################?;                                     
-		                                 *@####@&#####################################################################*                                       
-		                                   +$&##################@?!*++*!$&###################&$?*++*!?$###############&*                                      
-		                                     $###############&?+         ;!@###############@!;         ;!@##############!                                     
-		                                   ;$##############&!;              *&###########&!;              !&#############!                                    
-		                                   $##############@+    +@*          ;$#########$;          +@*    ;$#############!                                   
-		                                  ?##############$;    *###*           $#######$;          +&##!     ?#############+                                  
-		                                 +##############$     !#####!           $#####@;          *#####?     ?############@;                                 
-		                                 @#############@;    !#######!          ;&####+          *#######?     $############?                                 
-		                                +##############+    ?#########?          $###$          !#########$    +############&;                                
-		                                $#############$   ;$###########?         !###?         !###########$;   $############!                                
-		                                @#############*   !#############!        ?###$        *#############?   +############@                                
-		                               ;&############&;    +?@#######&$+;       ;&####;       ;+?@#######&?+;    @############;                               
-		                               ;#############@        +$&#&$*;         ;$#####@;          +$&#&$*;       $############+                               
-		                               ;#############$    *+    ;+;   ;*;     *&#######&!     ;*;   ;+;    +*;   $############*                               
-		                                &############@    ;$@!;     +$@!    ;?###########$;    *@$*     ;*$@+    $############*                               
-		                                $############&;    ;$#&$*+!@##*    +@#############@+    +&#@?++$&#@;     @############+                               
-		                                *#############*      $######&+    !#################?    +@######$;     +#############;                               
-		                                 @############$       ?####@+   ;$###################$;   ;@####$       $############@                                
-		                                 *#############*       !##@;   +@#####################&*   ;$##?       +#############!                                
-		                                  $#############+       *$;   ?#########################?;   $!       +&############&;                                
-		                                  ;&#############!          +$###########################@+          *&#############?                                 
-		                                   +##############$*;     ;?###############################$+      *$##############@;                                 
-		                                    *###############&$?!!$###################################$?!?$&################+                                  
-		                                     *###################################&@$$$$@&#################################!                                   
-		                                      +&##############################&?+;      ;+?&#############################?                                    
-		                                       ;$############################@;            ;@###########################!                                     
-		                                         ?###########################*              *##########################*                                      
-		                                          +@#############&$!+$#######?              ?########$+!$&###########@+                                       
-		                                            !&###########&;   $#######$+          +$########?   +&##########?;                                        
-		                                             ;?###########&*   *@#######@$!;   ;$@########@*   *##########$+                                          
-		                                               ;?&##########?;  ;*$&####&$*    ;!$&####&$*   ;$#########@*                                            
-		                                                 ;!@#########@!;   ;++*+;   ;*;   ;+*++;   ;!&########$*                                              
-		                                                    *$&########&$*;      ;*$&#&$*;      +*$&#######&?+                                                
-		                                                      ;*$&#########&@$$@&#########&@$$@&########&$*;                                                  
-		                                                         ;+?$&##############################&$?+;                                                     
-		                                                             ;+!?$@&###################&$$!+;                                                         
-		                                                                   ;++*!??$$$$$$$?!!*+;                                                               
-		                                                                                                                                                      
-		                  ;;;           ;;+*++;   ;;;++;;;++;;;  ;+++;;;++++; ;;;         ;;      ;;;      ;;;++;;;+++;;   ;;;+++++++;   ;+++++;              
-		                 ;@#&+        +$&&@$@&#?  @#@@@&#&@@@#$ ;$@@@@#&@@@@! !#@        !#$     +&#&;     !#&@@@#&@@@&&;  !#&@@@@@@@*   $#&@@@&&$+           
-		                 $#?#@;      ?#&!;   *#$  &&;;;$#!;;*#$   ;;;*#@;;;;   $#?      +#&;    ;@#?#$     !#!;;*#@;;;@#;  ?#$;;;;;;;    @#*   ;!&#?          
-		                *#$ ?#$     *#&;     ;+;  ++   $#!  ;+;      *#$       ;&#+     $#*     ?#? $#!    ;+;  +#@   ++   ?#$           $#*     ;&#*         
-		               ;&&;  @#*    $#$                $#!           *#$        !#@;   !#$     +#@  ;&#;        +#@        ?#@??????!    $#*      $#$         
-		               $#!;;;*#&;   $#?                $#!           *#$         $#?  ;&&;    ;@#*;;;!#$        +#@        ?#@??????!    $#*      $#$         
-		              !##@@@@@&#$   !#@;               $#!           *#$         ;&#+ $#*     ?#&@@@@@##!       +#@        ?#$           $#*      @#*         
-		             ;&&+;;;;;;@#*  ;$#$+     @$       $#!           *#$          *#@!#?     *#@;;;;;;+##+      +#@        ?#$           $#*    +$#$          
-		             $#*       +#&;  ;?&#@$$$$#$    +$$&#@$$;   ;$$$$@##$$$$*      $##@;    ;&#+       !#@;   $$@##$$*     ?#&$$$$$$$!   @#@$$$@&@!           
-		            ;**         +*;     +*!?!*+;    ;*******    ;***********+      ;**;     ;*+         **;   *******+     ;*********+   +*!!!!*;             
-		                                                                                                                                                      	                                                                                                                                                      
-`

beacon-chain/blockchain/metrics.go

@@ -6,14 +6,14 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
@@ -130,38 +130,6 @@ var (
 		Name: "sync_head_state_hit",
 		Help: "The number of sync head state requests that are present in the cache.",
 	})
-	stateBalanceCacheHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "state_balance_cache_hit",
-		Help: "Count the number of state balance cache hits.",
-	})
-	stateBalanceCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "state_balance_cache_miss",
-		Help: "Count the number of state balance cache hits.",
-	})
-	newPayloadValidNodeCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "new_payload_valid_node_count",
-		Help: "Count the number of valid nodes after newPayload EE call",
-	})
-	newPayloadOptimisticNodeCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "new_payload_optimistic_node_count",
-		Help: "Count the number of optimistic nodes after newPayload EE call",
-	})
-	newPayloadInvalidNodeCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "new_payload_invalid_node_count",
-		Help: "Count the number of invalid nodes after newPayload EE call",
-	})
-	forkchoiceUpdatedValidNodeCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "forkchoice_updated_valid_node_count",
-		Help: "Count the number of valid nodes after forkchoiceUpdated EE call",
-	})
-	forkchoiceUpdatedOptimisticNodeCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "forkchoice_updated_optimistic_node_count",
-		Help: "Count the number of optimistic nodes after forkchoiceUpdated EE call",
-	})
-	missedPayloadIDFilledCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "missed_payload_id_filled_count",
-		Help: "",
-	})
 )
 
 // reportSlotMetrics reports slot related metrics.
@@ -277,7 +245,16 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 		if err != nil {
 			return err
 		}
-	case version.Altair, version.Bellatrix:
+	case version.Altair:
+		v, b, err = altair.InitializePrecomputeValidators(ctx, headState)
+		if err != nil {
+			return err
+		}
+		_, b, err = altair.ProcessEpochParticipation(ctx, headState, b, v)
+		if err != nil {
+			return err
+		}
+	case version.Merge:
 		v, b, err = altair.InitializePrecomputeValidators(ctx, headState)
 		if err != nil {
 			return err
@@ -302,7 +279,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	return nil
 }
 
-func reportAttestationInclusion(blk interfaces.BeaconBlock) {
+func reportAttestationInclusion(blk block.BeaconBlock) {
 	for _, att := range blk.Body().Attestations() {
 		attestationInclusionDelay.Observe(float64(blk.Slot() - att.Data.Slot))
 	}

beacon-chain/blockchain/mock_test.go

@@ -1,50 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"errors"
-	"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"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-)
-
-func testServiceOptsWithDB(t *testing.T) []Option {
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	return []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-}
-
-// WARNING: only use these opts when you are certain there are no db calls
-// in your code path. this is a lightweight way to satisfy the stategen/beacondb
-// initialization requirements w/o the overhead of db init.
-func testServiceOptsNoDB() []Option {
-	return []Option{
-		withStateBalanceCache(satisfactoryStateBalanceCache()),
-	}
-}
-
-type mockStateByRooter struct {
-	state state.BeaconState
-	err   error
-}
-
-var _ stateByRooter = &mockStateByRooter{}
-
-func (m mockStateByRooter) StateByRoot(_ context.Context, _ [32]byte) (state.BeaconState, error) {
-	return m.state, m.err
-}
-
-// returns an instance of the state balance cache that can be used
-// to satisfy the requirement for one in NewService, but which will
-// always return an error if used.
-func satisfactoryStateBalanceCache() *stateBalanceCache {
-	err := errors.New("satisfactoryStateBalanceCache doesn't perform real caching")
-	return &stateBalanceCache{stateGen: mockStateByRooter{err: err}}
-}

beacon-chain/blockchain/options.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"github.com/prysmaticlabs/prysm/async/event"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
@@ -12,7 +11,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
@@ -52,7 +50,7 @@ func WithChainStartFetcher(f powchain.ChainStartFetcher) Option {
 }
 
 // WithExecutionEngineCaller to call execution engine.
-func WithExecutionEngineCaller(c powchain.EngineCaller) Option {
+func WithExecutionEngineCaller(c powchain.ExecutionEngineCaller) Option {
 	return func(s *Service) error {
 		s.cfg.ExecutionEngineCaller = c
 		return nil
@@ -67,14 +65,6 @@ func WithDepositCache(c *depositcache.DepositCache) Option {
 	}
 }
 
-// WithProposerIdsCache for proposer id cache.
-func WithProposerIdsCache(c *cache.ProposerPayloadIDsCache) Option {
-	return func(s *Service) error {
-		s.cfg.ProposerSlotIndexCache = c
-		return nil
-	}
-}
-
 // WithAttestationPool for attestation lifecycle after chain inclusion.
 func WithAttestationPool(p attestations.Pool) Option {
 	return func(s *Service) error {
@@ -146,18 +136,3 @@ func WithSlasherAttestationsFeed(f *event.Feed) Option {
 		return nil
 	}
 }
-
-func withStateBalanceCache(c *stateBalanceCache) Option {
-	return func(s *Service) error {
-		s.justifiedBalances = c
-		return nil
-	}
-}
-
-// WithFinalizedStateAtStartUp to store finalized state at start up.
-func WithFinalizedStateAtStartUp(st state.BeaconState) Option {
-	return func(s *Service) error {
-		s.cfg.FinalizedStateAtStartUp = st
-		return nil
-	}
-}

beacon-chain/blockchain/pow_block.go

@@ -1,144 +0,0 @@
-package blockchain
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/holiman/uint256"
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	"github.com/sirupsen/logrus"
-)
-
-// validateMergeBlock validates terminal block hash in the event of manual overrides before checking for total difficulty.
-//
-// def validate_merge_block(block: BeaconBlock) -> None:
-//    if TERMINAL_BLOCK_HASH != Hash32():
-//        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
-//        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
-//        assert block.body.execution_payload.parent_hash == TERMINAL_BLOCK_HASH
-//        return
-//
-//    pow_block = get_pow_block(block.body.execution_payload.parent_hash)
-//    # Check if `pow_block` is available
-//    assert pow_block is not None
-//    pow_parent = get_pow_block(pow_block.parent_hash)
-//    # Check if `pow_parent` is available
-//    assert pow_parent is not None
-//    # Check if `pow_block` is a valid terminal PoW block
-//    assert is_valid_terminal_pow_block(pow_block, pow_parent)
-func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.SignedBeaconBlock) error {
-	if err := wrapper.BeaconBlockIsNil(b); err != nil {
-		return err
-	}
-	payload, err := b.Block().Body().ExecutionPayload()
-	if err != nil {
-		return err
-	}
-	if payload == nil {
-		return errors.New("nil execution payload")
-	}
-	if err := validateTerminalBlockHash(b.Block().Slot(), payload); err != nil {
-		return errors.Wrap(err, "could not validate terminal block hash")
-	}
-	mergeBlockParentHash, mergeBlockTD, err := s.getBlkParentHashAndTD(ctx, payload.ParentHash)
-	if err != nil {
-		return errors.Wrap(err, "could not get merge block parent hash and total difficulty")
-	}
-	_, mergeBlockParentTD, err := s.getBlkParentHashAndTD(ctx, mergeBlockParentHash)
-	if err != nil {
-		return errors.Wrap(err, "could not get merge parent block total difficulty")
-	}
-	valid, err := validateTerminalBlockDifficulties(mergeBlockTD, mergeBlockParentTD)
-	if err != nil {
-		return err
-	}
-	if !valid {
-		err := fmt.Errorf("invalid TTD, configTTD: %s, currentTTD: %s, parentTTD: %s",
-			params.BeaconConfig().TerminalTotalDifficulty, mergeBlockTD, mergeBlockParentTD)
-		return invalidBlock{err}
-	}
-
-	log.WithFields(logrus.Fields{
-		"slot":                            b.Block().Slot(),
-		"mergeBlockHash":                  common.BytesToHash(payload.ParentHash).String(),
-		"mergeBlockParentHash":            common.BytesToHash(mergeBlockParentHash).String(),
-		"terminalTotalDifficulty":         params.BeaconConfig().TerminalTotalDifficulty,
-		"mergeBlockTotalDifficulty":       mergeBlockTD,
-		"mergeBlockParentTotalDifficulty": mergeBlockParentTD,
-	}).Info("Validated terminal block")
-
-	log.Info(mergeAsciiArt)
-
-	return nil
-}
-
-// getBlkParentHashAndTD retrieves the parent hash and total difficulty of the given block.
-func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]byte, *uint256.Int, error) {
-	blk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(blkHash))
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get pow block")
-	}
-	if blk == nil {
-		return nil, nil, errors.New("pow block is nil")
-	}
-	blkTDBig, err := hexutil.DecodeBig(blk.TotalDifficulty)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not decode merge block total difficulty")
-	}
-	blkTDUint256, overflows := uint256.FromBig(blkTDBig)
-	if overflows {
-		return nil, nil, errors.New("total difficulty overflows")
-	}
-	return blk.ParentHash, blkTDUint256, nil
-}
-
-// validateTerminalBlockHash validates if the merge block is a valid terminal PoW block.
-// spec code:
-// if TERMINAL_BLOCK_HASH != Hash32():
-//        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
-//        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
-//        assert block.body.execution_payload.parent_hash == TERMINAL_BLOCK_HASH
-//        return
-func validateTerminalBlockHash(blkSlot types.Slot, payload *enginev1.ExecutionPayload) error {
-	if bytesutil.ToBytes32(params.BeaconConfig().TerminalBlockHash.Bytes()) == [32]byte{} {
-		return nil
-	}
-	if params.BeaconConfig().TerminalBlockHashActivationEpoch > slots.ToEpoch(blkSlot) {
-		return errors.New("terminal block hash activation epoch not reached")
-	}
-	if !bytes.Equal(payload.ParentHash, params.BeaconConfig().TerminalBlockHash.Bytes()) {
-		return errors.New("parent hash does not match terminal block hash")
-	}
-	return nil
-}
-
-// validateTerminalBlockDifficulties validates terminal pow block by comparing own total difficulty with parent's total difficulty.
-//
-// def is_valid_terminal_pow_block(block: PowBlock, parent: PowBlock) -> bool:
-//    is_total_difficulty_reached = block.total_difficulty >= TERMINAL_TOTAL_DIFFICULTY
-//    is_parent_total_difficulty_valid = parent.total_difficulty < TERMINAL_TOTAL_DIFFICULTY
-//    return is_total_difficulty_reached and is_parent_total_difficulty_valid
-func validateTerminalBlockDifficulties(currentDifficulty *uint256.Int, parentDifficulty *uint256.Int) (bool, error) {
-	b, ok := new(big.Int).SetString(params.BeaconConfig().TerminalTotalDifficulty, 10)
-	if !ok {
-		return false, errors.New("failed to parse terminal total difficulty")
-	}
-	ttd, of := uint256.FromBig(b)
-	if of {
-		return false, errors.New("overflow terminal total difficulty")
-	}
-	totalDifficultyReached := currentDifficulty.Cmp(ttd) >= 0
-	parentTotalDifficultyValid := ttd.Cmp(parentDifficulty) > 0
-	return totalDifficultyReached && parentTotalDifficultyValid, nil
-}

beacon-chain/blockchain/pow_block_test.go

@@ -1,213 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"fmt"
-	"math/big"
-	"testing"
-
-	"github.com/holiman/uint256"
-	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	mocks "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func Test_validTerminalPowBlock(t *testing.T) {
-	tests := []struct {
-		name              string
-		currentDifficulty *uint256.Int
-		parentDifficulty  *uint256.Int
-		ttd               uint64
-		want              bool
-	}{
-		{
-			name:              "current > ttd, parent > ttd",
-			currentDifficulty: uint256.NewInt(2),
-			parentDifficulty:  uint256.NewInt(2),
-			ttd:               1,
-			want:              false,
-		},
-		{
-			name:              "current < ttd, parent < ttd",
-			currentDifficulty: uint256.NewInt(2),
-			parentDifficulty:  uint256.NewInt(2),
-			ttd:               3,
-			want:              false,
-		},
-		{
-			name:              "current == ttd, parent == ttd",
-			currentDifficulty: uint256.NewInt(2),
-			parentDifficulty:  uint256.NewInt(2),
-			ttd:               2,
-			want:              false,
-		},
-		{
-			name:              "current > ttd, parent == ttd",
-			currentDifficulty: uint256.NewInt(2),
-			parentDifficulty:  uint256.NewInt(1),
-			ttd:               1,
-			want:              false,
-		},
-		{
-			name:              "current == ttd, parent < ttd",
-			currentDifficulty: uint256.NewInt(2),
-			parentDifficulty:  uint256.NewInt(1),
-			ttd:               2,
-			want:              true,
-		},
-		{
-			name:              "current > ttd, parent < ttd",
-			currentDifficulty: uint256.NewInt(3),
-			parentDifficulty:  uint256.NewInt(1),
-			ttd:               2,
-			want:              true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cfg := params.BeaconConfig()
-			cfg.TerminalTotalDifficulty = fmt.Sprint(tt.ttd)
-			params.OverrideBeaconConfig(cfg)
-			got, err := validateTerminalBlockDifficulties(tt.currentDifficulty, tt.parentDifficulty)
-			require.NoError(t, err)
-			if got != tt.want {
-				t.Errorf("validateTerminalBlockDifficulties() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_validTerminalPowBlockSpecConfig(t *testing.T) {
-	cfg := params.BeaconConfig()
-	cfg.TerminalTotalDifficulty = "115792089237316195423570985008687907853269984665640564039457584007913129638912"
-	params.OverrideBeaconConfig(cfg)
-
-	i, _ := new(big.Int).SetString("115792089237316195423570985008687907853269984665640564039457584007913129638912", 10)
-	current, of := uint256.FromBig(i)
-	require.Equal(t, of, false)
-	i, _ = new(big.Int).SetString("115792089237316195423570985008687907853269984665640564039457584007913129638911", 10)
-	parent, of := uint256.FromBig(i)
-	require.Equal(t, of, false)
-
-	got, err := validateTerminalBlockDifficulties(current, parent)
-	require.NoError(t, err)
-	require.Equal(t, true, got)
-}
-
-func Test_validateMergeBlock(t *testing.T) {
-	cfg := params.BeaconConfig()
-	cfg.TerminalTotalDifficulty = "2"
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	engine := &mocks.EngineClient{BlockByHashMap: map[[32]byte]*enginev1.ExecutionBlock{}}
-	service.cfg.ExecutionEngineCaller = engine
-	engine.BlockByHashMap[[32]byte{'a'}] = &enginev1.ExecutionBlock{
-		ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
-		TotalDifficulty: "0x2",
-	}
-	engine.BlockByHashMap[[32]byte{'b'}] = &enginev1.ExecutionBlock{
-		ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
-		TotalDifficulty: "0x1",
-	}
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Slot: 1,
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &enginev1.ExecutionPayload{
-					ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-				},
-			},
-		},
-	}
-	b, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, service.validateMergeBlock(ctx, b))
-
-	cfg.TerminalTotalDifficulty = "1"
-	params.OverrideBeaconConfig(cfg)
-	err = service.validateMergeBlock(ctx, b)
-	require.ErrorContains(t, "invalid TTD, configTTD: 1, currentTTD: 2, parentTTD: 1", err)
-	require.Equal(t, true, IsInvalidBlock(err))
-}
-
-func Test_getBlkParentHashAndTD(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	engine := &mocks.EngineClient{BlockByHashMap: map[[32]byte]*enginev1.ExecutionBlock{}}
-	service.cfg.ExecutionEngineCaller = engine
-	h := [32]byte{'a'}
-	p := [32]byte{'b'}
-	td := "0x1"
-	engine.BlockByHashMap[h] = &enginev1.ExecutionBlock{
-		ParentHash:      p[:],
-		TotalDifficulty: td,
-	}
-	parentHash, totalDifficulty, err := service.getBlkParentHashAndTD(ctx, h[:])
-	require.NoError(t, err)
-	require.Equal(t, p, bytesutil.ToBytes32(parentHash))
-	require.Equal(t, td, totalDifficulty.String())
-
-	_, _, err = service.getBlkParentHashAndTD(ctx, []byte{'c'})
-	require.ErrorContains(t, "could not get pow block: block not found", err)
-
-	engine.BlockByHashMap[h] = nil
-	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
-	require.ErrorContains(t, "pow block is nil", err)
-
-	engine.BlockByHashMap[h] = &enginev1.ExecutionBlock{
-		ParentHash:      p[:],
-		TotalDifficulty: "1",
-	}
-	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
-	require.ErrorContains(t, "could not decode merge block total difficulty: hex string without 0x prefix", err)
-
-	engine.BlockByHashMap[h] = &enginev1.ExecutionBlock{
-		ParentHash:      p[:],
-		TotalDifficulty: "0XFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
-	}
-	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
-	require.ErrorContains(t, "could not decode merge block total difficulty: hex number > 256 bits", err)
-}
-
-func Test_validateTerminalBlockHash(t *testing.T) {
-	require.NoError(t, validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
-
-	cfg := params.BeaconConfig()
-	cfg.TerminalBlockHash = [32]byte{0x01}
-	params.OverrideBeaconConfig(cfg)
-	require.ErrorContains(t, "terminal block hash activation epoch not reached", validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
-
-	cfg.TerminalBlockHashActivationEpoch = 0
-	params.OverrideBeaconConfig(cfg)
-	require.ErrorContains(t, "parent hash does not match terminal block hash", validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
-
-	require.NoError(t, validateTerminalBlockHash(1, &enginev1.ExecutionPayload{ParentHash: cfg.TerminalBlockHash.Bytes()}))
-}

beacon-chain/blockchain/process_attestation.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"context"
-	"time"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -10,11 +9,12 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
+	"github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
 )
 
-// OnAttestation is called whenever an attestation is received, verifies the attestation is valid and saves
+// onAttestation is called whenever an attestation is received, verifies the attestation is valid and saves
 // it to the DB. As a stateless function, this does not hold nor delay attestation based on the spec descriptions.
 // The delay is handled by the caller in `processAttestations`.
 //
@@ -36,7 +36,7 @@ import (
 //
 //    # Update latest messages for attesting indices
 //    update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
-func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation) error {
+func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 
@@ -59,10 +59,10 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation) error
 		return err
 	}
 
-	genesisTime := uint64(s.genesisTime.Unix())
+	genesisTime := baseState.GenesisTime()
 
 	// Verify attestation target is from current epoch or previous epoch.
-	if err := verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {
+	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {
 		return err
 	}
 

beacon-chain/blockchain/process_attestation_helpers.go

@@ -6,12 +6,12 @@ import (
 	"strconv"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/async"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -42,9 +42,11 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 	if err != nil {
 		return nil, err
 	}
-	baseState, err = transition.ProcessSlotsIfPossible(ctx, baseState, epochStartSlot)
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+	if epochStartSlot > baseState.Slot() {
+		baseState, err = transition.ProcessSlots(ctx, baseState, epochStartSlot)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+		}
 	}
 
 	// Sharing the same state across caches is perfectly fine here, the fetching
@@ -59,7 +61,7 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 }
 
 // verifyAttTargetEpoch validates attestation is from the current or previous epoch.
-func verifyAttTargetEpoch(_ context.Context, genesisTime, nowTime uint64, c *ethpb.Checkpoint) error {
+func (s *Service) verifyAttTargetEpoch(_ context.Context, genesisTime, nowTime uint64, c *ethpb.Checkpoint) error {
 	currentSlot := types.Slot((nowTime - genesisTime) / params.BeaconConfig().SecondsPerSlot)
 	currentEpoch := slots.ToEpoch(currentSlot)
 	var prevEpoch types.Epoch
@@ -76,11 +78,16 @@ func verifyAttTargetEpoch(_ context.Context, genesisTime, nowTime uint64, c *eth
 // verifyBeaconBlock verifies beacon head block is known and not from the future.
 func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.AttestationData) error {
 	r := bytesutil.ToBytes32(data.BeaconBlockRoot)
-	b, err := s.getBlock(ctx, r)
+	b, err := s.cfg.BeaconDB.Block(ctx, r)
 	if err != nil {
 		return err
 	}
-	if err := wrapper.BeaconBlockIsNil(b); err != nil {
+	// If the block does not exist in db, check again if block exists in initial sync block cache.
+	// This could happen as the node first syncs to head.
+	if (b == nil || b.IsNil()) && s.hasInitSyncBlock(r) {
+		b = s.getInitSyncBlock(r)
+	}
+	if err := helpers.BeaconBlockIsNil(b); err != nil {
 		return err
 	}
 	if b.Block().Slot() > data.Slot {

beacon-chain/blockchain/process_attestation_test.go

@@ -3,50 +3,49 @@ package blockchain
 import (
 	"context"
 	"testing"
-	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"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"
+	"github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
+func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New()),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	_, err = blockTree1(t, beaconDB, []byte{'g'})
 	require.NoError(t, err)
 
-	blkWithoutState := util.NewBeaconBlock()
-	blkWithoutState.Block.Slot = 0
-	util.SaveBlock(t, ctx, beaconDB, blkWithoutState)
-	BlkWithOutStateRoot, err := blkWithoutState.Block.HashTreeRoot()
+	BlkWithOutState := util.NewBeaconBlock()
+	BlkWithOutState.Block.Slot = 0
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState)))
+	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	blkWithStateBadAtt := util.NewBeaconBlock()
-	blkWithStateBadAtt.Block.Slot = 1
-	util.SaveBlock(t, ctx, beaconDB, blkWithStateBadAtt)
-	BlkWithStateBadAttRoot, err := blkWithStateBadAtt.Block.HashTreeRoot()
+	BlkWithStateBadAtt := util.NewBeaconBlock()
+	BlkWithStateBadAtt.Block.Slot = 1
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt)))
+	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	s, err := util.NewBeaconState()
@@ -54,11 +53,11 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 	require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
 
-	blkWithValidState := util.NewBeaconBlock()
-	blkWithValidState.Block.Slot = 2
-	util.SaveBlock(t, ctx, beaconDB, blkWithValidState)
+	BlkWithValidState := util.NewBeaconBlock()
+	BlkWithValidState.Block.Slot = 2
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))
 
-	blkWithValidStateRoot, err := blkWithValidState.Block.HashTreeRoot()
+	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
 	s, err = util.NewBeaconState()
 	require.NoError(t, err)
@@ -68,7 +67,7 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 	})
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, blkWithValidStateRoot))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, BlkWithValidStateRoot))
 
 	tests := []struct {
 		name      string
@@ -105,9 +104,9 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 			name: "process nil field (a.Target) in attestation",
 			a: &ethpb.Attestation{
 				Data: &ethpb.AttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+					BeaconBlockRoot: make([]byte, 32),
 					Target:          nil,
-					Source:          &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
+					Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
 				},
 				AggregationBits: make([]byte, 1),
 				Signature:       make([]byte, 96),
@@ -118,7 +117,7 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := service.OnAttestation(ctx, tt.a)
+			err := service.onAttestation(ctx, tt.a)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
@@ -128,126 +127,20 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 	}
 }
 
-func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
+func TestStore_OnAttestation_Ok(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(doublylinkedtree.New()),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	_, err = blockTree1(t, beaconDB, []byte{'g'})
-	require.NoError(t, err)
-
-	blkWithoutState := util.NewBeaconBlock()
-	blkWithoutState.Block.Slot = 0
-	util.SaveBlock(t, ctx, beaconDB, blkWithoutState)
-	BlkWithOutStateRoot, err := blkWithoutState.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	blkWithStateBadAtt := util.NewBeaconBlock()
-	blkWithStateBadAtt.Block.Slot = 1
-	util.SaveBlock(t, ctx, beaconDB, blkWithStateBadAtt)
-	BlkWithStateBadAttRoot, err := blkWithStateBadAtt.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
-
-	blkWithValidState := util.NewBeaconBlock()
-	blkWithValidState.Block.Slot = 2
-	util.SaveBlock(t, ctx, beaconDB, blkWithValidState)
-
-	blkWithValidStateRoot, err := blkWithValidState.Block.HashTreeRoot()
-	require.NoError(t, err)
-	s, err = util.NewBeaconState()
-	require.NoError(t, err)
-	err = s.SetFork(&ethpb.Fork{
-		Epoch:           0,
-		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-	})
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, blkWithValidStateRoot))
-
-	tests := []struct {
-		name      string
-		a         *ethpb.Attestation
-		wantedErr string
-	}{
-		{
-			name:      "attestation's data slot not aligned with target vote",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
-			wantedErr: "slot 32 does not match target epoch 0",
-		},
-		{
-			name:      "no pre state for attestations's target block",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
-			wantedErr: "could not get pre state for epoch 0",
-		},
-		{
-			name: "process attestation doesn't match current epoch",
-			a: util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
-				Root: BlkWithStateBadAttRoot[:]}}}),
-			wantedErr: "target epoch 100 does not match current epoch",
-		},
-		{
-			name:      "process nil attestation",
-			a:         nil,
-			wantedErr: "attestation can't be nil",
-		},
-		{
-			name:      "process nil field (a.Data) in attestation",
-			a:         &ethpb.Attestation{},
-			wantedErr: "attestation's data can't be nil",
-		},
-		{
-			name: "process nil field (a.Target) in attestation",
-			a: &ethpb.Attestation{
-				Data: &ethpb.AttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
-					Target:          nil,
-					Source:          &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				},
-				AggregationBits: make([]byte, 1),
-				Signature:       make([]byte, 96),
-			},
-			wantedErr: "attestation's target can't be nil",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := service.OnAttestation(ctx, tt.a)
-			if tt.wantedErr != "" {
-				assert.ErrorContains(t, tt.wantedErr, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
-func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
+	require.NoError(t, genesisState.SetGenesisTime(uint64(time.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
@@ -256,62 +149,29 @@ func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	ojc := &ethpb.Checkpoint{Epoch: 1, Root: tRoot[:]}
-	ofc := &ethpb.Checkpoint{Epoch: 1, Root: tRoot[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, service.OnAttestation(ctx, att[0]))
-}
-
-func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	fcs := doublylinkedtree.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
-	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
-	require.NoError(t, err)
-	tRoot := bytesutil.ToBytes32(att[0].Data.Target.Root)
-	copied := genesisState.Copy()
-	copied, err = transition.ProcessSlots(ctx, copied, 1)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-	ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, service.OnAttestation(ctx, att[0]))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
+	require.NoError(t, service.onAttestation(ctx, att[0]))
 }
 
 func TestStore_SaveCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
-	err = s.SetFinalizedCheckpoint(&ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)})
+	err = s.SetFinalizedCheckpoint(&ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)})
 	require.NoError(t, err)
 	val := &ethpb.Validator{
 		PublicKey:             bytesutil.PadTo([]byte("foo"), 48),
-		WithdrawalCredentials: bytesutil.PadTo([]byte("bar"), fieldparams.RootLength),
+		WithdrawalCredentials: bytesutil.PadTo([]byte("bar"), 32),
 	}
 	err = s.SetValidators([]*ethpb.Validator{val})
 	require.NoError(t, err)
@@ -320,17 +180,23 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	r := [32]byte{'g'}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, r))
 
-	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)}
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+
+	r = bytesutil.ToBytes32([]byte{'A'})
+	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'A'})))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'A'}, 32)}))
 
 	s1, err := service.getAttPreState(ctx, cp1)
 	require.NoError(t, err)
 	assert.Equal(t, 1*params.BeaconConfig().SlotsPerEpoch, s1.Slot(), "Unexpected state slot")
 
-	cp2 := &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength)}
+	cp2 := &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'B'}, 32)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'B'})))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength)}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'B'}, 32)}))
 	s2, err := service.getAttPreState(ctx, cp2)
 	require.NoError(t, err)
 	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
@@ -348,9 +214,13 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
 
 	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))
-	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}
+	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, 32)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'C'})))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, 32)}))
 	s3, err := service.getAttPreState(ctx, cp3)
 	require.NoError(t, err)
 	assert.Equal(t, s.Slot(), s3.Slot(), "Unexpected state slot")
@@ -360,16 +230,17 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	epoch := types.Epoch(1)
 	baseState, _ := util.DeterministicGenesisState(t, 1)
-	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("hi"), fieldparams.RootLength)}
+	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("hi"), 32)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
 	returned, err := service.getAttPreState(ctx, checkpoint)
 	require.NoError(t, err)
@@ -380,7 +251,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	assert.Equal(t, returned.Slot(), cached.Slot(), "State should have been cached")
 
 	epoch = 2
-	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("bye"), fieldparams.RootLength)}
+	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("bye"), 32)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)
 	require.NoError(t, err)
@@ -397,46 +268,69 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 
 func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
+	require.NoError(t, err)
+	service.cfg = cfg
 
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
-	require.NoError(t, verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)}))
+	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)}))
 }
 
 func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
+	require.NoError(t, err)
+	service.cfg = cfg
 
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
-	require.NoError(t, verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
+	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
 }
 
 func TestAttEpoch_NotMatch(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
+	require.NoError(t, err)
+	service.cfg = cfg
 
 	nowTime := 2 * uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
-	err := verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)})
+	err = service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)})
 	assert.ErrorContains(t, "target epoch 0 does not match current epoch 2 or prev epoch 1", err)
 }
 
 func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	d := util.HydrateAttestationData(&ethpb.AttestationData{})
-	require.Equal(t, errBlockNotFoundInCacheOrDB, service.verifyBeaconBlock(ctx, d))
+	assert.ErrorContains(t, "signed beacon block can't be nil", service.verifyBeaconBlock(ctx, d))
 }
 
 func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
@@ -446,14 +340,16 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 
 func TestVerifyBeaconBlock_OK(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
@@ -461,61 +357,27 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 	assert.NoError(t, service.verifyBeaconBlock(ctx, d), "Did not receive the wanted error")
 }
 
-func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
+func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b32)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 1}))
+	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
+
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b33)
-	r33, err := b33.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	err = service.VerifyFinalizedConsistency(context.Background(), r33[:])
-	require.ErrorContains(t, "Root and finalized store are not consistent", err)
-}
-
-func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	fcs := doublylinkedtree.New()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	b32 := util.NewBeaconBlock()
-	b32.Block.Slot = 32
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b32)
-	r32, err := b32.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 1}))
-	b33 := util.NewBeaconBlock()
-	b33.Block.Slot = 33
-	b33.Block.ParentRoot = r32[:]
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b33)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -525,22 +387,25 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 
 func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b32)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 1, Root: r32}))
+	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
+
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b33)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -550,34 +415,30 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 
 func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
+	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
+
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, b32.Block.Slot, r32, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, b33.Block.Slot, r33, r32, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, b32.Block.Slot, r32, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, b33.Block.Slot, r33, r32, [32]byte{}, 0, 0))
 
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r32}
-	require.NoError(t, service.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(jc))
-	_, err = service.cfg.ForkChoiceStore.Head(ctx, []uint64{})
+	_, err = service.cfg.ForkChoiceStore.Head(ctx, 0, r32, []uint64{}, 0)
 	require.NoError(t, err)
 	err = service.VerifyFinalizedConsistency(context.Background(), r33[:])
 	require.NoError(t, err)

beacon-chain/blockchain/process_block.go

@@ -1,33 +1,33 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
+	"math/big"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/eth/catalyst"
+	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/async/event"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/execution"
 	"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"
 	coreTime "github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
@@ -93,11 +93,11 @@ var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch)
 //            ancestor_at_finalized_slot = get_ancestor(store, store.justified_checkpoint.root, finalized_slot)
 //            if ancestor_at_finalized_slot != store.finalized_checkpoint.root:
 //                store.justified_checkpoint = state.current_justified_checkpoint
-func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlock, blockRoot [32]byte) error {
+func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlock")
 	defer span.End()
-	if err := wrapper.BeaconBlockIsNil(signed); err != nil {
-		return invalidBlock{err}
+	if err := helpers.BeaconBlockIsNil(signed); err != nil {
+		return err
 	}
 	b := signed.Block()
 
@@ -106,42 +106,44 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		return err
 	}
 
-	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
-	if err != nil {
-		return err
-	}
+	body := signed.Block().Body()
+	// TODO_MERGE: Break `ExecuteStateTransition` into per_slot and block processing so we can call `ExecutePayload` in the middle.
 	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
-		return invalidBlock{err}
-	}
-	postStateVersion, postStateHeader, err := getStateVersionAndPayload(postState)
-	if err != nil {
+		// TODO_MERGE: Notify execution client in the event of invalid conensus block
 		return err
 	}
-	isValidPayload, err := s.notifyNewPayload(ctx, postStateVersion, postStateHeader, signed)
-	if err != nil {
-		return fmt.Errorf("could not verify new payload: %v", err)
-	}
-	if isValidPayload {
-		if err := s.validateMergeTransitionBlock(ctx, preStateVersion, preStateHeader, signed); err != nil {
-			return err
-		}
-	}
-	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState); err != nil {
-		return err
-	}
-	// save current justified and finalized epochs for future use
-	currJustifiedEpoch := s.ForkChoicer().JustifiedCheckpoint().Epoch
-	currFinalizedEpoch := s.ForkChoicer().FinalizedCheckpoint().Epoch
 
-	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, signed.Block(), blockRoot, postState); err != nil {
-		return errors.Wrapf(err, "could not insert block %d to fork choice store", signed.Block().Slot())
-	}
-	s.InsertSlashingsToForkChoiceStore(ctx, signed.Block().Body().AttesterSlashings())
-	if isValidPayload {
-		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, blockRoot); err != nil {
-			return errors.Wrap(err, "could not set optimistic block to valid")
+	if postState.Version() == version.Merge {
+		executionEnabled, err := execution.Enabled(postState, body)
+		if err != nil {
+			return errors.Wrap(err, "could not check if execution is enabled")
 		}
+		if executionEnabled {
+			payload, err := body.ExecutionPayload()
+			if err != nil {
+				return errors.Wrap(err, "could not get body execution payload")
+			}
+			// This is not the earliest we can call `ExecutePayload`, see above to do as the soonest we can call is after per_slot processing.
+			_, err = s.cfg.ExecutionEngineCaller.ExecutePayload(ctx, executionPayloadToExecutableData(payload))
+			if err != nil {
+				return errors.Wrap(err, "could not execute payload")
+			}
+
+			mergeBlock, err := execution.IsMergeBlock(postState, body)
+			if err != nil {
+				return errors.Wrap(err, "could not check if merge block is terminal")
+			}
+			if mergeBlock {
+				if err := s.validateTerminalBlock(signed); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, false /* reg sync */); err != nil {
+		return err
 	}
 
 	// If slasher is configured, forward the attestations in the block via
@@ -171,17 +173,69 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		}()
 	}
 
-	justified := s.ForkChoicer().JustifiedCheckpoint()
-	balances, err := s.justifiedBalances.get(ctx, justified.Root)
-	if err != nil {
-		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", justified.Root)
-		return errors.Wrap(err, msg)
+	// Update justified check point.
+	currJustifiedEpoch := s.justifiedCheckpt.Epoch
+	if postState.CurrentJustifiedCheckpoint().Epoch > currJustifiedEpoch {
+		if err := s.updateJustified(ctx, postState); err != nil {
+			return err
+		}
 	}
-	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
-	if err != nil {
+
+	newFinalized := postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch
+	if newFinalized {
+		if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
+			return errors.Wrap(err, "could not save new justified")
+		}
+		s.prevFinalizedCheckpt = s.finalizedCheckpt
+		s.finalizedCheckpt = postState.FinalizedCheckpoint()
+	}
+
+	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
-	s.notifyEngineIfChangedHead(ctx, headRoot)
+
+	// Notify execution layer with fork choice head update if this is post merge block.
+	if postState.Version() == version.Merge {
+		executionEnabled, err := execution.Enabled(postState, body)
+		if err != nil {
+			return errors.Wrap(err, "could not check if execution is enabled")
+		}
+		if executionEnabled {
+			// Spawn the update task, without waiting for it to complete.
+			go func() {
+				headPayload, err := s.headBlock().Block().Body().ExecutionPayload()
+				if err != nil {
+					log.WithError(err)
+					return
+				}
+				// TODO_MERGE: Loading the finalized block from DB on per block is not ideal. Finalized block should be cached here
+				finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, bytesutil.ToBytes32(s.finalizedCheckpt.Root))
+				if err != nil {
+					log.WithError(err)
+					return
+				}
+				finalizedBlockHash := params.BeaconConfig().ZeroHash[:]
+				if finalizedBlock != nil && finalizedBlock.Version() == version.Merge {
+					finalizedPayload, err := finalizedBlock.Block().Body().ExecutionPayload()
+					if err != nil {
+						log.WithError(err)
+						return
+					}
+					finalizedBlockHash = finalizedPayload.BlockHash
+				}
+
+				f := catalyst.ForkchoiceStateV1{
+					HeadBlockHash:      common.BytesToHash(headPayload.BlockHash),
+					SafeBlockHash:      common.BytesToHash(headPayload.BlockHash),
+					FinalizedBlockHash: common.BytesToHash(finalizedBlockHash),
+				}
+				if err := s.cfg.ExecutionEngineCaller.NotifyForkChoiceValidated(ctx, f); err != nil {
+					log.WithError(err)
+					return
+				}
+			}()
+		}
+	}
 
 	if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
 		return err
@@ -199,43 +253,43 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	})
 
 	// Updating next slot state cache can happen in the background. It shouldn't block rest of the process.
-	go func() {
-		// Use a custom deadline here, since this method runs asynchronously.
-		// We ignore the parent method's context and instead create a new one
-		// with a custom deadline, therefore using the background context instead.
-		slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
-		defer cancel()
-		if err := transition.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
-			log.WithError(err).Debug("could not update next slot state cache")
-		}
-	}()
+	if features.Get().EnableNextSlotStateCache {
+		go func() {
+			// Use a custom deadline here, since this method runs asynchronously.
+			// We ignore the parent method's context and instead create a new one
+			// with a custom deadline, therefore using the background context instead.
+			slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
+			defer cancel()
+			if err := transition.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
+				log.WithError(err).Debug("could not update next slot state cache")
+			}
+		}()
+	}
 
 	// Save justified check point to db.
-	if justified.Epoch > currJustifiedEpoch {
+	if postState.CurrentJustifiedCheckpoint().Epoch > currJustifiedEpoch {
 		if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, postState.CurrentJustifiedCheckpoint()); err != nil {
 			return err
 		}
 	}
 
 	// Update finalized check point.
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
-	if finalized.Epoch > currFinalizedEpoch {
+	if newFinalized {
 		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
 			return err
 		}
-		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(finalized.Root)
-		if err != nil {
-			return errors.Wrap(err, "could not check if node is optimistically synced")
+		fRoot := bytesutil.ToBytes32(postState.FinalizedCheckpoint().Root)
+		if err := s.cfg.ForkChoiceStore.Prune(ctx, fRoot); err != nil {
+			return errors.Wrap(err, "could not prune proto array fork choice nodes")
 		}
 		go func() {
 			// Send an event regarding the new finalized checkpoint over a common event feed.
 			s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 				Type: statefeed.FinalizedCheckpoint,
 				Data: &ethpbv1.EventFinalizedCheckpoint{
-					Epoch:               postState.FinalizedCheckpoint().Epoch,
-					Block:               postState.FinalizedCheckpoint().Root,
-					State:               signed.Block().StateRoot(),
-					ExecutionOptimistic: isOptimistic,
+					Epoch: postState.FinalizedCheckpoint().Epoch,
+					Block: postState.FinalizedCheckpoint().Root,
+					State: signed.Block().StateRoot(),
 				},
 			})
 
@@ -244,202 +298,132 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 			// with a custom deadline, therefore using the background context instead.
 			depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
 			defer cancel()
-			if err := s.insertFinalizedDeposits(depCtx, finalized.Root); err != nil {
+			if err := s.insertFinalizedDeposits(depCtx, fRoot); err != nil {
 				log.WithError(err).Error("Could not insert finalized deposits.")
 			}
 		}()
 
 	}
+
 	defer reportAttestationInclusion(b)
+
 	return s.handleEpochBoundary(ctx, postState)
 }
 
-func getStateVersionAndPayload(st state.BeaconState) (int, *enginev1.ExecutionPayloadHeader, error) {
-	if st == nil {
-		return 0, nil, errors.New("nil state")
-	}
-	var preStateHeader *enginev1.ExecutionPayloadHeader
-	var err error
-	preStateVersion := st.Version()
-	switch preStateVersion {
-	case version.Phase0, version.Altair:
-	default:
-		preStateHeader, err = st.LatestExecutionPayloadHeader()
-		if err != nil {
-			return 0, nil, err
-		}
-	}
-	return preStateVersion, preStateHeader, nil
-}
-
-func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock,
-	blockRoots [][32]byte) error {
+func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock,
+	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
 	defer span.End()
 
 	if len(blks) == 0 || len(blockRoots) == 0 {
-		return errors.New("no blocks provided")
+		return nil, nil, errors.New("no blocks provided")
 	}
-
-	if len(blks) != len(blockRoots) {
-		return errWrongBlockCount
-	}
-
-	if err := wrapper.BeaconBlockIsNil(blks[0]); err != nil {
-		return invalidBlock{err}
+	if err := helpers.BeaconBlockIsNil(blks[0]); err != nil {
+		return nil, nil, err
 	}
 	b := blks[0].Block()
 
 	// Retrieve incoming block's pre state.
 	if err := s.verifyBlkPreState(ctx, b); err != nil {
-		return err
+		return nil, nil, err
 	}
 	preState, err := s.cfg.StateGen.StateByRootInitialSync(ctx, bytesutil.ToBytes32(b.ParentRoot()))
 	if err != nil {
-		return err
+		return nil, nil, err
 	}
 	if preState == nil || preState.IsNil() {
-		return fmt.Errorf("nil pre state for slot %d", b.Slot())
-	}
-
-	// Fill in missing blocks
-	if err := s.fillInForkChoiceMissingBlocks(ctx, blks[0].Block(), preState.CurrentJustifiedCheckpoint(), preState.FinalizedCheckpoint()); err != nil {
-		return errors.Wrap(err, "could not fill in missing blocks to forkchoice")
+		return nil, nil, fmt.Errorf("nil pre state for slot %d", b.Slot())
 	}
 
 	jCheckpoints := make([]*ethpb.Checkpoint, len(blks))
 	fCheckpoints := make([]*ethpb.Checkpoint, len(blks))
-	sigSet := &bls.SignatureBatch{
+	sigSet := &bls.SignatureSet{
 		Signatures: [][]byte{},
 		PublicKeys: []bls.PublicKey{},
 		Messages:   [][32]byte{},
 	}
-	type versionAndHeader struct {
-		version int
-		header  *enginev1.ExecutionPayloadHeader
-	}
-	preVersionAndHeaders := make([]*versionAndHeader, len(blks))
-	postVersionAndHeaders := make([]*versionAndHeader, len(blks))
-	var set *bls.SignatureBatch
+	var set *bls.SignatureSet
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
-		v, h, err := getStateVersionAndPayload(preState)
-		if err != nil {
-			return err
-		}
-		preVersionAndHeaders[i] = &versionAndHeader{
-			version: v,
-			header:  h,
-		}
-
 		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
 		if err != nil {
-			return invalidBlock{err}
+			return nil, nil, err
 		}
 		// Save potential boundary states.
 		if slots.IsEpochStart(preState.Slot()) {
 			boundaries[blockRoots[i]] = preState.Copy()
+			if err := s.handleEpochBoundary(ctx, preState); err != nil {
+				return nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
+			}
 		}
 		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
 		fCheckpoints[i] = preState.FinalizedCheckpoint()
-
-		v, h, err = getStateVersionAndPayload(preState)
-		if err != nil {
-			return err
-		}
-		postVersionAndHeaders[i] = &versionAndHeader{
-			version: v,
-			header:  h,
-		}
 		sigSet.Join(set)
 	}
 	verify, err := sigSet.Verify()
 	if err != nil {
-		return invalidBlock{err}
+		return nil, nil, err
 	}
 	if !verify {
-		return errors.New("batch block signature verification failed")
+		return nil, nil, errors.New("batch block signature verification failed")
 	}
-
-	// blocks have been verified, save them and call the engine
-	pendingNodes := make([]*forkchoicetypes.BlockAndCheckpoints, len(blks))
-	var isValidPayload bool
-	for i, b := range blks {
-		isValidPayload, err = s.notifyNewPayload(ctx,
-			postVersionAndHeaders[i].version,
-			postVersionAndHeaders[i].header, b)
-		if err != nil {
-			return err
-		}
-		if isValidPayload {
-			if err := s.validateMergeTransitionBlock(ctx, preVersionAndHeaders[i].version,
-				preVersionAndHeaders[i].header, b); err != nil {
-				return err
-			}
-		}
-		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
-			JustifiedCheckpoint: jCheckpoints[i],
-			FinalizedCheckpoint: fCheckpoints[i]}
-		pendingNodes[len(blks)-i-1] = args
-		if err := s.saveInitSyncBlock(ctx, blockRoots[i], b); err != nil {
-			tracing.AnnotateError(span, err)
-			return err
-		}
-		if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
-			Slot: b.Block().Slot(),
-			Root: blockRoots[i][:],
-		}); err != nil {
-			tracing.AnnotateError(span, err)
-			return err
-		}
-		if i > 0 && jCheckpoints[i].Epoch > jCheckpoints[i-1].Epoch {
-			if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, jCheckpoints[i]); err != nil {
-				tracing.AnnotateError(span, err)
-				return err
-			}
-		}
-		if i > 0 && fCheckpoints[i].Epoch > fCheckpoints[i-1].Epoch {
-			if err := s.updateFinalized(ctx, fCheckpoints[i]); err != nil {
-				tracing.AnnotateError(span, err)
-				return err
-			}
-		}
-	}
-	// Insert all nodes but the last one to forkchoice
-	if err := s.cfg.ForkChoiceStore.InsertOptimisticChain(ctx, pendingNodes); err != nil {
-		return errors.Wrap(err, "could not insert batch to forkchoice")
-	}
-	// Insert the last block to forkchoice
-	lastBR := blockRoots[len(blks)-1]
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastBR); err != nil {
-		return errors.Wrap(err, "could not insert last block in batch to forkchoice")
-	}
-	// Set their optimistic status
-	if isValidPayload {
-		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, lastBR); err != nil {
-			return errors.Wrap(err, "could not set optimistic block to valid")
-		}
-	}
-
 	for r, st := range boundaries {
 		if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
-			return err
+			return nil, nil, err
 		}
 	}
 	// Also saves the last post state which to be used as pre state for the next batch.
 	lastB := blks[len(blks)-1]
+	lastBR := blockRoots[len(blockRoots)-1]
 	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
+		return nil, nil, err
+	}
+	if err := s.saveHeadNoDB(ctx, lastB, lastBR, preState); err != nil {
+		return nil, nil, err
+	}
+	return fCheckpoints, jCheckpoints, nil
+}
+
+// handles a block after the block's batch has been verified, where we can save blocks
+// their state summaries and split them off to relative hot/cold storage.
+func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.SignedBeaconBlock,
+	blockRoot [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
+	b := signed.Block()
+
+	s.saveInitSyncBlock(blockRoot, signed)
+	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
-	arg := &notifyForkchoiceUpdateArg{
-		headState: preState,
-		headRoot:  lastBR,
-		headBlock: lastB.Block(),
-	}
-	if _, err := s.notifyForkchoiceUpdate(ctx, arg); err != nil {
+	if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
+		Slot: signed.Block().Slot(),
+		Root: blockRoot[:],
+	}); err != nil {
 		return err
 	}
-	return s.saveHeadNoDB(ctx, lastB, lastBR, preState)
+
+	// Rate limit how many blocks (2 epochs worth of blocks) a node keeps in the memory.
+	if uint64(len(s.getInitSyncBlocks())) > initialSyncBlockCacheSize {
+		if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+			return err
+		}
+		s.clearInitSyncBlocks()
+	}
+
+	if jCheckpoint.Epoch > s.justifiedCheckpt.Epoch {
+		if err := s.updateJustifiedInitSync(ctx, jCheckpoint); err != nil {
+			return err
+		}
+	}
+
+	// Update finalized check point. Prune the block cache and helper caches on every new finalized epoch.
+	if fCheckpoint.Epoch > s.finalizedCheckpt.Epoch {
+		if err := s.updateFinalized(ctx, fCheckpoint); err != nil {
+			return err
+		}
+		s.prevFinalizedCheckpt = s.finalizedCheckpt
+		s.finalizedCheckpt = fCheckpoint
+	}
+	return nil
 }
 
 // Epoch boundary bookkeeping such as logging epoch summaries.
@@ -448,26 +432,22 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 	defer span.End()
 
 	if postState.Slot()+1 == s.nextEpochBoundarySlot {
+		// Update caches for the next epoch at epoch boundary slot - 1.
+		if err := helpers.UpdateCommitteeCache(postState, coreTime.NextEpoch(postState)); err != nil {
+			return err
+		}
 		copied := postState.Copy()
 		copied, err := transition.ProcessSlots(ctx, copied, copied.Slot()+1)
 		if err != nil {
 			return err
 		}
-		// Update caches for the next epoch at epoch boundary slot - 1.
-		if err := helpers.UpdateCommitteeCache(ctx, copied, coreTime.CurrentEpoch(copied)); err != nil {
-			return err
-		}
 		if err := helpers.UpdateProposerIndicesInCache(ctx, copied); err != nil {
 			return err
 		}
 	} else if postState.Slot() >= s.nextEpochBoundarySlot {
-		s.headLock.RLock()
-		st := s.head.state
-		s.headLock.RUnlock()
-		if err := reportEpochMetrics(ctx, postState, st); err != nil {
+		if err := reportEpochMetrics(ctx, postState, s.head.state); err != nil {
 			return err
 		}
-
 		var err error
 		s.nextEpochBoundarySlot, err = slots.EpochStart(coreTime.NextEpoch(postState))
 		if err != nil {
@@ -476,7 +456,7 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 
 		// Update caches at epoch boundary slot.
 		// The following updates have short cut to return nil cheaply if fulfilled during boundary slot - 1.
-		if err := helpers.UpdateCommitteeCache(ctx, postState, coreTime.CurrentEpoch(postState)); err != nil {
+		if err := helpers.UpdateCommitteeCache(postState, coreTime.CurrentEpoch(postState)); err != nil {
 			return err
 		}
 		if err := helpers.UpdateProposerIndicesInCache(ctx, postState); err != nil {
@@ -489,13 +469,14 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 
 // This feeds in the block and block's attestations to fork choice store. It's allows fork choice store
 // to gain information on the most current chain.
-func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Context, blk interfaces.BeaconBlock, root [32]byte, st state.BeaconState) error {
+func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Context, blk block.BeaconBlock, root [32]byte,
+	st state.BeaconState) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.insertBlockAndAttestationsToForkChoiceStore")
 	defer span.End()
 
 	fCheckpoint := st.FinalizedCheckpoint()
 	jCheckpoint := st.CurrentJustifiedCheckpoint()
-	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, st, fCheckpoint, jCheckpoint); err != nil {
+	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
 	// Feed in block's attestations to fork choice store.
@@ -513,41 +494,47 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 	return nil
 }
 
-func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk interfaces.BeaconBlock, root [32]byte, st state.BeaconState, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
+func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk block.BeaconBlock,
+	root [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
-	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, root)
-}
-
-// InsertSlashingsToForkChoiceStore inserts attester slashing indices to fork choice store.
-// To call this function, it's caller's responsibility to ensure the slashing object is valid.
-func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []*ethpb.AttesterSlashing) {
-	for _, slashing := range slashings {
-		indices := blocks.SlashableAttesterIndices(slashing)
-		for _, index := range indices {
-			s.ForkChoicer().InsertSlashedIndex(ctx, types.ValidatorIndex(index))
-		}
+	// Feed in block to fork choice store.
+	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
+		blk.Slot(), root, bytesutil.ToBytes32(blk.ParentRoot()), bytesutil.ToBytes32(blk.Body().Graffiti()),
+		jCheckpoint.Epoch,
+		fCheckpoint.Epoch); err != nil {
+		return errors.Wrap(err, "could not process block for proto array fork choice")
 	}
+	return nil
 }
 
 // This saves post state info to DB or cache. This also saves post state info to fork choice store.
 // Post state info consists of processed block and state. Do not call this method unless the block and state are verified.
-func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock, st state.BeaconState) error {
+func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b block.SignedBeaconBlock, st state.BeaconState, initSync bool) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.savePostStateInfo")
 	defer span.End()
-	if err := s.cfg.BeaconDB.SaveBlock(ctx, b); err != nil {
+	if initSync {
+		s.saveInitSyncBlock(r, b)
+	} else if err := s.cfg.BeaconDB.SaveBlock(ctx, b); err != nil {
 		return errors.Wrapf(err, "could not save block from slot %d", b.Block().Slot())
 	}
 	if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}
+	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, b.Block(), r, st); err != nil {
+		return errors.Wrapf(err, "could not insert block %d to fork choice store", b.Block().Slot())
+	}
 	return nil
 }
 
 // This removes the attestations from the mem pool. It will only remove the attestations if input root `r` is canonical,
 // meaning the block `b` is part of the canonical chain.
-func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock) error {
+func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b block.SignedBeaconBlock) error {
+	if !features.Get().CorrectlyPruneCanonicalAtts {
+		return nil
+	}
+
 	canonical, err := s.IsCanonical(ctx, r)
 	if err != nil {
 		return err
@@ -571,85 +558,98 @@ func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b
 	return nil
 }
 
-// validateMergeTransitionBlock validates the merge transition block.
-func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion int, stateHeader *enginev1.ExecutionPayloadHeader, blk interfaces.SignedBeaconBlock) error {
-	// Skip validation if block is older than Bellatrix.
-	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
-		return nil
-	}
-
-	// Skip validation if block has an empty payload.
-	payload, err := blk.Block().Body().ExecutionPayload()
+// validates terminal block hash in the event of manual overrides before checking for total difficulty.
+//
+// def validate_merge_block(block: BeaconBlock) -> None:
+//    """
+//    Check the parent PoW block of execution payload is a valid terminal PoW block.
+//
+//    Note: Unavailable PoW block(s) may later become available,
+//    and a client software MAY delay a call to ``validate_merge_block``
+//    until the PoW block(s) become available.
+//    """
+//    if TERMINAL_BLOCK_HASH != Hash32():
+//        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+//        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
+//        return block.block_hash == TERMINAL_BLOCK_HASH
+//
+//    pow_block = get_pow_block(block.body.execution_payload.parent_hash)
+//    # Check if `pow_block` is available
+//    assert pow_block is not None
+//    pow_parent = get_pow_block(pow_block.parent_hash)
+//    # Check if `pow_parent` is available
+//    assert pow_parent is not None
+//    # Check if `pow_block` is a valid terminal PoW block
+//    assert is_valid_terminal_pow_block(pow_block, pow_parent)
+func (s *Service) validateTerminalBlock(b block.SignedBeaconBlock) error {
+	payload, err := b.Block().Body().ExecutionPayload()
 	if err != nil {
-		return invalidBlock{err}
+		return err
 	}
-	if bellatrix.IsEmptyPayload(payload) {
+	if bytesutil.ToBytes32(params.BeaconConfig().TerminalBlockHash.Bytes()) != [32]byte{} {
+		// `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+		if params.BeaconConfig().TerminalBlockHashActivationEpoch > slots.ToEpoch(b.Block().Slot()) {
+			return errors.New("terminal block hash activation epoch not reached")
+		}
+		if !bytes.Equal(payload.ParentHash, params.BeaconConfig().TerminalBlockHash.Bytes()) {
+			return errors.New("parent hash does not match terminal block hash")
+		}
 		return nil
 	}
-
-	// Handle case where pre-state is Altair but block contains payload.
-	// To reach here, the block must have contained a valid payload.
-	if blocks.IsPreBellatrixVersion(stateVersion) {
-		return s.validateMergeBlock(ctx, blk)
-	}
-
-	// Skip validation if the block is not a merge transition block.
-	atTransition, err := blocks.IsMergeTransitionBlockUsingPreStatePayloadHeader(stateHeader, blk.Block().Body())
+	transitionBlk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(common.BytesToHash(payload.ParentHash))
 	if err != nil {
-		return errors.Wrap(err, "could not check if merge block is terminal")
+		return errors.Wrap(err, "could not get transition block")
 	}
-	if !atTransition {
-		return nil
+	parentTransitionBlk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(common.HexToHash(transitionBlk.ParentHash))
+	if err != nil {
+		return errors.Wrap(err, "could not get transition parent block")
 	}
-	return s.validateMergeBlock(ctx, blk)
+	if !validTerminalPowBlock(transitionBlk, parentTransitionBlk) {
+		return errors.New("invalid difficulty for terminal block")
+	}
+	return nil
 }
 
-// This routine checks if there is a cached proposer payload ID available for the next slot proposer.
-// If there is not, it will call forkchoice updated with the correct payload attribute then cache the payload ID.
-func (s *Service) fillMissingPayloadIDRoutine(ctx context.Context, stateFeed *event.Feed) {
-	// Wait for state to be initialized.
-	stateChannel := make(chan *feed.Event, 1)
-	stateSub := stateFeed.Subscribe(stateChannel)
-	go func() {
-		select {
-		case <-s.ctx.Done():
-			stateSub.Unsubscribe()
-			return
-		case <-stateChannel:
-			stateSub.Unsubscribe()
-			break
-		}
-
-		ticker := time.NewTicker(time.Second)
-		defer ticker.Stop()
-		for {
-			select {
-			case ti := <-ticker.C:
-				if !atHalfSlot(ti) {
-					continue
-				}
-				_, id, has := s.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(s.CurrentSlot() + 1)
-				// There exists proposer for next slot, but we haven't called fcu w/ payload attribute yet.
-				if has && id == [8]byte{} {
-					if _, err := s.notifyForkchoiceUpdate(ctx, &notifyForkchoiceUpdateArg{
-						headState: s.headState(ctx),
-						headRoot:  s.headRoot(),
-						headBlock: s.headBlock().Block(),
-					}); err != nil {
-						log.WithError(err).Error("Could not prepare payload on empty ID")
-					}
-					missedPayloadIDFilledCount.Inc()
-				}
-			case <-s.ctx.Done():
-				log.Debug("Context closed, exiting routine")
-				return
-			}
-		}
-	}()
+// validates terminal pow block by comparing own total difficulty with parent's total difficulty.
+//
+// def is_valid_terminal_pow_block(block: PowBlock, parent: PowBlock) -> bool:
+//    is_total_difficulty_reached = block.total_difficulty >= TERMINAL_TOTAL_DIFFICULTY
+//    is_parent_total_difficulty_valid = parent.total_difficulty < TERMINAL_TOTAL_DIFFICULTY
+//    return is_total_difficulty_reached and is_parent_total_difficulty_valid
+func validTerminalPowBlock(transitionBlock *powchain.ExecutionBlock, transitionParentBlock *powchain.ExecutionBlock) bool {
+	transitionBlkTTD, err := uint256.FromHex(transitionBlock.TotalDifficulty)
+	if err != nil {
+		return false
+	}
+	transitionParentBlkTTD, err := uint256.FromHex(transitionParentBlock.TotalDifficulty)
+	if err != nil {
+		return false
+	}
+	terminalTotalDifficulty := uint256.NewInt(params.BeaconConfig().TerminalTotalDifficulty)
+	totalDifficultyReached := transitionBlkTTD.Cmp(terminalTotalDifficulty) >= 0
+	parentTotalDifficultyValid := terminalTotalDifficulty.Cmp(transitionParentBlkTTD) >= 0
+	return totalDifficultyReached && parentTotalDifficultyValid
 }
 
-// Returns true if time `t` is halfway through the slot in sec.
-func atHalfSlot(t time.Time) bool {
-	s := params.BeaconConfig().SecondsPerSlot
-	return uint64(t.Second())%s == s/2
+func executionPayloadToExecutableData(payload *ethpb.ExecutionPayload) *catalyst.ExecutableDataV1 {
+	baseFeePerGas := new(big.Int)
+	// TODO_MERGE: The conversion from 32bytes to big int is broken. This assumes base fee per gas in single digit
+	baseFeePerGas.SetBytes([]byte{payload.BaseFeePerGas[0]})
+
+	return &catalyst.ExecutableDataV1{
+		BlockHash:     common.BytesToHash(payload.BlockHash),
+		ParentHash:    common.BytesToHash(payload.ParentHash),
+		Coinbase:      common.BytesToAddress(payload.Coinbase),
+		StateRoot:     common.BytesToHash(payload.StateRoot),
+		ReceiptRoot:   common.BytesToHash(payload.ReceiptRoot),
+		LogsBloom:     payload.LogsBloom,
+		Random:        common.BytesToHash(payload.Random),
+		Number:        payload.BlockNumber,
+		GasLimit:      payload.GasLimit,
+		GasUsed:       payload.GasUsed,
+		Timestamp:     payload.Timestamp,
+		ExtraData:     payload.ExtraData,
+		BaseFeePerGas: baseFeePerGas,
+		Transactions:  payload.Transactions,
+	}
 }

beacon-chain/blockchain/process_block_helpers.go

@@ -6,18 +6,15 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	mathutil "github.com/prysmaticlabs/prysm/math"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
 )
@@ -30,7 +27,7 @@ func (s *Service) CurrentSlot() types.Slot {
 // getBlockPreState returns the pre state of an incoming block. It uses the parent root of the block
 // to retrieve the state in DB. It verifies the pre state's validity and the incoming block
 // is in the correct time window.
-func (s *Service) getBlockPreState(ctx context.Context, b interfaces.BeaconBlock) (state.BeaconState, error) {
+func (s *Service) getBlockPreState(ctx context.Context, b block.BeaconBlock) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.getBlockPreState")
 	defer span.End()
 
@@ -48,7 +45,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.BeaconBlock
 	}
 
 	// Verify block slot time is not from the future.
-	if err := slots.VerifyTime(uint64(s.genesisTime.Unix()), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+	if err := slots.VerifyTime(preState.GenesisTime(), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return nil, err
 	}
 
@@ -61,7 +58,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.BeaconBlock
 }
 
 // verifyBlkPreState validates input block has a valid pre-state.
-func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.BeaconBlock) error {
+func (s *Service) verifyBlkPreState(ctx context.Context, b block.BeaconBlock) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.verifyBlkPreState")
 	defer span.End()
 
@@ -73,7 +70,7 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.BeaconBloc
 		return errors.New("could not reconstruct parent state")
 	}
 
-	if err := s.VerifyFinalizedBlkDescendant(ctx, bytesutil.ToBytes32(b.ParentRoot())); err != nil {
+	if err := s.VerifyBlkDescendant(ctx, bytesutil.ToBytes32(b.ParentRoot())); err != nil {
 		return err
 	}
 
@@ -90,18 +87,21 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.BeaconBloc
 	return nil
 }
 
-// VerifyFinalizedBlkDescendant validates if input block root is a descendant of the
+// VerifyBlkDescendant validates input block root is a descendant of the
 // current finalized block root.
-func (s *Service) VerifyFinalizedBlkDescendant(ctx context.Context, root [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.VerifyFinalizedBlkDescendant")
+func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.VerifyBlkDescendant")
 	defer span.End()
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
-	fRoot := s.ensureRootNotZeros(finalized.Root)
-	fSlot, err := slots.EpochStart(finalized.Epoch)
+	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.finalizedCheckpt.Root))
+	finalizedBlkSigned, err := s.cfg.BeaconDB.Block(ctx, fRoot)
 	if err != nil {
 		return err
 	}
-	bFinalizedRoot, err := s.ancestor(ctx, root[:], fSlot)
+	if finalizedBlkSigned == nil || finalizedBlkSigned.IsNil() || finalizedBlkSigned.Block().IsNil() {
+		return errors.New("nil finalized block")
+	}
+	finalizedBlk := finalizedBlkSigned.Block()
+	bFinalizedRoot, err := s.ancestor(ctx, root[:], finalizedBlk.Slot())
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized block root")
 	}
@@ -110,32 +110,124 @@ func (s *Service) VerifyFinalizedBlkDescendant(ctx context.Context, root [32]byt
 	}
 
 	if !bytes.Equal(bFinalizedRoot, fRoot[:]) {
-		err := fmt.Errorf("block %#x is not a descendant of the current finalized block slot %d, %#x != %#x",
-			bytesutil.Trunc(root[:]), fSlot, bytesutil.Trunc(bFinalizedRoot),
+		err := fmt.Errorf("block %#x is not a descendent of the current finalized block slot %d, %#x != %#x",
+			bytesutil.Trunc(root[:]), finalizedBlk.Slot(), bytesutil.Trunc(bFinalizedRoot),
 			bytesutil.Trunc(fRoot[:]))
 		tracing.AnnotateError(span, err)
-		return invalidBlock{err}
+		return err
 	}
 	return nil
 }
 
 // verifyBlkFinalizedSlot validates input block is not less than or equal
 // to current finalized slot.
-func (s *Service) verifyBlkFinalizedSlot(b interfaces.BeaconBlock) error {
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
-	finalizedSlot, err := slots.EpochStart(finalized.Epoch)
+func (s *Service) verifyBlkFinalizedSlot(b block.BeaconBlock) error {
+	finalizedSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
 	if err != nil {
 		return err
 	}
 	if finalizedSlot >= b.Slot() {
-		err = fmt.Errorf("block is equal or earlier than finalized block, slot %d < slot %d", b.Slot(), finalizedSlot)
-		return invalidBlock{err}
+		return fmt.Errorf("block is equal or earlier than finalized block, slot %d < slot %d", b.Slot(), finalizedSlot)
 	}
 	return nil
 }
 
-// updateFinalized saves the init sync blocks, finalized checkpoint, migrates
-// to cold old states and saves the last validated checkpoint to DB
+// shouldUpdateCurrentJustified prevents bouncing attack, by only update conflicting justified
+// checkpoints in the fork choice if in the early slots of the epoch.
+// Otherwise, delay incorporation of new justified checkpoint until next epoch boundary.
+// See https://ethresear.ch/t/prevention-of-bouncing-attack-on-ffg/6114 for more detailed analysis and discussion.
+func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustifiedCheckpt *ethpb.Checkpoint) (bool, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.shouldUpdateCurrentJustified")
+	defer span.End()
+
+	if slots.SinceEpochStarts(s.CurrentSlot()) < params.BeaconConfig().SafeSlotsToUpdateJustified {
+		return true, nil
+	}
+	var newJustifiedBlockSigned block.SignedBeaconBlock
+	justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(newJustifiedCheckpt.Root))
+	var err error
+	if s.hasInitSyncBlock(justifiedRoot) {
+		newJustifiedBlockSigned = s.getInitSyncBlock(justifiedRoot)
+	} else {
+		newJustifiedBlockSigned, err = s.cfg.BeaconDB.Block(ctx, justifiedRoot)
+		if err != nil {
+			return false, err
+		}
+	}
+	if newJustifiedBlockSigned == nil || newJustifiedBlockSigned.IsNil() || newJustifiedBlockSigned.Block().IsNil() {
+		return false, errors.New("nil new justified block")
+	}
+
+	newJustifiedBlock := newJustifiedBlockSigned.Block()
+	jSlot, err := slots.EpochStart(s.justifiedCheckpt.Epoch)
+	if err != nil {
+		return false, err
+	}
+	if newJustifiedBlock.Slot() <= jSlot {
+		return false, nil
+	}
+	var justifiedBlockSigned block.SignedBeaconBlock
+	cachedJustifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+	if s.hasInitSyncBlock(cachedJustifiedRoot) {
+		justifiedBlockSigned = s.getInitSyncBlock(cachedJustifiedRoot)
+	} else {
+		justifiedBlockSigned, err = s.cfg.BeaconDB.Block(ctx, cachedJustifiedRoot)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	if justifiedBlockSigned == nil || justifiedBlockSigned.IsNil() || justifiedBlockSigned.Block().IsNil() {
+		return false, errors.New("nil justified block")
+	}
+	justifiedBlock := justifiedBlockSigned.Block()
+	b, err := s.ancestor(ctx, justifiedRoot[:], justifiedBlock.Slot())
+	if err != nil {
+		return false, err
+	}
+	if !bytes.Equal(b, s.justifiedCheckpt.Root) {
+		return false, nil
+	}
+	return true, nil
+}
+
+func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaconState) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.updateJustified")
+	defer span.End()
+
+	cpt := state.CurrentJustifiedCheckpoint()
+	if cpt.Epoch > s.bestJustifiedCheckpt.Epoch {
+		s.bestJustifiedCheckpt = cpt
+	}
+	canUpdate, err := s.shouldUpdateCurrentJustified(ctx, cpt)
+	if err != nil {
+		return err
+	}
+
+	if canUpdate {
+		s.prevJustifiedCheckpt = s.justifiedCheckpt
+		s.justifiedCheckpt = cpt
+		if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// This caches input checkpoint as justified for the service struct. It rotates current justified to previous justified,
+// caches justified checkpoint balances for fork choice and save justified checkpoint in DB.
+// This method does not have defense against fork choice bouncing attack, which is why it's only recommend to be used during initial syncing.
+func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpoint) error {
+	s.prevJustifiedCheckpt = s.justifiedCheckpt
+	s.justifiedCheckpt = cp
+	if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+		return err
+	}
+
+	return s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cp)
+}
+
 func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.updateFinalized")
 	defer span.End()
@@ -152,19 +244,10 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 	}
 
 	fRoot := bytesutil.ToBytes32(cp.Root)
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(fRoot)
-	if err != nil && err != protoarray.ErrUnknownNodeRoot && err != doublylinkedtree.ErrNilNode {
-		return err
-	}
-	if !optimistic {
-		err = s.cfg.BeaconDB.SaveLastValidatedCheckpoint(ctx, cp)
-		if err != nil {
-			return err
-		}
-	}
 	if err := s.cfg.StateGen.MigrateToCold(ctx, fRoot); err != nil {
 		return errors.Wrap(err, "could not migrate to cold")
 	}
+
 	return nil
 }
 
@@ -208,8 +291,7 @@ func (s *Service) ancestorByForkChoiceStore(ctx context.Context, r [32]byte, slo
 	if !s.cfg.ForkChoiceStore.HasParent(r) {
 		return nil, errors.New("could not find root in fork choice store")
 	}
-	root, err := s.cfg.ForkChoiceStore.AncestorRoot(ctx, r, slot)
-	return root[:], err
+	return s.cfg.ForkChoiceStore.AncestorRoot(ctx, r, slot)
 }
 
 // This retrieves an ancestor root using DB. The look up is recursively looking up DB. Slower than `ancestorByForkChoiceStore`.
@@ -222,9 +304,17 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot types.Slot)
 		return nil, ctx.Err()
 	}
 
-	signed, err := s.getBlock(ctx, r)
+	signed, err := s.cfg.BeaconDB.Block(ctx, r)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "could not get ancestor block")
+	}
+
+	if s.hasInitSyncBlock(r) {
+		signed = s.getInitSyncBlock(r)
+	}
+
+	if signed == nil || signed.IsNil() || signed.Block().IsNil() {
+		return nil, errors.New("nil block")
 	}
 	b := signed.Block()
 	if b.Slot() == slot || b.Slot() < slot {
@@ -234,43 +324,93 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot types.Slot)
 	return s.ancestorByDB(ctx, bytesutil.ToBytes32(b.ParentRoot()), slot)
 }
 
-// This retrieves missing blocks from DB (ie. the blocks that couldn't be received over sync) and inserts them to fork choice store.
-// This is useful for block tree visualizer and additional vote accounting.
-func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfaces.BeaconBlock,
-	fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
-	pendingNodes := make([]*forkchoicetypes.BlockAndCheckpoints, 0)
+// This updates justified check point in store, if the new justified is later than stored justified or
+// the store's justified is not in chain with finalized check point.
+//
+// Spec definition:
+//   # Potentially update justified if different from store
+//        if store.justified_checkpoint != state.current_justified_checkpoint:
+//            # Update justified if new justified is later than store justified
+//            if state.current_justified_checkpoint.epoch > store.justified_checkpoint.epoch:
+//                store.justified_checkpoint = state.current_justified_checkpoint
+//                return
+//            # Update justified if store justified is not in chain with finalized checkpoint
+//            finalized_slot = compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)
+//            ancestor_at_finalized_slot = get_ancestor(store, store.justified_checkpoint.root, finalized_slot)
+//            if ancestor_at_finalized_slot != store.finalized_checkpoint.root:
+//                store.justified_checkpoint = state.current_justified_checkpoint
+func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state state.BeaconState) error {
+	// Update justified if it's different than the one cached in the store.
+	if !attestation.CheckPointIsEqual(s.justifiedCheckpt, state.CurrentJustifiedCheckpoint()) {
+		if state.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
+			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
+			return s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+		}
 
-	// Fork choice only matters from last finalized slot.
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
-	fSlot, err := slots.EpochStart(finalized.Epoch)
-	if err != nil {
-		return err
-	}
-	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: blk,
-		JustifiedCheckpoint: jCheckpoint, FinalizedCheckpoint: fCheckpoint})
-	// As long as parent node is not in fork choice store, and parent node is in DB.
-	root := bytesutil.ToBytes32(blk.ParentRoot())
-	for !s.cfg.ForkChoiceStore.HasNode(root) && s.cfg.BeaconDB.HasBlock(ctx, root) {
-		b, err := s.getBlock(ctx, root)
+		// Update justified if store justified is not in chain with finalized check point.
+		finalizedSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
 		if err != nil {
 			return err
 		}
-		if b.Block().Slot() <= fSlot {
-			break
+		justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+		anc, err := s.ancestor(ctx, justifiedRoot[:], finalizedSlot)
+		if err != nil {
+			return err
+		}
+		if !bytes.Equal(anc, s.finalizedCheckpt.Root) {
+			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
+			if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+				return err
+			}
 		}
-		root = bytesutil.ToBytes32(b.Block().ParentRoot())
-		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
-			JustifiedCheckpoint: jCheckpoint,
-			FinalizedCheckpoint: fCheckpoint}
-		pendingNodes = append(pendingNodes, args)
 	}
-	if len(pendingNodes) == 1 {
-		return nil
+	return nil
+}
+
+// This retrieves missing blocks from DB (ie. the blocks that couldn't be received over sync) and inserts them to fork choice store.
+// This is useful for block tree visualizer and additional vote accounting.
+func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk block.BeaconBlock,
+	fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
+	pendingNodes := make([]block.BeaconBlock, 0)
+	pendingRoots := make([][32]byte, 0)
+
+	parentRoot := bytesutil.ToBytes32(blk.ParentRoot())
+	slot := blk.Slot()
+	// Fork choice only matters from last finalized slot.
+	fSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+	if err != nil {
+		return err
 	}
-	if root != s.ensureRootNotZeros(finalized.Root) {
-		return errNotDescendantOfFinalized
+	higherThanFinalized := slot > fSlot
+	// As long as parent node is not in fork choice store, and parent node is in DB.
+	for !s.cfg.ForkChoiceStore.HasNode(parentRoot) && s.cfg.BeaconDB.HasBlock(ctx, parentRoot) && higherThanFinalized {
+		b, err := s.cfg.BeaconDB.Block(ctx, parentRoot)
+		if err != nil {
+			return err
+		}
+
+		pendingNodes = append(pendingNodes, b.Block())
+		copiedRoot := parentRoot
+		pendingRoots = append(pendingRoots, copiedRoot)
+		parentRoot = bytesutil.ToBytes32(b.Block().ParentRoot())
+		slot = b.Block().Slot()
+		higherThanFinalized = slot > fSlot
 	}
-	return s.cfg.ForkChoiceStore.InsertOptimisticChain(ctx, pendingNodes)
+
+	// Insert parent nodes to fork choice store in reverse order.
+	// Lower slots should be at the end of the list.
+	for i := len(pendingNodes) - 1; i >= 0; i-- {
+		b := pendingNodes[i]
+		r := pendingRoots[i]
+		if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
+			b.Slot(), r, bytesutil.ToBytes32(b.ParentRoot()), bytesutil.ToBytes32(b.Body().Graffiti()),
+			jCheckpoint.Epoch,
+			fCheckpoint.Epoch); err != nil {
+			return errors.Wrap(err, "could not process block for proto array fork choice")
+		}
+	}
+
+	return nil
 }
 
 // inserts finalized deposits into our finalized deposit trie.
@@ -286,17 +426,10 @@ func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) e
 	// We update the cache up to the last deposit index in the finalized block's state.
 	// We can be confident that these deposits will be included in some block
 	// because the Eth1 follow distance makes such long-range reorgs extremely unlikely.
-	eth1DepositIndex, err := mathutil.Int(finalizedState.Eth1DepositIndex())
-	if err != nil {
-		return errors.Wrap(err, "could not cast eth1 deposit index")
-	}
-	// The deposit index in the state is always the index of the next deposit
-	// to be included(rather than the last one to be processed). This was most likely
-	// done as the state cannot represent signed integers.
-	eth1DepositIndex -= 1
-	s.cfg.DepositCache.InsertFinalizedDeposits(ctx, int64(eth1DepositIndex))
+	eth1DepositIndex := int64(finalizedState.Eth1Data().DepositCount - 1)
+	s.cfg.DepositCache.InsertFinalizedDeposits(ctx, eth1DepositIndex)
 	// Deposit proofs are only used during state transition and can be safely removed to save space.
-	if err = s.cfg.DepositCache.PruneProofs(ctx, int64(eth1DepositIndex)); err != nil {
+	if err = s.cfg.DepositCache.PruneProofs(ctx, eth1DepositIndex); err != nil {
 		return errors.Wrap(err, "could not prune deposit proofs")
 	}
 	return nil
@@ -323,7 +456,7 @@ func (s *Service) deletePoolAtts(atts []*ethpb.Attestation) error {
 // fork choice justification routine.
 func (s *Service) ensureRootNotZeros(root [32]byte) [32]byte {
 	if root == params.BeaconConfig().ZeroHash {
-		return s.originBlockRoot
+		return s.genesisRoot
 	}
 	return root
 }

beacon-chain/blockchain/receive_attestation.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -28,10 +27,27 @@ type AttestationStateFetcher interface {
 // AttestationReceiver interface defines the methods of chain service receive and processing new attestations.
 type AttestationReceiver interface {
 	AttestationStateFetcher
+	ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation) error
 	VerifyLmdFfgConsistency(ctx context.Context, att *ethpb.Attestation) error
 	VerifyFinalizedConsistency(ctx context.Context, root []byte) error
 }
 
+// ReceiveAttestationNoPubsub is a function that defines the operations that are performed on
+// attestation that is received from regular sync. The operations consist of:
+//  1. Validate attestation, update validator's latest vote
+//  2. Apply fork choice to the processed attestation
+//  3. Save latest head info
+func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation) error {
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveAttestationNoPubsub")
+	defer span.End()
+
+	if err := s.onAttestation(ctx, att); err != nil {
+		return errors.Wrap(err, "could not process attestation")
+	}
+
+	return nil
+}
+
 // AttestationTargetState returns the pre state of attestation.
 func (s *Service) AttestationTargetState(ctx context.Context, target *ethpb.Checkpoint) (state.BeaconState, error) {
 	ss, err := slots.EpochStart(target.Epoch)
@@ -66,8 +82,7 @@ func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a *ethpb.Attestat
 func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) error {
 	// A canonical root implies the root to has an ancestor that aligns with finalized check point.
 	// In this case, we could exit early to save on additional computation.
-	blockRoot := bytesutil.ToBytes32(root)
-	if s.cfg.ForkChoiceStore.HasNode(blockRoot) && s.cfg.ForkChoiceStore.IsCanonical(blockRoot) {
+	if s.cfg.ForkChoiceStore.IsCanonical(bytesutil.ToBytes32(root)) {
 		return nil
 	}
 
@@ -88,123 +103,38 @@ func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) e
 }
 
 // This routine processes fork choice attestations from the pool to account for validator votes and fork choice.
-func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
+func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan<- struct{}) {
 	// Wait for state to be initialized.
 	stateChannel := make(chan *feed.Event, 1)
-	stateSub := stateFeed.Subscribe(stateChannel)
-	go func() {
+	stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
+	subscribedToStateEvents <- struct{}{}
+	<-stateChannel
+	stateSub.Unsubscribe()
+
+	if s.genesisTime.IsZero() {
+		log.Warn("ProcessAttestations routine waiting for genesis time")
+		for s.genesisTime.IsZero() {
+			time.Sleep(1 * time.Second)
+		}
+		log.Warn("Genesis time received, now available to process attestations")
+	}
+
+	st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+	for {
 		select {
 		case <-s.ctx.Done():
-			stateSub.Unsubscribe()
 			return
-		case <-stateChannel:
-			stateSub.Unsubscribe()
-			break
-		}
-
-		if s.genesisTime.IsZero() {
-			log.Warn("ProcessAttestations routine waiting for genesis time")
-			for s.genesisTime.IsZero() {
-				if err := s.ctx.Err(); err != nil {
-					log.WithError(err).Error("Giving up waiting for genesis time")
-					return
-				}
-				time.Sleep(1 * time.Second)
+		case <-st.C():
+			// Continue when there's no fork choice attestation, there's nothing to process and update head.
+			// This covers the condition when the node is still initial syncing to the head of the chain.
+			if s.cfg.AttPool.ForkchoiceAttestationCount() == 0 {
+				continue
 			}
-			log.Warn("Genesis time received, now available to process attestations")
-		}
-
-		st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
-		for {
-			select {
-			case <-s.ctx.Done():
-				return
-			case <-st.C():
-				if err := s.ForkChoicer().NewSlot(s.ctx, s.CurrentSlot()); err != nil {
-					log.WithError(err).Error("Could not process new slot")
-					return
-				}
-
-				if err := s.UpdateHead(s.ctx); err != nil {
-					log.WithError(err).Error("Could not process attestations and update head")
-					return
-				}
+			s.processAttestations(s.ctx)
+			if err := s.updateHead(s.ctx, s.getJustifiedBalances()); err != nil {
+				log.Warnf("Resolving fork due to new attestation: %v", err)
 			}
 		}
-	}()
-}
-
-// UpdateHead updates the canonical head of the chain based on information from fork-choice attestations and votes.
-// It requires no external inputs.
-func (s *Service) UpdateHead(ctx context.Context) error {
-	// Continue when there's no fork choice attestation, there's nothing to process and update head.
-	// This covers the condition when the node is still initial syncing to the head of the chain.
-	if s.cfg.AttPool.ForkchoiceAttestationCount() == 0 {
-		return nil
-	}
-
-	// Only one process can process attestations and update head at a time.
-	s.processAttestationsLock.Lock()
-	defer s.processAttestationsLock.Unlock()
-
-	s.processAttestations(ctx)
-
-	justified := s.ForkChoicer().JustifiedCheckpoint()
-	balances, err := s.justifiedBalances.get(ctx, justified.Root)
-	if err != nil {
-		return err
-	}
-	newHeadRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
-	if err != nil {
-		log.WithError(err).Warn("Resolving fork due to new attestation")
-	}
-	s.headLock.RLock()
-	if s.headRoot() != newHeadRoot {
-		log.WithFields(logrus.Fields{
-			"oldHeadRoot": fmt.Sprintf("%#x", s.headRoot()),
-			"newHeadRoot": fmt.Sprintf("%#x", newHeadRoot),
-		}).Debug("Head changed due to attestations")
-	}
-	s.headLock.RUnlock()
-	s.notifyEngineIfChangedHead(ctx, newHeadRoot)
-	return nil
-}
-
-// This calls notify Forkchoice Update in the event that the head has changed
-func (s *Service) notifyEngineIfChangedHead(ctx context.Context, newHeadRoot [32]byte) {
-	s.headLock.RLock()
-	if newHeadRoot == [32]byte{} || s.headRoot() == newHeadRoot {
-		s.headLock.RUnlock()
-		return
-	}
-	s.headLock.RUnlock()
-
-	if !s.hasBlockInInitSyncOrDB(ctx, newHeadRoot) {
-		log.Debug("New head does not exist in DB. Do nothing")
-		return // We don't have the block, don't notify the engine and update head.
-	}
-
-	newHeadBlock, err := s.getBlock(ctx, newHeadRoot)
-	if err != nil {
-		log.WithError(err).Error("Could not get new head block")
-		return
-	}
-	headState, err := s.cfg.StateGen.StateByRoot(ctx, newHeadRoot)
-	if err != nil {
-		log.WithError(err).Error("Could not get state from db")
-		return
-	}
-	arg := &notifyForkchoiceUpdateArg{
-		headState: headState,
-		headRoot:  newHeadRoot,
-		headBlock: newHeadBlock.Block(),
-	}
-	_, err = s.notifyForkchoiceUpdate(s.ctx, arg)
-	if err != nil {
-		log.WithError(err).Error("could not notify forkchoice update")
-	}
-	if err := s.saveHead(ctx, newHeadRoot, newHeadBlock, headState); err != nil {
-		log.WithError(err).Error("could not save head")
 	}
 }
 
@@ -234,7 +164,7 @@ func (s *Service) processAttestations(ctx context.Context) {
 			continue
 		}
 
-		if err := s.receiveAttestationNoPubsub(ctx, a); err != nil {
+		if err := s.ReceiveAttestationNoPubsub(ctx, a); err != nil {
 			log.WithFields(logrus.Fields{
 				"slot":             a.Data.Slot,
 				"committeeIndex":   a.Data.CommitteeIndex,
@@ -245,19 +175,3 @@ func (s *Service) processAttestations(ctx context.Context) {
 		}
 	}
 }
-
-// receiveAttestationNoPubsub is a function that defines the operations that are performed on
-// attestation that is received from regular sync. The operations consist of:
-//  1. Validate attestation, update validator's latest vote
-//  2. Apply fork choice to the processed attestation
-//  3. Save latest head info
-func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation) error {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.receiveAttestationNoPubsub")
-	defer span.End()
-
-	if err := s.OnAttestation(ctx, att); err != nil {
-		return errors.Wrap(err, "could not process attestation")
-	}
-
-	return nil
-}

beacon-chain/blockchain/receive_attestation_test.go

@@ -5,17 +5,17 @@ import (
 	"testing"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"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/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
@@ -42,20 +42,22 @@ func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 
 func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
+	beaconDB := testDB.SetupDB(t)
 
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b32)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b33)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -69,20 +71,22 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 
 func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b32)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b33)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -97,12 +101,18 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 func TestProcessAttestations_Ok(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	opts = append(opts, WithAttestationPool(attestations.NewPool()))
+	beaconDB := testDB.SetupDB(t)
 
-	service, err := NewService(ctx, opts...)
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
+		AttPool:         attestations.NewPool(),
+	}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
 	service.genesisTime = prysmTime.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
+	service.cfg = cfg
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	require.NoError(t, genesisState.SetGenesisTime(uint64(prysmTime.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
@@ -113,143 +123,9 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
 	service.processAttestations(ctx)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))
 	require.LogsDoNotContain(t, hook, "Could not process attestation for fork choice")
 }
-
-func TestNotifyEngineIfChangedHead(t *testing.T) {
-	hook := logTest.NewGlobal()
-	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	service.cfg.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
-	service.notifyEngineIfChangedHead(ctx, service.headRoot())
-	hookErr := "could not notify forkchoice update"
-	invalidStateErr := "Could not get state from db"
-	require.LogsDoNotContain(t, hook, invalidStateErr)
-	require.LogsDoNotContain(t, hook, hookErr)
-	gb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	require.NoError(t, service.saveInitSyncBlock(ctx, [32]byte{'a'}, gb))
-	service.notifyEngineIfChangedHead(ctx, [32]byte{'a'})
-	require.LogsContain(t, hook, invalidStateErr)
-
-	hook.Reset()
-	service.head = &head{
-		root:  [32]byte{'a'},
-		block: nil, /* should not panic if notify head uses correct head */
-	}
-
-	// Block in Cache
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 2
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	r1, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, service.saveInitSyncBlock(ctx, r1, wsb))
-	st, _ := util.DeterministicGenesisState(t, 1)
-	service.head = &head{
-		slot:  1,
-		root:  r1,
-		block: wsb,
-		state: st,
-	}
-	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1})
-	service.notifyEngineIfChangedHead(ctx, r1)
-	require.LogsDoNotContain(t, hook, invalidStateErr)
-	require.LogsDoNotContain(t, hook, hookErr)
-
-	// Block in DB
-	b = util.NewBeaconBlock()
-	b.Block.Slot = 3
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
-	r1, err = b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	st, _ = util.DeterministicGenesisState(t, 1)
-	service.head = &head{
-		slot:  1,
-		root:  r1,
-		block: wsb,
-		state: st,
-	}
-	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1})
-	service.notifyEngineIfChangedHead(ctx, r1)
-	require.LogsDoNotContain(t, hook, invalidStateErr)
-	require.LogsDoNotContain(t, hook, hookErr)
-	vId, payloadID, has := service.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(2)
-	require.Equal(t, true, has)
-	require.Equal(t, types.ValidatorIndex(1), vId)
-	require.Equal(t, [8]byte{1}, payloadID)
-
-	// Test zero headRoot returns immediately.
-	headRoot := service.headRoot()
-	service.notifyEngineIfChangedHead(ctx, [32]byte{})
-	require.Equal(t, service.headRoot(), headRoot)
-}
-
-func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
-	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	fcs := protoarray.New()
-	opts = append(opts,
-		WithAttestationPool(attestations.NewPool()),
-		WithStateNotifier(&mockBeaconNode{}),
-		WithForkChoiceStore(fcs),
-	)
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	service.genesisTime = prysmTime.Now().Add(-2 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
-	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	copied := genesisState.Copy()
-	// Generate a new block for attesters to attest
-	blk, err := util.GenerateFullBlock(copied, pks, util.DefaultBlockGenConfig(), 1)
-	require.NoError(t, err)
-	tRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, service.onBlock(ctx, wsb, tRoot))
-	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
-	require.NoError(t, err)
-	require.Equal(t, 2, fcs.NodeCount())
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
-
-	// Generate attestatios for this block in Slot 1
-	atts, err := util.GenerateAttestations(copied, pks, 1, 1, false)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
-	// Verify the target is in forchoice
-	require.Equal(t, true, fcs.HasNode(bytesutil.ToBytes32(atts[0].Data.BeaconBlockRoot)))
-
-	// Insert a new block to forkchoice
-	ojc := &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}
-	b, err := util.GenerateFullBlock(genesisState, pks, util.DefaultBlockGenConfig(), 2)
-	require.NoError(t, err)
-	b.Block.ParentRoot = service.originBlockRoot[:]
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
-	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, ojc, ojc)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	require.Equal(t, 3, fcs.NodeCount())
-	service.head.root = r // Old head
-
-	require.Equal(t, 1, len(service.cfg.AttPool.ForkchoiceAttestations()))
-	require.NoError(t, err, service.UpdateHead(ctx))
-
-	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations())) // Validate att pool is empty
-	require.Equal(t, tRoot, service.head.root)                             // Validate head is the new one
-}

beacon-chain/blockchain/receive_block.go

@@ -4,12 +4,11 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
@@ -18,24 +17,19 @@ import (
 // This defines how many epochs since finality the run time will begin to save hot state on to the DB.
 var epochsSinceFinalitySaveHotStateDB = types.Epoch(100)
 
-// BlockReceiver interface defines the methods of chain service for receiving and processing new blocks.
+// BlockReceiver interface defines the methods of chain service receive and processing new blocks.
 type BlockReceiver interface {
-	ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, blockRoot [32]byte) error
-	ReceiveBlockBatch(ctx context.Context, blocks []interfaces.SignedBeaconBlock, blkRoots [][32]byte) error
-	HasBlock(ctx context.Context, root [32]byte) bool
+	ReceiveBlock(ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error
+	ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBeaconBlock, blkRoots [][32]byte) error
+	HasInitSyncBlock(root [32]byte) bool
 }
 
-// SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
-type SlashingReceiver interface {
-	ReceiveAttesterSlashing(ctx context.Context, slashings *ethpb.AttesterSlashing)
-}
-
-// ReceiveBlock is a function that defines the operations (minus pubsub)
-// that are performed on a received block. The operations consist of:
-//   1. Validate block, apply state transition and update checkpoints
+// ReceiveBlock is a function that defines the the operations (minus pubsub)
+// that are performed on blocks that is received from regular sync service. The operations consists of:
+//   1. Validate block, apply state transition and update check points
 //   2. Apply fork choice to the processed block
 //   3. Save latest head info
-func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, blockRoot [32]byte) error {
+func (s *Service) ReceiveBlock(ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
 	receivedTime := time.Now()
@@ -59,22 +53,14 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaco
 	}
 
 	// Reports on block and fork choice metrics.
-	finalized := s.FinalizedCheckpt()
-	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
+	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 
 	// Log block sync status.
-	justified := s.CurrentJustifiedCheckpt()
-	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix())); err != nil {
-		log.WithError(err).Error("Unable to log block sync status")
-	}
-	// Log payload data
-	if err := logPayload(blockCopy.Block()); err != nil {
-		log.WithError(err).Error("Unable to log debug block payload data")
+	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, s.finalizedCheckpt, receivedTime, uint64(s.genesisTime.Unix())); err != nil {
+		return err
 	}
 	// Log state transition data.
-	if err := logStateTransitionData(blockCopy.Block()); err != nil {
-		log.WithError(err).Error("Unable to log state transition data")
-	}
+	logStateTransitionData(blockCopy.Block())
 
 	return nil
 }
@@ -82,12 +68,13 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaco
 // ReceiveBlockBatch processes the whole block batch at once, assuming the block batch is linear ,transitioning
 // the state, performing batch verification of all collected signatures and then performing the appropriate
 // actions for a block post-transition.
-func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.SignedBeaconBlock, blkRoots [][32]byte) error {
+func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBeaconBlock, blkRoots [][32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlockBatch")
 	defer span.End()
 
-	// Apply state transition on the incoming newly received block batches, one by one.
-	if err := s.onBlockBatch(ctx, blocks, blkRoots); err != nil {
+	// Apply state transition on the incoming newly received blockCopy without verifying its BLS contents.
+	fCheckpoints, jCheckpoints, err := s.onBlockBatch(ctx, blocks, blkRoots)
+	if err != nil {
 		err := errors.Wrap(err, "could not process block in batch")
 		tracing.AnnotateError(span, err)
 		return err
@@ -95,6 +82,10 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 
 	for i, b := range blocks {
 		blockCopy := b.Copy()
+		if err = s.handleBlockAfterBatchVerify(ctx, blockCopy, blkRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
+			tracing.AnnotateError(span, err)
+			return err
+		}
 		// Send notification of the processed block to the state feed.
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.BlockProcessed,
@@ -107,18 +98,13 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 		})
 
 		// Reports on blockCopy and fork choice metrics.
-		finalized := s.FinalizedCheckpt()
-		reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
+		reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 	}
 
 	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
 		return err
 	}
-	finalized := s.FinalizedCheckpt()
-	if finalized == nil {
-		return errNilFinalizedInStore
-	}
-	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, finalized.Epoch); err != nil {
+	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, s.finalizedCheckpt.Epoch); err != nil {
 		// log.Fatalf will prevent defer from being called
 		span.End()
 		// Exit run time if the node failed to verify weak subjectivity checkpoint.
@@ -128,17 +114,12 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 	return nil
 }
 
-// HasBlock returns true if the block of the input root exists in initial sync blocks cache or DB.
-func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
-	return s.hasBlockInInitSyncOrDB(ctx, root)
+// HasInitSyncBlock returns true if the block of the input root exists in initial sync blocks cache.
+func (s *Service) HasInitSyncBlock(root [32]byte) bool {
+	return s.hasInitSyncBlock(root)
 }
 
-// ReceiveAttesterSlashing receives an attester slashing and inserts it to forkchoice
-func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) {
-	s.InsertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
-}
-
-func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {
+func (s *Service) handlePostBlockOperations(b block.BeaconBlock) error {
 	// Delete the processed block attestations from attestation pool.
 	if err := s.deletePoolAtts(b.Body().Attestations()); err != nil {
 		return err
@@ -167,12 +148,8 @@ func (s *Service) checkSaveHotStateDB(ctx context.Context) error {
 	currentEpoch := slots.ToEpoch(s.CurrentSlot())
 	// Prevent `sinceFinality` going underflow.
 	var sinceFinality types.Epoch
-	finalized := s.FinalizedCheckpt()
-	if finalized == nil {
-		return errNilFinalizedInStore
-	}
-	if currentEpoch > finalized.Epoch {
-		sinceFinality = currentEpoch - finalized.Epoch
+	if currentEpoch > s.finalizedCheckpt.Epoch {
+		sinceFinality = currentEpoch - s.finalizedCheckpt.Epoch
 	}
 
 	if sinceFinality >= epochsSinceFinalitySaveHotStateDB {

beacon-chain/blockchain/receive_block_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	blockchainTesting "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
@@ -13,11 +14,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
@@ -33,8 +33,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		assert.NoError(t, err)
 		return blk
 	}
-	params.SetupTestConfigCleanup(t)
-	bc := params.BeaconConfig().Copy()
+	bc := params.BeaconConfig()
 	bc.ShardCommitteePeriod = 0 // Required for voluntary exits test in reasonable time.
 	params.OverrideBeaconConfig(bc)
 
@@ -125,23 +124,30 @@ func TestService_ReceiveBlock(t *testing.T) {
 			genesisBlockRoot := bytesutil.ToBytes32(nil)
 			require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
 
-			opts := []Option{
-				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New()),
-				WithAttestationPool(attestations.NewPool()),
-				WithExitPool(voluntaryexits.NewPool()),
-				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
-				WithStateGen(stategen.New(beaconDB)),
-				WithFinalizedStateAtStartUp(genesis),
+			cfg := &config{
+				BeaconDB: beaconDB,
+				ForkChoiceStore: protoarray.New(
+					0, // justifiedEpoch
+					0, // finalizedEpoch
+					genesisBlockRoot,
+				),
+				AttPool:       attestations.NewPool(),
+				ExitPool:      voluntaryexits.NewPool(),
+				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+				StateGen:      stategen.New(beaconDB),
 			}
-			s, err := NewService(ctx, opts...)
+			s, err := NewService(ctx)
 			require.NoError(t, err)
+			s.cfg = cfg
 			require.NoError(t, s.saveGenesisData(ctx, genesis))
+			gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
+			require.NoError(t, err)
+			gRoot, err := gBlk.Block().HashTreeRoot()
+			require.NoError(t, err)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
-			require.NoError(t, err)
-			err = s.ReceiveBlock(ctx, wsb, root)
+			err = s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block), root)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
@@ -160,26 +166,33 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	genesisBlockRoot := bytesutil.ToBytes32(nil)
 	require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New()),
-		WithAttestationPool(attestations.NewPool()),
-		WithExitPool(voluntaryexits.NewPool()),
-		WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		ForkChoiceStore: protoarray.New(
+			0, // justifiedEpoch
+			0, // finalizedEpoch
+			genesisBlockRoot,
+		),
+		AttPool:       attestations.NewPool(),
+		ExitPool:      voluntaryexits.NewPool(),
+		StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+		StateGen:      stategen.New(beaconDB),
 	}
-
-	s, err := NewService(ctx, opts...)
+	s, err := NewService(ctx)
 	require.NoError(t, err)
+	s.cfg = cfg
 	require.NoError(t, s.saveGenesisData(ctx, genesis))
+	gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
+	require.NoError(t, err)
+	gRoot, err := gBlk.Block().HashTreeRoot()
+	require.NoError(t, err)
+	s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, s.ReceiveBlock(ctx, wsb, root))
+		require.NoError(t, s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b), root))
 		wg.Done()
 	}()
 	wg.Wait()
@@ -187,7 +200,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 		t.Errorf("Received %d state notifications, expected at least 1", recvd)
 	}
 	// Verify fork choice has processed the block. (Genesis block and the new block)
-	assert.Equal(t, 2, s.cfg.ForkChoiceStore.NodeCount())
+	assert.Equal(t, 2, len(s.cfg.ForkChoiceStore.Nodes()))
 }
 
 func TestService_ReceiveBlockBatch(t *testing.T) {
@@ -235,21 +248,32 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			beaconDB := testDB.SetupDB(t)
-			opts := []Option{
-				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New()),
-				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
-				WithStateGen(stategen.New(beaconDB)),
-			}
-			s, err := NewService(ctx, opts...)
+			genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
 			require.NoError(t, err)
+			cfg := &config{
+				BeaconDB: beaconDB,
+				ForkChoiceStore: protoarray.New(
+					0, // justifiedEpoch
+					0, // finalizedEpoch
+					genesisBlockRoot,
+				),
+				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+				StateGen:      stategen.New(beaconDB),
+			}
+			s, err := NewService(ctx)
+			require.NoError(t, err)
+			s.cfg = cfg
 			err = s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
+			gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
+			require.NoError(t, err)
+
+			gRoot, err := gBlk.Block().HashTreeRoot()
+			require.NoError(t, err)
+			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
-			require.NoError(t, err)
-			blks := []interfaces.SignedBeaconBlock{wsb}
+			blks := []block.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block)}
 			roots := [][32]byte{root}
 			err = s.ReceiveBlockBatch(ctx, blks, roots)
 			if tt.wantedErr != "" {
@@ -262,48 +286,41 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 	}
 }
 
-func TestService_HasBlock(t *testing.T) {
-	opts := testServiceOptsWithDB(t)
-	opts = append(opts, WithStateNotifier(&blockchainTesting.MockStateNotifier{}))
-	s, err := NewService(context.Background(), opts...)
+func TestService_HasInitSyncBlock(t *testing.T) {
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
+	s.cfg = &config{StateNotifier: &blockchainTesting.MockStateNotifier{}}
 	r := [32]byte{'a'}
-	if s.HasBlock(context.Background(), r) {
+	if s.HasInitSyncBlock(r) {
 		t.Error("Should not have block")
 	}
-	wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	require.NoError(t, s.saveInitSyncBlock(context.Background(), r, wsb))
-	if !s.HasBlock(context.Background(), r) {
+	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()))
+	if !s.HasInitSyncBlock(r) {
 		t.Error("Should have block")
 	}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 1
-	util.SaveBlock(t, context.Background(), s.cfg.BeaconDB, b)
-	r, err = b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.Equal(t, true, s.HasBlock(context.Background(), r))
 }
 
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
-	opts := testServiceOptsWithDB(t)
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background(), opts...)
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
+	s.cfg = &config{StateGen: stategen.New(beaconDB)}
 	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
 	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
+	s.finalizedCheckpt = &ethpb.Checkpoint{}
 
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	assert.LogsContain(t, hook, "Entering mode to save hot states in DB")
 }
 
 func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	opts := testServiceOptsWithDB(t)
-	s, err := NewService(context.Background(), opts...)
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
-	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
-	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
+	s.cfg = &config{StateGen: stategen.New(beaconDB)}
+	s.finalizedCheckpt = &ethpb.Checkpoint{}
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	s.genesisTime = time.Now()
 
@@ -312,10 +329,12 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 }
 
 func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	opts := testServiceOptsWithDB(t)
-	s, err := NewService(context.Background(), opts...)
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
+	s.cfg = &config{StateGen: stategen.New(beaconDB)}
+	s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
 	s.genesisTime = time.Now()
 
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))

beacon-chain/blockchain/service.go

@@ -3,7 +3,6 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"runtime"
@@ -11,6 +10,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
@@ -20,9 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
@@ -31,15 +29,12 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	prysmTime "github.com/prysmaticlabs/prysm/time"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
@@ -50,21 +45,26 @@ const headSyncMinEpochsAfterCheckpoint = 128
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                     *config
-	ctx                     context.Context
-	cancel                  context.CancelFunc
-	genesisTime             time.Time
-	head                    *head
-	headLock                sync.RWMutex
-	originBlockRoot         [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	nextEpochBoundarySlot   types.Slot
-	boundaryRoots           [][32]byte
-	checkpointStateCache    *cache.CheckpointStateCache
-	initSyncBlocks          map[[32]byte]interfaces.SignedBeaconBlock
-	initSyncBlocksLock      sync.RWMutex
-	justifiedBalances       *stateBalanceCache
-	wsVerifier              *WeakSubjectivityVerifier
-	processAttestationsLock sync.Mutex
+	cfg                   *config
+	ctx                   context.Context
+	cancel                context.CancelFunc
+	genesisTime           time.Time
+	head                  *head
+	headLock              sync.RWMutex
+	genesisRoot           [32]byte
+	justifiedCheckpt      *ethpb.Checkpoint
+	prevJustifiedCheckpt  *ethpb.Checkpoint
+	bestJustifiedCheckpt  *ethpb.Checkpoint
+	finalizedCheckpt      *ethpb.Checkpoint
+	prevFinalizedCheckpt  *ethpb.Checkpoint
+	nextEpochBoundarySlot types.Slot
+	boundaryRoots         [][32]byte
+	checkpointStateCache  *cache.CheckpointStateCache
+	initSyncBlocks        map[[32]byte]block.SignedBeaconBlock
+	initSyncBlocksLock    sync.RWMutex
+	justifiedBalances     []uint64
+	justifiedBalancesLock sync.RWMutex
+	wsVerifier            *WeakSubjectivityVerifier
 }
 
 // config options for the service.
@@ -73,7 +73,6 @@ type config struct {
 	ChainStartFetcher       powchain.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
 	DepositCache            *depositcache.DepositCache
-	ProposerSlotIndexCache  *cache.ProposerPayloadIDsCache
 	AttPool                 attestations.Pool
 	ExitPool                voluntaryexits.PoolManager
 	SlashingPool            slashings.PoolManager
@@ -86,8 +85,7 @@ type config struct {
 	SlasherAttestationsFeed *event.Feed
 	WeakSubjectivityCheckpt *ethpb.Checkpoint
 	BlockFetcher            powchain.POWBlockFetcher
-	FinalizedStateAtStartUp state.BeaconState
-	ExecutionEngineCaller   powchain.EngineCaller
+	ExecutionEngineCaller   powchain.ExecutionEngineCaller
 }
 
 // NewService instantiates a new block service instance that will
@@ -99,7 +97,8 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		cancel:               cancel,
 		boundaryRoots:        [][32]byte{},
 		checkpointStateCache: cache.NewCheckpointStateCache(),
-		initSyncBlocks:       make(map[[32]byte]interfaces.SignedBeaconBlock),
+		initSyncBlocks:       make(map[[32]byte]block.SignedBeaconBlock),
+		justifiedBalances:    make([]uint64, 0),
 		cfg:                  &config{},
 	}
 	for _, opt := range opts {
@@ -108,12 +107,6 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		}
 	}
 	var err error
-	if srv.justifiedBalances == nil {
-		srv.justifiedBalances, err = newStateBalanceCache(srv.cfg.StateGen)
-		if err != nil {
-			return nil, err
-		}
-	}
 	srv.wsVerifier, err = NewWeakSubjectivityVerifier(srv.cfg.WeakSubjectivityCheckpt, srv.cfg.BeaconDB)
 	if err != nil {
 		return nil, err
@@ -123,271 +116,149 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 
 // Start a blockchain service's main event loop.
 func (s *Service) Start() {
-	saved := s.cfg.FinalizedStateAtStartUp
-
-	if saved != nil && !saved.IsNil() {
-		if err := s.StartFromSavedState(saved); err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		if err := s.startFromPOWChain(); err != nil {
-			log.Fatal(err)
-		}
-	}
-	s.spawnProcessAttestationsRoutine(s.cfg.StateNotifier.StateFeed())
-	s.fillMissingPayloadIDRoutine(s.ctx, s.cfg.StateNotifier.StateFeed())
-}
-
-// Stop the blockchain service's main event loop and associated goroutines.
-func (s *Service) Stop() error {
-	defer s.cancel()
-
-	// lock before accessing s.head, s.head.state, s.head.state.FinalizedCheckpoint().Root
-	s.headLock.RLock()
-	if s.cfg.StateGen != nil && s.head != nil && s.head.state != nil {
-		r := s.head.state.FinalizedCheckpoint().Root
-		s.headLock.RUnlock()
-		// Save the last finalized state so that starting up in the following run will be much faster.
-		if err := s.cfg.StateGen.ForceCheckpoint(s.ctx, r); err != nil {
-			return err
-		}
-	} else {
-		s.headLock.RUnlock()
-	}
-	// Save initial sync cached blocks to the DB before stop.
-	return s.cfg.BeaconDB.SaveBlocks(s.ctx, s.getInitSyncBlocks())
-}
-
-// Status always returns nil unless there is an error condition that causes
-// this service to be unhealthy.
-func (s *Service) Status() error {
-	if s.originBlockRoot == params.BeaconConfig().ZeroHash {
-		return errors.New("genesis state has not been created")
-	}
-	if runtime.NumGoroutine() > s.cfg.MaxRoutines {
-		return fmt.Errorf("too many goroutines (%d)", runtime.NumGoroutine())
-	}
-	return nil
-}
-
-// StartFromSavedState initializes the blockchain using a previously saved finalized checkpoint.
-func (s *Service) StartFromSavedState(saved state.BeaconState) error {
-	log.Info("Blockchain data already exists in DB, initializing...")
-	s.genesisTime = time.Unix(int64(saved.GenesisTime()), 0) // lint:ignore uintcast -- Genesis time will not exceed int64 in your lifetime.
-	s.cfg.AttService.SetGenesisTime(saved.GenesisTime())
-
-	originRoot, err := s.originRootFromSavedState(s.ctx)
+	// For running initial sync with state cache, in an event of restart, we use
+	// last finalized check point as start point to sync instead of head
+	// state. This is because we no longer save state every slot during sync.
+	cp, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
 	if err != nil {
-		return err
-	}
-	s.originBlockRoot = originRoot
-
-	if err := s.initializeHeadFromDB(s.ctx); err != nil {
-		return errors.Wrap(err, "could not set up chain info")
-	}
-	spawnCountdownIfPreGenesis(s.ctx, s.genesisTime, s.cfg.BeaconDB)
-
-	justified, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get justified checkpoint")
-	}
-	if justified == nil {
-		return errNilJustifiedCheckpoint
-	}
-	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint")
-	}
-	if finalized == nil {
-		return errNilFinalizedCheckpoint
+		log.Fatalf("Could not fetch finalized cp: %v", err)
 	}
 
-	var forkChoicer f.ForkChoicer
-	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
-	if features.Get().EnableForkChoiceDoublyLinkedTree {
-		forkChoicer = doublylinkedtree.New()
-	} else {
-		forkChoicer = protoarray.New()
-	}
-	s.cfg.ForkChoiceStore = forkChoicer
-	if err := forkChoicer.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
-		Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
-	}
-	if err := forkChoicer.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
-		Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's finalized checkpoint")
-	}
-	forkChoicer.SetGenesisTime(uint64(s.genesisTime.Unix()))
-
-	st, err := s.cfg.StateGen.StateByRoot(s.ctx, fRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint state")
-	}
-	if err := forkChoicer.InsertNode(s.ctx, st, fRoot); err != nil {
-		return errors.Wrap(err, "could not insert finalized block to forkchoice")
-	}
-
-	lastValidatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get last validated checkpoint")
-	}
-	if bytes.Equal(finalized.Root, lastValidatedCheckpoint.Root) {
-		if err := forkChoicer.SetOptimisticToValid(s.ctx, fRoot); err != nil {
-			return errors.Wrap(err, "could not set finalized block as validated")
-		}
-	}
-	// not attempting to save initial sync blocks here, because there shouldn't be any until
-	// after the statefeed.Initialized event is fired (below)
-	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, finalized.Epoch); err != nil {
-		// Exit run time if the node failed to verify weak subjectivity checkpoint.
-		return errors.Wrap(err, "could not verify initial checkpoint provided for chain sync")
-	}
-
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.Initialized,
-		Data: &statefeed.InitializedData{
-			StartTime:             s.genesisTime,
-			GenesisValidatorsRoot: saved.GenesisValidatorsRoot(),
-		},
-	})
-
-	return nil
-}
-
-func (s *Service) originRootFromSavedState(ctx context.Context) ([32]byte, error) {
-	// first check if we have started from checkpoint sync and have a root
-	originRoot, err := s.cfg.BeaconDB.OriginCheckpointBlockRoot(ctx)
-	if err == nil {
-		return originRoot, nil
-	}
-	if !errors.Is(err, db.ErrNotFound) {
-		return originRoot, errors.Wrap(err, "could not retrieve checkpoint sync chain origin data from db")
-	}
-
-	// we got here because OriginCheckpointBlockRoot gave us an ErrNotFound. this means the node was started from a genesis state,
-	// so we should have a value for GenesisBlock
-	genesisBlock, err := s.cfg.BeaconDB.GenesisBlock(ctx)
-	if err != nil {
-		return originRoot, errors.Wrap(err, "could not get genesis block from db")
-	}
-	if err := wrapper.BeaconBlockIsNil(genesisBlock); err != nil {
-		return originRoot, err
-	}
-	genesisBlkRoot, err := genesisBlock.Block().HashTreeRoot()
-	if err != nil {
-		return genesisBlkRoot, errors.Wrap(err, "could not get signing root of genesis block")
-	}
-	return genesisBlkRoot, nil
-}
-
-// initializeHeadFromDB uses the finalized checkpoint and head block found in the database to set the current head.
-// Note that this may block until stategen replays blocks between the finalized and head blocks
-// if the head sync flag was specified and the gap between the finalized and head blocks is at least 128 epochs long.
-func (s *Service) initializeHeadFromDB(ctx context.Context) error {
-	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint from db")
-	}
-	if finalized == nil {
-		// This should never happen. At chain start, the finalized checkpoint
-		// would be the genesis state and block.
-		return errors.New("no finalized epoch in the database")
-	}
-	finalizedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
-	var finalizedState state.BeaconState
-
-	finalizedState, err = s.cfg.StateGen.Resume(ctx, s.cfg.FinalizedStateAtStartUp)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized state from db")
-	}
-
-	if flags.Get().HeadSync {
-		headBlock, err := s.cfg.BeaconDB.HeadBlock(ctx)
+	r := bytesutil.ToBytes32(cp.Root)
+	// Before the first finalized epoch, in the current epoch,
+	// the finalized root is defined as zero hashes instead of genesis root hash.
+	// We want to use genesis root to retrieve for state.
+	if r == params.BeaconConfig().ZeroHash {
+		genesisBlock, err := s.cfg.BeaconDB.GenesisBlock(s.ctx)
 		if err != nil {
-			return errors.Wrap(err, "could not retrieve head block")
+			log.Fatalf("Could not fetch finalized cp: %v", err)
 		}
-		headEpoch := slots.ToEpoch(headBlock.Block().Slot())
-		var epochsSinceFinality types.Epoch
-		if headEpoch > finalized.Epoch {
-			epochsSinceFinality = headEpoch - finalized.Epoch
-		}
-		// Head sync when node is far enough beyond known finalized epoch,
-		// this becomes really useful during long period of non-finality.
-		if epochsSinceFinality >= headSyncMinEpochsAfterCheckpoint {
-			headRoot, err := headBlock.Block().HashTreeRoot()
+		if genesisBlock != nil && !genesisBlock.IsNil() {
+			r, err = genesisBlock.Block().HashTreeRoot()
 			if err != nil {
-				return errors.Wrap(err, "could not hash head block")
+				log.Fatalf("Could not tree hash genesis block: %v", err)
 			}
-			finalizedState, err := s.cfg.StateGen.Resume(ctx, s.cfg.FinalizedStateAtStartUp)
-			if err != nil {
-				return errors.Wrap(err, "could not get finalized state from db")
-			}
-			log.Infof("Regenerating state from the last checkpoint at slot %d to current head slot of %d."+
-				"This process may take a while, please wait.", finalizedState.Slot(), headBlock.Block().Slot())
-			headState, err := s.cfg.StateGen.StateByRoot(ctx, headRoot)
-			if err != nil {
-				return errors.Wrap(err, "could not retrieve head state")
-			}
-			s.setHead(headRoot, headBlock, headState)
-			return nil
-		} else {
-			log.Warnf("Finalized checkpoint at slot %d is too close to the current head slot, "+
-				"resetting head from the checkpoint ('--%s' flag is ignored).",
-				finalizedState.Slot(), flags.HeadSync.Name)
 		}
 	}
-	if finalizedState == nil || finalizedState.IsNil() {
-		return errors.New("finalized state can't be nil")
-	}
-
-	finalizedBlock, err := s.getBlock(ctx, finalizedRoot)
+	beaconState, err := s.cfg.StateGen.StateByRoot(s.ctx, r)
 	if err != nil {
-		return errors.Wrap(err, "could not get finalized block")
+		log.Fatalf("Could not fetch beacon state by root: %v", err)
 	}
-	s.setHead(finalizedRoot, finalizedBlock, finalizedState)
 
-	return nil
-}
+	// Make sure that attestation processor is subscribed and ready for state initializing event.
+	attestationProcessorSubscribed := make(chan struct{}, 1)
 
-func (s *Service) startFromPOWChain() error {
-	log.Info("Waiting to reach the validator deposit threshold to start the beacon chain...")
-	if s.cfg.ChainStartFetcher == nil {
-		return errors.New("not configured web3Service for POW chain")
-	}
-	go func() {
-		stateChannel := make(chan *feed.Event, 1)
-		stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
-		defer stateSub.Unsubscribe()
-		for {
-			select {
-			case e := <-stateChannel:
-				if e.Type == statefeed.ChainStarted {
-					data, ok := e.Data.(*statefeed.ChainStartedData)
-					if !ok {
-						log.Error("event data is not type *statefeed.ChainStartedData")
+	// If the chain has already been initialized, simply start the block processing routine.
+	if beaconState != nil && !beaconState.IsNil() {
+		log.Info("Blockchain data already exists in DB, initializing...")
+
+		s.genesisTime = time.Unix(int64(beaconState.GenesisTime()), 0)
+		s.cfg.AttService.SetGenesisTime(beaconState.GenesisTime())
+		if err := s.initializeChainInfo(s.ctx); err != nil {
+			log.Fatalf("Could not set up chain info: %v", err)
+		}
+
+		// We start a counter to genesis, if needed.
+		gState, err := s.cfg.BeaconDB.GenesisState(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not retrieve genesis state: %v", err)
+		}
+		gRoot, err := gState.HashTreeRoot(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not hash tree root genesis state: %v", err)
+		}
+		go slots.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()), gRoot)
+
+		justifiedCheckpoint, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not get justified checkpoint: %v", err)
+		}
+		finalizedCheckpoint, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not get finalized checkpoint: %v", err)
+		}
+
+		// Resume fork choice.
+		s.justifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		if err := s.cacheJustifiedStateBalances(s.ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))); err != nil {
+			log.Fatalf("Could not cache justified state balances: %v", err)
+		}
+		s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.finalizedCheckpt = ethpb.CopyCheckpoint(finalizedCheckpoint)
+		s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(finalizedCheckpoint)
+		s.resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint)
+
+		ss, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+		if err != nil {
+			log.Fatalf("Could not get start slot of finalized epoch: %v", err)
+		}
+		h := s.headBlock().Block()
+		if h.Slot() > ss {
+			log.WithFields(logrus.Fields{
+				"startSlot": ss,
+				"endSlot":   h.Slot(),
+			}).Info("Loading blocks to fork choice store, this may take a while.")
+			if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, s.finalizedCheckpt, s.justifiedCheckpt); err != nil {
+				log.Fatalf("Could not fill in fork choice store missing blocks: %v", err)
+			}
+		}
+
+		// not attempting to save initial sync blocks here, because there shouldn't be until
+		// after the statefeed.Initialized event is fired (below)
+		if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, s.finalizedCheckpt.Epoch); err != nil {
+			// Exit run time if the node failed to verify weak subjectivity checkpoint.
+			log.Fatalf("could not verify initial checkpoint provided for chain sync, with err=: %v", err)
+		}
+
+		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.Initialized,
+			Data: &statefeed.InitializedData{
+				StartTime:             s.genesisTime,
+				GenesisValidatorsRoot: beaconState.GenesisValidatorRoot(),
+			},
+		})
+	} else {
+		log.Info("Waiting to reach the validator deposit threshold to start the beacon chain...")
+		if s.cfg.ChainStartFetcher == nil {
+			log.Fatal("Not configured web3Service for POW chain")
+			return // return need for TestStartUninitializedChainWithoutConfigPOWChain.
+		}
+		go func() {
+			stateChannel := make(chan *feed.Event, 1)
+			stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
+			defer stateSub.Unsubscribe()
+			<-attestationProcessorSubscribed
+			for {
+				select {
+				case event := <-stateChannel:
+					if event.Type == statefeed.ChainStarted {
+						data, ok := event.Data.(*statefeed.ChainStartedData)
+						if !ok {
+							log.Error("event data is not type *statefeed.ChainStartedData")
+							return
+						}
+						log.WithField("starttime", data.StartTime).Debug("Received chain start event")
+						s.processChainStartTime(s.ctx, data.StartTime)
 						return
 					}
-					log.WithField("starttime", data.StartTime).Debug("Received chain start event")
-					s.onPowchainStart(s.ctx, data.StartTime)
+				case <-s.ctx.Done():
+					log.Debug("Context closed, exiting goroutine")
+					return
+				case err := <-stateSub.Err():
+					log.WithError(err).Error("Subscription to state notifier failed")
 					return
 				}
-			case <-s.ctx.Done():
-				log.Debug("Context closed, exiting goroutine")
-				return
-			case err := <-stateSub.Err():
-				log.WithError(err).Error("Subscription to state notifier failed")
-				return
 			}
-		}
-	}()
+		}()
+	}
 
-	return nil
+	go s.processAttestationsRoutine(attestationProcessorSubscribed)
 }
 
-// onPowchainStart initializes a series of deposits from the ChainStart deposits in the eth1
+// processChainStartTime initializes a series of deposits from the ChainStart deposits in the eth1
 // deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
-func (s *Service) onPowchainStart(ctx context.Context, genesisTime time.Time) {
+func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Time) {
 	preGenesisState := s.cfg.ChainStartFetcher.PreGenesisState()
 	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.cfg.ChainStartFetcher.ChainStartEth1Data())
 	if err != nil {
@@ -406,7 +277,7 @@ func (s *Service) onPowchainStart(ctx context.Context, genesisTime time.Time) {
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
 			StartTime:             genesisTime,
-			GenesisValidatorsRoot: initializedState.GenesisValidatorsRoot(),
+			GenesisValidatorsRoot: initializedState.GenesisValidatorRoot(),
 		},
 	})
 }
@@ -439,7 +310,7 @@ func (s *Service) initializeBeaconChain(
 	s.cfg.ChainStartFetcher.ClearPreGenesisData()
 
 	// Update committee shuffled indices for genesis epoch.
-	if err := helpers.UpdateCommitteeCache(ctx, genesisState, 0); err != nil {
+	if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
 		return nil, err
 	}
 	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState); err != nil {
@@ -451,6 +322,32 @@ func (s *Service) initializeBeaconChain(
 	return genesisState, nil
 }
 
+// Stop the blockchain service's main event loop and associated goroutines.
+func (s *Service) Stop() error {
+	defer s.cancel()
+
+	if s.cfg.StateGen != nil && s.head != nil && s.head.state != nil {
+		if err := s.cfg.StateGen.ForceCheckpoint(s.ctx, s.head.state.FinalizedCheckpoint().Root); err != nil {
+			return err
+		}
+	}
+
+	// Save initial sync cached blocks to the DB before stop.
+	return s.cfg.BeaconDB.SaveBlocks(s.ctx, s.getInitSyncBlocks())
+}
+
+// Status always returns nil unless there is an error condition that causes
+// this service to be unhealthy.
+func (s *Service) Status() error {
+	if s.genesisRoot == params.BeaconConfig().ZeroHash {
+		return errors.New("genesis state has not been created")
+	}
+	if runtime.NumGoroutine() > s.cfg.MaxRoutines {
+		return fmt.Errorf("too many goroutines %d", runtime.NumGoroutine())
+	}
+	return nil
+}
+
 // This gets called when beacon chain is first initialized to save genesis data (state, block, and more) in db.
 func (s *Service) saveGenesisData(ctx context.Context, genesisState state.BeaconState) error {
 	if err := s.cfg.BeaconDB.SaveGenesisData(ctx, genesisState); err != nil {
@@ -465,23 +362,123 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 		return errors.Wrap(err, "could not get genesis block root")
 	}
 
-	s.originBlockRoot = genesisBlkRoot
+	s.genesisRoot = genesisBlkRoot
 	s.cfg.StateGen.SaveFinalizedState(0 /*slot*/, genesisBlkRoot, genesisState)
 
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, genesisBlkRoot); err != nil {
+	// Finalized checkpoint at genesis is a zero hash.
+	genesisCheckpoint := genesisState.FinalizedCheckpoint()
+
+	s.justifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	if err := s.cacheJustifiedStateBalances(ctx, genesisBlkRoot); err != nil {
+		return err
+	}
+	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.finalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+
+	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
+		genesisBlk.Block().Slot(),
+		genesisBlkRoot,
+		params.BeaconConfig().ZeroHash,
+		[32]byte{},
+		genesisCheckpoint.Epoch,
+		genesisCheckpoint.Epoch); err != nil {
 		log.Fatalf("Could not process genesis block for fork choice: %v", err)
 	}
-	s.cfg.ForkChoiceStore.SetOriginRoot(genesisBlkRoot)
-	// Set genesis as fully validated
-	if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, genesisBlkRoot); err != nil {
-		return errors.Wrap(err, "Could not set optimistic status of genesis block to false")
-	}
-	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(s.genesisTime.Unix()))
 
 	s.setHead(genesisBlkRoot, genesisBlk, genesisState)
 	return nil
 }
 
+// This gets called to initialize chain info variables using the finalized checkpoint stored in DB
+func (s *Service) initializeChainInfo(ctx context.Context) error {
+	genesisBlock, err := s.cfg.BeaconDB.GenesisBlock(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get genesis block from db")
+	}
+	if err := helpers.BeaconBlockIsNil(genesisBlock); err != nil {
+		return err
+	}
+	genesisBlkRoot, err := genesisBlock.Block().HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not get signing root of genesis block")
+	}
+	s.genesisRoot = genesisBlkRoot
+
+	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized checkpoint from db")
+	}
+	if finalized == nil {
+		// This should never happen. At chain start, the finalized checkpoint
+		// would be the genesis state and block.
+		return errors.New("no finalized epoch in the database")
+	}
+	finalizedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
+	var finalizedState state.BeaconState
+
+	finalizedState, err = s.cfg.StateGen.Resume(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized state from db")
+	}
+
+	if flags.Get().HeadSync {
+		headBlock, err := s.cfg.BeaconDB.HeadBlock(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not retrieve head block")
+		}
+		headEpoch := slots.ToEpoch(headBlock.Block().Slot())
+		var epochsSinceFinality types.Epoch
+		if headEpoch > finalized.Epoch {
+			epochsSinceFinality = headEpoch - finalized.Epoch
+		}
+		// Head sync when node is far enough beyond known finalized epoch,
+		// this becomes really useful during long period of non-finality.
+		if epochsSinceFinality >= headSyncMinEpochsAfterCheckpoint {
+			headRoot, err := headBlock.Block().HashTreeRoot()
+			if err != nil {
+				return errors.Wrap(err, "could not hash head block")
+			}
+			finalizedState, err := s.cfg.StateGen.Resume(ctx)
+			if err != nil {
+				return errors.Wrap(err, "could not get finalized state from db")
+			}
+			log.Infof("Regenerating state from the last checkpoint at slot %d to current head slot of %d."+
+				"This process may take a while, please wait.", finalizedState.Slot(), headBlock.Block().Slot())
+			headState, err := s.cfg.StateGen.StateByRoot(ctx, headRoot)
+			if err != nil {
+				return errors.Wrap(err, "could not retrieve head state")
+			}
+			s.setHead(headRoot, headBlock, headState)
+			return nil
+		} else {
+			log.Warnf("Finalized checkpoint at slot %d is too close to the current head slot, "+
+				"resetting head from the checkpoint ('--%s' flag is ignored).",
+				finalizedState.Slot(), flags.HeadSync.Name)
+		}
+	}
+
+	finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, finalizedRoot)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized block from db")
+	}
+
+	if finalizedState == nil || finalizedState.IsNil() || finalizedBlock == nil || finalizedBlock.IsNil() {
+		return errors.New("finalized state and block can't be nil")
+	}
+	s.setHead(finalizedRoot, finalizedBlock, finalizedState)
+
+	return nil
+}
+
+// This is called when a client starts from non-genesis slot. This passes last justified and finalized
+// information to fork choice service to initializes fork choice store.
+func (s *Service) resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint *ethpb.Checkpoint) {
+	store := protoarray.New(justifiedCheckpoint.Epoch, finalizedCheckpoint.Epoch, bytesutil.ToBytes32(finalizedCheckpoint.Root))
+	s.cfg.ForkChoiceStore = store
+}
+
 // This returns true if block has been processed before. Two ways to verify the block has been processed:
 // 1.) Check fork choice store.
 // 2.) Check DB.
@@ -493,20 +490,3 @@ func (s *Service) hasBlock(ctx context.Context, root [32]byte) bool {
 
 	return s.cfg.BeaconDB.HasBlock(ctx, root)
 }
-
-func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db db.HeadAccessDatabase) {
-	currentTime := prysmTime.Now()
-	if currentTime.After(genesisTime) {
-		return
-	}
-
-	gState, err := db.GenesisState(ctx)
-	if err != nil {
-		log.Fatalf("Could not retrieve genesis state: %v", err)
-	}
-	gRoot, err := gState.HashTreeRoot(ctx)
-	if err != nil {
-		log.Fatalf("Could not hash tree root genesis state: %v", err)
-	}
-	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
-}

beacon-chain/blockchain/service_norace_test.go

@@ -2,19 +2,17 @@ package blockchain
 
 import (
 	"context"
-	"io"
+	"io/ioutil"
 	"testing"
 
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/sirupsen/logrus"
 )
 
 func init() {
 	logrus.SetLevel(logrus.DebugLevel)
-	logrus.SetOutput(io.Discard)
+	logrus.SetOutput(ioutil.Discard)
 }
 
 func TestChainService_SaveHead_DataRace(t *testing.T) {
@@ -22,11 +20,8 @@ func TestChainService_SaveHead_DataRace(t *testing.T) {
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB},
 	}
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	st, _ := util.DeterministicGenesisState(t, 1)
-	require.NoError(t, err)
 	go func() {
-		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
+	require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 }

beacon-chain/blockchain/service_test.go

@@ -9,30 +9,26 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/async/event"
-	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
-	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	"github.com/prysmaticlabs/prysm/container/trie"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
@@ -75,22 +71,16 @@ func (mb *mockBroadcaster) BroadcastSyncCommitteeMessage(_ context.Context, _ ui
 var _ p2p.Broadcaster = (*mockBroadcaster)(nil)
 
 func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
+	endpoint := "http://127.0.0.1"
 	ctx := context.Background()
 	var web3Service *powchain.Service
 	var err error
-	srv, endpoint, err := mockPOW.SetupRPCServer()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		srv.Stop()
-	})
 	bState, _ := util.DeterministicGenesisState(t, 10)
 	pbState, err := v1.ProtobufBeaconState(bState.InnerStateUnsafe())
 	require.NoError(t, err)
-	mockTrie, err := trie.NewTrie(0)
-	require.NoError(t, err)
 	err = beaconDB.SavePowchainData(ctx, &ethpb.ETH1ChainData{
 		BeaconState: pbState,
-		Trie:        mockTrie.ToProto(),
+		Trie:        &ethpb.SparseMerkleTrie{},
 		CurrentEth1Data: &ethpb.LatestETH1Data{
 			BlockHash: make([]byte, 32),
 		},
@@ -104,12 +94,11 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		DepositContainers: []*ethpb.DepositContainer{},
 	})
 	require.NoError(t, err)
-	web3Service, err = powchain.NewService(
-		ctx,
-		powchain.WithDatabase(beaconDB),
-		powchain.WithHttpEndpoints([]string{endpoint}),
-		powchain.WithDepositContractAddress(common.Address{}),
-	)
+	web3Service, err = powchain.NewService(ctx, &powchain.Web3ServiceConfig{
+		BeaconDB:        beaconDB,
+		HttpEndpoints:   []string{endpoint},
+		DepositContract: common.Address{},
+	})
 	require.NoError(t, err, "Unable to set up web3 service")
 
 	attService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
@@ -118,24 +107,25 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	stateGen := stategen.New(beaconDB)
-	// Safe a state in stategen to purposes of testing a service stop / shutdown.
-	require.NoError(t, stateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithDepositCache(depositCache),
-		WithChainStartFetcher(web3Service),
-		WithAttestationPool(attestations.NewPool()),
-		WithP2PBroadcaster(&mockBroadcaster{}),
-		WithStateNotifier(&mockBeaconNode{}),
-		WithForkChoiceStore(protoarray.New()),
-		WithAttestationService(attService),
-		WithStateGen(stateGen),
+	cfg := &config{
+		BeaconBlockBuf:    0,
+		BeaconDB:          beaconDB,
+		DepositCache:      depositCache,
+		ChainStartFetcher: web3Service,
+		P2p:               &mockBroadcaster{},
+		StateNotifier:     &mockBeaconNode{},
+		AttPool:           attestations.NewPool(),
+		StateGen:          stategen.New(beaconDB),
+		ForkChoiceStore:   protoarray.New(0, 0, params.BeaconConfig().ZeroHash),
+		AttService:        attService,
 	}
 
-	chainService, err := NewService(ctx, opts...)
+	// Safe a state in stategen to purposes of testing a service stop / shutdown.
+	require.NoError(t, cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
+
+	chainService, err := NewService(ctx)
 	require.NoError(t, err, "Unable to setup chain service")
+	chainService.cfg = cfg
 	chainService.genesisTime = time.Unix(1, 0) // non-zero time
 
 	return chainService
@@ -151,7 +141,7 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, genesisBlk)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
@@ -160,12 +150,7 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
 	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
-	ss := &ethpb.StateSummary{
-		Slot: 1,
-		Root: blkRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, ss))
-	chainService.cfg.FinalizedStateAtStartUp = s
+
 	// Test the start function.
 	chainService.Start()
 
@@ -186,15 +171,13 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb := util.SaveBlock(t, ctx, beaconDB, genesisBlk)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
-	chainService.cfg.FinalizedStateAtStartUp = s
+
 	// Test the start function.
 	chainService.Start()
 
@@ -217,10 +200,9 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 	count := uint64(10)
 	deposits, _, err := util.DeterministicDepositsAndKeys(count)
 	require.NoError(t, err)
-	dt, _, err := util.DepositTrieFromDeposits(deposits)
-	require.NoError(t, err)
-	hashTreeRoot, err := dt.HashTreeRoot()
+	trie, _, err := util.DepositTrieFromDeposits(deposits)
 	require.NoError(t, err)
+	hashTreeRoot := trie.HashTreeRoot()
 	genState, err := transition.EmptyGenesisState()
 	require.NoError(t, err)
 	err = genState.SetEth1Data(&ethpb.Eth1Data{
@@ -229,7 +211,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 		BlockHash:    make([]byte, 32),
 	})
 	require.NoError(t, err)
-	genState, err = blocks.ProcessPreGenesisDeposits(ctx, genState, deposits)
+	genState, err = b.ProcessPreGenesisDeposits(ctx, genState, deposits)
 	require.NoError(t, err)
 
 	_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:], BlockHash: make([]byte, 32)})
@@ -258,7 +240,7 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, genesisBlk)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(0))
@@ -266,15 +248,12 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
-	chainService.cfg.FinalizedStateAtStartUp = s
+
 	// Test the start function.
 	chainService.Start()
 
-	cp := chainService.FinalizedCheckpt()
-	require.DeepEqual(t, blkRoot[:], cp.Root, "Finalize Checkpoint root is incorrect")
-	cp = chainService.CurrentJustifiedCheckpt()
-	require.NoError(t, err)
-	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], cp.Root, "Justified Checkpoint root is incorrect")
+	require.DeepEqual(t, blkRoot[:], chainService.finalizedCheckpt.Root, "Finalize Checkpoint root is incorrect")
+	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], chainService.justifiedCheckpt.Root, "Justified Checkpoint root is incorrect")
 
 	require.NoError(t, chainService.Stop(), "Unable to stop chain service")
 
@@ -288,7 +267,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	util.SaveBlock(t, ctx, beaconDB, genesis)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
 	headBlock := util.NewBeaconBlock()
@@ -297,20 +276,15 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
-	util.SaveBlock(t, ctx, beaconDB, headBlock)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
-	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
-	require.NoError(t, err)
-	stateGen := stategen.New(beaconDB)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stateGen), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
-	require.NoError(t, err)
-	require.NoError(t, stateGen.SaveState(ctx, headRoot, headState))
-	require.NoError(t, c.StartFromSavedState(headState))
+	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
+	require.NoError(t, c.initializeChainInfo(ctx))
 	headBlk, err := c.HeadBlock(ctx)
 	require.NoError(t, err)
 	assert.DeepEqual(t, headBlock, headBlk.Proto(), "Head block incorrect")
@@ -323,7 +297,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	if !bytes.Equal(headRoot[:], r) {
 		t.Error("head slot incorrect")
 	}
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 }
 
 func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
@@ -334,7 +308,7 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	util.SaveBlock(t, ctx, beaconDB, genesis)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
 	headBlock := util.NewBeaconBlock()
@@ -343,30 +317,19 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
-	util.SaveBlock(t, ctx, beaconDB, headBlock)
-	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
-	require.NoError(t, err)
-	ss := &ethpb.StateSummary{
-		Slot: finalizedSlot,
-		Root: headRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, ss))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: headRoot[:], Epoch: slots.ToEpoch(finalizedSlot)}))
-	stateGen := stategen.New(beaconDB)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stateGen), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
-	require.NoError(t, err)
-
-	require.NoError(t, c.StartFromSavedState(headState))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
+	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
+	require.NoError(t, c.initializeChainInfo(ctx))
 	s, err := c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
-	assert.DeepEqual(t, headBlock, c.head.block.Proto())
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
+	assert.DeepEqual(t, genesis, c.head.block.Proto())
 }
 
 func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
@@ -387,14 +350,14 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	genesisRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	util.SaveBlock(t, ctx, beaconDB, genesisBlock)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))
 
 	finalizedBlock := util.NewBeaconBlock()
 	finalizedBlock.Block.Slot = finalizedSlot
 	finalizedBlock.Block.ParentRoot = genesisRoot[:]
 	finalizedRoot, err := finalizedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, finalizedBlock)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(finalizedBlock)))
 
 	// Set head slot close to the finalization point, no head sync is triggered.
 	headBlock := util.NewBeaconBlock()
@@ -402,30 +365,28 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, headBlock)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(headBlock.Block.Slot))
-	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
-	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
+	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, finalizedRoot))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
 		Epoch: slots.ToEpoch(finalizedBlock.Block.Slot),
 		Root:  finalizedRoot[:],
 	}))
 
-	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
-	require.NoError(t, err)
-	stateGen := stategen.New(beaconDB)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stateGen), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
-	require.NoError(t, err)
-	require.NoError(t, c.StartFromSavedState(headState))
+	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
+
+	require.NoError(t, c.initializeChainInfo(ctx))
 	s, err := c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 	// Since head sync is not triggered, chain is initialized to the last finalization checkpoint.
 	assert.DeepEqual(t, finalizedBlock, c.head.block.Proto())
 	assert.LogsContain(t, hook, "resetting head from the checkpoint ('--head-sync' flag is ignored)")
@@ -437,16 +398,16 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err = headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, headBlock)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
 
 	hook.Reset()
-	require.NoError(t, c.initializeHeadFromDB(ctx))
+	require.NoError(t, c.initializeChainInfo(ctx))
 	s, err = c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 	// Head slot is far beyond the latest finalized checkpoint, head sync is triggered.
 	assert.DeepEqual(t, headBlock, c.head.block.Proto())
 	assert.LogsContain(t, hook, "Regenerating state from the last checkpoint at slot 225")
@@ -457,7 +418,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 	s := &Service{
-		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New()},
+		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 	}
 	blk := util.NewBeaconBlock()
 	blk.Block.Slot = 1
@@ -466,9 +427,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	newState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, s.saveHeadNoDB(ctx, wsb, r, newState))
+	require.NoError(t, s.saveHeadNoDB(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r, newState))
 
 	newB, err := s.cfg.BeaconDB.HeadBlock(ctx)
 	require.NoError(t, err)
@@ -477,39 +436,19 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	}
 }
 
-func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
+func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg: &config{ForkChoiceStore: protoarray.New(), BeaconDB: beaconDB},
+		cfg:              &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
+		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	b := util.NewBeaconBlock()
-	r, err := b.Block.HashTreeRoot()
+	block := util.NewBeaconBlock()
+	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
-
-	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
-	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
-}
-
-func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
-	}
-	b := util.NewBeaconBlock()
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	beaconState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -522,14 +461,12 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 		cfg:            &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 		ctx:            ctx,
 		cancel:         cancel,
-		initSyncBlocks: make(map[[32]byte]interfaces.SignedBeaconBlock),
+		initSyncBlocks: make(map[[32]byte]block.SignedBeaconBlock),
 	}
-	bb := util.NewBeaconBlock()
-	r, err := bb.Block.HashTreeRoot()
+	block := util.NewBeaconBlock()
+	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
-	require.NoError(t, err)
-	require.NoError(t, s.saveInitSyncBlock(ctx, r, wsb))
+	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, s.Stop())
 	require.Equal(t, true, s.cfg.BeaconDB.HasBlock(ctx, r))
 }
@@ -540,7 +477,7 @@ func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
 	stateChannel := make(chan *feed.Event, 1)
 	stateSub := service.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
 	defer stateSub.Unsubscribe()
-	service.onPowchainStart(context.Background(), time.Now())
+	service.processChainStartTime(context.Background(), time.Now())
 
 	stateEvent := <-stateChannel
 	require.Equal(t, int(stateEvent.Type), statefeed.Initialized)
@@ -554,11 +491,9 @@ func BenchmarkHasBlockDB(b *testing.B) {
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB},
 	}
-	blk := util.NewBeaconBlock()
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(b, err)
-	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wsb))
-	r, err := blk.Block.HashTreeRoot()
+	block := util.NewBeaconBlock()
+	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block)))
+	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
 
 	b.ResetTimer()
@@ -567,42 +502,20 @@ func BenchmarkHasBlockDB(b *testing.B) {
 	}
 }
 
-func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
+func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
-		cfg: &config{ForkChoiceStore: protoarray.New(), BeaconDB: beaconDB},
+		cfg:              &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
+		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
-	r, err := blk.Block.HashTreeRoot()
+	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
+	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := v1.InitializeFromProto(bs)
 	require.NoError(b, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(b, err)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		require.Equal(b, true, s.cfg.ForkChoiceStore.HasNode(r), "Block is not in fork choice store")
-	}
-}
-func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(b)
-	s := &Service{
-		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
-	}
-	blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
-	r, err := blk.Block.HashTreeRoot()
-	require.NoError(b, err)
-	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
-	beaconState, err := v1.InitializeFromProto(bs)
-	require.NoError(b, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(b, err)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/blockchain/state_balance_cache.go

@@ -1,81 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"errors"
-	"sync"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-)
-
-type stateBalanceCache struct {
-	sync.Mutex
-	balances []uint64
-	root     [32]byte
-	stateGen stateByRooter
-}
-
-type stateByRooter interface {
-	StateByRoot(context.Context, [32]byte) (state.BeaconState, error)
-}
-
-// newStateBalanceCache exists to remind us that stateBalanceCache needs a state gen
-// to avoid nil pointer bugs when updating the cache in the read path (get())
-func newStateBalanceCache(sg *stategen.State) (*stateBalanceCache, error) {
-	if sg == nil {
-		return nil, errors.New("can't initialize state balance cache without stategen")
-	}
-	return &stateBalanceCache{stateGen: sg}, nil
-}
-
-// update is called by get() when the requested root doesn't match
-// the previously read value. This cache assumes we only want to cache one
-// set of balances for a single root (the current justified root).
-//
-// WARNING: this is not thread-safe on its own, relies on get() for locking
-func (c *stateBalanceCache) update(ctx context.Context, justifiedRoot [32]byte) ([]uint64, error) {
-	stateBalanceCacheMiss.Inc()
-	justifiedState, err := c.stateGen.StateByRoot(ctx, justifiedRoot)
-	if err != nil {
-		return nil, err
-	}
-	if justifiedState == nil || justifiedState.IsNil() {
-		return nil, errNilStateFromStategen
-	}
-	epoch := time.CurrentEpoch(justifiedState)
-
-	justifiedBalances := make([]uint64, justifiedState.NumValidators())
-	var balanceAccumulator = func(idx int, val state.ReadOnlyValidator) error {
-		if helpers.IsActiveValidatorUsingTrie(val, epoch) {
-			justifiedBalances[idx] = val.EffectiveBalance()
-		} else {
-			justifiedBalances[idx] = 0
-		}
-		return nil
-	}
-	if err := justifiedState.ReadFromEveryValidator(balanceAccumulator); err != nil {
-		return nil, err
-	}
-
-	c.balances = justifiedBalances
-	c.root = justifiedRoot
-	return c.balances, nil
-}
-
-// getBalances takes an explicit justifiedRoot so it can invalidate the singleton cache key
-// when the justified root changes, and takes a context so that the long-running stategen
-// read path can connect to the upstream cancellation/timeout chain.
-func (c *stateBalanceCache) get(ctx context.Context, justifiedRoot [32]byte) ([]uint64, error) {
-	c.Lock()
-	defer c.Unlock()
-
-	if justifiedRoot != [32]byte{} && justifiedRoot == c.root {
-		stateBalanceCacheHit.Inc()
-		return c.balances, nil
-	}
-
-	return c.update(ctx, justifiedRoot)
-}

beacon-chain/blockchain/state_balance_cache_test.go

@@ -1,227 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"encoding/binary"
-	"errors"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-type testStateOpt func(*ethpb.BeaconStateAltair)
-
-func testStateWithValidators(v []*ethpb.Validator) testStateOpt {
-	return func(a *ethpb.BeaconStateAltair) {
-		a.Validators = v
-	}
-}
-
-func testStateWithSlot(slot types.Slot) testStateOpt {
-	return func(a *ethpb.BeaconStateAltair) {
-		a.Slot = slot
-	}
-}
-
-func testStateFixture(opts ...testStateOpt) state.BeaconState {
-	a := &ethpb.BeaconStateAltair{}
-	for _, o := range opts {
-		o(a)
-	}
-	s, _ := v2.InitializeFromProtoUnsafe(a)
-	return s
-}
-
-func generateTestValidators(count int, opts ...func(*ethpb.Validator)) []*ethpb.Validator {
-	vs := make([]*ethpb.Validator, count)
-	var i uint32 = 0
-	for ; i < uint32(count); i++ {
-		pk := make([]byte, 48)
-		binary.LittleEndian.PutUint32(pk, i)
-		v := &ethpb.Validator{PublicKey: pk}
-		for _, o := range opts {
-			o(v)
-		}
-		vs[i] = v
-	}
-	return vs
-}
-
-func oddValidatorsExpired(currentSlot types.Slot) func(*ethpb.Validator) {
-	return func(v *ethpb.Validator) {
-		pki := binary.LittleEndian.Uint64(v.PublicKey)
-		if pki%2 == 0 {
-			v.ExitEpoch = types.Epoch(int(slots.ToEpoch(currentSlot)) + 1)
-		} else {
-			v.ExitEpoch = types.Epoch(int(slots.ToEpoch(currentSlot)) - 1)
-		}
-	}
-}
-
-func oddValidatorsQueued(currentSlot types.Slot) func(*ethpb.Validator) {
-	return func(v *ethpb.Validator) {
-		v.ExitEpoch = types.Epoch(int(slots.ToEpoch(currentSlot)) + 1)
-		pki := binary.LittleEndian.Uint64(v.PublicKey)
-		if pki%2 == 0 {
-			v.ActivationEpoch = types.Epoch(int(slots.ToEpoch(currentSlot)) - 1)
-		} else {
-			v.ActivationEpoch = types.Epoch(int(slots.ToEpoch(currentSlot)) + 1)
-		}
-	}
-}
-
-func allValidatorsValid(currentSlot types.Slot) func(*ethpb.Validator) {
-	return func(v *ethpb.Validator) {
-		v.ActivationEpoch = types.Epoch(int(slots.ToEpoch(currentSlot)) - 1)
-		v.ExitEpoch = types.Epoch(int(slots.ToEpoch(currentSlot)) + 1)
-	}
-}
-
-func balanceIsKeyTimes2(v *ethpb.Validator) {
-	pki := binary.LittleEndian.Uint64(v.PublicKey)
-	v.EffectiveBalance = uint64(pki) * 2
-}
-
-func testHalfExpiredValidators() ([]*ethpb.Validator, []uint64) {
-	balances := []uint64{0, 0, 4, 0, 8, 0, 12, 0, 16, 0}
-	return generateTestValidators(10,
-		oddValidatorsExpired(types.Slot(99)),
-		balanceIsKeyTimes2), balances
-}
-
-func testHalfQueuedValidators() ([]*ethpb.Validator, []uint64) {
-	balances := []uint64{0, 0, 4, 0, 8, 0, 12, 0, 16, 0}
-	return generateTestValidators(10,
-		oddValidatorsQueued(types.Slot(99)),
-		balanceIsKeyTimes2), balances
-}
-
-func testAllValidValidators() ([]*ethpb.Validator, []uint64) {
-	balances := []uint64{0, 2, 4, 6, 8, 10, 12, 14, 16, 18}
-	return generateTestValidators(10,
-		allValidatorsValid(types.Slot(99)),
-		balanceIsKeyTimes2), balances
-}
-
-func TestStateBalanceCache(t *testing.T) {
-	type sbcTestCase struct {
-		err      error
-		root     [32]byte
-		sbc      *stateBalanceCache
-		balances []uint64
-		name     string
-	}
-	sentinelCacheMiss := errors.New("cache missed, as expected")
-	sentinelBalances := []uint64{1, 2, 3, 4, 5}
-	halfExpiredValidators, halfExpiredBalances := testHalfExpiredValidators()
-	halfQueuedValidators, halfQueuedBalances := testHalfQueuedValidators()
-	allValidValidators, allValidBalances := testAllValidValidators()
-	cases := []sbcTestCase{
-		{
-			root:     bytesutil.ToBytes32([]byte{'A'}),
-			balances: sentinelBalances,
-			sbc: &stateBalanceCache{
-				stateGen: &mockStateByRooter{
-					err: sentinelCacheMiss,
-				},
-				root:     bytesutil.ToBytes32([]byte{'A'}),
-				balances: sentinelBalances,
-			},
-			name: "cache hit",
-		},
-		// this works by using a staterooter that returns a known error
-		// so really we're testing the miss by making sure stategen got called
-		// this also tells us stategen errors are propagated
-		{
-			sbc: &stateBalanceCache{
-				stateGen: &mockStateByRooter{
-					err: sentinelCacheMiss,
-				},
-				root: bytesutil.ToBytes32([]byte{'B'}),
-			},
-			err:  sentinelCacheMiss,
-			root: bytesutil.ToBytes32([]byte{'A'}),
-			name: "cache miss",
-		},
-		{
-			sbc: &stateBalanceCache{
-				stateGen: &mockStateByRooter{},
-				root:     bytesutil.ToBytes32([]byte{'B'}),
-			},
-			err:  errNilStateFromStategen,
-			root: bytesutil.ToBytes32([]byte{'A'}),
-			name: "error for nil state upon cache miss",
-		},
-		{
-			sbc: &stateBalanceCache{
-				stateGen: &mockStateByRooter{
-					state: testStateFixture(
-						testStateWithSlot(99),
-						testStateWithValidators(halfExpiredValidators)),
-				},
-			},
-			balances: halfExpiredBalances,
-			root:     bytesutil.ToBytes32([]byte{'A'}),
-			name:     "test filtering by exit epoch",
-		},
-		{
-			sbc: &stateBalanceCache{
-				stateGen: &mockStateByRooter{
-					state: testStateFixture(
-						testStateWithSlot(99),
-						testStateWithValidators(halfQueuedValidators)),
-				},
-			},
-			balances: halfQueuedBalances,
-			root:     bytesutil.ToBytes32([]byte{'A'}),
-			name:     "test filtering by activation epoch",
-		},
-		{
-			sbc: &stateBalanceCache{
-				stateGen: &mockStateByRooter{
-					state: testStateFixture(
-						testStateWithSlot(99),
-						testStateWithValidators(allValidValidators)),
-				},
-			},
-			balances: allValidBalances,
-			root:     bytesutil.ToBytes32([]byte{'A'}),
-			name:     "happy path",
-		},
-		{
-			sbc: &stateBalanceCache{
-				stateGen: &mockStateByRooter{
-					state: testStateFixture(
-						testStateWithSlot(99),
-						testStateWithValidators(allValidValidators)),
-				},
-			},
-			balances: allValidBalances,
-			root:     [32]byte{},
-			name:     "zero root",
-		},
-	}
-	ctx := context.Background()
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			cache := c.sbc
-			cacheRootStart := cache.root
-			b, err := cache.get(ctx, c.root)
-			require.ErrorIs(t, err, c.err)
-			require.DeepEqual(t, c.balances, b)
-			if c.err != nil {
-				// if there was an error somewhere, the root should not have changed (unless it already matched)
-				require.Equal(t, cacheRootStart, cache.root)
-			} else {
-				// when successful, the cache should always end with a root matching the request
-				require.Equal(t, c.root, cache.root)
-			}
-		})
-	}
-}

beacon-chain/blockchain/testing/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
     visibility = [
         "//beacon-chain:__subpackages__",
         "//testing:__subpackages__",
+        "//testing/fuzz:__pkg__",
     ],
     deps = [
         "//async/event:go_default_library",
@@ -18,15 +19,15 @@ go_library(
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db:go_default_library",
-        "//beacon-chain/forkchoice:go_default_library",
+        "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//config/fieldparams:go_default_library",
+        "//beacon-chain/state/v1:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/prysm/v1alpha1/block:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/blockchain/testing/mock.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
@@ -17,57 +18,46 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/sirupsen/logrus"
 )
 
-var ErrNilState = errors.New("nil state")
-
 // ChainService defines the mock interface for testing
 type ChainService struct {
-	Optimistic                  bool
-	ValidAttestation            bool
-	ValidatorsRoot              [32]byte
-	PublicKey                   [fieldparams.BLSPubkeyLength]byte
+	State                       state.BeaconState
+	Root                        []byte
+	Block                       block.SignedBeaconBlock
 	FinalizedCheckPoint         *ethpb.Checkpoint
 	CurrentJustifiedCheckPoint  *ethpb.Checkpoint
 	PreviousJustifiedCheckPoint *ethpb.Checkpoint
-	Slot                        *types.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
+	BlocksReceived              []block.SignedBeaconBlock
 	Balance                     *precompute.Balance
+	Genesis                     time.Time
+	ValidatorsRoot              [32]byte
 	CanonicalRoots              map[[32]byte]bool
 	Fork                        *ethpb.Fork
 	ETH1Data                    *ethpb.Eth1Data
-	InitSyncBlockRoots          map[[32]byte]bool
 	DB                          db.Database
-	State                       state.BeaconState
-	Block                       interfaces.SignedBeaconBlock
-	VerifyBlkDescendantErr      error
 	stateNotifier               statefeed.Notifier
-	BlocksReceived              []interfaces.SignedBeaconBlock
-	SyncCommitteeIndices        []types.CommitteeIndex
 	blockNotifier               blockfeed.Notifier
 	opNotifier                  opfeed.Notifier
-	Root                        []byte
+	ValidAttestation            bool
+	ForkChoiceStore             *protoarray.Store
+	VerifyBlkDescendantErr      error
+	Slot                        *types.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
+	SyncCommitteeIndices        []types.CommitteeIndex
 	SyncCommitteeDomain         []byte
 	SyncSelectionProofDomain    []byte
 	SyncContributionProofDomain []byte
+	PublicKey                   [48]byte
 	SyncCommitteePubkeys        [][]byte
-	Genesis                     time.Time
-	ForkChoiceStore             forkchoice.ForkChoicer
-	ReceiveBlockMockErr         error
-	OptimisticCheckRootReceived [32]byte
-}
-
-// ForkChoicer mocks the same method in the chain service
-func (s *ChainService) ForkChoicer() forkchoice.ForkChoicer {
-	return s.ForkChoiceStore
+	InitSyncBlockRoots          map[[32]byte]bool
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -166,9 +156,9 @@ func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
 }
 
 // ReceiveBlockInitialSync mocks ReceiveBlockInitialSync method in chain service.
-func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block interfaces.SignedBeaconBlock, _ [32]byte) error {
+func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block block.SignedBeaconBlock, _ [32]byte) error {
 	if s.State == nil {
-		return ErrNilState
+		s.State = &v1.BeaconState{}
 	}
 	if !bytes.Equal(s.Root, block.Block().ParentRoot()) {
 		return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block().ParentRoot())
@@ -193,41 +183,38 @@ func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block interf
 }
 
 // ReceiveBlockBatch processes blocks in batches from initial-sync.
-func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock, _ [][32]byte) error {
+func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock, _ [][32]byte) error {
 	if s.State == nil {
-		return ErrNilState
+		s.State = &v1.BeaconState{}
 	}
-	for _, b := range blks {
-		if !bytes.Equal(s.Root, b.Block().ParentRoot()) {
-			return errors.Errorf("wanted %#x but got %#x", s.Root, b.Block().ParentRoot())
+	for _, block := range blks {
+		if !bytes.Equal(s.Root, block.Block().ParentRoot()) {
+			return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block().ParentRoot())
 		}
-		if err := s.State.SetSlot(b.Block().Slot()); err != nil {
+		if err := s.State.SetSlot(block.Block().Slot()); err != nil {
 			return err
 		}
-		s.BlocksReceived = append(s.BlocksReceived, b)
-		signingRoot, err := b.Block().HashTreeRoot()
+		s.BlocksReceived = append(s.BlocksReceived, block)
+		signingRoot, err := block.Block().HashTreeRoot()
 		if err != nil {
 			return err
 		}
 		if s.DB != nil {
-			if err := s.DB.SaveBlock(ctx, b); err != nil {
+			if err := s.DB.SaveBlock(ctx, block); err != nil {
 				return err
 			}
-			logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, b.Block().Slot())
+			logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block().Slot())
 		}
 		s.Root = signingRoot[:]
-		s.Block = b
+		s.Block = block
 	}
 	return nil
 }
 
 // ReceiveBlock mocks ReceiveBlock method in chain service.
-func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, _ [32]byte) error {
-	if s.ReceiveBlockMockErr != nil {
-		return s.ReceiveBlockMockErr
-	}
+func (s *ChainService) ReceiveBlock(ctx context.Context, block block.SignedBeaconBlock, _ [32]byte) error {
 	if s.State == nil {
-		return ErrNilState
+		s.State = &v1.BeaconState{}
 	}
 	if !bytes.Equal(s.Root, block.Block().ParentRoot()) {
 		return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block().ParentRoot())
@@ -268,7 +255,7 @@ func (s *ChainService) HeadRoot(_ context.Context) ([]byte, error) {
 }
 
 // HeadBlock mocks HeadBlock method in chain service.
-func (s *ChainService) HeadBlock(context.Context) (interfaces.SignedBeaconBlock, error) {
+func (s *ChainService) HeadBlock(context.Context) (block.SignedBeaconBlock, error) {
 	return s.Block, nil
 }
 
@@ -298,7 +285,12 @@ func (s *ChainService) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 }
 
 // ReceiveAttestation mocks ReceiveAttestation method in chain service.
-func (_ *ChainService) ReceiveAttestation(_ context.Context, _ *ethpb.Attestation) error {
+func (s *ChainService) ReceiveAttestation(_ context.Context, _ *ethpb.Attestation) error {
+	return nil
+}
+
+// ReceiveAttestationNoPubsub mocks ReceiveAttestationNoPubsub method in chain service.
+func (s *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attestation) error {
 	return nil
 }
 
@@ -315,18 +307,28 @@ func (s *ChainService) HeadValidatorsIndices(ctx context.Context, epoch types.Ep
 	return helpers.ActiveValidatorIndices(ctx, s.State, epoch)
 }
 
+// HeadSeed mocks the same method in the chain service.
+func (s *ChainService) HeadSeed(_ context.Context, epoch types.Epoch) ([32]byte, error) {
+	return helpers.Seed(s.State, epoch, params.BeaconConfig().DomainBeaconAttester)
+}
+
 // HeadETH1Data provides the current ETH1Data of the head state.
 func (s *ChainService) HeadETH1Data() *ethpb.Eth1Data {
 	return s.ETH1Data
 }
 
+// ProtoArrayStore mocks the same method in the chain service.
+func (s *ChainService) ProtoArrayStore() *protoarray.Store {
+	return s.ForkChoiceStore
+}
+
 // GenesisTime mocks the same method in the chain service.
 func (s *ChainService) GenesisTime() time.Time {
 	return s.Genesis
 }
 
-// GenesisValidatorsRoot mocks the same method in the chain service.
-func (s *ChainService) GenesisValidatorsRoot() [32]byte {
+// GenesisValidatorRoot mocks the same method in the chain service.
+func (s *ChainService) GenesisValidatorRoot() [32]byte {
 	return s.ValidatorsRoot
 }
 
@@ -358,32 +360,26 @@ func (s *ChainService) IsCanonical(_ context.Context, r [32]byte) (bool, error)
 	return true, nil
 }
 
-// HasBlock mocks the same method in the chain service.
-func (s *ChainService) HasBlock(ctx context.Context, rt [32]byte) bool {
-	if s.DB == nil {
-		return false
-	}
-	if s.DB.HasBlock(ctx, rt) {
-		return true
-	}
+// HasInitSyncBlock mocks the same method in the chain service.
+func (s *ChainService) HasInitSyncBlock(rt [32]byte) bool {
 	if s.InitSyncBlockRoots == nil {
 		return false
 	}
 	return s.InitSyncBlockRoots[rt]
 }
 
-// HeadGenesisValidatorsRoot mocks HeadGenesisValidatorsRoot method in chain service.
-func (_ *ChainService) HeadGenesisValidatorsRoot() [32]byte {
+// HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
+func (s *ChainService) HeadGenesisValidatorRoot() [32]byte {
 	return [32]byte{}
 }
 
-// VerifyFinalizedBlkDescendant mocks VerifyBlkDescendant and always returns nil.
-func (s *ChainService) VerifyFinalizedBlkDescendant(_ context.Context, _ [32]byte) error {
+// VerifyBlkDescendant mocks VerifyBlkDescendant and always returns nil.
+func (s *ChainService) VerifyBlkDescendant(_ context.Context, _ [32]byte) error {
 	return s.VerifyBlkDescendantErr
 }
 
 // VerifyLmdFfgConsistency mocks VerifyLmdFfgConsistency and always returns nil.
-func (_ *ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
+func (s *ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
 	if !bytes.Equal(a.Data.BeaconBlockRoot, a.Data.Target.Root) {
 		return errors.New("LMD and FFG miss matched")
 	}
@@ -399,7 +395,7 @@ func (s *ChainService) VerifyFinalizedConsistency(_ context.Context, r []byte) e
 }
 
 // ChainHeads mocks ChainHeads and always return nil.
-func (_ *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
+func (s *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
 	return [][32]byte{
 			bytesutil.ToBytes32(bytesutil.PadTo([]byte("foo"), 32)),
 			bytesutil.ToBytes32(bytesutil.PadTo([]byte("bar"), 32)),
@@ -408,17 +404,17 @@ func (_ *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
 }
 
 // HeadPublicKeyToValidatorIndex mocks HeadPublicKeyToValidatorIndex and always return 0 and true.
-func (_ *ChainService) HeadPublicKeyToValidatorIndex(_ [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool) {
+func (s *ChainService) HeadPublicKeyToValidatorIndex(_ context.Context, _ [48]byte) (types.ValidatorIndex, bool) {
 	return 0, true
 }
 
 // HeadValidatorIndexToPublicKey mocks HeadValidatorIndexToPublicKey and always return empty and nil.
-func (s *ChainService) HeadValidatorIndexToPublicKey(_ context.Context, _ types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error) {
+func (s *ChainService) HeadValidatorIndexToPublicKey(_ context.Context, _ types.ValidatorIndex) ([48]byte, error) {
 	return s.PublicKey, nil
 }
 
 // HeadSyncCommitteeIndices mocks HeadSyncCommitteeIndices and always return `HeadNextSyncCommitteeIndices`.
-func (s *ChainService) HeadSyncCommitteeIndices(_ context.Context, _ types.ValidatorIndex, _ types.Slot) ([]types.CommitteeIndex, error) {
+func (s *ChainService) HeadSyncCommitteeIndices(_ context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
 	return s.SyncCommitteeIndices, nil
 }
 
@@ -441,20 +437,3 @@ func (s *ChainService) HeadSyncSelectionProofDomain(_ context.Context, _ types.S
 func (s *ChainService) HeadSyncContributionProofDomain(_ context.Context, _ types.Slot) ([]byte, error) {
 	return s.SyncContributionProofDomain, nil
 }
-
-// IsOptimistic mocks the same method in the chain service.
-func (s *ChainService) IsOptimistic(_ context.Context) (bool, error) {
-	return s.Optimistic, nil
-}
-
-// IsOptimisticForRoot mocks the same method in the chain service.
-func (s *ChainService) IsOptimisticForRoot(_ context.Context, root [32]byte) (bool, error) {
-	s.OptimisticCheckRootReceived = root
-	return s.Optimistic, nil
-}
-
-// UpdateHead mocks the same method in the chain service.
-func (s *ChainService) UpdateHead(_ context.Context) error { return nil }
-
-// ReceiveAttesterSlashing mocks the same method in the chain service.
-func (s *ChainService) ReceiveAttesterSlashing(context.Context, *ethpb.AttesterSlashing) {}

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -5,14 +5,17 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	"github.com/prysmaticlabs/prysm/config/params"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
+var errWSBlockNotFound = errors.New("weak subjectivity root not found in db")
+var errWSBlockNotFoundInEpoch = errors.New("weak subjectivity root not found in db within epoch")
+
 type weakSubjectivityDB interface {
 	HasBlock(ctx context.Context, blockRoot [32]byte) bool
 	BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]byte, error)
@@ -27,11 +30,12 @@ type WeakSubjectivityVerifier struct {
 	db       weakSubjectivityDB
 }
 
-// NewWeakSubjectivityVerifier validates a checkpoint, and if valid, uses it to initialize a weak subjectivity verifier.
+// NewWeakSubjectivityVerifier validates a checkpoint, and if valid, uses it to initialize a weak subjectivity verifier
 func NewWeakSubjectivityVerifier(wsc *ethpb.Checkpoint, db weakSubjectivityDB) (*WeakSubjectivityVerifier, error) {
+	// TODO(7342): Weak subjectivity checks are currently optional. When we require the flag to be specified
+	// per 7342, a nil checkpoint, zero-root or zero-epoch should all fail validation
+	// and return an error instead of creating a WeakSubjectivityVerifier that permits any chain history.
 	if wsc == nil || len(wsc.Root) == 0 || wsc.Epoch == 0 {
-		log.Info("--weak-subjectivity-checkpoint not provided. Prysm recommends providing a weak subjectivity checkpoint" +
-			"for nodes synced from genesis, or manual verification of block and state roots for checkpoint sync nodes.")
 		return &WeakSubjectivityVerifier{
 			enabled: false,
 		}, nil
@@ -56,6 +60,7 @@ func (v *WeakSubjectivityVerifier) VerifyWeakSubjectivity(ctx context.Context, f
 	if v.verified || !v.enabled {
 		return nil
 	}
+
 	// Two conditions are described in the specs:
 	// IF epoch_number > store.finalized_checkpoint.epoch,
 	// then ASSERT during block sync that block with root block_root
@@ -74,20 +79,19 @@ func (v *WeakSubjectivityVerifier) VerifyWeakSubjectivity(ctx context.Context, f
 	if !v.db.HasBlock(ctx, v.root) {
 		return errors.Wrap(errWSBlockNotFound, fmt.Sprintf("missing root %#x", v.root))
 	}
-	endSlot := v.slot + params.BeaconConfig().SlotsPerEpoch
-	filter := filters.NewFilter().SetStartSlot(v.slot).SetEndSlot(endSlot)
+	filter := filters.NewFilter().SetStartSlot(v.slot).SetEndSlot(v.slot + params.BeaconConfig().SlotsPerEpoch)
 	// A node should have the weak subjectivity block corresponds to the correct epoch in the DB.
-	log.Infof("Searching block roots for weak subjectivity root=%#x, between slots %d-%d", v.root, v.slot, endSlot)
 	roots, err := v.db.BlockRoots(ctx, filter)
 	if err != nil {
 		return errors.Wrap(err, "error while retrieving block roots to verify weak subjectivity")
 	}
 	for _, root := range roots {
 		if v.root == root {
-			log.Info("Weak subjectivity check has passed!!")
+			log.Info("Weak subjectivity check has passed")
 			v.verified = true
 			return nil
 		}
 	}
+
 	return errors.Wrap(errWSBlockNotFoundInEpoch, fmt.Sprintf("root=%#x, epoch=%d", v.root, v.epoch))
 }

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -5,81 +5,72 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"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/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
 func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	b := util.NewBeaconBlock()
-	b.Block.Slot = 1792480
-	util.SaveBlock(t, context.Background(), beaconDB, b)
+	b.Block.Slot = 32
+	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-
-	blockEpoch := slots.ToEpoch(b.Block.Slot)
 	tests := []struct {
 		wsVerified     bool
-		disabled       bool
 		wantErr        error
 		checkpt        *ethpb.Checkpoint
 		finalizedEpoch types.Epoch
 		name           string
 	}{
 		{
-			name:     "nil root and epoch",
-			disabled: true,
+			name: "nil root and epoch",
+		},
+		{
+			name:           "already verified",
+			checkpt:        &ethpb.Checkpoint{Epoch: 2},
+			finalizedEpoch: 2,
+			wsVerified:     true,
 		},
 		{
 			name:           "not yet to verify, ws epoch higher than finalized epoch",
-			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, 32), Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch - 1,
+			checkpt:        &ethpb.Checkpoint{Epoch: 2},
+			finalizedEpoch: 1,
 		},
 		{
 			name:           "can't find the block in DB",
-			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength), Epoch: 1},
-			finalizedEpoch: blockEpoch + 1,
+			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, 32), Epoch: 1},
+			finalizedEpoch: 3,
 			wantErr:        errWSBlockNotFound,
 		},
 		{
 			name:           "can't find the block corresponds to ws epoch in DB",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch - 2}, // Root belongs in epoch 1.
-			finalizedEpoch: blockEpoch - 1,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 2}, // Root belongs in epoch 1.
+			finalizedEpoch: 3,
 			wantErr:        errWSBlockNotFoundInEpoch,
 		},
 		{
 			name:           "can verify and pass",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch + 1,
-		},
-		{
-			name:           "equal epoch",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 1},
+			finalizedEpoch: 3,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			wv, err := NewWeakSubjectivityVerifier(tt.checkpt, beaconDB)
-			require.Equal(t, !tt.disabled, wv.enabled)
 			require.NoError(t, err)
-			fcs := protoarray.New()
 			s := &Service{
-				cfg:        &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt, ForkChoiceStore: fcs},
-				wsVerifier: wv,
+				cfg:              &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt},
+				finalizedCheckpt: &ethpb.Checkpoint{Epoch: tt.finalizedEpoch},
+				wsVerifier:       wv,
 			}
-			require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: tt.finalizedEpoch}))
-			cp := s.ForkChoicer().FinalizedCheckpoint()
-			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), cp.Epoch)
+			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), s.finalizedCheckpt.Epoch)
 			if tt.wantErr == nil {
 				require.NoError(t, err)
 			} else {

beacon-chain/builder/BUILD.bazel

@@ -1,31 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "error.go",
-        "metric.go",
-        "option.go",
-        "service.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/builder",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//api/client/builder:go_default_library",
-        "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/db:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//network:go_default_library",
-        "//network/authorization:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1: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_sirupsen_logrus//:go_default_library",
-        "@com_github_urfave_cli_v2//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
-    ],
-)

beacon-chain/builder/error.go

@@ -1,7 +0,0 @@
-package builder
-
-import "github.com/pkg/errors"
-
-var (
-	ErrNotRunning = errors.New("builder is not running")
-)

beacon-chain/builder/metric.go

@@ -1,37 +0,0 @@
-package builder
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var (
-	submitBlindedBlockLatency = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "submit_blinded_block_latency_milliseconds",
-			Help:    "Captures RPC latency for submitting blinded block in milliseconds",
-			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
-		},
-	)
-	getHeaderLatency = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "get_header_latency_milliseconds",
-			Help:    "Captures RPC latency for get header in milliseconds",
-			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
-		},
-	)
-	getStatusLatency = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "get_status_latency_milliseconds",
-			Help:    "Captures RPC latency for get status in milliseconds",
-			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
-		},
-	)
-	registerValidatorLatency = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "register_validator_latency_milliseconds",
-			Help:    "Captures RPC latency for register validator in milliseconds",
-			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
-		},
-	)
-)

beacon-chain/builder/option.go

@@ -1,54 +0,0 @@
-package builder
-
-import (
-	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/network"
-	"github.com/prysmaticlabs/prysm/network/authorization"
-	"github.com/urfave/cli/v2"
-)
-
-type Option func(s *Service) error
-
-// FlagOptions for builder service flag configurations.
-func FlagOptions(c *cli.Context) ([]Option, error) {
-	endpoint := c.String(flags.MevRelayEndpoint.Name)
-	opts := []Option{
-		WithBuilderEndpoints(endpoint),
-	}
-	return opts, nil
-}
-
-// WithBuilderEndpoints sets the endpoint for the beacon chain builder service.
-func WithBuilderEndpoints(endpoint string) Option {
-	return func(s *Service) error {
-		s.cfg.builderEndpoint = covertEndPoint(endpoint)
-		return nil
-	}
-}
-
-// WithHeadFetcher gets the head info from chain service.
-func WithHeadFetcher(svc *blockchain.Service) Option {
-	return func(s *Service) error {
-		s.cfg.headFetcher = svc
-		return nil
-	}
-}
-
-// WithDatabase for head access.
-func WithDatabase(beaconDB db.HeadAccessDatabase) Option {
-	return func(s *Service) error {
-		s.cfg.beaconDB = beaconDB
-		return nil
-	}
-}
-
-func covertEndPoint(ep string) network.Endpoint {
-	return network.Endpoint{
-		Url: ep,
-		Auth: network.AuthorizationData{ // Auth is not used for builder.
-			Method: authorization.None,
-			Value:  "",
-		}}
-}

beacon-chain/builder/service.go

@@ -1,152 +0,0 @@
-package builder
-
-import (
-	"context"
-	"time"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/api/client/builder"
-	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/network"
-	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	log "github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-)
-
-// BlockBuilder defines the interface for interacting with the block builder
-type BlockBuilder interface {
-	SubmitBlindedBlock(ctx context.Context, block *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error)
-	GetHeader(ctx context.Context, slot types.Slot, parentHash [32]byte, pubKey [48]byte) (*ethpb.SignedBuilderBid, error)
-	Status() error
-	RegisterValidator(ctx context.Context, reg []*ethpb.SignedValidatorRegistrationV1) error
-	Configured() bool
-}
-
-// config defines a config struct for dependencies into the service.
-type config struct {
-	builderEndpoint network.Endpoint
-	beaconDB        db.HeadAccessDatabase
-	headFetcher     blockchain.HeadFetcher
-}
-
-// Service defines a service that provides a client for interacting with the beacon chain and MEV relay network.
-type Service struct {
-	cfg    *config
-	c      *builder.Client
-	ctx    context.Context
-	cancel context.CancelFunc
-}
-
-// NewService instantiates a new service.
-func NewService(ctx context.Context, opts ...Option) (*Service, error) {
-	ctx, cancel := context.WithCancel(ctx)
-	s := &Service{
-		ctx:    ctx,
-		cancel: cancel,
-		cfg:    &config{},
-	}
-	for _, opt := range opts {
-		if err := opt(s); err != nil {
-			return nil, err
-		}
-	}
-	if s.cfg.builderEndpoint.Url != "" {
-		c, err := builder.NewClient(s.cfg.builderEndpoint.Url)
-		if err != nil {
-			return nil, err
-		}
-		s.c = c
-	}
-	return s, nil
-}
-
-// Start initializes the service.
-func (*Service) Start() {}
-
-// Stop halts the service.
-func (*Service) Stop() error {
-	return nil
-}
-
-// SubmitBlindedBlock submits a blinded block to the builder relay network.
-func (s *Service) SubmitBlindedBlock(ctx context.Context, b *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error) {
-	ctx, span := trace.StartSpan(ctx, "builder.SubmitBlindedBlock")
-	defer span.End()
-	start := time.Now()
-	defer func() {
-		submitBlindedBlockLatency.Observe(float64(time.Since(start).Milliseconds()))
-	}()
-
-	return s.c.SubmitBlindedBlock(ctx, b)
-}
-
-// GetHeader retrieves the header for a given slot and parent hash from the builder relay network.
-func (s *Service) GetHeader(ctx context.Context, slot types.Slot, parentHash [32]byte, pubKey [48]byte) (*ethpb.SignedBuilderBid, error) {
-	ctx, span := trace.StartSpan(ctx, "builder.GetHeader")
-	defer span.End()
-	start := time.Now()
-	defer func() {
-		getHeaderLatency.Observe(float64(time.Since(start).Milliseconds()))
-	}()
-
-	return s.c.GetHeader(ctx, slot, parentHash, pubKey)
-}
-
-// Status retrieves the status of the builder relay network.
-func (s *Service) Status() error {
-	ctx, span := trace.StartSpan(context.Background(), "builder.Status")
-	defer span.End()
-	start := time.Now()
-	defer func() {
-		getStatusLatency.Observe(float64(time.Since(start).Milliseconds()))
-	}()
-
-	// Return early if builder isn't initialized in service.
-	if s.c == nil {
-		return nil
-	}
-
-	return s.c.Status(ctx)
-}
-
-// RegisterValidator registers a validator with the builder relay network.
-// It also saves the registration object to the DB.
-func (s *Service) RegisterValidator(ctx context.Context, reg []*ethpb.SignedValidatorRegistrationV1) error {
-	ctx, span := trace.StartSpan(ctx, "builder.RegisterValidator")
-	defer span.End()
-	start := time.Now()
-	defer func() {
-		registerValidatorLatency.Observe(float64(time.Since(start).Milliseconds()))
-	}()
-
-	idxs := make([]types.ValidatorIndex, 0)
-	msgs := make([]*ethpb.ValidatorRegistrationV1, 0)
-	valid := make([]*ethpb.SignedValidatorRegistrationV1, 0)
-	for i := 0; i < len(reg); i++ {
-		r := reg[i]
-		nx, exists := s.cfg.headFetcher.HeadPublicKeyToValidatorIndex(bytesutil.ToBytes48(r.Message.Pubkey))
-		if !exists {
-			// we want to allow validators to set up keys that haven't been added to the beaconstate validator list yet,
-			// so we should tolerate keys that do not seem to be valid by skipping past them.
-			log.Warnf("Skipping validator registration for pubkey=%#x - not in current validator set.", r.Message.Pubkey)
-			continue
-		}
-		idxs = append(idxs, nx)
-		msgs = append(msgs, r.Message)
-		valid = append(valid, r)
-	}
-	if err := s.c.RegisterValidator(ctx, valid); err != nil {
-		return errors.Wrap(err, "could not register validator(s)")
-	}
-
-	return s.cfg.beaconDB.SaveRegistrationsByValidatorIDs(ctx, idxs, msgs)
-}
-
-// Configured returns true if the user has input a builder URL.
-func (s *Service) Configured() bool {
-	return s.cfg.builderEndpoint.Url != ""
-}

beacon-chain/builder/testing/BUILD.bazel

@@ -1,14 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    testonly = True,
-    srcs = ["mock.go"],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/builder/testing",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-    ],
-)

beacon-chain/builder/testing/mock.go

@@ -1,45 +0,0 @@
-package testing
-
-import (
-	"context"
-
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-// MockBuilderService to mock builder.
-type MockBuilderService struct {
-	HasConfigured         bool
-	Payload               *v1.ExecutionPayload
-	ErrSubmitBlindedBlock error
-	Bid                   *ethpb.SignedBuilderBid
-	ErrGetHeader          error
-	ErrStatus             error
-	ErrRegisterValidator  error
-}
-
-// Configured for mocking.
-func (s *MockBuilderService) Configured() bool {
-	return s.HasConfigured
-}
-
-// SubmitBlindedBlock for mocking.
-func (s *MockBuilderService) SubmitBlindedBlock(context.Context, *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error) {
-	return s.Payload, s.ErrSubmitBlindedBlock
-}
-
-// GetHeader for mocking.
-func (s *MockBuilderService) GetHeader(context.Context, types.Slot, [32]byte, [48]byte) (*ethpb.SignedBuilderBid, error) {
-	return s.Bid, s.ErrGetHeader
-}
-
-// Status for mocking.
-func (s *MockBuilderService) Status() error {
-	return s.ErrStatus
-}
-
-// RegisterValidator for mocking.
-func (s *MockBuilderService) RegisterValidator(context.Context, []*ethpb.SignedValidatorRegistrationV1) error {
-	return s.ErrRegisterValidator
-}

beacon-chain/cache/BUILD.bazel

@@ -1,52 +1,60 @@
 load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
+# gazelle:exclude committee_disabled.go
+# gazelle:exclude proposer_indices_disabled.go
 go_library(
     name = "go_default_library",
     srcs = [
-        "active_balance.go",
-        "active_balance_disabled.go",  # keep
         "attestation_data.go",
         "checkpoint_state.go",
-        "committee.go",
-        "committee_disabled.go",  # keep
         "committees.go",
         "common.go",
         "doc.go",
         "error.go",
-        "payload_id.go",
-        "proposer_indices.go",
-        "proposer_indices_disabled.go",  # keep
         "proposer_indices_type.go",
         "skip_slot_cache.go",
         "subnet_ids.go",
-        "sync_committee.go",
-        "sync_committee_disabled.go",  # keep
         "sync_committee_head_state.go",
         "sync_subnet_ids.go",
-    ],
+    ] + select({
+        "//testing/fuzz:fuzzing_enabled": [
+            "active_balance_disabled.go",
+            "committee_disabled.go",
+            "proposer_indices_disabled.go",
+            "sync_committee_disabled.go",
+        ],
+        "//conditions:default": [
+            "active_balance.go",
+            "committee.go",
+            "proposer_indices.go",
+            "sync_committee.go",
+        ],
+    }),
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache",
     visibility = [
         "//beacon-chain:__subpackages__",
-        "//testing/spectest:__subpackages__",
+        "//testing/fuzz:__pkg__",
         "//tools:__subpackages__",
     ],
     deps = [
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/v2:go_default_library",
+        "//beacon-chain/state/v3:go_default_library",
         "//cache/lru:go_default_library",
+        "//config/features:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//crypto/hash:go_default_library",
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",
         "@com_github_patrickmn_go_cache//: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_eth2_types//:go_default_library",
         "@io_k8s_client_go//tools/cache:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -62,7 +70,6 @@ go_test(
         "checkpoint_state_test.go",
         "committee_fuzz_test.go",
         "committee_test.go",
-        "payload_id_test.go",
         "proposer_indices_test.go",
         "skip_slot_cache_test.go",
         "subnet_ids_test.go",
@@ -75,16 +82,15 @@ go_test(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
-        "//beacon-chain/state/v3:go_default_library",
-        "//config/fieldparams:go_default_library",
+        "//config/features:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/cache/active_balance.go

@@ -1,4 +1,4 @@
-//go:build !fuzz
+// +build !libfuzzer
 
 package cache
 
@@ -10,18 +10,17 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	ethTypes "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
+	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	ethTypes "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-)
-
-const (
-	// maxBalanceCacheSize defines the max number of active balances can cache.
-	maxBalanceCacheSize = int(4)
 )
 
 var (
+	// maxBalanceCacheSize defines the max number of active balances can cache.
+	maxBalanceCacheSize = uint64(4)
+
 	// BalanceCacheMiss tracks the number of balance requests that aren't present in the cache.
 	balanceCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "total_effective_balance_cache_miss",
@@ -43,12 +42,15 @@ type BalanceCache struct {
 // NewEffectiveBalanceCache creates a new effective balance cache for storing/accessing total balance by epoch.
 func NewEffectiveBalanceCache() *BalanceCache {
 	return &BalanceCache{
-		cache: lruwrpr.New(maxBalanceCacheSize),
+		cache: lruwrpr.New(int(maxBalanceCacheSize)),
 	}
 }
 
 // AddTotalEffectiveBalance adds a new total effective balance entry for current balance for state `st` into the cache.
 func (c *BalanceCache) AddTotalEffectiveBalance(st state.ReadOnlyBeaconState, balance uint64) error {
+	if !features.Get().EnableActiveBalanceCache {
+		return nil
+	}
 	key, err := balanceCacheKey(st)
 	if err != nil {
 		return err
@@ -63,6 +65,9 @@ func (c *BalanceCache) AddTotalEffectiveBalance(st state.ReadOnlyBeaconState, ba
 
 // Get returns the current epoch's effective balance for state `st` in cache.
 func (c *BalanceCache) Get(st state.ReadOnlyBeaconState) (uint64, error) {
+	if !features.Get().EnableActiveBalanceCache {
+		return 0, ErrNotFound
+	}
 	key, err := balanceCacheKey(st)
 	if err != nil {
 		return 0, err

beacon-chain/cache/active_balance_disabled.go

@@ -1,4 +1,4 @@
-//go:build fuzz
+// +build libfuzzer
 
 package cache