Do not require a handler function in the gateway (#9264 )

* Do not require a handler function in the gateway * test fix Co-authored-by: Raul Jordan <raul@prysmaticlabs.com> Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com> (cherry picked from commit be82c8714f)
Fix Parsing of Nested Subcommands (#9236 )
2026-01-11 06:18:05 -05:00 · 2021-07-30 13:44:40 -05:00 · 2021-07-21 14:08:42 -05:00
2125 changed files with 82031 additions and 114096 deletions
--- a/.bazelrc
+++ b/.bazelrc
@@ -21,24 +21,34 @@ run --host_force_python=PY2
 build --sandbox_default_allow_network=false

 # Stamp binaries with git information
-build --workspace_status_command=./hack/workspace_status.sh
+build --workspace_status_command=./scripts/workspace_status.sh
 build --stamp

+# Use mainnet protobufs at runtime
+run --define ssz=mainnet
+test --define ssz=mainnet
+build --define ssz=mainnet
+
 # Prevent PATH changes from rebuilding when switching from IDE to command line.
 build --incompatible_strict_action_env
 test --incompatible_strict_action_env
 run --incompatible_strict_action_env

+# Disable kafka by default, it takes a long time to build...
+build --define kafka_enabled=false
+test --define kafka_enabled=false
+run --define kafka_enabled=false
+
 build --define blst_disabled=false
 test --define blst_disabled=false
 run --define blst_disabled=false

+build:kafka_enabled --define kafka_enabled=true
+build:kafka_enabled --define gotags=kafka_enabled
+
 build:blst_disabled --define blst_disabled=true
 build:blst_disabled --define gotags=blst_disabled

-build:minimal --//proto:network=minimal
-build:minimal --@io_bazel_rules_go//go/config:tags=minimal
-
 # Release flags
 build:release --compilation_mode=opt
 build:release --config=llvm
--- a/.bazelversion
+++ b/.bazelversion
@@ -1 +1 @@
-4.2.1
+3.7.0
--- a/.buildkite-bazelrc
+++ b/.buildkite-bazelrc
@@ -10,7 +10,7 @@

 # Prysm specific remote-cache properties.
 #build:remote-cache --disk_cache=
-build:remote-cache --remote_download_toplevel
+build:remote-cache --remote_download_minimal
 build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
 build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
 build:remote-cache --remote_local_fallback
@@ -43,7 +43,3 @@ build --flaky_test_attempts=5

 # 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
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -24,23 +24,13 @@ jobs:
        uses: ./.github/actions/gofmt
        with:
          path: ./
-
+      
      - name: GoImports checker
        id: goimports
        uses: Jerome1337/goimports-action@v1.0.2
        with:
          goimports-path: ./

-      - name: Gosec security scanner
-        uses: securego/gosec@master
-        with:
-          args: '-exclude=G307 -exclude-dir=crypto/bls/herumi ./...'
-
-      - name: Golangci-lint
-        uses: golangci/golangci-lint-action@v2
-        with:
-          args: --print-issued-lines --sort-results --no-config --timeout=10m --disable-all -E deadcode  -E errcheck -E gosimple --skip-files=validator/web/site_data.go
-
  build:
    name: Build
    runs-on: ubuntu-latest
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -144,6 +144,12 @@ common_files = {
    "//:README.md": "README.md",
 }

+toolchain(
+    name = "built_cmake_toolchain",
+    toolchain = "@rules_foreign_cc//tools/build_defs/native_tools:built_cmake",
+    toolchain_type = "@rules_foreign_cc//tools/build_defs:cmake_toolchain",
+)
+
 string_setting(
    name = "gotags",
    build_setting_default = "",
--- a/DEPENDENCIES.md
+++ b/DEPENDENCIES.md
@@ -33,8 +33,8 @@ generates SSZ marshal related code based on defined data structures. These gener
 also be updated and checked in as frequently.

 ```bash
-./hack/update-go-pbs.sh
-./hack/update-go-ssz.sh
+./scripts/update-go-pbs.sh
+./scripts/update-go-ssz.sh
 ```

 *Recommendation: Use go build only for local development and use bazel build for production.*
--- a/README.md
+++ b/README.md
@@ -2,7 +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)
-[![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)
+[![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/eth2.0-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.
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,11 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-[Releases](https://github.com/prysmaticlabs/prysm/releases/) contains all available releases. We recommend using the [most recently released version](https://github.com/prysmaticlabs/prysm/releases/latest).
-
-## Reporting a Vulnerability
-
-Please see our signed [security.txt](https://github.com/prysmaticlabs/prysm/blob/develop/.well-known/security.txt) for preferred encryption and reporting destination.
-
-**Please do not file a public ticket** mentioning the vulnerability, as doing so could increase the likelihood of the vulnerability being used before a fix has been created, released and installed on the network.
--- a/132
+++ b/132
@@ -76,9 +76,9 @@ http_archive(

 http_archive(
    name = "io_bazel_rules_docker",
-    sha256 = "1f4e59843b61981a96835dc4ac377ad4da9f8c334ebe5e0bb3f58f80c09735f4",
-    strip_prefix = "rules_docker-0.19.0",
-    urls = ["https://github.com/bazelbuild/rules_docker/releases/download/v0.19.0/rules_docker-v0.19.0.tar.gz"],
+    sha256 = "59d5b42ac315e7eadffa944e86e90c2990110a1c8075f1cd145f487e999d22b3",
+    strip_prefix = "rules_docker-0.17.0",
+    urls = ["https://github.com/bazelbuild/rules_docker/releases/download/v0.17.0/rules_docker-v0.17.0.tar.gz"],
 )

 http_archive(
@@ -139,34 +139,6 @@ load(
    "container_pull",
 )

-container_pull(
-    name = "cc_image_base",
-    digest = "sha256:2c4bb6b7236db0a55ec54ba8845e4031f5db2be957ac61867872bf42e56c4deb",
-    registry = "gcr.io",
-    repository = "distroless/cc",
-)
-
-container_pull(
-    name = "cc_debug_image_base",
-    digest = "sha256:3680c61e81f68fc00bfb5e1ec65e8e678aaafa7c5f056bc2681c29527ebbb30c",
-    registry = "gcr.io",
-    repository = "distroless/cc",
-)
-
-container_pull(
-    name = "go_image_base",
-    digest = "sha256:ba7a315f86771332e76fa9c3d423ecfdbb8265879c6f1c264d6fff7d4fa460a4",
-    registry = "gcr.io",
-    repository = "distroless/base",
-)
-
-container_pull(
-    name = "go_debug_image_base",
-    digest = "sha256:efd8711717d9e9b5d0dbb20ea10876dab0609c923bc05321b912f9239090ca80",
-    registry = "gcr.io",
-    repository = "distroless/base",
-)
-
 container_pull(
    name = "alpine_cc_linux_amd64",
    digest = "sha256:752aa0c9a88461ffc50c5267bb7497ef03a303e38b2c8f7f2ded9bebe5f1f00e",
@@ -225,12 +197,8 @@ filegroup(
    url = "https://github.com/eth2-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )

-consensus_spec_version = "v1.1.3"
-
-bls_test_version = "v0.1.1"
-
 http_archive(
-    name = "consensus_spec_tests_general",
+    name = "eth2_spec_tests_general",
    build_file_content = """
 filegroup(
    name = "test_data",
@@ -241,12 +209,12 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    sha256 = "e572f8c57e2dbbaeee056a600dc9d08396010dd5134a3a95e43c540470acf6f5",
-    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
+    sha256 = "deacc076365c727d653ac064894ecf0d1b0a675d86704dc8de271259f6a7314b",
+    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v1.1.0-alpha.3/general.tar.gz",
 )

 http_archive(
-    name = "consensus_spec_tests_minimal",
+    name = "eth2_spec_tests_minimal",
    build_file_content = """
 filegroup(
    name = "test_data",
@@ -257,12 +225,12 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    sha256 = "7e2f62eaae9fd541690cc61d252556d0c5deb585ca1873aacbeb5b02d06f1362",
-    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
+    sha256 = "6e9886af3d2f024e563249d70388129e28e3e92f742f289238ed9b7ec7a7f930",
+    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v1.1.0-alpha.3/minimal.tar.gz",
 )

 http_archive(
-    name = "consensus_spec_tests_mainnet",
+    name = "eth2_spec_tests_mainnet",
    build_file_content = """
 filegroup(
    name = "test_data",
@@ -273,55 +241,8 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    sha256 = "05cbb89810c8acd6c57c4773ddfd167305cd4539960e9b4d7b69e1a988b35ad2",
-    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
-)
-
-http_archive(
-    name = "consensus_spec",
-    build_file_content = """
-filegroup(
-    name = "spec_data",
-    srcs = glob([
-        "**/*.yaml",
-    ]),
-    visibility = ["//visibility:public"],
-)
-    """,
-    sha256 = "0cef67b08448f7eb43bf66c464451c9e7a4852df8ef90555cca6d440e3436882",
-    strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
-    url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
-)
-
-http_archive(
-    name = "bls_spec_tests",
-    build_file_content = """
-filegroup(
-    name = "test_data",
-    srcs = glob([
-        "**/*.yaml",
-    ]),
-    visibility = ["//visibility:public"],
-)
-    """,
-    sha256 = "93c7d006e7c5b882cbd11dc9ec6c5d0e07f4a8c6b27a32f964eb17cf2db9763a",
-    url = "https://github.com/ethereum/bls12-381-tests/releases/download/%s/bls_tests_yaml.tar.gz" % bls_test_version,
-)
-
-http_archive(
-    name = "eth2_networks",
-    build_file_content = """
-filegroup(
-    name = "configs",
-    srcs = glob([
-        "shared/**/config.yaml",
-    ]),
-    visibility = ["//visibility:public"],
-)
-    """,
-    sha256 = "9dc47bf6b14aed7fac8833e35ab83a69131b43fa5789b3256bf1ac3d4861aeb8",
-    strip_prefix = "eth2-networks-7fa1b868985ee24aad65567f9250cf7fa86f97b1",
-    url = "https://github.com/eth2-clients/eth2-networks/archive/7fa1b868985ee24aad65567f9250cf7fa86f97b1.tar.gz",
+    sha256 = "a7b3d0ffc02a567250f424d69b2474fdc9477cd56eada60af7474560b46a8527",
+    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v1.1.0-alpha.3/mainnet.tar.gz",
 )

 http_archive(
@@ -341,6 +262,27 @@ 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 = "rules_foreign_cc",
+    sha256 = "b85ce66a3410f7370d1a9a61dfe3a29c7532b7637caeb2877d8d0dfd41d77abb",
+    strip_prefix = "rules_foreign_cc-3515b20a2417c4dd51c8a4a8cac1f6ecf3c6d934",
+    url = "https://github.com/bazelbuild/rules_foreign_cc/archive/3515b20a2417c4dd51c8a4a8cac1f6ecf3c6d934.zip",
+)
+
+load("@rules_foreign_cc//:workspace_definitions.bzl", "rules_foreign_cc_dependencies")
+
+rules_foreign_cc_dependencies([
+    "@prysm//:built_cmake_toolchain",
+])
+
+http_archive(
+    name = "librdkafka",
+    build_file_content = all_content,
+    sha256 = "3b99a36c082a67ef6295eabd4fb3e32ab0bff7c6b0d397d6352697335f4e57eb",
+    strip_prefix = "librdkafka-1.4.2",
+    urls = ["https://github.com/edenhill/librdkafka/archive/v1.4.2.tar.gz"],
+)
+
 http_archive(
    name = "sigp_beacon_fuzz_corpora",
    build_file = "//third_party:beacon-fuzz/corpora.BUILD",
@@ -362,9 +304,9 @@ filegroup(
    visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "0a3d94428ea28916276694c517b82b364122063fdbf924f54ee9ae0bc500289f",
+    sha256 = "54ce527b83d092da01127f2e3816f4d5cfbab69354caba8537f1ea55889b6d7c",
    urls = [
-        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.1/prysm-web-ui.tar.gz",
+        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.0-beta.4/prysm-web-ui.tar.gz",
    ],
 )

@@ -395,6 +337,10 @@ load(

 _cc_image_repos()

+load("@com_github_ethereum_go_ethereum//:deps.bzl", "geth_dependencies")
+
+geth_dependencies()
+
 load("@io_bazel_rules_go//extras:embed_data_deps.bzl", "go_embed_data_dependencies")

 go_embed_data_dependencies()
--- a/api/gateway/apimiddleware/BUILD.bazel
+++ b/api/gateway/apimiddleware/BUILD.bazel
@@ -1,40 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "api_middleware.go",
-        "log.go",
-        "param_handling.go",
-        "process_field.go",
-        "process_request.go",
-        "structs.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/gateway/apimiddleware",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//api/grpc:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_wealdtech_go_bytesutil//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "param_handling_test.go",
-        "process_request_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//api/grpc:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-    ],
-)
--- a/api/gateway/apimiddleware/api_middleware.go
+++ b/api/gateway/apimiddleware/api_middleware.go
@@ -1,233 +0,0 @@
-package apimiddleware
-
-import (
-	"net/http"
-	"reflect"
-
-	"github.com/gorilla/mux"
-)
-
-// ApiProxyMiddleware is a proxy between an Ethereum consensus API HTTP client and grpc-gateway.
-// The purpose of the proxy is to handle HTTP requests and gRPC responses in such a way that:
-//   - Ethereum consensus API requests can be handled by grpc-gateway correctly
-//   - gRPC responses can be returned as spec-compliant Ethereum consensus API responses
-type ApiProxyMiddleware struct {
-	GatewayAddress  string
-	EndpointCreator EndpointFactory
-}
-
-// EndpointFactory is responsible for creating new instances of Endpoint values.
-type EndpointFactory interface {
-	Create(path string) (*Endpoint, error)
-	Paths() []string
-	IsNil() bool
-}
-
-// Endpoint is a representation of an API HTTP endpoint that should be proxied by the middleware.
-type Endpoint struct {
-	Path               string          // The path of the HTTP endpoint.
-	GetResponse        interface{}     // The struct corresponding to the JSON structure used in a GET response.
-	PostRequest        interface{}     // The struct corresponding to the JSON structure used in a POST request.
-	PostResponse       interface{}     // The struct corresponding to the JSON structure used in a POST response.
-	RequestURLLiterals []string        // Names of URL parameters that should not be base64-encoded.
-	RequestQueryParams []QueryParam    // Query parameters of the request.
-	Err                ErrorJson       // The struct corresponding to the error that should be returned in case of a request failure.
-	Hooks              HookCollection  // A collection of functions that can be invoked at various stages of the request/response cycle.
-	CustomHandlers     []CustomHandler // Functions that will be executed instead of the default request/response behaviour.
-}
-
-// RunDefault expresses whether the default processing logic should be carried out after running a pre hook.
-type RunDefault bool
-
-// DefaultEndpoint returns an Endpoint with default configuration, e.g. DefaultErrorJson for error handling.
-func DefaultEndpoint() Endpoint {
-	return Endpoint{
-		Err: &DefaultErrorJson{},
-	}
-}
-
-// QueryParam represents a single query parameter's metadata.
-type QueryParam struct {
-	Name string
-	Hex  bool
-	Enum bool
-}
-
-// CustomHandler is a function that can be invoked at the very beginning of the request,
-// essentially replacing the whole default request/response logic with custom logic for a specific endpoint.
-type CustomHandler = func(m *ApiProxyMiddleware, endpoint Endpoint, w http.ResponseWriter, req *http.Request) (handled bool)
-
-// HookCollection contains hooks that can be used to amend the default request/response cycle with custom logic for a specific endpoint.
-type HookCollection struct {
-	OnPreDeserializeRequestBodyIntoContainer      func(endpoint *Endpoint, w http.ResponseWriter, req *http.Request) (RunDefault, ErrorJson)
-	OnPostDeserializeRequestBodyIntoContainer     func(endpoint *Endpoint, w http.ResponseWriter, req *http.Request) ErrorJson
-	OnPreDeserializeGrpcResponseBodyIntoContainer func([]byte, interface{}) (RunDefault, ErrorJson)
-	OnPreSerializeMiddlewareResponseIntoJson      func(interface{}) (RunDefault, []byte, ErrorJson)
-}
-
-// fieldProcessor applies the processing function f to a value when the tag is present on the field.
-type fieldProcessor struct {
-	tag string
-	f   func(value reflect.Value) error
-}
-
-// Run starts the proxy, registering all proxy endpoints.
-func (m *ApiProxyMiddleware) Run(gatewayRouter *mux.Router) {
-	for _, path := range m.EndpointCreator.Paths() {
-		m.handleApiPath(gatewayRouter, path, m.EndpointCreator)
-	}
-}
-
-func (m *ApiProxyMiddleware) handleApiPath(gatewayRouter *mux.Router, path string, endpointFactory EndpointFactory) {
-	gatewayRouter.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) {
-		endpoint, err := endpointFactory.Create(path)
-		if err != nil {
-			errJson := InternalServerErrorWithMessage(err, "could not create endpoint")
-			WriteError(w, errJson, nil)
-		}
-
-		for _, handler := range endpoint.CustomHandlers {
-			if handler(m, *endpoint, w, req) {
-				return
-			}
-		}
-
-		if req.Method == "POST" {
-			if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-
-			if errJson := ProcessRequestContainerFields(endpoint.PostRequest); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-			if errJson := SetRequestBodyToRequestContainer(endpoint.PostRequest, req); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-		}
-
-		if errJson := m.PrepareRequestForProxying(*endpoint, req); errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-		grpcResp, errJson := ProxyRequest(req)
-		if errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-		grpcRespBody, errJson := ReadGrpcResponseBody(grpcResp.Body)
-		if errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-
-		var respJson []byte
-		if !GrpcResponseIsEmpty(grpcRespBody) {
-			respHasError, errJson := HandleGrpcResponseError(endpoint.Err, grpcResp, grpcRespBody, w)
-			if errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-			if respHasError {
-				return
-			}
-
-			var resp interface{}
-			if req.Method == "GET" {
-				resp = endpoint.GetResponse
-			} else {
-				resp = endpoint.PostResponse
-			}
-			if errJson := deserializeGrpcResponseBodyIntoContainerWrapped(endpoint, grpcRespBody, resp); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-			if errJson := ProcessMiddlewareResponseFields(resp); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-
-			respJson, errJson = serializeMiddlewareResponseIntoJsonWrapped(endpoint, respJson, resp)
-			if errJson != nil {
-				WriteError(w, errJson, nil)
-				return
-			}
-		}
-
-		if errJson := WriteMiddlewareResponseHeadersAndBody(grpcResp, respJson, w); errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-		if errJson := Cleanup(grpcResp.Body); errJson != nil {
-			WriteError(w, errJson, nil)
-			return
-		}
-	})
-}
-
-func deserializeRequestBodyIntoContainerWrapped(endpoint *Endpoint, req *http.Request, w http.ResponseWriter) ErrorJson {
-	runDefault := true
-	if endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer != nil {
-		run, errJson := endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer(endpoint, w, req)
-		if errJson != nil {
-			return errJson
-		}
-		if !run {
-			runDefault = false
-		}
-	}
-	if runDefault {
-		if errJson := DeserializeRequestBodyIntoContainer(req.Body, endpoint.PostRequest); errJson != nil {
-			return errJson
-		}
-	}
-	if endpoint.Hooks.OnPostDeserializeRequestBodyIntoContainer != nil {
-		if errJson := endpoint.Hooks.OnPostDeserializeRequestBodyIntoContainer(endpoint, w, req); errJson != nil {
-			return errJson
-		}
-	}
-	return nil
-}
-
-func deserializeGrpcResponseBodyIntoContainerWrapped(endpoint *Endpoint, grpcResponseBody []byte, resp interface{}) ErrorJson {
-	runDefault := true
-	if endpoint.Hooks.OnPreDeserializeGrpcResponseBodyIntoContainer != nil {
-		run, errJson := endpoint.Hooks.OnPreDeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, resp)
-		if errJson != nil {
-			return errJson
-		}
-		if !run {
-			runDefault = false
-		}
-	}
-	if runDefault {
-		if errJson := DeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, resp); errJson != nil {
-			return errJson
-		}
-	}
-	return nil
-}
-
-func serializeMiddlewareResponseIntoJsonWrapped(endpoint *Endpoint, respJson []byte, resp interface{}) ([]byte, ErrorJson) {
-	runDefault := true
-	var errJson ErrorJson
-	if endpoint.Hooks.OnPreSerializeMiddlewareResponseIntoJson != nil {
-		var run RunDefault
-		run, respJson, errJson = endpoint.Hooks.OnPreSerializeMiddlewareResponseIntoJson(resp)
-		if errJson != nil {
-			return nil, errJson
-		}
-		if !run {
-			runDefault = false
-		}
-	}
-	if runDefault {
-		respJson, errJson = SerializeMiddlewareResponseIntoJson(resp)
-		if errJson != nil {
-			return nil, errJson
-		}
-	}
-	return respJson, nil
-}
--- a/api/gateway/apimiddleware/log.go
+++ b/api/gateway/apimiddleware/log.go
@@ -1,5 +0,0 @@
-package apimiddleware
-
-import "github.com/sirupsen/logrus"
-
-var log = logrus.WithField("prefix", "apimiddleware")
--- a/api/gateway/apimiddleware/process_field.go
+++ b/api/gateway/apimiddleware/process_field.go
@@ -1,108 +0,0 @@
-package apimiddleware
-
-import (
-	"encoding/base64"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
-	"github.com/wealdtech/go-bytesutil"
-)
-
-// processField calls each processor function on any field that has the matching tag set.
-// It is a recursive function.
-func processField(s interface{}, processors []fieldProcessor) error {
-	kind := reflect.TypeOf(s).Kind()
-	if kind != reflect.Ptr && kind != reflect.Slice && kind != reflect.Array {
-		return fmt.Errorf("processing fields of kind '%v' is unsupported", kind)
-	}
-
-	t := reflect.TypeOf(s).Elem()
-	v := reflect.Indirect(reflect.ValueOf(s))
-
-	for i := 0; i < t.NumField(); i++ {
-		switch v.Field(i).Kind() {
-		case reflect.Slice:
-			sliceElem := t.Field(i).Type.Elem()
-			kind := sliceElem.Kind()
-			// Recursively process slices to struct pointers.
-			if kind == reflect.Ptr && sliceElem.Elem().Kind() == reflect.Struct {
-				for j := 0; j < v.Field(i).Len(); j++ {
-					if err := processField(v.Field(i).Index(j).Interface(), processors); err != nil {
-						return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-					}
-				}
-			}
-			// Process each string in string slices.
-			if kind == reflect.String {
-				for _, proc := range processors {
-					_, hasTag := t.Field(i).Tag.Lookup(proc.tag)
-					if hasTag {
-						for j := 0; j < v.Field(i).Len(); j++ {
-							if err := proc.f(v.Field(i).Index(j)); err != nil {
-								return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-							}
-						}
-					}
-				}
-
-			}
-		// Recursively process struct pointers.
-		case reflect.Ptr:
-			if v.Field(i).Elem().Kind() == reflect.Struct {
-				if err := processField(v.Field(i).Interface(), processors); err != nil {
-					return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-				}
-			}
-		default:
-			field := t.Field(i)
-			for _, proc := range processors {
-				if _, hasTag := field.Tag.Lookup(proc.tag); hasTag {
-					if err := proc.f(v.Field(i)); err != nil {
-						return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func hexToBase64Processor(v reflect.Value) error {
-	b, err := bytesutil.FromHexString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(base64.StdEncoding.EncodeToString(b))
-	return nil
-}
-
-func base64ToHexProcessor(v reflect.Value) error {
-	if v.String() == "" {
-		return nil
-	}
-	b, err := base64.StdEncoding.DecodeString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(hexutil.Encode(b))
-	return nil
-}
-
-func enumToLowercaseProcessor(v reflect.Value) error {
-	v.SetString(strings.ToLower(v.String()))
-	return nil
-}
-
-func timeToUnixProcessor(v reflect.Value) error {
-	t, err := time.Parse(time.RFC3339, v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(strconv.FormatUint(uint64(t.Unix()), 10))
-	return nil
-}
--- a/beacon-chain/README.md
+++ b/beacon-chain/README.md
@@ -6,4 +6,4 @@ You can also read our main [README](https://github.com/prysmaticlabs/prysm/blob/

 [![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)

-Also, read the official beacon chain [specification](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/beacon-chain.md), this design spec serves as a source of truth for the beacon chain implementation we follow at Prysmatic Labs.
+Also, read the official beacon chain [specification](https://github.com/ethereum/eth2.0-specs/blob/master/specs/phase0/beacon-chain.md), this design spec serves as a source of truth for the beacon chain implementation we follow at Prysmatic Labs.
--- a/beacon-chain/blockchain/BUILD.bazel
+++ b/beacon-chain/blockchain/BUILD.bazel
@@ -5,12 +5,10 @@ go_library(
    srcs = [
        "chain_info.go",
        "head.go",
-        "head_sync_committee_info.go",
        "info.go",
        "init_sync_process_block.go",
        "log.go",
        "metrics.go",
-        "options.go",
        "process_attestation.go",
        "process_attestation_helpers.go",
        "process_block.go",
@@ -23,23 +21,16 @@ go_library(
    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain",
    visibility = [
        "//beacon-chain:__subpackages__",
-        "//cmd/beacon-chain:__subpackages__",
-        "//testing/fuzz:__pkg__",
-        "//testing/slasher/simulator:__pkg__",
+        "//fuzz:__pkg__",
    ],
    deps = [
-        "//async:go_default_library",
-        "//async/event:go_default_library",
        "//beacon-chain/cache:go_default_library",
        "//beacon-chain/cache/depositcache:go_default_library",
-        "//beacon-chain/core/altair:go_default_library",
        "//beacon-chain/core/epoch/precompute:go_default_library",
        "//beacon-chain/core/feed:go_default_library",
        "//beacon-chain/core/feed/state:go_default_library",
        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/core/state:go_default_library",
        "//beacon-chain/db:go_default_library",
        "//beacon-chain/db/filters:go_default_library",
        "//beacon-chain/forkchoice:go_default_library",
@@ -49,21 +40,23 @@ go_library(
        "//beacon-chain/operations/voluntaryexits:go_default_library",
        "//beacon-chain/p2p:go_default_library",
        "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/interface:go_default_library",
        "//beacon-chain/state/stategen:go_default_library",
        "//cmd/beacon-chain/flags:go_default_library",
-        "//config/features:go_default_library",
-        "//config/params:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//monitoring/tracing:go_default_library",
+        "//proto/beacon/p2p/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",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//proto/interfaces:go_default_library",
+        "//shared/attestationutil:go_default_library",
+        "//shared/bls:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/copyutil:go_default_library",
+        "//shared/featureconfig:go_default_library",
+        "//shared/mputil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/slotutil:go_default_library",
+        "//shared/timeutils:go_default_library",
+        "//shared/traceutil:go_default_library",
        "@com_github_emicklei_dot//:go_default_library",
        "@com_github_pkg_errors//:go_default_library",
        "@com_github_prometheus_client_golang//prometheus:go_default_library",
@@ -89,11 +82,9 @@ go_test(
        "blockchain_test.go",
        "chain_info_test.go",
        "checktags_test.go",
-        "head_sync_committee_info_test.go",
        "head_test.go",
        "info_test.go",
        "init_test.go",
-        "log_test.go",
        "metrics_test.go",
        "process_attestation_test.go",
        "process_block_test.go",
@@ -105,25 +96,27 @@ go_test(
    embed = [":go_default_library"],
    gotags = ["develop"],
    deps = [
-        "//async/event:go_default_library",
        "//beacon-chain/blockchain/testing:go_default_library",
        "//beacon-chain/cache/depositcache:go_default_library",
        "//beacon-chain/core/blocks:go_default_library",
        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/core/state:go_default_library",
        "//beacon-chain/db:go_default_library",
        "//beacon-chain/db/testing:go_default_library",
        "//beacon-chain/p2p:go_default_library",
        "//beacon-chain/powchain:go_default_library",
        "//beacon-chain/state/stateutil:go_default_library",
        "//beacon-chain/state/v1:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
+        "//proto/beacon/db:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//proto/eth/v1alpha1/wrapper:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/event:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
        "@com_github_ethereum_go_ethereum//:go_default_library",
        "@com_github_ethereum_go_ethereum//common:go_default_library",
        "@com_github_ethereum_go_ethereum//core/types:go_default_library",
@@ -156,23 +149,24 @@ go_test(
    race = "on",
    tags = ["race_on"],
    deps = [
-        "//async/event:go_default_library",
        "//beacon-chain/blockchain/testing:go_default_library",
        "//beacon-chain/cache/depositcache:go_default_library",
        "//beacon-chain/core/blocks:go_default_library",
        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/core/state:go_default_library",
        "//beacon-chain/db:go_default_library",
        "//beacon-chain/db/testing:go_default_library",
        "//beacon-chain/p2p:go_default_library",
        "//beacon-chain/powchain:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//proto/eth/v1alpha1/wrapper:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/event:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
        "@com_github_ethereum_go_ethereum//:go_default_library",
        "@com_github_ethereum_go_ethereum//common:go_default_library",
        "@com_github_ethereum_go_ethereum//core/types:go_default_library",
--- a/beacon-chain/blockchain/chain_info.go
+++ b/beacon-chain/blockchain/chain_info.go
@@ -7,11 +7,13 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/copyutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )

@@ -23,8 +25,6 @@ type ChainInfoFetcher interface {
 	GenesisFetcher
 	CanonicalFetcher
 	ForkFetcher
-	TimeFetcher
-	HeadDomainFetcher
 }

 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
@@ -43,23 +43,19 @@ type GenesisFetcher interface {
 type HeadFetcher interface {
 	HeadSlot() types.Slot
 	HeadRoot(ctx context.Context) ([]byte, error)
-	HeadBlock(ctx context.Context) (block.SignedBeaconBlock, error)
-	HeadState(ctx context.Context) (state.BeaconState, error)
+	HeadBlock(ctx context.Context) (interfaces.SignedBeaconBlock, error)
+	HeadState(ctx context.Context) (iface.BeaconState, error)
 	HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error)
 	HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error)
 	HeadGenesisValidatorRoot() [32]byte
 	HeadETH1Data() *ethpb.Eth1Data
-	HeadPublicKeyToValidatorIndex(ctx context.Context, pubKey [48]byte) (types.ValidatorIndex, bool)
-	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([48]byte, error)
 	ProtoArrayStore() *protoarray.Store
 	ChainHeads() ([][32]byte, []types.Slot)
-	HeadSyncCommitteeFetcher
-	HeadDomainFetcher
 }

 // ForkFetcher retrieves the current fork information of the Ethereum beacon chain.
 type ForkFetcher interface {
-	CurrentFork() *ethpb.Fork
+	CurrentFork() *pb.Fork
 }

 // CanonicalFetcher retrieves the current chain's canonical information.
@@ -82,7 +78,7 @@ func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}

-	return ethpb.CopyCheckpoint(s.finalizedCheckpt)
+	return copyutil.CopyCheckpoint(s.finalizedCheckpt)
 }

 // CurrentJustifiedCheckpt returns the current justified checkpoint from head state.
@@ -91,7 +87,7 @@ func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}

-	return ethpb.CopyCheckpoint(s.justifiedCheckpt)
+	return copyutil.CopyCheckpoint(s.justifiedCheckpt)
 }

 // PreviousJustifiedCheckpt returns the previous justified checkpoint from head state.
@@ -100,7 +96,7 @@ func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}

-	return ethpb.CopyCheckpoint(s.prevJustifiedCheckpt)
+	return copyutil.CopyCheckpoint(s.prevJustifiedCheckpt)
 }

 // HeadSlot returns the slot of the head of the chain.
@@ -144,7 +140,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) (block.SignedBeaconBlock, error) {
+func (s *Service) HeadBlock(ctx context.Context) (interfaces.SignedBeaconBlock, error) {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()

@@ -158,7 +154,7 @@ func (s *Service) HeadBlock(ctx context.Context) (block.SignedBeaconBlock, error
 // HeadState returns the head state of the chain.
 // If the head is nil from service struct,
 // it will attempt to get the head state from DB.
-func (s *Service) HeadState(ctx context.Context) (state.BeaconState, error) {
+func (s *Service) HeadState(ctx context.Context) (iface.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.HeadState")
 	defer span.End()
 	s.headLock.RLock()
@@ -182,7 +178,7 @@ func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch types.Epoch)
 	if !s.hasHeadState() {
 		return []types.ValidatorIndex{}, nil
 	}
-	return helpers.ActiveValidatorIndices(ctx, s.headState(ctx), epoch)
+	return helpers.ActiveValidatorIndices(s.headState(ctx), epoch)
 }

 // HeadSeed returns the seed from the head view of a given epoch.
@@ -243,12 +239,12 @@ func (s *Service) GenesisValidatorRoot() [32]byte {
 }

 // CurrentFork retrieves the latest fork information of the beacon chain.
-func (s *Service) CurrentFork() *ethpb.Fork {
+func (s *Service) CurrentFork() *pb.Fork {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()

 	if !s.hasHeadState() {
-		return &ethpb.Fork{
+		return &pb.Fork{
 			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
 		}
@@ -288,27 +284,3 @@ func (s *Service) ChainHeads() ([][32]byte, []types.Slot) {

 	return headsRoots, headsSlots
 }
-
-// HeadPublicKeyToValidatorIndex returns the validator index of the `pubkey` in current head state.
-func (s *Service) HeadPublicKeyToValidatorIndex(ctx context.Context, pubKey [48]byte) (types.ValidatorIndex, bool) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-	if !s.hasHeadState() {
-		return 0, false
-	}
-	return s.headState(ctx).ValidatorIndexByPubkey(pubKey)
-}
-
-// HeadValidatorIndexToPublicKey returns the pubkey of the validator `index`  in current head state.
-func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.ValidatorIndex) ([48]byte, error) {
-	s.headLock.RLock()
-	defer s.headLock.RUnlock()
-	if !s.hasHeadState() {
-		return [48]byte{}, nil
-	}
-	v, err := s.headValidatorAtIndex(index)
-	if err != nil {
-		return [48]byte{}, err
-	}
-	return v.PublicKey(), nil
-}
--- a/beacon-chain/blockchain/chain_info_norace_test.go
+++ b/beacon-chain/blockchain/chain_info_norace_test.go
@@ -6,15 +6,15 @@ import (

 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestHeadSlot_DataRace(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg: &config{BeaconDB: beaconDB},
+		cfg: &Config{BeaconDB: beaconDB},
 	}
 	go func() {
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
@@ -25,7 +25,7 @@ func TestHeadSlot_DataRace(t *testing.T) {
 func TestHeadRoot_DataRace(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
+		cfg:  &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 		head: &head{root: [32]byte{'A'}},
 	}
 	go func() {
@@ -38,7 +38,7 @@ func TestHeadRoot_DataRace(t *testing.T) {
 func TestHeadBlock_DataRace(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
+		cfg:  &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 		head: &head{block: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{})},
 	}
 	go func() {
@@ -51,7 +51,7 @@ func TestHeadBlock_DataRace(t *testing.T) {
 func TestHeadState_DataRace(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
+		cfg: &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 	}
 	go func() {
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
--- a/beacon-chain/blockchain/chain_info_test.go
+++ b/beacon-chain/blockchain/chain_info_test.go
@@ -9,14 +9,15 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"google.golang.org/protobuf/proto"
 )

@@ -104,7 +105,7 @@ func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {

 func TestHeadSlot_CanRetrieve(t *testing.T) {
 	c := &Service{}
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
+	s, err := v1.InitializeFromProto(&pb.BeaconState{})
 	require.NoError(t, err)
 	c.head = &head{slot: 100, state: s}
 	assert.Equal(t, types.Slot(100), c.HeadSlot())
@@ -120,13 +121,13 @@ func TestHeadRoot_CanRetrieve(t *testing.T) {

 func TestHeadRoot_UseDB(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	c := &Service{cfg: &config{BeaconDB: beaconDB}}
+	c := &Service{cfg: &Config{BeaconDB: beaconDB}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:]}))
+	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &pb.StateSummary{Root: br[:]}))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(context.Background(), br))
 	r, err := c.HeadRoot(context.Background())
 	require.NoError(t, err)
@@ -134,9 +135,9 @@ func TestHeadRoot_UseDB(t *testing.T) {
 }

 func TestHeadBlock_CanRetrieve(t *testing.T) {
-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 1
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
+	s, err := v1.InitializeFromProto(&pb.BeaconState{})
 	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{block: wrapper.WrappedPhase0SignedBeaconBlock(b), state: s}
@@ -147,7 +148,7 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
 }

 func TestHeadState_CanRetrieve(t *testing.T) {
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Slot: 2, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
+	s, err := v1.InitializeFromProto(&pb.BeaconState{Slot: 2, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
 	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{state: s}
@@ -163,8 +164,8 @@ func TestGenesisTime_CanRetrieve(t *testing.T) {
 }

 func TestCurrentFork_CanRetrieve(t *testing.T) {
-	f := &ethpb.Fork{Epoch: 999}
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Fork: f})
+	f := &pb.Fork{Epoch: 999}
+	s, err := v1.InitializeFromProto(&pb.BeaconState{Fork: f})
 	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{state: s}
@@ -174,7 +175,7 @@ func TestCurrentFork_CanRetrieve(t *testing.T) {
 }

 func TestCurrentFork_NilHeadSTate(t *testing.T) {
-	f := &ethpb.Fork{
+	f := &pb.Fork{
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
 	}
@@ -189,7 +190,7 @@ func TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
 	c := &Service{}
 	assert.Equal(t, [32]byte{}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")

-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
+	s, err := v1.InitializeFromProto(&pb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
 	require.NoError(t, err)
 	c.head = &head{state: s}
 	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
@@ -203,7 +204,7 @@ func TestHeadETH1Data_Nil(t *testing.T) {

 func TestHeadETH1Data_CanRetrieve(t *testing.T) {
 	d := &ethpb.Eth1Data{DepositCount: 999}
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Eth1Data: d})
+	s, err := v1.InitializeFromProto(&pb.BeaconState{Eth1Data: d})
 	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{state: s}
@@ -217,7 +218,7 @@ func TestIsCanonical_Ok(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	c := setupBeaconChain(t, beaconDB)

-	blk := util.NewBeaconBlock()
+	blk := testutil.NewBeaconBlock()
 	blk.Block.Slot = 0
 	root, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -233,7 +234,7 @@ func TestIsCanonical_Ok(t *testing.T) {
 }

 func TestService_HeadValidatorsIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 10)
+	s, _ := testutil.DeterministicGenesisState(t, 10)
 	c := &Service{}

 	c.head = &head{}
@@ -248,7 +249,7 @@ func TestService_HeadValidatorsIndices(t *testing.T) {
 }

 func TestService_HeadSeed(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 1)
+	s, _ := testutil.DeterministicGenesisState(t, 1)
 	c := &Service{}
 	seed, err := helpers.Seed(s, 0, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
@@ -265,7 +266,7 @@ func TestService_HeadSeed(t *testing.T) {
 }

 func TestService_HeadGenesisValidatorRoot(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 1)
+	s, _ := testutil.DeterministicGenesisState(t, 1)
 	c := &Service{}

 	c.head = &head{}
@@ -278,14 +279,14 @@ func TestService_HeadGenesisValidatorRoot(t *testing.T) {
 }

 func TestService_ProtoArrayStore(t *testing.T) {
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}}
+	c := &Service{cfg: &Config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}}
 	p := c.ProtoArrayStore()
 	require.Equal(t, 0, int(p.FinalizedEpoch()))
 }

 func TestService_ChainHeads(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}}
+	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))
@@ -296,61 +297,3 @@ func TestService_ChainHeads(t *testing.T) {
 	require.DeepEqual(t, [][32]byte{{'c'}, {'d'}, {'e'}}, roots)
 	require.DeepEqual(t, []types.Slot{102, 103, 104}, slots)
 }
-
-func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	_, e := c.HeadPublicKeyToValidatorIndex(context.Background(), [48]byte{})
-	require.Equal(t, false, e)
-
-	v, err := s.ValidatorAtIndex(0)
-	require.NoError(t, err)
-
-	i, e := c.HeadPublicKeyToValidatorIndex(context.Background(), bytesutil.ToBytes48(v.PublicKey))
-	require.Equal(t, true, e)
-	require.Equal(t, types.ValidatorIndex(0), i)
-}
-
-func TestService_HeadPublicKeyToValidatorIndexNil(t *testing.T) {
-	c := &Service{}
-	c.head = nil
-
-	idx, e := c.HeadPublicKeyToValidatorIndex(context.Background(), [48]byte{})
-	require.Equal(t, false, e)
-	require.Equal(t, types.ValidatorIndex(0), idx)
-
-	c.head = &head{state: nil}
-	i, e := c.HeadPublicKeyToValidatorIndex(context.Background(), [48]byte{})
-	require.Equal(t, false, e)
-	require.Equal(t, types.ValidatorIndex(0), i)
-}
-
-func TestService_HeadValidatorIndexToPublicKey(t *testing.T) {
-	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	p, err := c.HeadValidatorIndexToPublicKey(context.Background(), 0)
-	require.NoError(t, err)
-
-	v, err := s.ValidatorAtIndex(0)
-	require.NoError(t, err)
-
-	require.Equal(t, bytesutil.ToBytes48(v.PublicKey), p)
-}
-
-func TestService_HeadValidatorIndexToPublicKeyNil(t *testing.T) {
-	c := &Service{}
-	c.head = nil
-
-	p, err := c.HeadValidatorIndexToPublicKey(context.Background(), 0)
-	require.NoError(t, err)
-	require.Equal(t, [48]byte{}, p)
-
-	c.head = &head{state: nil}
-	p, err = c.HeadValidatorIndexToPublicKey(context.Background(), 0)
-	require.NoError(t, err)
-	require.Equal(t, [48]byte{}, p)
-}
--- a/beacon-chain/blockchain/head.go
+++ b/beacon-chain/blockchain/head.go
@@ -10,25 +10,23 @@ import (
 	"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/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/features"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/slotutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )

 // 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.
+	slot  types.Slot                   // current head slot.
+	root  [32]byte                     // current head root.
+	block interfaces.SignedBeaconBlock // current head block.
+	state iface.BeaconState            // current head state.
 }

 // Determined the head from the fork choice service and saves its new data
@@ -107,8 +105,8 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 	if err != nil {
 		return err
 	}
-	if err := helpers.BeaconBlockIsNil(newHeadBlock); err != nil {
-		return err
+	if newHeadBlock == nil || newHeadBlock.IsNil() || newHeadBlock.Block().IsNil() {
+		return errors.New("cannot save nil head block")
 	}

 	// Get the new head state from cached state or DB.
@@ -131,7 +129,7 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 			"newSlot": fmt.Sprintf("%d", newHeadSlot),
 			"oldSlot": fmt.Sprintf("%d", headSlot),
 		}).Debug("Chain reorg occurred")
-		absoluteSlotDifference := slots.AbsoluteValueSlotDifference(newHeadSlot, headSlot)
+		absoluteSlotDifference := slotutil.AbsoluteValueSlotDifference(newHeadSlot, headSlot)
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Reorg,
 			Data: &ethpbv1.EventChainReorg{
@@ -141,14 +139,10 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 				NewHeadBlock: headRoot[:],
 				OldHeadState: oldStateRoot,
 				NewHeadState: newStateRoot,
-				Epoch:        slots.ToEpoch(newHeadSlot),
+				Epoch:        helpers.SlotToEpoch(newHeadSlot),
 			},
 		})

-		if err := s.saveOrphanedAtts(ctx, bytesutil.ToBytes32(r)); err != nil {
-			return err
-		}
-
 		reorgCount.Inc()
 	}

@@ -174,8 +168,8 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 // This gets called to update canonical root mapping. It does not save head block
 // root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
 // check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
-func (s *Service) saveHeadNoDB(ctx context.Context, b block.SignedBeaconBlock, r [32]byte, hs state.BeaconState) error {
-	if err := helpers.BeaconBlockIsNil(b); err != nil {
+func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.SignedBeaconBlock, r [32]byte, hs iface.BeaconState) error {
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
 		return err
 	}
 	cachedHeadRoot, err := s.HeadRoot(ctx)
@@ -191,7 +185,7 @@ func (s *Service) saveHeadNoDB(ctx context.Context, b block.SignedBeaconBlock, r
 }

 // This sets head view object which is used to track the head slot, root, block and state.
-func (s *Service) setHead(root [32]byte, block block.SignedBeaconBlock, state state.BeaconState) {
+func (s *Service) setHead(root [32]byte, block interfaces.SignedBeaconBlock, state iface.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()

@@ -207,7 +201,7 @@ func (s *Service) setHead(root [32]byte, block block.SignedBeaconBlock, state st
 // This sets head view object which is used to track the head slot, root, block and state. The method
 // assumes that state being passed into the method will not be modified by any other alternate
 // caller which holds the state's reference.
-func (s *Service) setHeadInitialSync(root [32]byte, block block.SignedBeaconBlock, state state.BeaconState) {
+func (s *Service) setHeadInitialSync(root [32]byte, block interfaces.SignedBeaconBlock, state iface.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()

@@ -240,14 +234,14 @@ 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() block.SignedBeaconBlock {
+func (s *Service) headBlock() interfaces.SignedBeaconBlock {
 	return s.head.block.Copy()
 }

 // This returns the head state.
 // It does a full copy on head state for immutability.
 // This is a lock free version.
-func (s *Service) headState(ctx context.Context) state.BeaconState {
+func (s *Service) headState(ctx context.Context) iface.BeaconState {
 	ctx, span := trace.StartSpan(ctx, "blockChain.headState")
 	defer span.End()

@@ -260,13 +254,6 @@ func (s *Service) headGenesisValidatorRoot() [32]byte {
 	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
 }

-// This returns the validator referenced by the provided index in
-// the head state.
-// This is a lock free version.
-func (s *Service) headValidatorAtIndex(index types.ValidatorIndex) (state.ReadOnlyValidator, error) {
-	return s.head.state.ValidatorAtIndexReadOnly(index)
-}
-
 // Returns true if head state exists.
 // This is the lock free version.
 func (s *Service) hasHeadState() bool {
@@ -281,7 +268,7 @@ func (s *Service) cacheJustifiedStateBalances(ctx context.Context, justifiedRoot

 	s.clearInitSyncBlocks()

-	var justifiedState state.BeaconState
+	var justifiedState iface.BeaconState
 	var err error
 	if justifiedRoot == s.genesisRoot {
 		justifiedState, err = s.cfg.BeaconDB.GenesisState(ctx)
@@ -298,10 +285,10 @@ func (s *Service) cacheJustifiedStateBalances(ctx context.Context, justifiedRoot
 		return errors.New("justified state can't be nil")
 	}

-	epoch := time.CurrentEpoch(justifiedState)
+	epoch := helpers.CurrentEpoch(justifiedState)

 	justifiedBalances := make([]uint64, justifiedState.NumValidators())
-	if err := justifiedState.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
+	if err := justifiedState.ReadFromEveryValidator(func(idx int, val iface.ReadOnlyValidator) error {
 		if helpers.IsActiveValidatorUsingTrie(val, epoch) {
 			justifiedBalances[idx] = val.EffectiveBalance()
 		} else {
@@ -328,7 +315,7 @@ func (s *Service) getJustifiedBalances() []uint64 {
 // chain head is determined, set, and saved to disk.
 func (s *Service) notifyNewHeadEvent(
 	newHeadSlot types.Slot,
-	newHeadState state.BeaconState,
+	newHeadState iface.BeaconState,
 	newHeadStateRoot,
 	newHeadRoot []byte,
 ) error {
@@ -336,15 +323,15 @@ func (s *Service) notifyNewHeadEvent(
 	currentDutyDependentRoot := s.genesisRoot[:]

 	var previousDutyEpoch types.Epoch
-	currentDutyEpoch := slots.ToEpoch(newHeadSlot)
+	currentDutyEpoch := helpers.SlotToEpoch(newHeadSlot)
 	if currentDutyEpoch > 0 {
 		previousDutyEpoch = currentDutyEpoch.Sub(1)
 	}
-	currentDutySlot, err := slots.EpochStart(currentDutyEpoch)
+	currentDutySlot, err := helpers.StartSlot(currentDutyEpoch)
 	if err != nil {
 		return errors.Wrap(err, "could not get duty slot")
 	}
-	previousDutySlot, err := slots.EpochStart(previousDutyEpoch)
+	previousDutySlot, err := helpers.StartSlot(previousDutyEpoch)
 	if err != nil {
 		return errors.Wrap(err, "could not get duty slot")
 	}
@@ -366,47 +353,10 @@ func (s *Service) notifyNewHeadEvent(
 			Slot:                      newHeadSlot,
 			Block:                     newHeadRoot,
 			State:                     newHeadStateRoot,
-			EpochTransition:           slots.IsEpochStart(newHeadSlot),
+			EpochTransition:           helpers.IsEpochEnd(newHeadSlot),
 			PreviousDutyDependentRoot: previousDutyDependentRoot,
 			CurrentDutyDependentRoot:  currentDutyDependentRoot,
 		},
 	})
 	return nil
 }
-
-// This saves the attestations inside the beacon block with respect to root `orphanedRoot` back into the
-// attestation pool. It also filters out the attestations that is one epoch older as a
-// defense so invalid attestations don't flow into the attestation pool.
-func (s *Service) saveOrphanedAtts(ctx context.Context, orphanedRoot [32]byte) error {
-	if !features.Get().CorrectlyInsertOrphanedAtts {
-		return nil
-	}
-
-	orphanedBlk, err := s.cfg.BeaconDB.Block(ctx, orphanedRoot)
-	if err != nil {
-		return err
-	}
-
-	if orphanedBlk == nil || orphanedBlk.IsNil() {
-		return errors.New("orphaned block can't be nil")
-	}
-
-	for _, a := range orphanedBlk.Block().Body().Attestations() {
-		// Is the attestation one epoch older.
-		if a.Data.Slot+params.BeaconConfig().SlotsPerEpoch < s.CurrentSlot() {
-			continue
-		}
-		if helpers.IsAggregated(a) {
-			if err := s.cfg.AttPool.SaveAggregatedAttestation(a); err != nil {
-				return err
-			}
-		} else {
-			if err := s.cfg.AttPool.SaveUnaggregatedAttestation(a); err != nil {
-				return err
-			}
-		}
-		saveOrphanedAttCount.Inc()
-	}
-
-	return nil
-}
--- a/beacon-chain/blockchain/head_sync_committee_info.go
+++ b/beacon-chain/blockchain/head_sync_committee_info.go
@@ -1,174 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/async"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-// Initialize the state cache for sync committees.
-var syncCommitteeHeadStateCache = cache.NewSyncCommitteeHeadState()
-
-// HeadSyncCommitteeFetcher is the interface that wraps the head sync committee related functions.
-// The head sync committee functions return callers sync committee indices and public keys with respect to current head state.
-type HeadSyncCommitteeFetcher interface {
-	HeadSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error)
-	HeadSyncCommitteePubKeys(ctx context.Context, slot types.Slot, committeeIndex types.CommitteeIndex) ([][]byte, error)
-}
-
-// HeadDomainFetcher is the interface that wraps the head sync domain related functions.
-// The head sync committee domain functions return callers domain data with respect to slot and head state.
-type HeadDomainFetcher interface {
-	HeadSyncCommitteeDomain(ctx context.Context, slot types.Slot) ([]byte, error)
-	HeadSyncSelectionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error)
-	HeadSyncContributionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error)
-}
-
-// HeadSyncCommitteeDomain returns the head sync committee domain using current head state advanced up to `slot`.
-func (s *Service) HeadSyncCommitteeDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
-	return s.domainWithHeadState(ctx, slot, params.BeaconConfig().DomainSyncCommittee)
-}
-
-// HeadSyncSelectionProofDomain returns the head sync committee domain using current head state advanced up to `slot`.
-func (s *Service) HeadSyncSelectionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
-	return s.domainWithHeadState(ctx, slot, params.BeaconConfig().DomainSyncCommitteeSelectionProof)
-}
-
-// HeadSyncContributionProofDomain returns the head sync committee domain using current head state advanced up to `slot`.
-func (s *Service) HeadSyncContributionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
-	return s.domainWithHeadState(ctx, slot, params.BeaconConfig().DomainContributionAndProof)
-}
-
-// HeadSyncCommitteeIndices returns the sync committee index position using the head state. Input `slot` is taken in consideration
-// where validator's duty for `slot - 1` is used for block inclusion in `slot`. That means when a validator is at epoch boundary
-// across EPOCHS_PER_SYNC_COMMITTEE_PERIOD then the valiator will be considered using next period sync committee.
-//
-// Spec definition:
-// Being assigned to a sync committee for a given slot means that the validator produces and broadcasts signatures for slot - 1 for inclusion in slot.
-// This means that when assigned to an epoch sync committee signatures must be produced and broadcast for slots on range
-// [compute_start_slot_at_epoch(epoch) - 1, compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH - 1)
-// rather than for the range
-// [compute_start_slot_at_epoch(epoch), compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH)
-func (s *Service) HeadSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
-	nextSlotEpoch := slots.ToEpoch(slot + 1)
-	currentEpoch := slots.ToEpoch(slot)
-
-	switch {
-	case slots.SyncCommitteePeriod(nextSlotEpoch) == slots.SyncCommitteePeriod(currentEpoch):
-		return s.headCurrentSyncCommitteeIndices(ctx, index, slot)
-	// At sync committee period boundary, validator should sample the next epoch sync committee.
-	case slots.SyncCommitteePeriod(nextSlotEpoch) == slots.SyncCommitteePeriod(currentEpoch)+1:
-		return s.headNextSyncCommitteeIndices(ctx, index, slot)
-	default:
-		// Impossible condition.
-		return nil, errors.New("could get calculate sync subcommittee based on the period")
-	}
-}
-
-// headCurrentSyncCommitteeIndices returns the input validator `index`'s position indices in the current sync committee with respect to `slot`.
-// Head state advanced up to `slot` is used for calculation.
-func (s *Service) headCurrentSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-	return helpers.CurrentPeriodSyncSubcommitteeIndices(headState, index)
-}
-
-// headNextSyncCommitteeIndices returns the input validator `index`'s position indices in the next sync committee with respect to `slot`.
-// Head state advanced up to `slot` is used for calculation.
-func (s *Service) headNextSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-	return helpers.NextPeriodSyncSubcommitteeIndices(headState, index)
-}
-
-// HeadSyncCommitteePubKeys returns the head sync committee public keys with respect to `slot` and subcommittee index `committeeIndex`.
-// Head state advanced up to `slot` is used for calculation.
-func (s *Service) HeadSyncCommitteePubKeys(ctx context.Context, slot types.Slot, committeeIndex types.CommitteeIndex) ([][]byte, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-
-	nextSlotEpoch := slots.ToEpoch(headState.Slot() + 1)
-	currEpoch := slots.ToEpoch(headState.Slot())
-
-	var syncCommittee *ethpb.SyncCommittee
-	if currEpoch == nextSlotEpoch || slots.SyncCommitteePeriod(currEpoch) == slots.SyncCommitteePeriod(nextSlotEpoch) {
-		syncCommittee, err = headState.CurrentSyncCommittee()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		syncCommittee, err = headState.NextSyncCommittee()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return altair.SyncSubCommitteePubkeys(syncCommittee, committeeIndex)
-}
-
-// returns calculated domain using input `domain` and `slot`.
-func (s *Service) domainWithHeadState(ctx context.Context, slot types.Slot, domain [4]byte) ([]byte, error) {
-	headState, err := s.getSyncCommitteeHeadState(ctx, slot)
-	if err != nil {
-		return nil, err
-	}
-	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorRoot())
-}
-
-// returns the head state that is advanced up to `slot`. It utilizes the cache `syncCommitteeHeadState` by retrieving using `slot` as key.
-// For the cache miss, it processes head state up to slot and fill the cache with `slot` as key.
-func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot types.Slot) (state.BeaconState, error) {
-	var headState state.BeaconState
-	var err error
-	mLock := async.NewMultilock(fmt.Sprintf("%s-%d", "syncHeadState", slot))
-	mLock.Lock()
-	defer mLock.Unlock()
-
-	// If there's already a head state exists with the request slot, we don't need to process slots.
-	cachedState, err := syncCommitteeHeadStateCache.Get(slot)
-	switch {
-	case err == nil:
-		syncHeadStateHit.Inc()
-		headState = cachedState
-		return headState, nil
-	case errors.Is(err, cache.ErrNotFound):
-		headState, err = s.HeadState(ctx)
-		if err != nil {
-			return nil, err
-		}
-		if headState == nil || headState.IsNil() {
-			return nil, errors.New("nil state")
-		}
-		if slot > headState.Slot() {
-			headState, err = transition.ProcessSlots(ctx, headState, slot)
-			if err != nil {
-				return nil, err
-			}
-		}
-		syncHeadStateMiss.Inc()
-		err = syncCommitteeHeadStateCache.Put(slot, headState)
-		return headState, err
-	default:
-		// In the event, we encounter another error
-		// we return it.
-		return nil, err
-	}
-}
--- a/beacon-chain/blockchain/head_sync_committee_info_test.go
+++ b/beacon-chain/blockchain/head_sync_committee_info_test.go
@@ -1,176 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-func TestService_headSyncCommitteeFetcher_Errors(t *testing.T) {
-	beaconDB := dbtest.SetupDB(t)
-	c := &Service{
-		cfg: &config{
-			StateGen: stategen.New(beaconDB),
-		},
-	}
-	c.head = &head{}
-	_, err := c.headCurrentSyncCommitteeIndices(context.Background(), types.ValidatorIndex(0), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.headNextSyncCommitteeIndices(context.Background(), types.ValidatorIndex(0), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.HeadSyncCommitteePubKeys(context.Background(), types.Slot(0), types.CommitteeIndex(0))
-	require.ErrorContains(t, "nil state", err)
-}
-
-func TestService_HeadDomainFetcher_Errors(t *testing.T) {
-	beaconDB := dbtest.SetupDB(t)
-	c := &Service{
-		cfg: &config{
-			StateGen: stategen.New(beaconDB),
-		},
-	}
-	c.head = &head{}
-	_, err := c.HeadSyncCommitteeDomain(context.Background(), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.HeadSyncSelectionProofDomain(context.Background(), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-
-	_, err = c.HeadSyncSelectionProofDomain(context.Background(), types.Slot(0))
-	require.ErrorContains(t, "nil state", err)
-}
-
-func TestService_HeadSyncCommitteeIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Current period
-	slot := 2*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	a, err := c.HeadSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-
-	// Current period where slot-2 across EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-	slot = 3*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) - 2
-	b, err := c.HeadSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-	require.DeepEqual(t, a, b)
-
-	// Next period where slot-1 across EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-	slot = 3*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) - 1
-	b, err = c.HeadSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-	require.DeepNotEqual(t, a, b)
-}
-
-func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
-	slot := uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	indices, err := c.headCurrentSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-
-	// NextSyncCommittee becomes CurrentSyncCommittee so it should be empty by default.
-	require.Equal(t, 0, len(indices))
-}
-
-func TestService_headNextSyncCommitteeIndices(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
-	slot := uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	indices, err := c.headNextSyncCommitteeIndices(context.Background(), 0, types.Slot(slot))
-	require.NoError(t, err)
-
-	// NextSyncCommittee should be be empty after `ProcessSyncCommitteeUpdates`. Validator should get indices.
-	require.NotEqual(t, 0, len(indices))
-}
-
-func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	// Process slot up to 2 * `EpochsPerSyncCommitteePeriod` so it can run `ProcessSyncCommitteeUpdates` twice.
-	slot := uint64(2*params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	pubkeys, err := c.HeadSyncCommitteePubKeys(context.Background(), types.Slot(slot), 0)
-	require.NoError(t, err)
-
-	// Any subcommittee should match the subcommittee size.
-	subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
-	require.Equal(t, int(subCommitteeSize), len(pubkeys))
-}
-
-func TestService_HeadSyncCommitteeDomain(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorRoot())
-	require.NoError(t, err)
-
-	d, err := c.HeadSyncCommitteeDomain(context.Background(), 0)
-	require.NoError(t, err)
-
-	require.DeepEqual(t, wanted, d)
-}
-
-func TestService_HeadSyncContributionProofDomain(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorRoot())
-	require.NoError(t, err)
-
-	d, err := c.HeadSyncContributionProofDomain(context.Background(), 0)
-	require.NoError(t, err)
-
-	require.DeepEqual(t, wanted, d)
-}
-
-func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
-	c.head = &head{state: s}
-
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorRoot())
-	require.NoError(t, err)
-
-	d, err := c.HeadSyncSelectionProofDomain(context.Background(), 0)
-	require.NoError(t, err)
-
-	require.DeepEqual(t, wanted, d)
-}
-
-func TestSyncCommitteeHeadStateCache_RoundTrip(t *testing.T) {
-	c := syncCommitteeHeadStateCache
-	t.Cleanup(func() {
-		syncCommitteeHeadStateCache = cache.NewSyncCommitteeHeadState()
-	})
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
-	require.NoError(t, beaconState.SetSlot(100))
-	cachedState, err := c.Get(101)
-	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
-	require.Equal(t, nil, cachedState)
-	require.NoError(t, c.Put(101, beaconState))
-	cachedState, err = c.Get(101)
-	require.NoError(t, err)
-	require.DeepEqual(t, beaconState, cachedState)
-}
--- a/beacon-chain/blockchain/head_test.go
+++ b/beacon-chain/blockchain/head_test.go
@@ -4,20 +4,18 @@ import (
 	"bytes"
 	"context"
 	"testing"
-	"time"

 	types "github.com/prysmaticlabs/eth2-types"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/config/features"
-	"github.com/prysmaticlabs/prysm/config/params"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )

@@ -38,30 +36,31 @@ func TestSaveHead_Different(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, 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)
+	oldRoot := [32]byte{'A'}
 	service.head = &head{
-		slot:  0,
-		root:  oldRoot,
-		block: oldBlock,
+		slot: 0,
+		root: oldRoot,
+		block: wrapper.WrappedPhase0SignedBeaconBlock(
+			&ethpb.SignedBeaconBlock{
+				Block: &ethpb.BeaconBlock{
+					Slot:      0,
+					StateRoot: make([]byte, 32),
+				},
+			},
+		),
 	}

-	newHeadSignedBlock := util.NewBeaconBlock()
+	newHeadSignedBlock := testutil.NewBeaconBlock()
 	newHeadSignedBlock.Block.Slot = 1
 	newHeadBlock := newHeadSignedBlock.Block

 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	headState, err := util.NewBeaconState()
+	headState, err := testutil.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.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), headState, newRoot))
 	require.NoError(t, service.saveHead(context.Background(), newRoot))

@@ -80,20 +79,22 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)

-	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
-		util.NewBeaconBlock(),
-	)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
-	oldRoot, err := oldBlock.Block().HashTreeRoot()
-	require.NoError(t, err)
+	oldRoot := [32]byte{'A'}
 	service.head = &head{
-		slot:  0,
-		root:  oldRoot,
-		block: oldBlock,
+		slot: 0,
+		root: oldRoot,
+		block: wrapper.WrappedPhase0SignedBeaconBlock(
+			&ethpb.SignedBeaconBlock{
+				Block: &ethpb.BeaconBlock{
+					Slot:      0,
+					StateRoot: make([]byte, 32),
+				},
+			},
+		),
 	}

 	reorgChainParent := [32]byte{'B'}
-	newHeadSignedBlock := util.NewBeaconBlock()
+	newHeadSignedBlock := testutil.NewBeaconBlock()
 	newHeadSignedBlock.Block.Slot = 1
 	newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
 	newHeadBlock := newHeadSignedBlock.Block
@@ -101,10 +102,10 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	headState, err := util.NewBeaconState()
+	headState, err := testutil.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.SaveStateSummary(context.Background(), &pb.StateSummary{Slot: 1, Root: newRoot[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), headState, newRoot))
 	require.NoError(t, service.saveHead(context.Background(), newRoot))

@@ -124,9 +125,9 @@ func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)

-	state, _ := util.DeterministicGenesisState(t, 100)
+	state, _ := testutil.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.SaveStateSummary(context.Background(), &pb.StateSummary{Root: r[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), state, r))
 	require.NoError(t, service.cacheJustifiedStateBalances(context.Background(), r))
 	require.DeepEqual(t, service.getJustifiedBalances(), state.Balances(), "Incorrect justified balances")
@@ -136,7 +137,7 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)

-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -150,10 +151,10 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {

 func Test_notifyNewHeadEvent(t *testing.T) {
 	t.Run("genesis_state_root", func(t *testing.T) {
-		bState, _ := util.DeterministicGenesisState(t, 10)
+		bState, _ := testutil.DeterministicGenesisState(t, 10)
 		notifier := &mock.MockStateNotifier{RecordEvents: true}
 		srv := &Service{
-			cfg: &config{
+			cfg: &Config{
 				StateNotifier: notifier,
 			},
 			genesisRoot: [32]byte{1},
@@ -178,18 +179,18 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 		require.DeepSSZEqual(t, wanted, eventHead)
 	})
 	t.Run("non_genesis_values", func(t *testing.T) {
-		bState, _ := util.DeterministicGenesisState(t, 10)
+		bState, _ := testutil.DeterministicGenesisState(t, 10)
 		notifier := &mock.MockStateNotifier{RecordEvents: true}
 		genesisRoot := [32]byte{1}
 		srv := &Service{
-			cfg: &config{
+			cfg: &Config{
 				StateNotifier: notifier,
 			},
 			genesisRoot: genesisRoot,
 		}
-		epoch1Start, err := slots.EpochStart(1)
+		epoch1Start, err := helpers.StartSlot(1)
 		require.NoError(t, err)
-		epoch2Start, err := slots.EpochStart(1)
+		epoch2Start, err := helpers.StartSlot(1)
 		require.NoError(t, err)
 		require.NoError(t, bState.SetSlot(epoch1Start))

@@ -206,62 +207,10 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			Slot:                      epoch2Start,
 			Block:                     newHeadRoot[:],
 			State:                     newHeadStateRoot[:],
-			EpochTransition:           true,
+			EpochTransition:           false,
 			PreviousDutyDependentRoot: genesisRoot[:],
 			CurrentDutyDependentRoot:  make([]byte, 32),
 		}
 		require.DeepSSZEqual(t, wanted, eventHead)
 	})
 }
-
-func TestSaveOrphanedAtts(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		CorrectlyInsertOrphanedAtts: true,
-	})
-	defer resetCfg()
-
-	genesis, keys := util.DeterministicGenesisState(t, 64)
-	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	service := setupBeaconChain(t, beaconDB)
-	service.genesisTime = time.Now()
-
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
-	require.NoError(t, service.saveOrphanedAtts(ctx, r))
-
-	require.Equal(t, len(b.Block.Body.Attestations), service.cfg.AttPool.AggregatedAttestationCount())
-	savedAtts := service.cfg.AttPool.AggregatedAttestations()
-	atts := b.Block.Body.Attestations
-	require.DeepSSZEqual(t, atts, savedAtts)
-}
-
-func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		CorrectlyInsertOrphanedAtts: true,
-	})
-	defer resetCfg()
-
-	genesis, keys := util.DeterministicGenesisState(t, 64)
-	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
-	assert.NoError(t, err)
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	service := setupBeaconChain(t, beaconDB)
-	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
-	require.NoError(t, service.saveOrphanedAtts(ctx, r))
-
-	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
-	savedAtts := service.cfg.AttPool.AggregatedAttestations()
-	atts := b.Block.Body.Attestations
-	require.DeepNotSSZEqual(t, atts, savedAtts)
-}
--- a/beacon-chain/blockchain/info.go
+++ b/beacon-chain/blockchain/info.go
@@ -6,7 +6,7 @@ import (
 	"net/http"

 	"github.com/emicklei/dot"
-	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/shared/params"
 )

 const template = `<html>
--- a/beacon-chain/blockchain/info_test.go
+++ b/beacon-chain/blockchain/info_test.go
@@ -9,11 +9,11 @@ import (
 	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"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestService_TreeHandler(t *testing.T) {
@@ -22,10 +22,10 @@ func TestService_TreeHandler(t *testing.T) {

 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	headState, err := util.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetBalances([]uint64{params.BeaconConfig().GweiPerEth}))
-	cfg := &config{
+	cfg := &Config{
 		BeaconDB: beaconDB,
 		ForkChoiceStore: protoarray.New(
 			0, // justifiedEpoch
@@ -34,12 +34,11 @@ func TestService_TreeHandler(t *testing.T) {
 		),
 		StateGen: stategen.New(beaconDB),
 	}
-	s, err := NewService(ctx)
+	s, err := NewService(ctx, cfg)
 	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)
+	s.setHead([32]byte{'a'}, wrapper.WrappedPhase0SignedBeaconBlock(testutil.NewBeaconBlock()), headState)

 	rr := httptest.NewRecorder()
 	handler := http.HandlerFunc(s.TreeHandler)
--- a/beacon-chain/blockchain/init_sync_process_block.go
+++ b/beacon-chain/blockchain/init_sync_process_block.go
@@ -1,11 +1,11 @@
 package blockchain

 import (
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
 )

 // This saves a beacon block to the initial sync blocks cache.
-func (s *Service) saveInitSyncBlock(r [32]byte, b block.SignedBeaconBlock) {
+func (s *Service) saveInitSyncBlock(r [32]byte, b interfaces.SignedBeaconBlock) {
 	s.initSyncBlocksLock.Lock()
 	defer s.initSyncBlocksLock.Unlock()
 	s.initSyncBlocks[r] = b
@@ -22,7 +22,7 @@ func (s *Service) hasInitSyncBlock(r [32]byte) bool {

 // This retrieves a beacon block from the initial sync blocks cache using the root of
 // the block.
-func (s *Service) getInitSyncBlock(r [32]byte) block.SignedBeaconBlock {
+func (s *Service) getInitSyncBlock(r [32]byte) interfaces.SignedBeaconBlock {
 	s.initSyncBlocksLock.RLock()
 	defer s.initSyncBlocksLock.RUnlock()
 	b := s.initSyncBlocks[r]
@@ -31,11 +31,11 @@ func (s *Service) getInitSyncBlock(r [32]byte) block.SignedBeaconBlock {

 // This retrieves all the beacon blocks from the initial sync blocks cache, the returned
 // blocks are unordered.
-func (s *Service) getInitSyncBlocks() []block.SignedBeaconBlock {
+func (s *Service) getInitSyncBlocks() []interfaces.SignedBeaconBlock {
 	s.initSyncBlocksLock.RLock()
 	defer s.initSyncBlocksLock.RUnlock()

-	blks := make([]block.SignedBeaconBlock, 0, len(s.initSyncBlocks))
+	blks := make([]interfaces.SignedBeaconBlock, 0, len(s.initSyncBlocks))
 	for _, b := range s.initSyncBlocks {
 		blks = append(blks, b)
 	}
@@ -46,5 +46,5 @@ func (s *Service) getInitSyncBlocks() []block.SignedBeaconBlock {
 func (s *Service) clearInitSyncBlocks() {
 	s.initSyncBlocksLock.Lock()
 	defer s.initSyncBlocksLock.Unlock()
-	s.initSyncBlocks = make(map[[32]byte]block.SignedBeaconBlock)
+	s.initSyncBlocks = make(map[[32]byte]interfaces.SignedBeaconBlock)
 }
--- a/beacon-chain/blockchain/init_test.go
+++ b/beacon-chain/blockchain/init_test.go
@@ -1,7 +1,7 @@
 package blockchain

 import (
-	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/shared/params"
 )

 func init() {
--- a/beacon-chain/blockchain/log.go
+++ b/beacon-chain/blockchain/log.go
@@ -5,20 +5,19 @@ import (
 	"fmt"
 	"time"

-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	prysmTime "github.com/prysmaticlabs/prysm/time"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 	"github.com/sirupsen/logrus"
 )

 var log = logrus.WithField("prefix", "blockchain")

 // logs state transition related data every slot.
-func logStateTransitionData(b block.BeaconBlock) {
-	log := log.WithField("slot", b.Slot())
+func logStateTransitionData(b interfaces.BeaconBlock) {
+	log := log.WithField("slot", b.Slot)
 	if len(b.Body().Attestations()) > 0 {
 		log = log.WithField("attestations", len(b.Body().Attestations()))
 	}
@@ -34,17 +33,11 @@ func logStateTransitionData(b block.BeaconBlock) {
 	if len(b.Body().VoluntaryExits()) > 0 {
 		log = log.WithField("voluntaryExits", len(b.Body().VoluntaryExits()))
 	}
-	if b.Version() == version.Altair {
-		agg, err := b.Body().SyncAggregate()
-		if err == nil {
-			log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
-		}
-	}
 	log.Info("Finished applying state transition")
 }

-func logBlockSyncStatus(block block.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint, receivedTime time.Time, genesisTime uint64) error {
-	startTime, err := slots.ToTime(genesisTime, block.Slot())
+func logBlockSyncStatus(block interfaces.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint, receivedTime time.Time, genesisTime uint64) error {
+	startTime, err := helpers.SlotToTime(genesisTime, block.Slot())
 	if err != nil {
 		return err
 	}
@@ -52,16 +45,14 @@ func logBlockSyncStatus(block block.BeaconBlock, blockRoot [32]byte, finalized *
 		"slot":           block.Slot(),
 		"slotInEpoch":    block.Slot() % params.BeaconConfig().SlotsPerEpoch,
 		"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
-		"epoch":          slots.ToEpoch(block.Slot()),
+		"epoch":          helpers.SlotToEpoch(block.Slot()),
 		"finalizedEpoch": finalized.Epoch,
 		"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
-		"parentRoot":     fmt.Sprintf("0x%s...", hex.EncodeToString(block.ParentRoot())[:8]),
-		"version":        version.String(block.Version()),
 	}).Info("Synced new block")
 	log.WithFields(logrus.Fields{
 		"slot":                      block.Slot,
-		"sinceSlotStartTime":        prysmTime.Now().Sub(startTime),
-		"chainServiceProcessedTime": prysmTime.Now().Sub(receivedTime),
+		"sinceSlotStartTime":        timeutils.Now().Sub(startTime),
+		"chainServiceProcessedTime": timeutils.Now().Sub(receivedTime),
 	}).Debug("Sync new block times")
 	return nil
 }
--- a/beacon-chain/blockchain/log_test.go
+++ b/beacon-chain/blockchain/log_test.go
@@ -3,17 +3,17 @@ package blockchain
 import (
 	"testing"

-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )

 func Test_logStateTransitionData(t *testing.T) {
 	tests := []struct {
 		name string
-		b    block.BeaconBlock
+		b    interfaces.BeaconBlock
 		want string
 	}{
 		{name: "empty block body",
--- a/beacon-chain/blockchain/metrics.go
+++ b/beacon-chain/blockchain/metrics.go
@@ -3,18 +3,15 @@ package blockchain
 import (
 	"context"

-	"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/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/runtime/version"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
 )

 var (
@@ -63,10 +60,6 @@ var (
 		Name: "beacon_previous_justified_root",
 		Help: "Previous justified root of the processed state",
 	})
-	activeValidatorCount = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_current_active_validators",
-		Help: "Current total active validators",
-	})
 	validatorsCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
 		Name: "validator_count",
 		Help: "The total number of validators",
@@ -83,10 +76,6 @@ var (
 		Name: "current_eth1_data_deposit_count",
 		Help: "The current eth1 deposit count in the last processed state eth1data field.",
 	})
-	processedDepositsCount = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "beacon_processed_deposits_total",
-		Help: "Total number of deposits processed",
-	})
 	stateTrieReferences = promauto.NewGaugeVec(prometheus.GaugeOpts{
 		Name: "field_references",
 		Help: "The number of states a particular field is shared with.",
@@ -108,13 +97,9 @@ var (
 		Help: "The total amount of ether, in gwei, that has been used in voting attestation head of previous epoch",
 	})
 	reorgCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "beacon_reorgs_total",
+		Name: "beacon_reorg_total",
 		Help: "Count the number of times beacon chain has a reorg",
 	})
-	saveOrphanedAttCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "saved_orphaned_att_total",
-		Help: "Count the number of times an orphaned attestation is saved",
-	})
 	attestationInclusionDelay = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "attestation_inclusion_delay_slots",
@@ -122,14 +107,6 @@ var (
 			Buckets: []float64{1, 2, 3, 4, 6, 32, 64},
 		},
 	)
-	syncHeadStateMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "sync_head_state_miss",
-		Help: "The number of sync head state requests that are not present in the cache.",
-	})
-	syncHeadStateHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "sync_head_state_hit",
-		Help: "The number of sync head state requests that are present in the cache.",
-	})
 )

 // reportSlotMetrics reports slot related metrics.
@@ -144,7 +121,7 @@ func reportSlotMetrics(stateSlot, headSlot, clockSlot types.Slot, finalizedCheck
 }

 // reportEpochMetrics reports epoch related metrics.
-func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconState) error {
+func reportEpochMetrics(ctx context.Context, postState, headState iface.BeaconState) error {
 	currentEpoch := types.Epoch(postState.Slot() / params.BeaconConfig().SlotsPerEpoch)

 	// Validator instances
@@ -202,7 +179,6 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	activeBalance += exitingBalance + slashingBalance
 	activeEffectiveBalance += exitingEffectiveBalance + slashingEffectiveBalance

-	activeValidatorCount.Set(float64(activeInstances))
 	validatorsCount.WithLabelValues("Pending").Set(float64(pendingInstances))
 	validatorsCount.WithLabelValues("Active").Set(float64(activeInstances))
 	validatorsCount.WithLabelValues("Exiting").Set(float64(exitingInstances))
@@ -229,33 +205,15 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	beaconFinalizedEpoch.Set(float64(postState.FinalizedCheckpointEpoch()))
 	beaconFinalizedRoot.Set(float64(bytesutil.ToLowInt64(postState.FinalizedCheckpoint().Root)))
 	currentEth1DataDepositCount.Set(float64(postState.Eth1Data().DepositCount))
-	processedDepositsCount.Set(float64(postState.Eth1DepositIndex() + 1))

-	var b *precompute.Balance
-	var v []*precompute.Validator
-	var err error
-	switch headState.Version() {
-	case version.Phase0:
-		// Validator participation should be viewed on the canonical chain.
-		v, b, err = precompute.New(ctx, headState)
-		if err != nil {
-			return err
-		}
-		_, b, err = precompute.ProcessAttestations(ctx, headState, v, b)
-		if err != nil {
-			return err
-		}
-	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
-		}
-	default:
-		return errors.Errorf("invalid state type provided: %T", headState.InnerStateUnsafe())
+	// Validator participation should be viewed on the canonical chain.
+	v, b, err := precompute.New(ctx, headState)
+	if err != nil {
+		return err
+	}
+	_, b, err = precompute.ProcessAttestations(ctx, headState, v, b)
+	if err != nil {
+		return err
 	}
 	prevEpochActiveBalances.Set(float64(b.ActivePrevEpoch))
 	prevEpochSourceBalances.Set(float64(b.PrevEpochAttested))
@@ -270,7 +228,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	return nil
 }

-func reportAttestationInclusion(blk block.BeaconBlock) {
+func reportAttestationInclusion(blk interfaces.BeaconBlock) {
 	for _, att := range blk.Body().Attestations() {
 		attestationInclusionDelay.Observe(float64(blk.Slot() - att.Data.Slot))
 	}
--- a/beacon-chain/blockchain/metrics_test.go
+++ b/beacon-chain/blockchain/metrics_test.go
@@ -4,15 +4,16 @@ import (
 	"context"
 	"testing"

-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	eth "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestReportEpochMetrics_BadHeadState(t *testing.T) {
-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
-	h, err := util.NewBeaconState()
+	h, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, h.SetValidators(nil))
 	err = reportEpochMetrics(context.Background(), s, h)
@@ -20,22 +21,22 @@ func TestReportEpochMetrics_BadHeadState(t *testing.T) {
 }

 func TestReportEpochMetrics_BadAttestation(t *testing.T) {
-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
-	h, err := util.NewBeaconState()
+	h, err := testutil.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 0}))
+	require.NoError(t, h.AppendCurrentEpochAttestations(&pb.PendingAttestation{InclusionDelay: 0}))
 	err = reportEpochMetrics(context.Background(), s, h)
 	require.ErrorContains(t, "attestation with inclusion delay of 0", err)
 }

 func TestReportEpochMetrics_SlashedValidatorOutOfBound(t *testing.T) {
-	h, _ := util.DeterministicGenesisState(t, 1)
+	h, _ := testutil.DeterministicGenesisState(t, 1)
 	v, err := h.ValidatorAtIndex(0)
 	require.NoError(t, err)
 	v.Slashed = true
 	require.NoError(t, h.UpdateValidatorAtIndex(0, v))
-	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 1, Data: util.HydrateAttestationData(&eth.AttestationData{})}))
+	require.NoError(t, h.AppendCurrentEpochAttestations(&pb.PendingAttestation{InclusionDelay: 1, Data: testutil.HydrateAttestationData(&eth.AttestationData{})}))
 	err = reportEpochMetrics(context.Background(), h, h)
 	require.ErrorContains(t, "slot 0 out of bounds", err)
 }
--- a/beacon-chain/blockchain/options.go
+++ b/beacon-chain/blockchain/options.go
@@ -1,139 +0,0 @@
-package blockchain
-
-import (
-	"github.com/prysmaticlabs/prysm/async/event"
-	"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"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
-	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
-	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
-	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
-	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
-	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-type Option func(s *Service) error
-
-// WithMaxGoroutines to control resource use of the blockchain service.
-func WithMaxGoroutines(x int) Option {
-	return func(s *Service) error {
-		s.cfg.MaxRoutines = x
-		return nil
-	}
-}
-
-// WithWeakSubjectivityCheckpoint for checkpoint sync.
-func WithWeakSubjectivityCheckpoint(c *ethpb.Checkpoint) Option {
-	return func(s *Service) error {
-		s.cfg.WeakSubjectivityCheckpt = c
-		return nil
-	}
-}
-
-// WithDatabase for head access.
-func WithDatabase(beaconDB db.HeadAccessDatabase) Option {
-	return func(s *Service) error {
-		s.cfg.BeaconDB = beaconDB
-		return nil
-	}
-}
-
-// WithChainStartFetcher to retrieve information about genesis.
-func WithChainStartFetcher(f powchain.ChainStartFetcher) Option {
-	return func(s *Service) error {
-		s.cfg.ChainStartFetcher = f
-		return nil
-	}
-}
-
-// WithDepositCache for deposit lifecycle after chain inclusion.
-func WithDepositCache(c *depositcache.DepositCache) Option {
-	return func(s *Service) error {
-		s.cfg.DepositCache = c
-		return nil
-	}
-}
-
-// WithAttestationPool for attestation lifecycle after chain inclusion.
-func WithAttestationPool(p attestations.Pool) Option {
-	return func(s *Service) error {
-		s.cfg.AttPool = p
-		return nil
-	}
-}
-
-// WithExitPool for exits lifecycle after chain inclusion.
-func WithExitPool(p voluntaryexits.PoolManager) Option {
-	return func(s *Service) error {
-		s.cfg.ExitPool = p
-		return nil
-	}
-}
-
-// WithSlashingPool for slashings lifecycle after chain inclusion.
-func WithSlashingPool(p slashings.PoolManager) Option {
-	return func(s *Service) error {
-		s.cfg.SlashingPool = p
-		return nil
-	}
-}
-
-// WithP2PBroadcaster to broadcast messages after appropriate processing.
-func WithP2PBroadcaster(p p2p.Broadcaster) Option {
-	return func(s *Service) error {
-		s.cfg.P2p = p
-		return nil
-	}
-}
-
-// WithStateNotifier to notify an event feed of state processing.
-func WithStateNotifier(n statefeed.Notifier) Option {
-	return func(s *Service) error {
-		s.cfg.StateNotifier = n
-		return nil
-	}
-}
-
-// WithForkChoiceStore to update an optimized fork-choice representation.
-func WithForkChoiceStore(f forkchoice.ForkChoicer) Option {
-	return func(s *Service) error {
-		s.cfg.ForkChoiceStore = f
-		return nil
-	}
-}
-
-// WithAttestationService for dealing with attestation lifecycles.
-func WithAttestationService(srv *attestations.Service) Option {
-	return func(s *Service) error {
-		s.cfg.AttService = srv
-		return nil
-	}
-}
-
-// WithStateGen for managing state regeneration and replay.
-func WithStateGen(g *stategen.State) Option {
-	return func(s *Service) error {
-		s.cfg.StateGen = g
-		return nil
-	}
-}
-
-// WithSlasherAttestationsFeed to forward attestations into slasher if enabled.
-func WithSlasherAttestationsFeed(f *event.Feed) Option {
-	return func(s *Service) error {
-		s.cfg.SlasherAttestationsFeed = f
-		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
-	}
-}
--- a/beacon-chain/blockchain/process_attestation.go
+++ b/beacon-chain/blockchain/process_attestation.go
@@ -5,12 +5,12 @@ import (

 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/time"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/copyutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 	"go.opencensus.io/trace"
 )

@@ -46,7 +46,7 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error
 	if err := helpers.ValidateSlotTargetEpoch(a.Data); err != nil {
 		return err
 	}
-	tgt := ethpb.CopyCheckpoint(a.Data.Target)
+	tgt := copyutil.CopyCheckpoint(a.Data.Target)

 	// Note that target root check is ignored here because it was performed in sync's validation pipeline:
 	// validate_aggregate_proof.go and validate_beacon_attestation.go
@@ -62,7 +62,7 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error
 	genesisTime := baseState.GenesisTime()

 	// Verify attestation target is from current epoch or previous epoch.
-	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {
+	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(timeutils.Now().Unix()), tgt); err != nil {
 		return err
 	}

@@ -75,20 +75,20 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error
 	// validate_aggregate_proof.go and validate_beacon_attestation.go

 	// Verify attestations can only affect the fork choice of subsequent slots.
-	if err := slots.VerifyTime(genesisTime, a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+	if err := helpers.VerifySlotTime(genesisTime, a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return err
 	}

 	// Use the target state to verify attesting indices are valid.
-	committee, err := helpers.BeaconCommitteeFromState(ctx, baseState, a.Data.Slot, a.Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(baseState, a.Data.Slot, a.Data.CommitteeIndex)
 	if err != nil {
 		return err
 	}
-	indexedAtt, err := attestation.ConvertToIndexed(ctx, a, committee)
+	indexedAtt, err := attestationutil.ConvertToIndexed(ctx, a, committee)
 	if err != nil {
 		return err
 	}
-	if err := attestation.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
+	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
 		return err
 	}

--- a/beacon-chain/blockchain/process_attestation_helpers.go
+++ b/beacon-chain/blockchain/process_attestation_helpers.go
@@ -7,22 +7,22 @@ import (

 	"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"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+	"github.com/prysmaticlabs/prysm/shared/mputil"
+	"github.com/prysmaticlabs/prysm/shared/params"
 )

 // getAttPreState retrieves the att pre state by either from the cache or the DB.
-func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (state.BeaconState, error) {
+func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (iface.BeaconState, error) {
 	// Use a multilock to allow scoped holding of a mutex by a checkpoint root + epoch
 	// allowing us to behave smarter in terms of how this function is used concurrently.
 	epochKey := strconv.FormatUint(uint64(c.Epoch), 10 /* base 10 */)
-	lock := async.NewMultilock(string(c.Root) + epochKey)
+	lock := mputil.NewMultilock(string(c.Root) + epochKey)
 	lock.Lock()
 	defer lock.Unlock()
 	cachedState, err := s.checkpointStateCache.StateByCheckpoint(c)
@@ -38,23 +38,38 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 		return nil, errors.Wrapf(err, "could not get pre state for epoch %d", c.Epoch)
 	}

-	epochStartSlot, err := slots.EpochStart(c.Epoch)
+	epochStartSlot, err := helpers.StartSlot(c.Epoch)
 	if err != nil {
 		return nil, err
 	}
 	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)
+		if featureconfig.Get().EnableNextSlotStateCache {
+			baseState, err = state.ProcessSlotsUsingNextSlotCache(ctx, baseState, c.Root, epochStartSlot)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+			}
+		} else {
+			baseState, err = state.ProcessSlots(ctx, baseState, epochStartSlot)
+			if err != nil {
+				return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
+			}
 		}
+		if err := s.checkpointStateCache.AddCheckpointState(c, baseState); err != nil {
+			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
+		}
+		return baseState, nil
 	}

-	// Sharing the same state across caches is perfectly fine here, the fetching
-	// of attestation prestate is by far the most accessed state fetching pattern in
-	// the beacon node. An extra state instance cached isn't an issue in the bigger
-	// picture.
-	if err := s.checkpointStateCache.AddCheckpointState(c, baseState); err != nil {
-		return nil, errors.Wrap(err, "could not save checkpoint state to cache")
+	// To avoid sharing the same state across checkpoint state cache and hot state cache,
+	// we don't add the state to check point cache.
+	has, err := s.cfg.StateGen.HasStateInCache(ctx, bytesutil.ToBytes32(c.Root))
+	if err != nil {
+		return nil, err
+	}
+	if !has {
+		if err := s.checkpointStateCache.AddCheckpointState(c, baseState); err != nil {
+			return nil, errors.Wrap(err, "could not saved checkpoint state to cache")
+		}
 	}
 	return baseState, nil

@@ -63,7 +78,7 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 // verifyAttTargetEpoch validates attestation is from the current or previous epoch.
 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)
+	currentEpoch := helpers.SlotToEpoch(currentSlot)
 	var prevEpoch types.Epoch
 	// Prevents previous epoch under flow
 	if currentEpoch > 1 {
@@ -87,7 +102,7 @@ func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.Attestation
 	if (b == nil || b.IsNil()) && s.hasInitSyncBlock(r) {
 		b = s.getInitSyncBlock(r)
 	}
-	if err := helpers.BeaconBlockIsNil(b); err != nil {
+	if err := helpers.VerifyNilBeaconBlock(b); err != nil {
 		return err
 	}
 	if b.Block().Slot() > data.Slot {
--- a/beacon-chain/blockchain/process_attestation_test.go
+++ b/beacon-chain/blockchain/process_attestation_test.go
@@ -5,63 +5,63 @@ import (
 	"testing"

 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 )

 func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB:        beaconDB,
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

 	_, err = blockTree1(t, beaconDB, []byte{'g'})
 	require.NoError(t, err)

-	BlkWithOutState := util.NewBeaconBlock()
+	BlkWithOutState := testutil.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 := testutil.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()
+	s, err := testutil.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 := testutil.NewBeaconBlock()
 	BlkWithValidState.Block.Slot = 2
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))

 	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
-	s, err = util.NewBeaconState()
+	s, err = testutil.NewBeaconState()
 	require.NoError(t, err)
-	err = s.SetFork(&ethpb.Fork{
+	err = s.SetFork(&pb.Fork{
 		Epoch:           0,
 		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
@@ -76,17 +76,17 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	}{
 		{
 			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)}}}),
+			a:         testutil.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[:]}}}),
+			a:         testutil.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,
+			a: testutil.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",
 		},
@@ -131,22 +131,21 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB:        beaconDB,
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
-	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	require.NoError(t, genesisState.SetGenesisTime(uint64(time.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
+	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
+	require.NoError(t, genesisState.SetGenesisTime(uint64(timeutils.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
+	att, err := testutil.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)
+	copied, err = state.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
@@ -157,15 +156,14 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	err = s.SetFinalizedCheckpoint(&ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)})
 	require.NoError(t, err)
@@ -188,7 +186,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	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'}, 32)}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'A'}, 32)}))

 	s1, err := service.getAttPreState(ctx, cp1)
 	require.NoError(t, err)
@@ -196,7 +194,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {

 	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'}, 32)}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'B'}, 32)}))
 	s2, err := service.getAttPreState(ctx, cp2)
 	require.NoError(t, err)
 	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
@@ -220,7 +218,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	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'}, 32)}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, 32)}))
 	s3, err := service.getAttPreState(ctx, cp3)
 	require.NoError(t, err)
 	assert.Equal(t, s.Slot(), s3.Slot(), "Unexpected state slot")
@@ -230,16 +228,15 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

 	epoch := types.Epoch(1)
-	baseState, _ := util.DeterministicGenesisState(t, 1)
+	baseState, _ := testutil.DeterministicGenesisState(t, 1)
 	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)
@@ -255,9 +252,9 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)
 	require.NoError(t, err)
-	s, err := slots.EpochStart(newCheckpoint.Epoch)
+	s, err := helpers.StartSlot(newCheckpoint.Epoch)
 	require.NoError(t, err)
-	baseState, err = transition.ProcessSlots(ctx, baseState, s)
+	baseState, err = state.ProcessSlots(ctx, baseState, s)
 	require.NoError(t, err)
 	assert.Equal(t, returned.Slot(), baseState.Slot(), "Incorrectly returned base state")

@@ -270,10 +267,9 @@ func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)}))
@@ -283,10 +279,9 @@ func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
@@ -296,10 +291,9 @@ func TestAttEpoch_NotMatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

 	nowTime := 2 * uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	err = service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)})
@@ -310,12 +304,11 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	d := util.HydrateAttestationData(&ethpb.AttestationData{})
+	d := testutil.HydrateAttestationData(&ethpb.AttestationData{})
 	assert.ErrorContains(t, "signed beacon block can't be nil", service.verifyBeaconBlock(ctx, d))
 }

@@ -323,12 +316,11 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 2
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
@@ -342,12 +334,11 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 2
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
@@ -361,12 +352,11 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b32 := util.NewBeaconBlock()
+	b32 := testutil.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
@@ -374,7 +364,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {

 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}

-	b33 := util.NewBeaconBlock()
+	b33 := testutil.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
@@ -389,12 +379,11 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b32 := util.NewBeaconBlock()
+	b32 := testutil.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
@@ -402,7 +391,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {

 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}

-	b33 := util.NewBeaconBlock()
+	b33 := testutil.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
@@ -417,19 +406,18 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b32 := util.NewBeaconBlock()
+	b32 := testutil.NewBeaconBlock()
 	b32.Block.Slot = 32
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)

 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}

-	b33 := util.NewBeaconBlock()
+	b33 := testutil.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	r33, err := b33.Block.HashTreeRoot()
--- a/beacon-chain/blockchain/process_block.go
+++ b/beacon-chain/blockchain/process_block.go
@@ -9,19 +9,17 @@ import (
 	"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"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/features"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/monitoring/tracing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/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/time/slots"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bls"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )

@@ -85,11 +83,12 @@ 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 block.SignedBeaconBlock, blockRoot [32]byte) error {
+func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlock, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlock")
 	defer span.End()
-	if err := helpers.BeaconBlockIsNil(signed); err != nil {
-		return err
+
+	if signed == nil || signed.IsNil() || signed.Block().IsNil() {
+		return errors.New("nil block")
 	}
 	b := signed.Block()

@@ -98,7 +97,7 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		return err
 	}

-	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
+	postState, err := state.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
 		return err
 	}
@@ -107,90 +106,53 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		return err
 	}

-	// If slasher is configured, forward the attestations in the block via
-	// an event feed for processing.
-	if features.Get().EnableSlasher {
-		// Feed the indexed attestation to slasher if enabled. This action
-		// is done in the background to avoid adding more load to this critical code path.
-		go func() {
-			// Using a different context to prevent timeouts as this operation can be expensive
-			// and we want to avoid affecting the critical code path.
-			ctx := context.TODO()
-			for _, att := range signed.Block().Body().Attestations() {
-				committee, err := helpers.BeaconCommitteeFromState(ctx, preState, att.Data.Slot, att.Data.CommitteeIndex)
-				if err != nil {
-					log.WithError(err).Error("Could not get attestation committee")
-					tracing.AnnotateError(span, err)
-					return
-				}
-				indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
-				if err != nil {
-					log.WithError(err).Error("Could not convert to indexed attestation")
-					tracing.AnnotateError(span, err)
-					return
-				}
-				s.cfg.SlasherAttestationsFeed.Send(indexedAtt)
-			}
-		}()
-	}
-
-	// Update justified check point.
-	currJustifiedEpoch := s.justifiedCheckpt.Epoch
-	if postState.CurrentJustifiedCheckpoint().Epoch > currJustifiedEpoch {
-		if err := s.updateJustified(ctx, postState); err != nil {
-			return err
-		}
-	}
-
-	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")
-	}
-
-	if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
-		return err
-	}
-
-	// Send notification of the processed block to the state feed.
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.BlockProcessed,
-		Data: &statefeed.BlockProcessedData{
-			Slot:        signed.Block().Slot(),
-			BlockRoot:   blockRoot,
-			SignedBlock: signed,
-			Verified:    true,
-		},
-	})
-
 	// Updating next slot state cache can happen in the background. It shouldn't block rest of the process.
-	if features.Get().EnableNextSlotStateCache {
+	if featureconfig.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 {
+			if err := state.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
 				log.WithError(err).Debug("could not update next slot state cache")
 			}
 		}()
 	}

-	// Save justified check point to db.
-	if postState.CurrentJustifiedCheckpoint().Epoch > currJustifiedEpoch {
-		if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, postState.CurrentJustifiedCheckpoint()); err != nil {
+	// Update justified check point.
+	if postState.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
+		if err := s.updateJustified(ctx, postState); err != nil {
 			return err
 		}
 	}

+	newFinalized := postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch
+	if featureconfig.Get().UpdateHeadTimely {
+		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")
+		}
+
+		// Send notification of the processed block to the state feed.
+		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.BlockProcessed,
+			Data: &statefeed.BlockProcessedData{
+				Slot:        signed.Block().Slot(),
+				BlockRoot:   blockRoot,
+				SignedBlock: signed,
+				Verified:    true,
+			},
+		})
+	}
+
 	// Update finalized check point.
 	if newFinalized {
 		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
@@ -200,6 +162,11 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		if err := s.cfg.ForkChoiceStore.Prune(ctx, fRoot); err != nil {
 			return errors.Wrap(err, "could not prune proto array fork choice nodes")
 		}
+		if !featureconfig.Get().UpdateHeadTimely {
+			if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
+				return errors.Wrap(err, "could not save new justified")
+			}
+		}
 		go func() {
 			// Send an event regarding the new finalized checkpoint over a common event feed.
 			s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
@@ -228,7 +195,7 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	return s.handleEpochBoundary(ctx, postState)
 }

-func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock,
+func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock,
 	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
 	defer span.End()
@@ -236,8 +203,8 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 	if len(blks) == 0 || len(blockRoots) == 0 {
 		return nil, nil, errors.New("no blocks provided")
 	}
-	if err := helpers.BeaconBlockIsNil(blks[0]); err != nil {
-		return nil, nil, err
+	if blks[0] == nil || blks[0].IsNil() || blks[0].Block().IsNil() {
+		return nil, nil, errors.New("nil block")
 	}
 	b := blks[0].Block()

@@ -261,14 +228,14 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 		Messages:   [][32]byte{},
 	}
 	var set *bls.SignatureSet
-	boundaries := make(map[[32]byte]state.BeaconState)
+	boundaries := make(map[[32]byte]iface.BeaconState)
 	for i, b := range blks {
-		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
+		set, preState, err = state.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
 		if err != nil {
 			return nil, nil, err
 		}
 		// Save potential boundary states.
-		if slots.IsEpochStart(preState.Slot()) {
+		if helpers.IsEpochStart(preState.Slot()) {
 			boundaries[blockRoots[i]] = preState.Copy()
 			if err := s.handleEpochBoundary(ctx, preState); err != nil {
 				return nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
@@ -304,7 +271,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo

 // 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,
+func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed interfaces.SignedBeaconBlock,
 	blockRoot [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	b := signed.Block()

@@ -312,7 +279,7 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
-	if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
+	if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{
 		Slot: signed.Block().Slot(),
 		Root: blockRoot[:],
 	}); err != nil {
@@ -338,28 +305,23 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 		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.
-func (s *Service) handleEpochBoundary(ctx context.Context, postState state.BeaconState) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.handleEpochBoundary")
-	defer span.End()
-
+func (s *Service) handleEpochBoundary(ctx context.Context, postState iface.BeaconState) error {
 	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 {
+		if err := helpers.UpdateCommitteeCache(postState, helpers.NextEpoch(postState)); err != nil {
 			return err
 		}
 		copied := postState.Copy()
-		copied, err := transition.ProcessSlots(ctx, copied, copied.Slot()+1)
+		copied, err := state.ProcessSlots(ctx, copied, copied.Slot()+1)
 		if err != nil {
 			return err
 		}
-		if err := helpers.UpdateProposerIndicesInCache(ctx, copied); err != nil {
+		if err := helpers.UpdateProposerIndicesInCache(copied); err != nil {
 			return err
 		}
 	} else if postState.Slot() >= s.nextEpochBoundarySlot {
@@ -367,17 +329,17 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 			return err
 		}
 		var err error
-		s.nextEpochBoundarySlot, err = slots.EpochStart(coreTime.NextEpoch(postState))
+		s.nextEpochBoundarySlot, err = helpers.StartSlot(helpers.NextEpoch(postState))
 		if err != nil {
 			return err
 		}

 		// 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(postState, coreTime.CurrentEpoch(postState)); err != nil {
+		if err := helpers.UpdateCommitteeCache(postState, helpers.CurrentEpoch(postState)); err != nil {
 			return err
 		}
-		if err := helpers.UpdateProposerIndicesInCache(ctx, postState); err != nil {
+		if err := helpers.UpdateProposerIndicesInCache(postState); err != nil {
 			return err
 		}
 	}
@@ -387,11 +349,8 @@ 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 block.BeaconBlock, root [32]byte,
-	st state.BeaconState) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.insertBlockAndAttestationsToForkChoiceStore")
-	defer span.End()
-
+func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Context, blk interfaces.BeaconBlock, root [32]byte,
+	st iface.BeaconState) error {
 	fCheckpoint := st.FinalizedCheckpoint()
 	jCheckpoint := st.CurrentJustifiedCheckpoint()
 	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint); err != nil {
@@ -399,11 +358,11 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 	}
 	// Feed in block's attestations to fork choice store.
 	for _, a := range blk.Body().Attestations() {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, st, a.Data.Slot, a.Data.CommitteeIndex)
+		committee, err := helpers.BeaconCommitteeFromState(st, a.Data.Slot, a.Data.CommitteeIndex)
 		if err != nil {
 			return err
 		}
-		indices, err := attestation.AttestingIndices(a.AggregationBits, committee)
+		indices, err := attestationutil.AttestingIndices(a.AggregationBits, committee)
 		if err != nil {
 			return err
 		}
@@ -412,7 +371,7 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 	return nil
 }

-func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk block.BeaconBlock,
+func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk interfaces.BeaconBlock,
 	root [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
 		return err
@@ -429,7 +388,7 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk block.Be

 // 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 block.SignedBeaconBlock, st state.BeaconState, initSync bool) error {
+func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock, st iface.BeaconState, initSync bool) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.savePostStateInfo")
 	defer span.End()
 	if initSync {
@@ -445,33 +404,3 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b block.Sig
 	}
 	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 block.SignedBeaconBlock) error {
-	if !features.Get().CorrectlyPruneCanonicalAtts {
-		return nil
-	}
-
-	canonical, err := s.IsCanonical(ctx, r)
-	if err != nil {
-		return err
-	}
-	if !canonical {
-		return nil
-	}
-
-	atts := b.Block().Body().Attestations()
-	for _, att := range atts {
-		if helpers.IsAggregated(att) {
-			if err := s.cfg.AttPool.DeleteAggregatedAttestation(att); err != nil {
-				return err
-			}
-		} else {
-			if err := s.cfg.AttPool.DeleteUnaggregatedAttestation(att); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
--- a/beacon-chain/blockchain/process_block_helpers.go
+++ b/beacon-chain/blockchain/process_block_helpers.go
@@ -8,26 +8,26 @@ import (
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"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"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/traceutil"
 	"go.opencensus.io/trace"
 )

 // CurrentSlot returns the current slot based on time.
 func (s *Service) CurrentSlot() types.Slot {
-	return slots.CurrentSlot(uint64(s.genesisTime.Unix()))
+	return helpers.CurrentSlot(uint64(s.genesisTime.Unix()))
 }

 // getBlockPreState returns the pre state of an incoming block. It uses the parent root of the block
 // to retrieve the state in DB. It verifies the pre state's validity and the incoming block
 // is in the correct time window.
-func (s *Service) getBlockPreState(ctx context.Context, b block.BeaconBlock) (state.BeaconState, error) {
+func (s *Service) getBlockPreState(ctx context.Context, b interfaces.BeaconBlock) (iface.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.getBlockPreState")
 	defer span.End()

@@ -45,7 +45,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b block.BeaconBlock) (st
 	}

 	// Verify block slot time is not from the future.
-	if err := slots.VerifyTime(preState.GenesisTime(), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+	if err := helpers.VerifySlotTime(preState.GenesisTime(), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return nil, err
 	}

@@ -58,7 +58,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b block.BeaconBlock) (st
 }

 // verifyBlkPreState validates input block has a valid pre-state.
-func (s *Service) verifyBlkPreState(ctx context.Context, b block.BeaconBlock) error {
+func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.BeaconBlock) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.verifyBlkPreState")
 	defer span.End()

@@ -113,7 +113,7 @@ func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error
 		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)
+		traceutil.AnnotateError(span, err)
 		return err
 	}
 	return nil
@@ -121,8 +121,8 @@ func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error

 // verifyBlkFinalizedSlot validates input block is not less than or equal
 // to current finalized slot.
-func (s *Service) verifyBlkFinalizedSlot(b block.BeaconBlock) error {
-	finalizedSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+func (s *Service) verifyBlkFinalizedSlot(b interfaces.BeaconBlock) error {
+	finalizedSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
 	if err != nil {
 		return err
 	}
@@ -135,52 +135,60 @@ func (s *Service) verifyBlkFinalizedSlot(b block.BeaconBlock) error {
 // 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.
-//
-// Spec code:
-// def should_update_justified_checkpoint(store: Store, new_justified_checkpoint: Checkpoint) -> bool:
-//    """
-//    To address the bouncing attack, 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.
-//    """
-//    if compute_slots_since_epoch_start(get_current_slot(store)) < SAFE_SLOTS_TO_UPDATE_JUSTIFIED:
-//        return True
-//
-//    justified_slot = compute_start_slot_at_epoch(store.justified_checkpoint.epoch)
-//    if not get_ancestor(store, new_justified_checkpoint.root, justified_slot) == store.justified_checkpoint.root:
-//        return False
-//
-//    return True
+// 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 {
+	if helpers.SlotsSinceEpochStarts(s.CurrentSlot()) < params.BeaconConfig().SafeSlotsToUpdateJustified {
 		return true, nil
 	}
+	var newJustifiedBlockSigned interfaces.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")
+	}

-	jSlot, err := slots.EpochStart(s.justifiedCheckpt.Epoch)
+	newJustifiedBlock := newJustifiedBlockSigned.Block()
+	jSlot, err := helpers.StartSlot(s.justifiedCheckpt.Epoch)
 	if err != nil {
 		return false, err
 	}
-	justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(newJustifiedCheckpt.Root))
-	b, err := s.ancestor(ctx, justifiedRoot[:], jSlot)
+	if newJustifiedBlock.Slot() <= jSlot {
+		return false, nil
+	}
+	var justifiedBlockSigned interfaces.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()
-
+func (s *Service) updateJustified(ctx context.Context, state iface.ReadOnlyBeaconState) error {
 	cpt := state.CurrentJustifiedCheckpoint()
 	if cpt.Epoch > s.bestJustifiedCheckpt.Epoch {
 		s.bestJustifiedCheckpt = cpt
@@ -198,7 +206,7 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 		}
 	}

-	return nil
+	return s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cpt)
 }

 // This caches input checkpoint as justified for the service struct. It rotates current justified to previous justified,
@@ -215,9 +223,6 @@ func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpo
 }

 func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.updateFinalized")
-	defer span.End()
-
 	// Blocks need to be saved so that we can retrieve finalized block from
 	// DB when migrating states.
 	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
@@ -228,6 +233,10 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 	if err := s.cfg.BeaconDB.SaveFinalizedCheckpoint(ctx, cp); err != nil {
 		return err
 	}
+	if !featureconfig.Get().UpdateHeadTimely {
+		s.prevFinalizedCheckpt = s.finalizedCheckpt
+		s.finalizedCheckpt = cp
+	}

 	fRoot := bytesutil.ToBytes32(cp.Root)
 	if err := s.cfg.StateGen.MigrateToCold(ctx, fRoot); err != nil {
@@ -325,16 +334,16 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot types.Slot)
 //            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 {
+func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state iface.BeaconState) error {
 	// Update justified if it's different than the one cached in the store.
-	if !attestation.CheckPointIsEqual(s.justifiedCheckpt, state.CurrentJustifiedCheckpoint()) {
+	if !attestationutil.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))
 		}

 		// Update justified if store justified is not in chain with finalized check point.
-		finalizedSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+		finalizedSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
 		if err != nil {
 			return err
 		}
@@ -355,15 +364,15 @@ func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state state.

 // 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,
+func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfaces.BeaconBlock,
 	fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
-	pendingNodes := make([]block.BeaconBlock, 0)
+	pendingNodes := make([]interfaces.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)
+	fSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
 	if err != nil {
 		return err
 	}
--- a/beacon-chain/blockchain/process_block_test.go
+++ b/beacon-chain/blockchain/process_block_test.go
@@ -13,77 +13,76 @@ import (
 	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"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/features"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"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"
-	prysmTime "github.com/prysmaticlabs/prysm/time"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 )

 func TestStore_OnBlock(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB:        beaconDB,
 		StateGen:        stategen.New(beaconDB),
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	st, err := util.NewBeaconState()
+	st, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)
-	random := util.NewBeaconBlock()
+	random := testutil.NewBeaconBlock()
 	random.Block.Slot = 1
 	random.Block.ParentRoot = validGenesisRoot[:]
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random)))
 	randomParentRoot, err := random.Block.HashTreeRoot()
 	assert.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), randomParentRoot))
 	randomParentRoot2 := roots[1]
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot2}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: st.Slot(), Root: randomParentRoot2}))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), bytesutil.ToBytes32(randomParentRoot2)))

 	tests := []struct {
 		name          string
 		blk           *ethpb.SignedBeaconBlock
-		s             state.BeaconState
+		s             iface.BeaconState
 		time          uint64
 		wantErrString string
 	}{
 		{
 			name:          "parent block root does not have a state",
-			blk:           util.NewBeaconBlock(),
+			blk:           testutil.NewBeaconBlock(),
 			s:             st.Copy(),
 			wantErrString: "could not reconstruct parent state",
 		},
 		{
 			name: "block is from the future",
 			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
+				b := testutil.NewBeaconBlock()
 				b.Block.ParentRoot = randomParentRoot2
 				b.Block.Slot = params.BeaconConfig().FarFutureSlot
 				return b
@@ -94,7 +93,7 @@ func TestStore_OnBlock(t *testing.T) {
 		{
 			name: "could not get finalized block",
 			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
+				b := testutil.NewBeaconBlock()
 				b.Block.ParentRoot = randomParentRoot[:]
 				return b
 			}(),
@@ -104,7 +103,7 @@ func TestStore_OnBlock(t *testing.T) {
 		{
 			name: "same slot as finalized block",
 			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
+				b := testutil.NewBeaconBlock()
 				b.Block.Slot = 0
 				b.Block.ParentRoot = randomParentRoot2
 				return b
@@ -134,13 +133,12 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -153,17 +151,17 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))

-	st, keys := util.DeterministicGenesisState(t, 64)
+	st, keys := testutil.DeterministicGenesisState(t, 64)

 	bState := st.Copy()

-	var blks []block.SignedBeaconBlock
+	var blks []interfaces.SignedBeaconBlock
 	var blkRoots [][32]byte
-	var firstState state.BeaconState
+	var firstState iface.BeaconState
 	for i := 1; i < 10; i++ {
-		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
+		b, err := testutil.GenerateFullBlock(bState, keys, testutil.DefaultBlockGenConfig(), types.Slot(i))
 		require.NoError(t, err)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		bState, err = state.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		require.NoError(t, err)
 		if i == 1 {
 			firstState = bState.Copy()
@@ -190,20 +188,19 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
 	service.genesisTime = time.Now()

 	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: make([]byte, 32)})
 	require.NoError(t, err)
 	assert.Equal(t, true, update, "Should be able to update justified")
-	lastJustifiedBlk := util.NewBeaconBlock()
+	lastJustifiedBlk := testutil.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	newJustifiedBlk := util.NewBeaconBlock()
+	newJustifiedBlk := testutil.NewBeaconBlock()
 	newJustifiedBlk.Block.Slot = 1
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
@@ -225,17 +222,14 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
-	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
-
-	lastJustifiedBlk := util.NewBeaconBlock()
+	lastJustifiedBlk := testutil.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	newJustifiedBlk := util.NewBeaconBlock()
+	newJustifiedBlk := testutil.NewBeaconBlock()
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -255,15 +249,14 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
+	s, err := v1.InitializeFromProto(&pb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
 	require.NoError(t, err)

 	genesisStateRoot := [32]byte{}
@@ -277,10 +270,10 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))

-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 1
 	b.Block.ParentRoot = gRoot[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: gRoot[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s))
 	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block)))
 }
@@ -289,13 +282,12 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB: beaconDB,
 		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -308,7 +300,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))

-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 1
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
 	err = service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block))
@@ -316,9 +308,9 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	assert.ErrorContains(t, wanted, err)

 	b.Block.ParentRoot = gRoot[:]
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Slot: 1})
+	s, err := v1.InitializeFromProto(&pb.BeaconState{Slot: 1})
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: gRoot[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s))
 	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b).Block()))
 }
@@ -327,23 +319,22 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	signedBlock := util.NewBeaconBlock()
+	signedBlock := testutil.NewBeaconBlock()
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock)))
 	r, err := signedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
 	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
-	st, err := util.NewBeaconState()
+	st, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, st.Copy(), r))

 	// Could update
-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: r[:]}))
 	require.NoError(t, service.updateJustified(context.Background(), s))
@@ -361,10 +352,9 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}

@@ -373,15 +363,15 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	st, err := util.NewBeaconState()
+	st, err := testutil.NewBeaconState()
 	require.NoError(t, err)

 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)

-	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
+	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
+	block := testutil.NewBeaconBlock()
 	block.Block.Slot = 9
 	block.Block.ParentRoot = roots[8]

@@ -400,10 +390,9 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}

@@ -412,15 +401,15 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	st, err := util.NewBeaconState()
+	st, err := testutil.NewBeaconState()
 	require.NoError(t, err)

 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)

-	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
+	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
+	block := testutil.NewBeaconBlock()
 	block.Block.Slot = 9
 	block.Block.ParentRoot = roots[8]

@@ -442,10 +431,9 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	// Set finalized epoch to 1.
 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
@@ -455,29 +443,29 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	assert.NoError(t, err)
-	st, err := util.NewBeaconState()
+	st, err := testutil.NewBeaconState()
 	require.NoError(t, err)

 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))

 	// Define a tree branch, slot 63 <- 64 <- 65
-	b63 := util.NewBeaconBlock()
+	b63 := testutil.NewBeaconBlock()
 	b63.Block.Slot = 63
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63)))
 	r63, err := b63.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b64 := util.NewBeaconBlock()
+	b64 := testutil.NewBeaconBlock()
 	b64.Block.Slot = 64
 	b64.Block.ParentRoot = r63[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64)))
 	r64, err := b64.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b65 := util.NewBeaconBlock()
+	b65 := testutil.NewBeaconBlock()
 	b65.Block.Slot = 65
 	b65.Block.ParentRoot = r64[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65)))

-	beaconState, _ := util.DeterministicGenesisState(t, 32)
+	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
 	err = service.fillInForkChoiceMissingBlocks(
 		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
@@ -496,67 +484,67 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 // (B1, and B3 are all from the same slots)
 func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byte, error) {
 	genesisRoot = bytesutil.PadTo(genesisRoot, 32)
-	b0 := util.NewBeaconBlock()
+	b0 := testutil.NewBeaconBlock()
 	b0.Block.Slot = 0
 	b0.Block.ParentRoot = genesisRoot
 	r0, err := b0.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b1 := util.NewBeaconBlock()
+	b1 := testutil.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = r0[:]
 	r1, err := b1.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b3 := util.NewBeaconBlock()
+	b3 := testutil.NewBeaconBlock()
 	b3.Block.Slot = 3
 	b3.Block.ParentRoot = r0[:]
 	r3, err := b3.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b4 := util.NewBeaconBlock()
+	b4 := testutil.NewBeaconBlock()
 	b4.Block.Slot = 4
 	b4.Block.ParentRoot = r3[:]
 	r4, err := b4.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b5 := util.NewBeaconBlock()
+	b5 := testutil.NewBeaconBlock()
 	b5.Block.Slot = 5
 	b5.Block.ParentRoot = r4[:]
 	r5, err := b5.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b6 := util.NewBeaconBlock()
+	b6 := testutil.NewBeaconBlock()
 	b6.Block.Slot = 6
 	b6.Block.ParentRoot = r4[:]
 	r6, err := b6.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b7 := util.NewBeaconBlock()
+	b7 := testutil.NewBeaconBlock()
 	b7.Block.Slot = 7
 	b7.Block.ParentRoot = r5[:]
 	r7, err := b7.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b8 := util.NewBeaconBlock()
+	b8 := testutil.NewBeaconBlock()
 	b8.Block.Slot = 8
 	b8.Block.ParentRoot = r6[:]
 	r8, err := b8.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	st, err := util.NewBeaconState()
+	st, err := testutil.NewBeaconState()
 	require.NoError(t, err)

 	for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
-		beaconBlock := util.NewBeaconBlock()
+		beaconBlock := testutil.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil {
@@ -579,14 +567,14 @@ func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byt
 }

 func TestCurrentSlot_HandlesOverflow(t *testing.T) {
-	svc := Service{genesisTime: prysmTime.Now().Add(1 * time.Hour)}
+	svc := Service{genesisTime: timeutils.Now().Add(1 * time.Hour)}

 	slot := svc.CurrentSlot()
 	require.Equal(t, types.Slot(0), slot, "Unexpected slot")
 }
 func TestAncestorByDB_CtxErr(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, &Config{})
 	require.NoError(t, err)

 	cancel()
@@ -598,28 +586,27 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b1 := util.NewBeaconBlock()
+	b1 := testutil.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b100 := util.NewBeaconBlock()
+	b100 := testutil.NewBeaconBlock()
 	b100.Block.Slot = 100
 	b100.Block.ParentRoot = r1[:]
 	r100, err := b100.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b200 := util.NewBeaconBlock()
+	b200 := testutil.NewBeaconBlock()
 	b200.Block.Slot = 200
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
-		beaconBlock := util.NewBeaconBlock()
+		beaconBlock := testutil.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)))
@@ -642,28 +629,27 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {

 func TestAncestor_CanUseForkchoice(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b1 := util.NewBeaconBlock()
+	b1 := testutil.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b100 := util.NewBeaconBlock()
+	b100 := testutil.NewBeaconBlock()
 	b100.Block.Slot = 100
 	b100.Block.ParentRoot = r1[:]
 	r100, err := b100.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b200 := util.NewBeaconBlock()
+	b200 := testutil.NewBeaconBlock()
 	b200.Block.Slot = 200
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
-		beaconBlock := util.NewBeaconBlock()
+		beaconBlock := testutil.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
@@ -682,28 +668,27 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b1 := util.NewBeaconBlock()
+	b1 := testutil.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b100 := util.NewBeaconBlock()
+	b100 := testutil.NewBeaconBlock()
 	b100.Block.Slot = 100
 	b100.Block.ParentRoot = r1[:]
 	r100, err := b100.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b200 := util.NewBeaconBlock()
+	b200 := testutil.NewBeaconBlock()
 	b200.Block.Slot = 200
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
-		beaconBlock := util.NewBeaconBlock()
+		beaconBlock := testutil.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock))) // Saves blocks to DB.
@@ -720,10 +705,9 @@ func TestAncestor_CanUseDB(t *testing.T) {

 func TestEnsureRootNotZeroHashes(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{}
-	service, err := NewService(ctx)
+	cfg := &Config{}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg
 	service.genesisRoot = [32]byte{'a'}

 	r := service.ensureRootNotZeros(params.BeaconConfig().ZeroHash)
@@ -773,31 +757,30 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		beaconState, err := util.NewBeaconState()
+		beaconState, err := testutil.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(test.args.stateCheckPoint))
-		service, err := NewService(ctx)
+		service, err := NewService(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
 		require.NoError(t, err)
-		service.cfg = &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
 		service.justifiedCheckpt = test.args.cachedCheckPoint
-		require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
-		genesisState, err := util.NewBeaconState()
+		require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
+		genesisState, err := testutil.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, bytesutil.ToBytes32(test.want.Root)))

 		if test.args.diffFinalizedCheckPoint {
-			b1 := util.NewBeaconBlock()
+			b1 := testutil.NewBeaconBlock()
 			b1.Block.Slot = 1
 			b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 			r1, err := b1.Block.HashTreeRoot()
 			require.NoError(t, err)
-			b100 := util.NewBeaconBlock()
+			b100 := testutil.NewBeaconBlock()
 			b100.Block.Slot = 100
 			b100.Block.ParentRoot = r1[:]
 			r100, err := b100.Block.HashTreeRoot()
 			require.NoError(t, err)
 			for _, b := range []*ethpb.SignedBeaconBlock{b1, b100} {
-				beaconBlock := util.NewBeaconBlock()
+				beaconBlock := testutil.NewBeaconBlock()
 				beaconBlock.Block.Slot = b.Block.Slot
 				beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 				require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)))
@@ -807,7 +790,7 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		}

 		require.NoError(t, service.finalizedImpliesNewJustified(ctx, beaconState))
-		assert.Equal(t, true, attestation.CheckPointIsEqual(test.want, service.justifiedCheckpt), "Did not get wanted check point")
+		assert.Equal(t, true, attestationutil.CheckPointIsEqual(test.want, service.justifiedCheckpt), "Did not get wanted check point")
 	}
 }

@@ -815,13 +798,13 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()

-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 1
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))

-	b1 := util.NewBeaconBlock()
+	b1 := testutil.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
@@ -869,9 +852,8 @@ func TestVerifyBlkDescendant(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		service, err := NewService(ctx)
+		service, err := NewService(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
 		require.NoError(t, err)
-		service.cfg = &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
 		service.finalizedCheckpt = &ethpb.Checkpoint{
 			Root: tt.args.finalizedRoot[:],
 		}
@@ -887,18 +869,17 @@ func TestVerifyBlkDescendant(t *testing.T) {
 func TestUpdateJustifiedInitSync(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	gBlk := util.NewBeaconBlock()
+	gBlk := testutil.NewBeaconBlock()
 	gRoot, err := gBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(gBlk)))
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, gRoot))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: gRoot[:]}))
-	beaconState, _ := util.DeterministicGenesisState(t, 32)
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: gRoot[:]}))
+	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, beaconState, gRoot))
 	service.genesisRoot = gRoot
 	currentCp := &ethpb.Checkpoint{Epoch: 1}
@@ -916,12 +897,11 @@ func TestUpdateJustifiedInitSync(t *testing.T) {

 func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{}
-	service, err := NewService(ctx)
+	cfg := &Config{}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
 	service.head = &head{state: (*v1.BeaconState)(nil)}
@@ -931,12 +911,11 @@ func TestHandleEpochBoundary_BadMetrics(t *testing.T) {

 func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{}
-	service, err := NewService(ctx)
+	cfg := &Config{}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	s, _ := util.DeterministicGenesisState(t, 1024)
+	s, _ := testutil.DeterministicGenesisState(t, 1024)
 	service.head = &head{state: s}
 	require.NoError(t, s.SetSlot(2*params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, service.handleEpochBoundary(ctx, s))
@@ -948,18 +927,17 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
-	cfg := &config{
+	cfg := &Config{
 		BeaconDB:        beaconDB,
 		StateGen:        stategen.New(beaconDB),
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		DepositCache:    depositCache,
 		StateNotifier:   &mock.MockStateNotifier{},
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	gs, keys := util.DeterministicGenesisState(t, 32)
+	gs, keys := testutil.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
 	gBlk, err := service.cfg.BeaconDB.GenesisBlock(ctx)
 	require.NoError(t, err)
@@ -969,7 +947,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {

 	testState := gs.Copy()
 	for i := types.Slot(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
-		blk, err := util.GenerateFullBlock(testState, keys, util.DefaultBlockGenConfig(), i)
+		blk, err := testutil.GenerateFullBlock(testState, keys, testutil.DefaultBlockGenConfig(), i)
 		require.NoError(t, err)
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
@@ -979,14 +957,6 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	}
 	require.Equal(t, types.Epoch(3), service.CurrentJustifiedCheckpt().Epoch)
 	require.Equal(t, types.Epoch(2), service.FinalizedCheckpt().Epoch)
-
-	// The update should persist in DB.
-	j, err := service.cfg.BeaconDB.JustifiedCheckpoint(ctx)
-	require.NoError(t, err)
-	require.Equal(t, j.Epoch, service.CurrentJustifiedCheckpt().Epoch)
-	f, err := service.cfg.BeaconDB.FinalizedCheckpoint(ctx)
-	require.NoError(t, err)
-	require.Equal(t, f.Epoch, service.FinalizedCheckpt().Epoch)
 }

 func TestInsertFinalizedDeposits(t *testing.T) {
@@ -994,17 +964,16 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
-	cfg := &config{
+	cfg := &Config{
 		BeaconDB:        beaconDB,
 		StateGen:        stategen.New(beaconDB),
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		DepositCache:    depositCache,
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	gs, _ := util.DeterministicGenesisState(t, 32)
+	gs, _ := testutil.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
 	gBlk, err := service.cfg.BeaconDB.GenesisBlock(ctx)
 	require.NoError(t, err)
@@ -1032,49 +1001,3 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 		assert.DeepEqual(t, [][]byte(nil), d.Proof, "Proofs are not empty")
 	}
 }
-
-func TestRemoveBlockAttestationsInPool_Canonical(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		CorrectlyPruneCanonicalAtts: 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)
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: r[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, r))
-
-	atts := b.Block.Body.Attestations
-	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
-	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b)))
-	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
-}
-
-func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		CorrectlyPruneCanonicalAtts: 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)
-
-	atts := b.Block.Body.Attestations
-	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
-	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b)))
-	require.Equal(t, 1, service.cfg.AttPool.AggregatedAttestationCount())
-}
--- a/beacon-chain/blockchain/receive_attestation.go
+++ b/beacon-chain/blockchain/receive_attestation.go
@@ -9,25 +9,19 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/slotutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )

-// AttestationStateFetcher allows for retrieving a beacon state corresponding to the block
-// root of an attestation's target checkpoint.
-type AttestationStateFetcher interface {
-	AttestationTargetState(ctx context.Context, target *ethpb.Checkpoint) (state.BeaconState, error)
-}
-
 // 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
+	AttestationPreState(ctx context.Context, att *ethpb.Attestation) (iface.BeaconState, error)
 	VerifyLmdFfgConsistency(ctx context.Context, att *ethpb.Attestation) error
 	VerifyFinalizedConsistency(ctx context.Context, root []byte) error
 }
@@ -48,21 +42,21 @@ func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Att
 	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)
+// AttestationPreState returns the pre state of attestation.
+func (s *Service) AttestationPreState(ctx context.Context, att *ethpb.Attestation) (iface.BeaconState, error) {
+	ss, err := helpers.StartSlot(att.Data.Target.Epoch)
 	if err != nil {
 		return nil, err
 	}
-	if err := slots.ValidateClock(ss, uint64(s.genesisTime.Unix())); err != nil {
+	if err := helpers.ValidateSlotClock(ss, uint64(s.genesisTime.Unix())); err != nil {
 		return nil, err
 	}
-	return s.getAttPreState(ctx, target)
+	return s.getAttPreState(ctx, att.Data.Target)
 }

 // VerifyLmdFfgConsistency verifies that attestation's LMD and FFG votes are consistency to each other.
 func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a *ethpb.Attestation) error {
-	targetSlot, err := slots.EpochStart(a.Data.Target.Epoch)
+	targetSlot, err := helpers.StartSlot(a.Data.Target.Epoch)
 	if err != nil {
 		return err
 	}
@@ -87,7 +81,7 @@ func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) e
 	}

 	f := s.FinalizedCheckpt()
-	ss, err := slots.EpochStart(f.Epoch)
+	ss, err := helpers.StartSlot(f.Epoch)
 	if err != nil {
 		return err
 	}
@@ -119,7 +113,7 @@ func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan<- stru
 		log.Warn("Genesis time received, now available to process attestations")
 	}

-	st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+	st := slotutil.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
 	for {
 		select {
 		case <-s.ctx.Done():
@@ -144,9 +138,9 @@ func (s *Service) processAttestations(ctx context.Context) {
 	for _, a := range atts {
 		// Based on the spec, don't process the attestation until the subsequent slot.
 		// This delays consideration in the fork choice until their slot is in the past.
-		// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
+		// https://github.com/ethereum/eth2.0-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
 		nextSlot := a.Data.Slot + 1
-		if err := slots.VerifyTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+		if err := helpers.VerifySlotTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 			continue
 		}

--- a/beacon-chain/blockchain/receive_attestation_test.go
+++ b/beacon-chain/blockchain/receive_attestation_test.go
@@ -7,27 +7,21 @@ import (

 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	prysmTime "github.com/prysmaticlabs/prysm/time"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )

-var (
-	_ = AttestationReceiver(&Service{})
-	_ = AttestationStateFetcher(&Service{})
-)
-
 func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 	helpers.ClearCache()
 	beaconDB := testDB.SetupDB(t)
@@ -35,8 +29,8 @@ func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 	chainService := setupBeaconChain(t, beaconDB)
 	chainService.genesisTime = time.Now()

-	e := types.Epoch(slots.MaxSlotBuffer/uint64(params.BeaconConfig().SlotsPerEpoch) + 1)
-	_, err := chainService.AttestationTargetState(context.Background(), &ethpb.Checkpoint{Epoch: e})
+	e := types.Epoch(helpers.MaxSlotBuffer/uint64(params.BeaconConfig().SlotsPerEpoch) + 1)
+	_, err := chainService.AttestationPreState(context.Background(), &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: e}}})
 	require.ErrorContains(t, "exceeds max allowed value relative to the local clock", err)
 }

@@ -44,17 +38,16 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b32 := util.NewBeaconBlock()
+	b32 := testutil.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b33 := util.NewBeaconBlock()
+	b33 := testutil.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
@@ -62,7 +55,7 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	require.NoError(t, err)

 	wanted := "FFG and LMD votes are not consistent"
-	a := util.NewAttestation()
+	a := testutil.NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = []byte{'a'}
 	a.Data.BeaconBlockRoot = r33[:]
@@ -73,24 +66,23 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	cfg := &Config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	service.cfg = cfg

-	b32 := util.NewBeaconBlock()
+	b32 := testutil.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b33 := util.NewBeaconBlock()
+	b33 := testutil.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)

-	a := util.NewAttestation()
+	a := testutil.NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = r32[:]
 	a.Data.BeaconBlockRoot = r33[:]
@@ -103,24 +95,23 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

-	cfg := &config{
+	cfg := &Config{
 		BeaconDB:        beaconDB,
 		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
 		StateGen:        stategen.New(beaconDB),
 		AttPool:         attestations.NewPool(),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, cfg)
+	service.genesisTime = timeutils.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
 	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))
+	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
+	require.NoError(t, genesisState.SetGenesisTime(uint64(timeutils.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	atts, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
+	atts, err := testutil.GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
 	tRoot := bytesutil.ToBytes32(atts[0].Data.Target.Root)
 	copied := genesisState.Copy()
-	copied, err = transition.ProcessSlots(ctx, copied, 1)
+	copied, err = state.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
--- a/beacon-chain/blockchain/receive_block.go
+++ b/beacon-chain/blockchain/receive_block.go
@@ -7,10 +7,11 @@ import (
 	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/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/time"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
+	"github.com/prysmaticlabs/prysm/shared/timeutils"
+	"github.com/prysmaticlabs/prysm/shared/traceutil"
 	"go.opencensus.io/trace"
 )

@@ -19,8 +20,8 @@ var epochsSinceFinalitySaveHotStateDB = types.Epoch(100)

 // BlockReceiver interface defines the methods of chain service receive and processing new blocks.
 type BlockReceiver interface {
-	ReceiveBlock(ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error
-	ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBeaconBlock, blkRoots [][32]byte) error
+	ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, blockRoot [32]byte) error
+	ReceiveBlockBatch(ctx context.Context, blocks []interfaces.SignedBeaconBlock, blkRoots [][32]byte) error
 	HasInitSyncBlock(root [32]byte) bool
 }

@@ -29,19 +30,36 @@ type BlockReceiver interface {
 //   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 block.SignedBeaconBlock, blockRoot [32]byte) error {
+func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
-	receivedTime := time.Now()
+	receivedTime := timeutils.Now()
 	blockCopy := block.Copy()

 	// Apply state transition on the new block.
 	if err := s.onBlock(ctx, blockCopy, blockRoot); err != nil {
 		err := errors.Wrap(err, "could not process block")
-		tracing.AnnotateError(span, err)
+		traceutil.AnnotateError(span, err)
 		return err
 	}

+	// Update and save head block after fork choice.
+	if !featureconfig.Get().UpdateHeadTimely {
+		if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
+			log.WithError(err).Warn("Could not update head")
+		}
+		// Send notification of the processed block to the state feed.
+		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.BlockProcessed,
+			Data: &statefeed.BlockProcessedData{
+				Slot:        blockCopy.Block().Slot(),
+				BlockRoot:   blockRoot,
+				SignedBlock: blockCopy,
+				Verified:    true,
+			},
+		})
+	}
+
 	// Handle post block operations such as attestations and exits.
 	if err := s.handlePostBlockOperations(blockCopy.Block()); err != nil {
 		return err
@@ -68,7 +86,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block block.SignedBeaconBloc
 // 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 []block.SignedBeaconBlock, blkRoots [][32]byte) error {
+func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.SignedBeaconBlock, blkRoots [][32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlockBatch")
 	defer span.End()

@@ -76,14 +94,14 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 	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)
+		traceutil.AnnotateError(span, err)
 		return err
 	}

 	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)
+			traceutil.AnnotateError(span, err)
 			return err
 		}
 		// Send notification of the processed block to the state feed.
@@ -101,10 +119,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 		reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
 	}

-	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
-		return err
-	}
-	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, s.finalizedCheckpt.Epoch); err != nil {
+	if err := s.VerifyWeakSubjectivityRoot(s.ctx); err != nil {
 		// log.Fatalf will prevent defer from being called
 		span.End()
 		// Exit run time if the node failed to verify weak subjectivity checkpoint.
@@ -119,7 +134,7 @@ func (s *Service) HasInitSyncBlock(root [32]byte) bool {
 	return s.hasInitSyncBlock(root)
 }

-func (s *Service) handlePostBlockOperations(b block.BeaconBlock) error {
+func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {
 	// Delete the processed block attestations from attestation pool.
 	if err := s.deletePoolAtts(b.Body().Attestations()); err != nil {
 		return err
@@ -145,7 +160,7 @@ func (s *Service) handlePostBlockOperations(b block.BeaconBlock) error {
 // This checks whether it's time to start saving hot state to DB.
 // It's time when there's `epochsSinceFinalitySaveHotStateDB` epochs of non-finality.
 func (s *Service) checkSaveHotStateDB(ctx context.Context) error {
-	currentEpoch := slots.ToEpoch(s.CurrentSlot())
+	currentEpoch := helpers.SlotToEpoch(s.CurrentSlot())
 	// Prevent `sinceFinality` going underflow.
 	var sinceFinality types.Epoch
 	if currentEpoch > s.finalizedCheckpt.Epoch {
--- a/beacon-chain/blockchain/receive_block_test.go
+++ b/beacon-chain/blockchain/receive_block_test.go
@@ -13,23 +13,23 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )

 func TestService_ReceiveBlock(t *testing.T) {
 	ctx := context.Background()

-	genesis, keys := util.DeterministicGenesisState(t, 64)
-	genFullBlock := func(t *testing.T, conf *util.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
-		blk, err := util.GenerateFullBlock(genesis, keys, conf, slot)
+	genesis, keys := testutil.DeterministicGenesisState(t, 64)
+	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
+		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
 		assert.NoError(t, err)
 		return blk
 	}
@@ -49,7 +49,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		{
 			name: "applies block with state transition",
 			args: args{
-				block: genFullBlock(t, util.DefaultBlockGenConfig(), 2 /*slot*/),
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				if hs := s.head.state.Slot(); hs != 2 {
@@ -64,7 +64,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 			name: "saves attestations to pool",
 			args: args{
 				block: genFullBlock(t,
-					&util.BlockGenConfig{
+					&testutil.BlockGenConfig{
 						NumProposerSlashings: 0,
 						NumAttesterSlashings: 0,
 						NumAttestations:      2,
@@ -84,7 +84,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		{
 			name: "updates exit pool",
 			args: args{
-				block: genFullBlock(t, &util.BlockGenConfig{
+				block: genFullBlock(t, &testutil.BlockGenConfig{
 					NumProposerSlashings: 0,
 					NumAttesterSlashings: 0,
 					NumAttestations:      0,
@@ -108,7 +108,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		{
 			name: "notifies block processed on state feed",
 			args: args{
-				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
@@ -124,7 +124,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 			genesisBlockRoot := bytesutil.ToBytes32(nil)
 			require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))

-			cfg := &config{
+			cfg := &Config{
 				BeaconDB: beaconDB,
 				ForkChoiceStore: protoarray.New(
 					0, // justifiedEpoch
@@ -136,9 +136,8 @@ func TestService_ReceiveBlock(t *testing.T) {
 				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
 				StateGen:      stategen.New(beaconDB),
 			}
-			s, err := NewService(ctx)
+			s, err := NewService(ctx, cfg)
 			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)
@@ -160,13 +159,13 @@ func TestService_ReceiveBlock(t *testing.T) {

 func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	ctx := context.Background()
-	genesis, keys := util.DeterministicGenesisState(t, 64)
-	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
+	genesis, keys := testutil.DeterministicGenesisState(t, 64)
+	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
 	beaconDB := testDB.SetupDB(t)
 	genesisBlockRoot := bytesutil.ToBytes32(nil)
 	require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
-	cfg := &config{
+	cfg := &Config{
 		BeaconDB: beaconDB,
 		ForkChoiceStore: protoarray.New(
 			0, // justifiedEpoch
@@ -178,9 +177,8 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 		StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
 		StateGen:      stategen.New(beaconDB),
 	}
-	s, err := NewService(ctx)
+	s, err := NewService(ctx, cfg)
 	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)
@@ -206,9 +204,9 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 func TestService_ReceiveBlockBatch(t *testing.T) {
 	ctx := context.Background()

-	genesis, keys := util.DeterministicGenesisState(t, 64)
-	genFullBlock := func(t *testing.T, conf *util.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
-		blk, err := util.GenerateFullBlock(genesis, keys, conf, slot)
+	genesis, keys := testutil.DeterministicGenesisState(t, 64)
+	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
+		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
 		assert.NoError(t, err)
 		return blk
 	}
@@ -225,7 +223,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 		{
 			name: "applies block with state transition",
 			args: args{
-				block: genFullBlock(t, util.DefaultBlockGenConfig(), 2 /*slot*/),
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				assert.Equal(t, types.Slot(2), s.head.state.Slot(), "Incorrect head state slot")
@@ -235,7 +233,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 		{
 			name: "notifies block processed on state feed",
 			args: args{
-				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
+				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
@@ -250,7 +248,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			beaconDB := testDB.SetupDB(t)
 			genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
 			require.NoError(t, err)
-			cfg := &config{
+			cfg := &Config{
 				BeaconDB: beaconDB,
 				ForkChoiceStore: protoarray.New(
 					0, // justifiedEpoch
@@ -260,9 +258,8 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
 				StateGen:      stategen.New(beaconDB),
 			}
-			s, err := NewService(ctx)
+			s, err := NewService(ctx, cfg)
 			require.NoError(t, err)
-			s.cfg = cfg
 			err = s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
 			gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
@@ -273,7 +270,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			blks := []block.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block)}
+			blks := []interfaces.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block)}
 			roots := [][32]byte{root}
 			err = s.ReceiveBlockBatch(ctx, blks, roots)
 			if tt.wantedErr != "" {
@@ -287,14 +284,13 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 }

 func TestService_HasInitSyncBlock(t *testing.T) {
-	s, err := NewService(context.Background())
+	s, err := NewService(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
 	require.NoError(t, err)
-	s.cfg = &config{StateNotifier: &blockchainTesting.MockStateNotifier{}}
 	r := [32]byte{'a'}
 	if s.HasInitSyncBlock(r) {
 		t.Error("Should not have block")
 	}
-	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()))
+	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(testutil.NewBeaconBlock()))
 	if !s.HasInitSyncBlock(r) {
 		t.Error("Should have block")
 	}
@@ -303,9 +299,8 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background())
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
 	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{}
@@ -317,9 +312,8 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background())
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
 	require.NoError(t, err)
-	s.cfg = &config{StateGen: stategen.New(beaconDB)}
 	s.finalizedCheckpt = &ethpb.Checkpoint{}
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	s.genesisTime = time.Now()
@@ -331,9 +325,8 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background())
+	s, err := NewService(context.Background(), &Config{StateGen: stategen.New(beaconDB)})
 	require.NoError(t, err)
-	s.cfg = &config{StateGen: stategen.New(beaconDB)}
 	s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
 	s.genesisTime = time.Now()

--- a/beacon-chain/blockchain/service.go
+++ b/beacon-chain/blockchain/service.go
@@ -11,13 +11,12 @@ import (

 	"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"
 	"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/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
@@ -26,14 +25,15 @@ 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"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/copyutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/slotutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -45,7 +45,7 @@ const headSyncMinEpochsAfterCheckpoint = 128
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                   *config
+	cfg                   *Config
 	ctx                   context.Context
 	cancel                context.CancelFunc
 	genesisTime           time.Time
@@ -60,15 +60,15 @@ type Service struct {
 	nextEpochBoundarySlot types.Slot
 	boundaryRoots         [][32]byte
 	checkpointStateCache  *cache.CheckpointStateCache
-	initSyncBlocks        map[[32]byte]block.SignedBeaconBlock
+	initSyncBlocks        map[[32]byte]interfaces.SignedBeaconBlock
 	initSyncBlocksLock    sync.RWMutex
 	justifiedBalances     []uint64
 	justifiedBalancesLock sync.RWMutex
-	wsVerifier            *WeakSubjectivityVerifier
+	wsVerified            bool
 }

-// config options for the service.
-type config struct {
+// Config options for the service.
+type Config struct {
 	BeaconBlockBuf          int
 	ChainStartFetcher       powchain.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
@@ -82,40 +82,54 @@ type config struct {
 	ForkChoiceStore         f.ForkChoicer
 	AttService              *attestations.Service
 	StateGen                *stategen.State
-	SlasherAttestationsFeed *event.Feed
 	WeakSubjectivityCheckpt *ethpb.Checkpoint
-	FinalizedStateAtStartUp state.BeaconState
 }

 // NewService instantiates a new block service instance that will
 // be registered into a running beacon node.
-func NewService(ctx context.Context, opts ...Option) (*Service, error) {
+func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
-	srv := &Service{
+	return &Service{
+		cfg:                  cfg,
 		ctx:                  ctx,
 		cancel:               cancel,
 		boundaryRoots:        [][32]byte{},
 		checkpointStateCache: cache.NewCheckpointStateCache(),
-		initSyncBlocks:       make(map[[32]byte]block.SignedBeaconBlock),
+		initSyncBlocks:       make(map[[32]byte]interfaces.SignedBeaconBlock),
 		justifiedBalances:    make([]uint64, 0),
-		cfg:                  &config{},
-	}
-	for _, opt := range opts {
-		if err := opt(srv); err != nil {
-			return nil, err
-		}
-	}
-	var err error
-	srv.wsVerifier, err = NewWeakSubjectivityVerifier(srv.cfg.WeakSubjectivityCheckpt, srv.cfg.BeaconDB)
-	if err != nil {
-		return nil, err
-	}
-	return srv, nil
+	}, nil
 }

 // Start a blockchain service's main event loop.
 func (s *Service) Start() {
-	beaconState := s.cfg.FinalizedStateAtStartUp
+	// 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 {
+		log.Fatalf("Could not fetch finalized cp: %v", err)
+	}
+
+	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 {
+			log.Fatalf("Could not fetch finalized cp: %v", err)
+		}
+		if genesisBlock != nil && !genesisBlock.IsNil() {
+			r, err = genesisBlock.Block().HashTreeRoot()
+			if err != nil {
+				log.Fatalf("Could not tree hash genesis block: %v", err)
+			}
+		}
+	}
+	beaconState, err := s.cfg.StateGen.StateByRoot(s.ctx, r)
+	if err != nil {
+		log.Fatalf("Could not fetch beacon state by root: %v", err)
+	}

 	// Make sure that attestation processor is subscribed and ready for state initializing event.
 	attestationProcessorSubscribed := make(chan struct{}, 1)
@@ -138,7 +152,7 @@ func (s *Service) Start() {
 		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)
+		go slotutil.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()), gRoot)

 		justifiedCheckpoint, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
 		if err != nil {
@@ -150,17 +164,17 @@ func (s *Service) Start() {
 		}

 		// Resume fork choice.
-		s.justifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.justifiedCheckpt = copyutil.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.prevJustifiedCheckpt = copyutil.CopyCheckpoint(justifiedCheckpoint)
+		s.bestJustifiedCheckpt = copyutil.CopyCheckpoint(justifiedCheckpoint)
+		s.finalizedCheckpt = copyutil.CopyCheckpoint(finalizedCheckpoint)
+		s.prevFinalizedCheckpt = copyutil.CopyCheckpoint(finalizedCheckpoint)
 		s.resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint)

-		ss, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+		ss, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
 		if err != nil {
 			log.Fatalf("Could not get start slot of finalized epoch: %v", err)
 		}
@@ -175,11 +189,9 @@ func (s *Service) Start() {
 			}
 		}

-		// 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 {
+		if err := s.VerifyWeakSubjectivityRoot(s.ctx); err != nil {
 			// Exit run time if the node failed to verify weak subjectivity checkpoint.
-			log.Fatalf("could not verify initial checkpoint provided for chain sync, with err=: %v", err)
+			log.Fatalf("Could not verify weak subjectivity checkpoint: %v", err)
 		}

 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
@@ -240,7 +252,7 @@ func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Ti
 	if err != nil {
 		log.Fatalf("Could not hash tree root genesis state: %v", err)
 	}
-	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
+	go slotutil.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)

 	// We send out a state initialized event to the rest of the services
 	// running in the beacon node.
@@ -259,14 +271,14 @@ func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Ti
 func (s *Service) initializeBeaconChain(
 	ctx context.Context,
 	genesisTime time.Time,
-	preGenesisState state.BeaconState,
-	eth1data *ethpb.Eth1Data) (state.BeaconState, error) {
+	preGenesisState iface.BeaconState,
+	eth1data *ethpb.Eth1Data) (iface.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.Service.initializeBeaconChain")
 	defer span.End()
 	s.genesisTime = genesisTime
 	unixTime := uint64(genesisTime.Unix())

-	genesisState, err := transition.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
+	genesisState, err := state.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not initialize genesis state")
 	}
@@ -284,7 +296,7 @@ func (s *Service) initializeBeaconChain(
 	if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
 		return nil, err
 	}
-	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState); err != nil {
+	if err := helpers.UpdateProposerIndicesInCache(genesisState); err != nil {
 		return nil, err
 	}

@@ -320,7 +332,7 @@ func (s *Service) Status() error {
 }

 // 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 {
+func (s *Service) saveGenesisData(ctx context.Context, genesisState iface.BeaconState) error {
 	if err := s.cfg.BeaconDB.SaveGenesisData(ctx, genesisState); err != nil {
 		return errors.Wrap(err, "could not save genesis data")
 	}
@@ -339,14 +351,14 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	// Finalized checkpoint at genesis is a zero hash.
 	genesisCheckpoint := genesisState.FinalizedCheckpoint()

-	s.justifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.justifiedCheckpt = copyutil.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)
+	s.prevJustifiedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)
+	s.bestJustifiedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)
+	s.finalizedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)
+	s.prevFinalizedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)

 	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
 		genesisBlk.Block().Slot(),
@@ -368,8 +380,8 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get genesis block from db")
 	}
-	if err := helpers.BeaconBlockIsNil(genesisBlock); err != nil {
-		return err
+	if genesisBlock == nil || genesisBlock.IsNil() {
+		return errors.New("no genesis block in db")
 	}
 	genesisBlkRoot, err := genesisBlock.Block().HashTreeRoot()
 	if err != nil {
@@ -387,9 +399,9 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 		return errors.New("no finalized epoch in the database")
 	}
 	finalizedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
-	var finalizedState state.BeaconState
+	var finalizedState iface.BeaconState

-	finalizedState, err = s.cfg.StateGen.Resume(ctx, s.cfg.FinalizedStateAtStartUp)
+	finalizedState, err = s.cfg.StateGen.Resume(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized state from db")
 	}
@@ -399,7 +411,7 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 		if err != nil {
 			return errors.Wrap(err, "could not retrieve head block")
 		}
-		headEpoch := slots.ToEpoch(headBlock.Block().Slot())
+		headEpoch := helpers.SlotToEpoch(headBlock.Block().Slot())
 		var epochsSinceFinality types.Epoch
 		if headEpoch > finalized.Epoch {
 			epochsSinceFinality = headEpoch - finalized.Epoch
@@ -411,7 +423,7 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 			if err != nil {
 				return errors.Wrap(err, "could not hash head block")
 			}
-			finalizedState, err := s.cfg.StateGen.Resume(ctx, s.cfg.FinalizedStateAtStartUp)
+			finalizedState, err := s.cfg.StateGen.Resume(ctx)
 			if err != nil {
 				return errors.Wrap(err, "could not get finalized state from db")
 			}
--- a/beacon-chain/blockchain/service_norace_test.go
+++ b/beacon-chain/blockchain/service_norace_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"

 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"github.com/sirupsen/logrus"
 )

@@ -18,7 +18,7 @@ func init() {
 func TestChainService_SaveHead_DataRace(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg: &config{BeaconDB: beaconDB},
+		cfg: &Config{BeaconDB: beaconDB},
 	}
 	go func() {
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
--- a/beacon-chain/blockchain/service_test.go
+++ b/beacon-chain/blockchain/service_test.go
@@ -8,13 +8,12 @@ import (
 	"time"

 	"github.com/ethereum/go-ethereum/common"
-	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
@@ -22,17 +21,19 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/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/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"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	protodb "github.com/prysmaticlabs/prysm/proto/beacon/db"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/event"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 	"google.golang.org/protobuf/proto"
 )
@@ -63,11 +64,6 @@ func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ *
 	return nil
 }

-func (mb *mockBroadcaster) BroadcastSyncCommitteeMessage(_ context.Context, _ uint64, _ *ethpb.SyncCommitteeMessage) error {
-	mb.broadcastCalled = true
-	return nil
-}
-
 var _ p2p.Broadcaster = (*mockBroadcaster)(nil)

 func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
@@ -75,31 +71,30 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	ctx := context.Background()
 	var web3Service *powchain.Service
 	var err error
-	bState, _ := util.DeterministicGenesisState(t, 10)
+	bState, _ := testutil.DeterministicGenesisState(t, 10)
 	pbState, err := v1.ProtobufBeaconState(bState.InnerStateUnsafe())
 	require.NoError(t, err)
-	err = beaconDB.SavePowchainData(ctx, &ethpb.ETH1ChainData{
+	err = beaconDB.SavePowchainData(ctx, &protodb.ETH1ChainData{
 		BeaconState: pbState,
-		Trie:        &ethpb.SparseMerkleTrie{},
-		CurrentEth1Data: &ethpb.LatestETH1Data{
+		Trie:        &protodb.SparseMerkleTrie{},
+		CurrentEth1Data: &protodb.LatestETH1Data{
 			BlockHash: make([]byte, 32),
 		},
-		ChainstartData: &ethpb.ChainStartData{
+		ChainstartData: &protodb.ChainStartData{
 			Eth1Data: &ethpb.Eth1Data{
 				DepositRoot:  make([]byte, 32),
 				DepositCount: 0,
 				BlockHash:    make([]byte, 32),
 			},
 		},
-		DepositContainers: []*ethpb.DepositContainer{},
+		DepositContainers: []*protodb.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()})
@@ -108,7 +103,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)

-	cfg := &config{
+	cfg := &Config{
 		BeaconBlockBuf:    0,
 		BeaconDB:          beaconDB,
 		DepositCache:      depositCache,
@@ -124,9 +119,8 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	// 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)
+	chainService, err := NewService(ctx, cfg)
 	require.NoError(t, err, "Unable to setup chain service")
-	chainService.cfg = cfg
 	chainService.genesisTime = time.Unix(1, 0) // non-zero time

 	return chainService
@@ -139,11 +133,11 @@ func TestChainStartStop_Initialized(t *testing.T) {

 	chainService := setupBeaconChain(t, beaconDB)

-	genesisBlk := util.NewBeaconBlock()
+	genesisBlk := testutil.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
@@ -151,7 +145,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[:]}))
-	chainService.cfg.FinalizedStateAtStartUp = s
+
 	// Test the start function.
 	chainService.Start()

@@ -169,16 +163,16 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {

 	chainService := setupBeaconChain(t, beaconDB)

-	genesisBlk := util.NewBeaconBlock()
+	genesisBlk := testutil.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
 	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}))
-	chainService.cfg.FinalizedStateAtStartUp = s
+
 	// Test the start function.
 	chainService.Start()

@@ -199,12 +193,12 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {

 	// Set up 10 deposits pre chain start for validators to register
 	count := uint64(10)
-	deposits, _, err := util.DeterministicDepositsAndKeys(count)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(count)
 	require.NoError(t, err)
-	trie, _, err := util.DepositTrieFromDeposits(deposits)
+	trie, _, err := testutil.DepositTrieFromDeposits(deposits)
 	require.NoError(t, err)
 	hashTreeRoot := trie.HashTreeRoot()
-	genState, err := transition.EmptyGenesisState()
+	genState, err := state.EmptyGenesisState()
 	require.NoError(t, err)
 	err = genState.SetEth1Data(&ethpb.Eth1Data{
 		DepositRoot:  hashTreeRoot[:],
@@ -238,18 +232,18 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {

 	chainService := setupBeaconChain(t, beaconDB)

-	genesisBlk := util.NewBeaconBlock()
+	genesisBlk := testutil.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
-	s, err := util.NewBeaconState()
+	s, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(0))
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
 	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()

@@ -264,17 +258,17 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()

-	genesis := util.NewBeaconBlock()
+	genesis := testutil.NewBeaconBlock()
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))

 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
-	headBlock := util.NewBeaconBlock()
+	headBlock := testutil.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot
 	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
-	headState, err := util.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
 	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
@@ -283,9 +277,8 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
-	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
-	c.cfg.FinalizedStateAtStartUp = headState
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: helpers.SlotToEpoch(finalizedSlot), Root: headRoot[:]}))
+	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)
@@ -306,17 +299,17 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()

-	genesis := util.NewBeaconBlock()
+	genesis := testutil.NewBeaconBlock()
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))

 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
-	headBlock := util.NewBeaconBlock()
+	headBlock := testutil.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot
 	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
-	headState, err := util.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
 	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
@@ -325,7 +318,7 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
-	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
+	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)
@@ -348,13 +341,13 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()

-	genesisBlock := util.NewBeaconBlock()
+	genesisBlock := testutil.NewBeaconBlock()
 	genesisRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))

-	finalizedBlock := util.NewBeaconBlock()
+	finalizedBlock := testutil.NewBeaconBlock()
 	finalizedBlock.Block.Slot = finalizedSlot
 	finalizedBlock.Block.ParentRoot = genesisRoot[:]
 	finalizedRoot, err := finalizedBlock.Block.HashTreeRoot()
@@ -362,14 +355,14 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	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()
+	headBlock := testutil.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot + params.BeaconConfig().SlotsPerEpoch*5
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))

-	headState, err := util.NewBeaconState()
+	headState, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(headBlock.Block.Slot))
 	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
@@ -378,12 +371,12 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	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),
+		Epoch: helpers.SlotToEpoch(finalizedBlock.Block.Slot),
 		Root:  finalizedRoot[:],
 	}))

-	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
-	c.cfg.FinalizedStateAtStartUp = 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)
@@ -395,7 +388,7 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	assert.LogsDoNotContain(t, hook, "Regenerating state from the last checkpoint at slot")

 	// Set head slot far beyond the finalization point, head sync should be triggered.
-	headBlock = util.NewBeaconBlock()
+	headBlock = testutil.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot + params.BeaconConfig().SlotsPerEpoch*headSyncMinEpochsAfterCheckpoint
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err = headBlock.Block.HashTreeRoot()
@@ -420,13 +413,13 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 	s := &Service{
-		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
+		cfg: &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 	}
-	blk := util.NewBeaconBlock()
+	blk := testutil.NewBeaconBlock()
 	blk.Block.Slot = 1
 	r, err := blk.HashTreeRoot()
 	require.NoError(t, err)
-	newState, err := util.NewBeaconState()
+	newState, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
 	require.NoError(t, s.saveHeadNoDB(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r, newState))
@@ -442,13 +435,13 @@ func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg:              &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
+		cfg:              &Config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
 		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	block := util.NewBeaconBlock()
+	block := testutil.NewBeaconBlock()
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
-	beaconState, err := util.NewBeaconState()
+	beaconState, err := testutil.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))

@@ -460,12 +453,12 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg:            &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
+		cfg:            &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 		ctx:            ctx,
 		cancel:         cancel,
-		initSyncBlocks: make(map[[32]byte]block.SignedBeaconBlock),
+		initSyncBlocks: make(map[[32]byte]interfaces.SignedBeaconBlock),
 	}
-	block := util.NewBeaconBlock()
+	block := testutil.NewBeaconBlock()
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
 	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(block))
@@ -491,9 +484,9 @@ func BenchmarkHasBlockDB(b *testing.B) {
 	beaconDB := testDB.SetupDB(b)
 	ctx := context.Background()
 	s := &Service{
-		cfg: &config{BeaconDB: beaconDB},
+		cfg: &Config{BeaconDB: beaconDB},
 	}
-	block := util.NewBeaconBlock()
+	block := testutil.NewBeaconBlock()
 	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block)))
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
@@ -508,13 +501,13 @@ func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
-		cfg:              &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
+		cfg:              &Config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
 		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
 	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)}}
+	bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := v1.InitializeFromProto(bs)
 	require.NoError(b, err)
 	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
--- a/beacon-chain/blockchain/testing/BUILD.bazel
+++ b/beacon-chain/blockchain/testing/BUILD.bazel
@@ -7,11 +7,9 @@ go_library(
    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing",
    visibility = [
        "//beacon-chain:__subpackages__",
-        "//testing:__subpackages__",
-        "//testing/fuzz:__pkg__",
+        "//fuzz:__pkg__",
    ],
    deps = [
-        "//async/event:go_default_library",
        "//beacon-chain/core/epoch/precompute:go_default_library",
        "//beacon-chain/core/feed:go_default_library",
        "//beacon-chain/core/feed/block:go_default_library",
@@ -20,12 +18,14 @@ go_library(
        "//beacon-chain/core/helpers:go_default_library",
        "//beacon-chain/db:go_default_library",
        "//beacon-chain/forkchoice/protoarray:go_default_library",
-        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/interface:go_default_library",
        "//beacon-chain/state/v1:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/block:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//proto/interfaces:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/event:go_default_library",
+        "//shared/params:go_default_library",
        "@com_github_pkg_errors//:go_default_library",
        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
        "@com_github_sirupsen_logrus//:go_default_library",
--- a/beacon-chain/blockchain/testing/mock.go
+++ b/beacon-chain/blockchain/testing/mock.go
@@ -10,7 +10,6 @@ import (

 	"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"
 	blockfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/block"
@@ -19,29 +18,31 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/interfaces"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/event"
+	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/sirupsen/logrus"
 )

 // ChainService defines the mock interface for testing
 type ChainService struct {
-	State                       state.BeaconState
+	State                       iface.BeaconState
 	Root                        []byte
-	Block                       block.SignedBeaconBlock
+	Block                       interfaces.SignedBeaconBlock
 	FinalizedCheckPoint         *ethpb.Checkpoint
 	CurrentJustifiedCheckPoint  *ethpb.Checkpoint
 	PreviousJustifiedCheckPoint *ethpb.Checkpoint
-	BlocksReceived              []block.SignedBeaconBlock
+	BlocksReceived              []interfaces.SignedBeaconBlock
 	Balance                     *precompute.Balance
 	Genesis                     time.Time
 	ValidatorsRoot              [32]byte
 	CanonicalRoots              map[[32]byte]bool
-	Fork                        *ethpb.Fork
+	Fork                        *pb.Fork
 	ETH1Data                    *ethpb.Eth1Data
 	DB                          db.Database
 	stateNotifier               statefeed.Notifier
@@ -51,13 +52,6 @@ type ChainService struct {
 	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
-	InitSyncBlockRoots          map[[32]byte]bool
 }

 // StateNotifier mocks the same method in the chain service.
@@ -156,7 +150,7 @@ func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
 }

 // ReceiveBlockInitialSync mocks ReceiveBlockInitialSync method in chain service.
-func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block block.SignedBeaconBlock, _ [32]byte) error {
+func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block interfaces.SignedBeaconBlock, _ [32]byte) error {
 	if s.State == nil {
 		s.State = &v1.BeaconState{}
 	}
@@ -183,7 +177,7 @@ func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block block.
 }

 // ReceiveBlockBatch processes blocks in batches from initial-sync.
-func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock, _ [][32]byte) error {
+func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock, _ [][32]byte) error {
 	if s.State == nil {
 		s.State = &v1.BeaconState{}
 	}
@@ -212,7 +206,7 @@ func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []block.Signe
 }

 // ReceiveBlock mocks ReceiveBlock method in chain service.
-func (s *ChainService) ReceiveBlock(ctx context.Context, block block.SignedBeaconBlock, _ [32]byte) error {
+func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, _ [32]byte) error {
 	if s.State == nil {
 		s.State = &v1.BeaconState{}
 	}
@@ -255,17 +249,17 @@ func (s *ChainService) HeadRoot(_ context.Context) ([]byte, error) {
 }

 // HeadBlock mocks HeadBlock method in chain service.
-func (s *ChainService) HeadBlock(context.Context) (block.SignedBeaconBlock, error) {
+func (s *ChainService) HeadBlock(context.Context) (interfaces.SignedBeaconBlock, error) {
 	return s.Block, nil
 }

 // HeadState mocks HeadState method in chain service.
-func (s *ChainService) HeadState(context.Context) (state.BeaconState, error) {
+func (s *ChainService) HeadState(context.Context) (iface.BeaconState, error) {
 	return s.State, nil
 }

 // CurrentFork mocks HeadState method in chain service.
-func (s *ChainService) CurrentFork() *ethpb.Fork {
+func (s *ChainService) CurrentFork() *pb.Fork {
 	return s.Fork
 }

@@ -294,17 +288,17 @@ func (s *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attest
 	return nil
 }

-// AttestationTargetState mocks AttestationTargetState method in chain service.
-func (s *ChainService) AttestationTargetState(_ context.Context, _ *ethpb.Checkpoint) (state.BeaconState, error) {
+// AttestationPreState mocks AttestationPreState method in chain service.
+func (s *ChainService) AttestationPreState(_ context.Context, _ *ethpb.Attestation) (iface.BeaconState, error) {
 	return s.State, nil
 }

 // HeadValidatorsIndices mocks the same method in the chain service.
-func (s *ChainService) HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error) {
+func (s *ChainService) HeadValidatorsIndices(_ context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error) {
 	if s.State == nil {
 		return []types.ValidatorIndex{}, nil
 	}
-	return helpers.ActiveValidatorIndices(ctx, s.State, epoch)
+	return helpers.ActiveValidatorIndices(s.State, epoch)
 }

 // HeadSeed mocks the same method in the chain service.
@@ -361,11 +355,8 @@ func (s *ChainService) IsCanonical(_ context.Context, r [32]byte) (bool, error)
 }

 // 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]
+func (s *ChainService) HasInitSyncBlock(_ [32]byte) bool {
+	return false
 }

 // HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
@@ -402,38 +393,3 @@ func (s *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
 		},
 		[]types.Slot{0, 1}
 }
-
-// HeadPublicKeyToValidatorIndex mocks HeadPublicKeyToValidatorIndex and always return 0 and true.
-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) ([48]byte, error) {
-	return s.PublicKey, nil
-}
-
-// HeadSyncCommitteeIndices mocks HeadSyncCommitteeIndices and always return `HeadNextSyncCommitteeIndices`.
-func (s *ChainService) HeadSyncCommitteeIndices(_ context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
-	return s.SyncCommitteeIndices, nil
-}
-
-// HeadSyncCommitteePubKeys mocks HeadSyncCommitteePubKeys and always return empty nil.
-func (s *ChainService) HeadSyncCommitteePubKeys(_ context.Context, _ types.Slot, _ types.CommitteeIndex) ([][]byte, error) {
-	return s.SyncCommitteePubkeys, nil
-}
-
-// HeadSyncCommitteeDomain mocks HeadSyncCommitteeDomain and always return empty nil.
-func (s *ChainService) HeadSyncCommitteeDomain(_ context.Context, _ types.Slot) ([]byte, error) {
-	return s.SyncCommitteeDomain, nil
-}
-
-// HeadSyncSelectionProofDomain mocks HeadSyncSelectionProofDomain and always return empty nil.
-func (s *ChainService) HeadSyncSelectionProofDomain(_ context.Context, _ types.Slot) ([]byte, error) {
-	return s.SyncSelectionProofDomain, nil
-}
-
-// HeadSyncContributionProofDomain mocks HeadSyncContributionProofDomain and always return empty nil.
-func (s *ChainService) HeadSyncContributionProofDomain(_ context.Context, _ types.Slot) ([]byte, error) {
-	return s.SyncContributionProofDomain, nil
-}
--- a/beacon-chain/blockchain/weak_subjectivity_checks.go
+++ b/beacon-chain/blockchain/weak_subjectivity_checks.go
@@ -4,94 +4,57 @@ import (
 	"context"
 	"fmt"

-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
 )

-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)
-}
-
-type WeakSubjectivityVerifier struct {
-	enabled  bool
-	verified bool
-	root     [32]byte
-	epoch    types.Epoch
-	slot     types.Slot
-	db       weakSubjectivityDB
-}
-
-// 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 {
-		return &WeakSubjectivityVerifier{
-			enabled: false,
-		}, nil
+// VerifyWeakSubjectivityRoot verifies the weak subjectivity root in the service struct.
+// Reference design: https://github.com/ethereum/eth2.0-specs/blob/master/specs/phase0/weak-subjectivity.md#weak-subjectivity-sync-procedure
+func (s *Service) VerifyWeakSubjectivityRoot(ctx context.Context) error {
+	// TODO(7342): Remove the following to fully use weak subjectivity in production.
+	if s.cfg.WeakSubjectivityCheckpt == nil || len(s.cfg.WeakSubjectivityCheckpt.Root) == 0 || s.cfg.WeakSubjectivityCheckpt.Epoch == 0 {
+		return nil
 	}
-	startSlot, err := slots.EpochStart(wsc.Epoch)
+
+	// Do nothing if the weak subjectivity has previously been verified,
+	// or weak subjectivity epoch is higher than last finalized epoch.
+	if s.wsVerified {
+		return nil
+	}
+	if s.cfg.WeakSubjectivityCheckpt.Epoch > s.finalizedCheckpt.Epoch {
+		return nil
+	}
+
+	r := bytesutil.ToBytes32(s.cfg.WeakSubjectivityCheckpt.Root)
+	log.Infof("Performing weak subjectivity check for root %#x in epoch %d", r, s.cfg.WeakSubjectivityCheckpt.Epoch)
+	// Save initial sync cached blocks to DB.
+	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+		return err
+	}
+	// A node should have the weak subjectivity block in the DB.
+	if !s.cfg.BeaconDB.HasBlock(ctx, r) {
+		return fmt.Errorf("node does not have root in DB: %#x", r)
+	}
+
+	startSlot, err := helpers.StartSlot(s.cfg.WeakSubjectivityCheckpt.Epoch)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	return &WeakSubjectivityVerifier{
-		enabled:  true,
-		verified: false,
-		root:     bytesutil.ToBytes32(wsc.Root),
-		epoch:    wsc.Epoch,
-		db:       db,
-		slot:     startSlot,
-	}, nil
-}
-
-// VerifyWeakSubjectivity verifies the weak subjectivity root in the service struct.
-// Reference design: https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/weak-subjectivity.md#weak-subjectivity-sync-procedure
-func (v *WeakSubjectivityVerifier) VerifyWeakSubjectivity(ctx context.Context, finalizedEpoch types.Epoch) error {
-	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
-	// is in the sync path at epoch epoch_number. Emit descriptive critical error if this assert fails,
-	// then exit client process.
-	// we do not handle this case ^, because we can only blocks that have been processed / are currently
-	// in line for finalization, we don't have the ability to look ahead. so we only satisfy the following:
-	// IF epoch_number <= store.finalized_checkpoint.epoch,
-	// then ASSERT that the block in the canonical chain at epoch epoch_number has root block_root.
-	// Emit descriptive critical error if this assert fails, then exit client process.
-	if v.epoch > finalizedEpoch {
-		return nil
-	}
-	log.Infof("Performing weak subjectivity check for root %#x in epoch %d", v.root, v.epoch)
-
-	if !v.db.HasBlock(ctx, v.root) {
-		return errors.Wrap(errWSBlockNotFound, fmt.Sprintf("missing root %#x", v.root))
-	}
-	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.
-	roots, err := v.db.BlockRoots(ctx, filter)
+	filter := filters.NewFilter().SetStartSlot(startSlot).SetEndSlot(startSlot + params.BeaconConfig().SlotsPerEpoch)
+	roots, err := s.cfg.BeaconDB.BlockRoots(ctx, filter)
 	if err != nil {
-		return errors.Wrap(err, "error while retrieving block roots to verify weak subjectivity")
+		return err
 	}
 	for _, root := range roots {
-		if v.root == root {
+		if r == root {
 			log.Info("Weak subjectivity check has passed")
-			v.verified = true
+			s.wsVerified = true
 			return nil
 		}
 	}

-	return errors.Wrap(errWSBlockNotFoundInEpoch, fmt.Sprintf("root=%#x, epoch=%d", v.root, v.epoch))
+	return fmt.Errorf("node does not have root in db corresponding to epoch: %#x %d", r, s.cfg.WeakSubjectivityCheckpt.Epoch)
 }
--- a/beacon-chain/blockchain/weak_subjectivity_checks_test.go
+++ b/beacon-chain/blockchain/weak_subjectivity_checks_test.go
@@ -4,77 +4,78 @@ import (
 	"context"
 	"testing"

-	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"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"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)

-	b := util.NewBeaconBlock()
+	b := testutil.NewBeaconBlock()
 	b.Block.Slot = 32
 	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	tests := []struct {
 		wsVerified     bool
-		wantErr        error
+		wantErr        bool
 		checkpt        *ethpb.Checkpoint
 		finalizedEpoch types.Epoch
+		errString      string
 		name           string
 	}{
 		{
-			name: "nil root and epoch",
+			name:    "nil root and epoch",
+			wantErr: false,
 		},
 		{
 			name:           "already verified",
 			checkpt:        &ethpb.Checkpoint{Epoch: 2},
 			finalizedEpoch: 2,
 			wsVerified:     true,
+			wantErr:        false,
 		},
 		{
 			name:           "not yet to verify, ws epoch higher than finalized epoch",
 			checkpt:        &ethpb.Checkpoint{Epoch: 2},
 			finalizedEpoch: 1,
+			wantErr:        false,
 		},
 		{
 			name:           "can't find the block in DB",
 			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, 32), Epoch: 1},
 			finalizedEpoch: 3,
-			wantErr:        errWSBlockNotFound,
+			wantErr:        true,
+			errString:      "node does not have root in DB",
 		},
 		{
 			name:           "can't find the block corresponds to ws epoch in DB",
 			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 2}, // Root belongs in epoch 1.
 			finalizedEpoch: 3,
-			wantErr:        errWSBlockNotFoundInEpoch,
+			wantErr:        true,
+			errString:      "node does not have root in db corresponding to epoch",
 		},
 		{
 			name:           "can verify and pass",
 			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 1},
 			finalizedEpoch: 3,
+			wantErr:        false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wv, err := NewWeakSubjectivityVerifier(tt.checkpt, beaconDB)
-			require.NoError(t, err)
 			s := &Service{
-				cfg:              &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt},
+				cfg:              &Config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt},
+				wsVerified:       tt.wsVerified,
 				finalizedCheckpt: &ethpb.Checkpoint{Epoch: tt.finalizedEpoch},
-				wsVerifier:       wv,
 			}
-			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), s.finalizedCheckpt.Epoch)
-			if tt.wantErr == nil {
-				require.NoError(t, err)
-			} else {
-				require.Equal(t, true, errors.Is(err, tt.wantErr))
+			if err := s.VerifyWeakSubjectivityRoot(context.Background()); (err != nil) != tt.wantErr {
+				require.ErrorContains(t, tt.errString, err)
 			}
 		})
 	}
--- a/beacon-chain/cache/BUILD.bazel
+++ b/beacon-chain/cache/BUILD.bazel
@@ -10,47 +10,34 @@ go_library(
        "committees.go",
        "common.go",
        "doc.go",
-        "error.go",
        "proposer_indices_type.go",
        "skip_slot_cache.go",
        "subnet_ids.go",
-        "sync_committee_head_state.go",
-        "sync_subnet_ids.go",
    ] + select({
-        "//testing/fuzz:fuzzing_enabled": [
-            "active_balance_disabled.go",
+        "//fuzz:fuzzing_enabled": [
            "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/fuzz:__pkg__",
+        "//fuzz:__pkg__",
        "//tools:__subpackages__",
    ],
    deps = [
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/v2:go_default_library",
-        "//cache/lru:go_default_library",
-        "//config/features:go_default_library",
-        "//config/params: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",
+        "//beacon-chain/state/interface:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//shared/copyutil:go_default_library",
+        "//shared/hashutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/sliceutil: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",
@@ -63,7 +50,6 @@ go_test(
    name = "go_default_test",
    size = "small",
    srcs = [
-        "active_balance_test.go",
        "attestation_data_test.go",
        "cache_test.go",
        "checkpoint_state_test.go",
@@ -72,22 +58,17 @@ go_test(
        "proposer_indices_test.go",
        "skip_slot_cache_test.go",
        "subnet_ids_test.go",
-        "sync_committee_head_state_test.go",
-        "sync_committee_test.go",
-        "sync_subnet_ids_test.go",
    ],
    embed = [":go_default_library"],
    deps = [
-        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/interface:go_default_library",
        "//beacon-chain/state/v1:go_default_library",
-        "//beacon-chain/state/v2:go_default_library",
-        "//config/features:go_default_library",
-        "//config/params: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",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
        "@com_github_google_gofuzz//:go_default_library",
        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
        "@org_golang_google_protobuf//proto:go_default_library",
--- a/beacon-chain/cache/active_balance.go
+++ b/beacon-chain/cache/active_balance.go
@@ -1,119 +0,0 @@
-// +build !libfuzzer
-
-package cache
-
-import (
-	"encoding/binary"
-	"sync"
-
-	lru "github.com/hashicorp/golang-lru"
-	"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"
-)
-
-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",
-		Help: "The number of get requests that aren't present in the cache.",
-	})
-	// BalanceCacheHit tracks the number of balance requests that are in the cache.
-	balanceCacheHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "total_effective_balance_cache_hit",
-		Help: "The number of get requests that are present in the cache.",
-	})
-)
-
-// BalanceCache is a struct with 1 LRU cache for looking up balance by epoch.
-type BalanceCache struct {
-	cache *lru.Cache
-	lock  sync.RWMutex
-}
-
-// NewEffectiveBalanceCache creates a new effective balance cache for storing/accessing total balance by epoch.
-func NewEffectiveBalanceCache() *BalanceCache {
-	return &BalanceCache{
-		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
-	}
-
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	_ = c.cache.Add(key, balance)
-	return nil
-}
-
-// 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
-	}
-
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-
-	value, exists := c.cache.Get(key)
-	if !exists {
-		balanceCacheMiss.Inc()
-		return 0, ErrNotFound
-	}
-	balanceCacheHit.Inc()
-	return value.(uint64), nil
-}
-
-// Given input state `st`, balance key is constructed as:
-// (block_root in `st` at epoch_start_slot - 1) + current_epoch + validator_count
-func balanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	currentEpoch := st.Slot().DivSlot(slotsPerEpoch)
-	epochStartSlot, err := slotsPerEpoch.SafeMul(uint64(currentEpoch))
-	if err != nil {
-		// impossible condition due to early division
-		return "", errors.Errorf("start slot calculation overflows: %v", err)
-	}
-	prevSlot := ethTypes.Slot(0)
-	if epochStartSlot > 1 {
-		prevSlot = epochStartSlot - 1
-	}
-	r, err := st.BlockRootAtIndex(uint64(prevSlot % params.BeaconConfig().SlotsPerHistoricalRoot))
-	if err != nil {
-		// impossible condition because index is always constrained within state
-		return "", err
-	}
-
-	// Mix in current epoch
-	b := make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(currentEpoch))
-	key := append(r, b...)
-
-	// Mix in validator count
-	b = make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(st.NumValidators()))
-	key = append(key, b...)
-
-	return string(key), nil
-}
--- a/beacon-chain/cache/active_balance_disabled.go
+++ b/beacon-chain/cache/active_balance_disabled.go
@@ -1,31 +0,0 @@
-// +build libfuzzer
-
-package cache
-
-import (
-	"sync"
-
-	lru "github.com/hashicorp/golang-lru"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-)
-
-// FakeBalanceCache is a fake struct with 1 LRU cache for looking up balance by epoch.
-type FakeBalanceCache struct {
-	cache *lru.Cache
-	lock  sync.RWMutex
-}
-
-// NewEffectiveBalanceCache creates a new effective balance cache for storing/accessing total balance by epoch.
-func NewEffectiveBalanceCache() *FakeBalanceCache {
-	return &FakeBalanceCache{}
-}
-
-// AddTotalEffectiveBalance adds a new total effective balance entry for current balance for state `st` into the cache.
-func (c *FakeBalanceCache) AddTotalEffectiveBalance(st state.ReadOnlyBeaconState, balance uint64) error {
-	return nil
-}
-
-// Get returns the current epoch's effective balance for state `st` in cache.
-func (c *FakeBalanceCache) Get(st state.ReadOnlyBeaconState) (uint64, error) {
-	return 0, nil
-}
--- a/beacon-chain/cache/active_balance_test.go
+++ b/beacon-chain/cache/active_balance_test.go
@@ -1,81 +0,0 @@
-package cache
-
-import (
-	"encoding/binary"
-	"math"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	state "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/features"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestBalanceCache_AddGetBalance(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnableActiveBalanceCache: true,
-	})
-	defer resetCfg()
-
-	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := 0; i < len(blockRoots); i++ {
-		b := make([]byte, 8)
-		binary.LittleEndian.PutUint64(b, uint64(i))
-		blockRoots[i] = b
-	}
-	raw := &ethpb.BeaconState{
-		BlockRoots: blockRoots,
-	}
-	st, err := state.InitializeFromProto(raw)
-	require.NoError(t, err)
-
-	cache := NewEffectiveBalanceCache()
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
-
-	b := uint64(100)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err := cache.Get(st)
-	require.NoError(t, err)
-	require.Equal(t, b, cachedB)
-
-	require.NoError(t, st.SetSlot(1000))
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
-
-	b = uint64(200)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cache.Get(st)
-	require.NoError(t, err)
-	require.Equal(t, b, cachedB)
-
-	require.NoError(t, st.SetSlot(1000+params.BeaconConfig().SlotsPerHistoricalRoot))
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
-
-	b = uint64(300)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cache.Get(st)
-	require.NoError(t, err)
-	require.Equal(t, b, cachedB)
-}
-
-func TestBalanceCache_BalanceKey(t *testing.T) {
-	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := 0; i < len(blockRoots); i++ {
-		b := make([]byte, 8)
-		binary.LittleEndian.PutUint64(b, uint64(i))
-		blockRoots[i] = b
-	}
-	raw := &ethpb.BeaconState{
-		BlockRoots: blockRoots,
-	}
-	st, err := state.InitializeFromProto(raw)
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(types.Slot(math.MaxUint64)))
-
-	_, err = balanceCacheKey(st)
-	require.NoError(t, err)
-}
--- a/beacon-chain/cache/attestation_data.go
+++ b/beacon-chain/cache/attestation_data.go
@@ -10,7 +10,8 @@ import (

 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/copyutil"
 	"k8s.io/client-go/tools/cache"
 )

@@ -97,7 +98,7 @@ func (c *AttestationCache) Get(ctx context.Context, req *ethpb.AttestationDataRe

 	if exists && item != nil && item.(*attestationReqResWrapper).res != nil {
 		attestationCacheHit.Inc()
-		return ethpb.CopyAttestationData(item.(*attestationReqResWrapper).res), nil
+		return copyutil.CopyAttestationData(item.(*attestationReqResWrapper).res), nil
 	}
 	attestationCacheMiss.Inc()
 	return nil, nil
--- a/beacon-chain/cache/attestation_data_test.go
+++ b/beacon-chain/cache/attestation_data_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"

 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"google.golang.org/protobuf/proto"
 )

--- a/beacon-chain/cache/checkpoint_state.go
+++ b/beacon-chain/cache/checkpoint_state.go
@@ -6,10 +6,9 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
-	"github.com/prysmaticlabs/prysm/crypto/hash"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/hashutil"
 )

 var (
@@ -37,17 +36,21 @@ type CheckpointStateCache struct {

 // NewCheckpointStateCache creates a new checkpoint state cache for storing/accessing processed state.
 func NewCheckpointStateCache() *CheckpointStateCache {
+	cache, err := lru.New(maxCheckpointStateSize)
+	if err != nil {
+		panic(err)
+	}
 	return &CheckpointStateCache{
-		cache: lruwrpr.New(maxCheckpointStateSize),
+		cache: cache,
 	}
 }

 // StateByCheckpoint fetches state by checkpoint. Returns true with a
 // reference to the CheckpointState info, if exists. Otherwise returns false, nil.
-func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.BeaconState, error) {
+func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (iface.BeaconState, error) {
 	c.lock.RLock()
 	defer c.lock.RUnlock()
-	h, err := hash.HashProto(cp)
+	h, err := hashutil.HashProto(cp)
 	if err != nil {
 		return nil, err
 	}
@@ -57,7 +60,7 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.Be
 	if exists && item != nil {
 		checkpointStateHit.Inc()
 		// Copy here is unnecessary since the return will only be used to verify attestation signature.
-		return item.(state.BeaconState), nil
+		return item.(iface.BeaconState), nil
 	}

 	checkpointStateMiss.Inc()
@@ -66,10 +69,10 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.Be

 // AddCheckpointState adds CheckpointState object to the cache. This method also trims the least
 // recently added CheckpointState object if the cache size has ready the max cache size limit.
-func (c *CheckpointStateCache) AddCheckpointState(cp *ethpb.Checkpoint, s state.ReadOnlyBeaconState) error {
+func (c *CheckpointStateCache) AddCheckpointState(cp *ethpb.Checkpoint, s iface.ReadOnlyBeaconState) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
-	h, err := hash.HashProto(cp)
+	h, err := hashutil.HashProto(cp)
 	if err != nil {
 		return err
 	}
--- a/beacon-chain/cache/checkpoint_state_test.go
+++ b/beacon-chain/cache/checkpoint_state_test.go
@@ -4,13 +4,14 @@ import (
 	"testing"

 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"google.golang.org/protobuf/proto"
 )

@@ -18,48 +19,48 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 	cache := NewCheckpointStateCache()

 	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
-	st, err := v1.InitializeFromProto(&ethpb.BeaconState{
+	st, err := v1.InitializeFromProto(&pb.BeaconState{
 		GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:],
 		Slot:                  64,
 	})
 	require.NoError(t, err)

-	s, err := cache.StateByCheckpoint(cp1)
+	state, err := cache.StateByCheckpoint(cp1)
 	require.NoError(t, err)
-	assert.Equal(t, state.BeaconState(nil), s, "Expected state not to exist in empty cache")
+	assert.Equal(t, iface.BeaconState(nil), state, "Expected state not to exist in empty cache")

 	require.NoError(t, cache.AddCheckpointState(cp1, st))

-	s, err = cache.StateByCheckpoint(cp1)
+	state, err = cache.StateByCheckpoint(cp1)
 	require.NoError(t, err)

-	pbState1, err := v1.ProtobufBeaconState(s.InnerStateUnsafe())
+	pbState1, err := v1.ProtobufBeaconState(state.InnerStateUnsafe())
 	require.NoError(t, err)
-	pbstate, err := v1.ProtobufBeaconState(st.InnerStateUnsafe())
+	pbState2, err := v1.ProtobufBeaconState(st.InnerStateUnsafe())
 	require.NoError(t, err)
-	if !proto.Equal(pbState1, pbstate) {
+	if !proto.Equal(pbState1, pbState2) {
 		t.Error("incorrectly cached state")
 	}

 	cp2 := &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'B'}, 32)}
-	st2, err := v1.InitializeFromProto(&ethpb.BeaconState{
+	st2, err := v1.InitializeFromProto(&pb.BeaconState{
 		Slot: 128,
 	})
 	require.NoError(t, err)
 	require.NoError(t, cache.AddCheckpointState(cp2, st2))

-	s, err = cache.StateByCheckpoint(cp2)
+	state, err = cache.StateByCheckpoint(cp2)
 	require.NoError(t, err)
-	assert.DeepEqual(t, st2.CloneInnerState(), s.CloneInnerState(), "incorrectly cached state")
+	assert.DeepEqual(t, st2.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")

-	s, err = cache.StateByCheckpoint(cp1)
+	state, err = cache.StateByCheckpoint(cp1)
 	require.NoError(t, err)
-	assert.DeepEqual(t, st.CloneInnerState(), s.CloneInnerState(), "incorrectly cached state")
+	assert.DeepEqual(t, st.CloneInnerState(), state.CloneInnerState(), "incorrectly cached state")
 }

 func TestCheckpointStateCache_MaxSize(t *testing.T) {
 	c := NewCheckpointStateCache()
-	st, err := v1.InitializeFromProto(&ethpb.BeaconState{
+	st, err := v1.InitializeFromProto(&pb.BeaconState{
 		Slot: 0,
 	})
 	require.NoError(t, err)
--- a/beacon-chain/cache/committee.go
+++ b/beacon-chain/cache/committee.go
@@ -3,20 +3,15 @@
 package cache

 import (
-	"context"
 	"errors"
-	"math"
 	"sync"
-	"time"

 	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	types "github.com/prysmaticlabs/eth2-types"
-	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/container/slice"
-	mathutil "github.com/prysmaticlabs/prysm/math"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 )

 var (
@@ -40,7 +35,6 @@ var (
 type CommitteeCache struct {
 	CommitteeCache *lru.Cache
 	lock           sync.RWMutex
-	inProgress     map[string]bool
 }

 // committeeKeyFn takes the seed as the key to retrieve shuffled indices of a committee in a given epoch.
@@ -54,18 +48,22 @@ func committeeKeyFn(obj interface{}) (string, error) {

 // NewCommitteesCache creates a new committee cache for storing/accessing shuffled indices of a committee.
 func NewCommitteesCache() *CommitteeCache {
+	cCache, err := lru.New(int(maxCommitteesCacheSize))
+	// An error is only returned if the size of the cache is
+	// <= 0.
+	if err != nil {
+		panic(err)
+	}
 	return &CommitteeCache{
-		CommitteeCache: lruwrpr.New(int(maxCommitteesCacheSize)),
-		inProgress:     make(map[string]bool),
+		CommitteeCache: cCache,
 	}
 }

 // Committee fetches the shuffled indices by slot and committee index. Every list of indices
 // represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.
-func (c *CommitteeCache) Committee(ctx context.Context, slot types.Slot, seed [32]byte, index types.CommitteeIndex) ([]types.ValidatorIndex, error) {
-	if err := c.checkInProgress(ctx, seed); err != nil {
-		return nil, err
-	}
+func (c *CommitteeCache) Committee(slot types.Slot, seed [32]byte, index types.CommitteeIndex) ([]types.ValidatorIndex, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()

 	obj, exists := c.CommitteeCache.Get(key(seed))
 	if exists {
@@ -85,10 +83,7 @@ func (c *CommitteeCache) Committee(ctx context.Context, slot types.Slot, seed [3
 		committeeCountPerSlot = item.CommitteeCount / uint64(params.BeaconConfig().SlotsPerEpoch)
 	}

-	indexOffSet, err := mathutil.Add64(uint64(index), uint64(slot.ModSlot(params.BeaconConfig().SlotsPerEpoch).Mul(committeeCountPerSlot)))
-	if err != nil {
-		return nil, err
-	}
+	indexOffSet := uint64(index) + uint64(slot.ModSlot(params.BeaconConfig().SlotsPerEpoch).Mul(committeeCountPerSlot))
 	start, end := startEndIndices(item, indexOffSet)

 	if end > uint64(len(item.ShuffledIndices)) || end < start {
@@ -112,10 +107,9 @@ func (c *CommitteeCache) AddCommitteeShuffledList(committees *Committees) error
 }

 // ActiveIndices returns the active indices of a given seed stored in cache.
-func (c *CommitteeCache) ActiveIndices(ctx context.Context, seed [32]byte) ([]types.ValidatorIndex, error) {
-	if err := c.checkInProgress(ctx, seed); err != nil {
-		return nil, err
-	}
+func (c *CommitteeCache) ActiveIndices(seed [32]byte) ([]types.ValidatorIndex, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
 	obj, exists := c.CommitteeCache.Get(key(seed))

 	if exists {
@@ -134,11 +128,9 @@ func (c *CommitteeCache) ActiveIndices(ctx context.Context, seed [32]byte) ([]ty
 }

 // ActiveIndicesCount returns the active indices count of a given seed stored in cache.
-func (c *CommitteeCache) ActiveIndicesCount(ctx context.Context, seed [32]byte) (int, error) {
-	if err := c.checkInProgress(ctx, seed); err != nil {
-		return 0, err
-	}
-
+func (c *CommitteeCache) ActiveIndicesCount(seed [32]byte) (int, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
 	obj, exists := c.CommitteeCache.Get(key(seed))
 	if exists {
 		CommitteeCacheHit.Inc()
@@ -161,65 +153,17 @@ func (c *CommitteeCache) HasEntry(seed string) bool {
 	return ok
 }

-// MarkInProgress a request so that any other similar requests will block on
-// Get until MarkNotInProgress is called.
-func (c *CommitteeCache) MarkInProgress(seed [32]byte) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	s := key(seed)
-	if c.inProgress[s] {
-		return ErrAlreadyInProgress
-	}
-	c.inProgress[s] = true
-	return nil
-}
-
-// MarkNotInProgress will release the lock on a given request. This should be
-// called after put.
-func (c *CommitteeCache) MarkNotInProgress(seed [32]byte) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	s := key(seed)
-	delete(c.inProgress, s)
-	return nil
-}
-
 func startEndIndices(c *Committees, index uint64) (uint64, uint64) {
 	validatorCount := uint64(len(c.ShuffledIndices))
-	start := slice.SplitOffset(validatorCount, c.CommitteeCount, index)
-	end := slice.SplitOffset(validatorCount, c.CommitteeCount, index+1)
+	start := sliceutil.SplitOffset(validatorCount, c.CommitteeCount, index)
+	end := sliceutil.SplitOffset(validatorCount, c.CommitteeCount, index+1)
 	return start, end
 }

 // Using seed as source for key to handle reorgs in the same epoch.
 // The seed is derived from state's array of randao mixes and epoch value
 // hashed together. This avoids collisions on different validator set. Spec definition:
-// https://github.com/ethereum/consensus-specs/blob/v0.9.3/specs/core/0_beacon-chain.md#get_seed
+// https://github.com/ethereum/eth2.0-specs/blob/v0.9.3/specs/core/0_beacon-chain.md#get_seed
 func key(seed [32]byte) string {
 	return string(seed[:])
 }
-
-func (c *CommitteeCache) checkInProgress(ctx context.Context, seed [32]byte) error {
-	delay := minDelay
-	// Another identical request may be in progress already. Let's wait until
-	// any in progress request resolves or our timeout is exceeded.
-	for {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-
-		c.lock.RLock()
-		if !c.inProgress[key(seed)] {
-			c.lock.RUnlock()
-			break
-		}
-		c.lock.RUnlock()
-
-		// This increasing backoff is to decrease the CPU cycles while waiting
-		// for the in progress boolean to flip to false.
-		time.Sleep(time.Duration(delay) * time.Nanosecond)
-		delay *= delayFactor
-		delay = math.Min(delay, maxDelay)
-	}
-	return nil
-}
--- a/beacon-chain/cache/committee_disabled.go
+++ b/beacon-chain/cache/committee_disabled.go
@@ -3,11 +3,7 @@
 // This file is used in fuzzer builds to bypass global committee caches.
 package cache

-import (
-	"context"
-
-	types "github.com/prysmaticlabs/eth2-types"
-)
+import types "github.com/prysmaticlabs/eth2-types"

 // FakeCommitteeCache is a struct with 1 queue for looking up shuffled indices list by seed.
 type FakeCommitteeCache struct {
@@ -20,7 +16,7 @@ func NewCommitteesCache() *FakeCommitteeCache {

 // Committee fetches the shuffled indices by slot and committee index. Every list of indices
 // represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.
-func (c *FakeCommitteeCache) Committee(ctx context.Context, slot types.Slot, seed [32]byte, index types.CommitteeIndex) ([]types.ValidatorIndex, error) {
+func (c *FakeCommitteeCache) Committee(slot types.Slot, seed [32]byte, index types.CommitteeIndex) ([]types.ValidatorIndex, error) {
 	return nil, nil
 }

@@ -36,17 +32,12 @@ func (c *FakeCommitteeCache) AddProposerIndicesList(seed [32]byte, indices []typ
 }

 // ActiveIndices returns the active indices of a given seed stored in cache.
-func (c *FakeCommitteeCache) ActiveIndices(ctx context.Context, seed [32]byte) ([]types.ValidatorIndex, error) {
+func (c *FakeCommitteeCache) ActiveIndices(seed [32]byte) ([]types.ValidatorIndex, error) {
 	return nil, nil
 }

 // ActiveIndicesCount returns the active indices count of a given seed stored in cache.
-func (c *FakeCommitteeCache) ActiveIndicesCount(ctx context.Context, seed [32]byte) (int, error) {
-	return 0, nil
-}
-
-// ActiveBalance returns the active balance of a given seed stored in cache.
-func (c *FakeCommitteeCache) ActiveBalance(seed [32]byte) (uint64, error) {
+func (c *FakeCommitteeCache) ActiveIndicesCount(seed [32]byte) (int, error) {
 	return 0, nil
 }

@@ -59,13 +50,3 @@ func (c *FakeCommitteeCache) ProposerIndices(seed [32]byte) ([]types.ValidatorIn
 func (c *FakeCommitteeCache) HasEntry(string) bool {
 	return false
 }
-
-// MarkInProgress is a stub.
-func (c *FakeCommitteeCache) MarkInProgress(seed [32]byte) error {
-	return nil
-}
-
-// MarkNotInProgress is a stub.
-func (c *FakeCommitteeCache) MarkNotInProgress(seed [32]byte) error {
-	return nil
-}
--- a/beacon-chain/cache/committee_fuzz_test.go
+++ b/beacon-chain/cache/committee_fuzz_test.go
@@ -1,12 +1,11 @@
 package cache

 import (
-	"context"
 	"testing"

 	fuzz "github.com/google/gofuzz"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestCommitteeKeyFuzz_OK(t *testing.T) {
@@ -29,7 +28,7 @@ func TestCommitteeCache_FuzzCommitteesByEpoch(t *testing.T) {
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
 		require.NoError(t, cache.AddCommitteeShuffledList(c))
-		_, err := cache.Committee(context.Background(), 0, c.Seed, 0)
+		_, err := cache.Committee(0, c.Seed, 0)
 		require.NoError(t, err)
 	}

@@ -45,7 +44,7 @@ func TestCommitteeCache_FuzzActiveIndices(t *testing.T) {
 		fuzzer.Fuzz(c)
 		require.NoError(t, cache.AddCommitteeShuffledList(c))

-		indices, err := cache.ActiveIndices(context.Background(), c.Seed)
+		indices, err := cache.ActiveIndices(c.Seed)
 		require.NoError(t, err)
 		assert.DeepEqual(t, c.SortedIndices, indices)
 	}
--- a/beacon-chain/cache/committee_test.go
+++ b/beacon-chain/cache/committee_test.go
@@ -1,17 +1,16 @@
 package cache

 import (
-	"context"
 	"math"
 	"sort"
 	"strconv"
 	"testing"

 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestCommitteeKeyFn_OK(t *testing.T) {
@@ -42,7 +41,7 @@ func TestCommitteeCache_CommitteesByEpoch(t *testing.T) {

 	slot := params.BeaconConfig().SlotsPerEpoch
 	committeeIndex := types.CommitteeIndex(1)
-	indices, err := cache.Committee(context.Background(), slot, item.Seed, committeeIndex)
+	indices, err := cache.Committee(slot, item.Seed, committeeIndex)
 	require.NoError(t, err)
 	if indices != nil {
 		t.Error("Expected committee not to exist in empty cache")
@@ -50,7 +49,7 @@ func TestCommitteeCache_CommitteesByEpoch(t *testing.T) {
 	require.NoError(t, cache.AddCommitteeShuffledList(item))

 	wantedIndex := types.CommitteeIndex(0)
-	indices, err = cache.Committee(context.Background(), slot, item.Seed, wantedIndex)
+	indices, err = cache.Committee(slot, item.Seed, wantedIndex)
 	require.NoError(t, err)

 	start, end := startEndIndices(item, uint64(wantedIndex))
@@ -61,7 +60,7 @@ func TestCommitteeCache_ActiveIndices(t *testing.T) {
 	cache := NewCommitteesCache()

 	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []types.ValidatorIndex{1, 2, 3, 4, 5, 6}}
-	indices, err := cache.ActiveIndices(context.Background(), item.Seed)
+	indices, err := cache.ActiveIndices(item.Seed)
 	require.NoError(t, err)
 	if indices != nil {
 		t.Error("Expected committee not to exist in empty cache")
@@ -69,7 +68,7 @@ func TestCommitteeCache_ActiveIndices(t *testing.T) {

 	require.NoError(t, cache.AddCommitteeShuffledList(item))

-	indices, err = cache.ActiveIndices(context.Background(), item.Seed)
+	indices, err = cache.ActiveIndices(item.Seed)
 	require.NoError(t, err)
 	assert.DeepEqual(t, item.SortedIndices, indices)
 }
@@ -78,13 +77,13 @@ func TestCommitteeCache_ActiveCount(t *testing.T) {
 	cache := NewCommitteesCache()

 	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []types.ValidatorIndex{1, 2, 3, 4, 5, 6}}
-	count, err := cache.ActiveIndicesCount(context.Background(), item.Seed)
+	count, err := cache.ActiveIndicesCount(item.Seed)
 	require.NoError(t, err)
 	assert.Equal(t, 0, count, "Expected active count not to exist in empty cache")

 	require.NoError(t, cache.AddCommitteeShuffledList(item))

-	count, err = cache.ActiveIndicesCount(context.Background(), item.Seed)
+	count, err = cache.ActiveIndicesCount(item.Seed)
 	require.NoError(t, err)
 	assert.Equal(t, len(item.SortedIndices), count)
 }
@@ -128,6 +127,6 @@ func TestCommitteeCacheOutOfRange(t *testing.T) {
 	assert.NoError(t, err)
 	_ = cache.CommitteeCache.Add(key, comms)

-	_, err = cache.Committee(context.Background(), 0, seed, math.MaxUint64) // Overflow!
+	_, err = cache.Committee(0, seed, math.MaxUint64) // Overflow!
 	require.NotNil(t, err, "Did not fail as expected")
 }
--- a/beacon-chain/cache/common.go
+++ b/beacon-chain/cache/common.go
@@ -1,7 +1,7 @@
 package cache

 import (
-	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/shared/params"
 	"k8s.io/client-go/tools/cache"
 )

--- a/beacon-chain/cache/depositcache/BUILD.bazel
+++ b/beacon-chain/cache/depositcache/BUILD.bazel
@@ -10,11 +10,12 @@ go_library(
    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache",
    visibility = ["//beacon-chain:__subpackages__"],
    deps = [
-        "//config/params:go_default_library",
-        "//container/trie:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/beacon/db:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/hashutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/trieutil:go_default_library",
        "@com_github_pkg_errors//:go_default_library",
        "@com_github_prometheus_client_golang//prometheus:go_default_library",
        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
@@ -31,12 +32,13 @@ go_test(
    ],
    embed = [":go_default_library"],
    deps = [
-        "//config/params:go_default_library",
-        "//container/trie:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
+        "//proto/beacon/db:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
+        "//shared/trieutil:go_default_library",
        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
        "@org_golang_google_protobuf//proto:go_default_library",
    ],
--- a/beacon-chain/cache/depositcache/deposits_cache.go
+++ b/beacon-chain/cache/depositcache/deposits_cache.go
@@ -15,11 +15,11 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/container/trie"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/trieutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -43,7 +43,7 @@ type DepositFetcher interface {
 // FinalizedDeposits stores the trie of deposits that have been included
 // in the beacon state up to the latest finalized checkpoint.
 type FinalizedDeposits struct {
-	Deposits        *trie.SparseMerkleTrie
+	Deposits        *trieutil.SparseMerkleTrie
 	MerkleTrieIndex int64
 }

@@ -59,7 +59,7 @@ type DepositCache struct {

 // New instantiates a new deposit cache
 func New() (*DepositCache, error) {
-	finalizedDepositsTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
+	finalizedDepositsTrie, err := trieutil.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
 	if err != nil {
 		return nil, err
 	}
@@ -136,10 +136,7 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
 			log.WithError(err).Error("Could not hash deposit data. Finalized deposit cache not updated.")
 			return
 		}
-		if err = depositTrie.Insert(depHash[:], insertIndex); err != nil {
-			log.WithError(err).Error("Could not insert deposit hash")
-			return
-		}
+		depositTrie.Insert(depHash[:], insertIndex)
 		insertIndex++
 	}

--- a/beacon-chain/cache/depositcache/deposits_cache_test.go
+++ b/beacon-chain/cache/depositcache/deposits_cache_test.go
@@ -7,13 +7,13 @@ import (
 	"math/big"
 	"testing"

-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/container/trie"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/shared/trieutil"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )

@@ -429,7 +429,7 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 		require.NoError(t, err, "Could not hash deposit data")
 		deps = append(deps, hash[:])
 	}
-	trie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
+	trie, err := trieutil.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate deposit trie")
 	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
 }
@@ -487,7 +487,7 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 		require.NoError(t, err, "Could not hash deposit data")
 		deps = append(deps, hash[:])
 	}
-	trie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
+	trie, err := trieutil.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate deposit trie")
 	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
 }
--- a/beacon-chain/cache/depositcache/pending_deposits.go
+++ b/beacon-chain/cache/depositcache/pending_deposits.go
@@ -7,9 +7,9 @@ import (

 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/crypto/hash"
-	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/hashutil"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -99,7 +99,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 		return
 	}

-	depRoot, err := hash.HashProto(d)
+	depRoot, err := hashutil.HashProto(d)
 	if err != nil {
 		log.Errorf("Could not remove deposit %v", err)
 		return
@@ -110,7 +110,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos

 	idx := -1
 	for i, ctnr := range dc.pendingDeposits {
-		hash, err := hash.HashProto(ctnr.Deposit)
+		hash, err := hashutil.HashProto(ctnr.Deposit)
 		if err != nil {
 			log.Errorf("Could not hash deposit %v", err)
 			continue
--- a/beacon-chain/cache/depositcache/pending_deposits_test.go
+++ b/beacon-chain/cache/depositcache/pending_deposits_test.go
@@ -5,10 +5,10 @@ import (
 	"math/big"
 	"testing"

-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
+	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"google.golang.org/protobuf/proto"
 )

--- a/beacon-chain/cache/error.go
+++ b/beacon-chain/cache/error.go
@@ -1,15 +0,0 @@
-package cache
-
-import "errors"
-
-var (
-	// ErrNilValueProvided for when we try to put a nil value in a cache.
-	ErrNilValueProvided = errors.New("nil value provided on Put()")
-	// ErrIncorrectType for when the state is of the incorrect type.
-	ErrIncorrectType = errors.New("incorrect state type provided")
-	// ErrNotFound for cache fetches that return a nil value.
-	ErrNotFound = errors.New("not found in cache")
-	// ErrNonExistingSyncCommitteeKey when sync committee key (root) does not exist in cache.
-	ErrNonExistingSyncCommitteeKey   = errors.New("does not exist sync committee key")
-	errNotSyncCommitteeIndexPosition = errors.New("not syncCommitteeIndexPosition struct")
-)
--- a/beacon-chain/cache/proposer_indices_test.go
+++ b/beacon-chain/cache/proposer_indices_test.go
@@ -5,9 +5,9 @@ import (
 	"testing"

 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestProposerKeyFn_OK(t *testing.T) {
--- a/beacon-chain/cache/skip_slot_cache.go
+++ b/beacon-chain/cache/skip_slot_cache.go
@@ -9,8 +9,7 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
 	"go.opencensus.io/trace"
 )

@@ -26,7 +25,7 @@ var (
 	})
 )

-// SkipSlotCache is used to store the cached results of processing skip slots in transition.ProcessSlots.
+// SkipSlotCache is used to store the cached results of processing skip slots in state.ProcessSlots.
 type SkipSlotCache struct {
 	cache      *lru.Cache
 	lock       sync.RWMutex
@@ -36,8 +35,12 @@ type SkipSlotCache struct {

 // NewSkipSlotCache initializes the map and underlying cache.
 func NewSkipSlotCache() *SkipSlotCache {
+	cache, err := lru.New(8)
+	if err != nil {
+		panic(err)
+	}
 	return &SkipSlotCache{
-		cache:      lruwrpr.New(8),
+		cache:      cache,
 		inProgress: make(map[[32]byte]bool),
 	}
 }
@@ -54,7 +57,7 @@ func (c *SkipSlotCache) Disable() {

 // Get waits for any in progress calculation to complete before returning a
 // cached response, if any.
-func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (state.BeaconState, error) {
+func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (iface.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "skipSlotCache.Get")
 	defer span.End()
 	if c.disabled {
@@ -94,7 +97,7 @@ func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (state.BeaconState,
 	if exists && item != nil {
 		skipSlotCacheHit.Inc()
 		span.AddAttributes(trace.BoolAttribute("hit", true))
-		return item.(state.BeaconState).Copy(), nil
+		return item.(iface.BeaconState).Copy(), nil
 	}
 	skipSlotCacheMiss.Inc()
 	span.AddAttributes(trace.BoolAttribute("hit", false))
@@ -133,7 +136,7 @@ func (c *SkipSlotCache) MarkNotInProgress(r [32]byte) error {
 }

 // Put the response in the cache.
-func (c *SkipSlotCache) Put(_ context.Context, r [32]byte, state state.BeaconState) error {
+func (c *SkipSlotCache) Put(_ context.Context, r [32]byte, state iface.BeaconState) error {
 	if c.disabled {
 		return nil
 	}
--- a/beacon-chain/cache/skip_slot_cache_test.go
+++ b/beacon-chain/cache/skip_slot_cache_test.go
@@ -5,11 +5,11 @@ import (
 	"testing"

 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestSkipSlotCache_RoundTrip(t *testing.T) {
@@ -17,21 +17,21 @@ func TestSkipSlotCache_RoundTrip(t *testing.T) {
 	c := cache.NewSkipSlotCache()

 	r := [32]byte{'a'}
-	s, err := c.Get(ctx, r)
+	state, err := c.Get(ctx, r)
 	require.NoError(t, err)
-	assert.Equal(t, state.BeaconState(nil), s, "Empty cache returned an object")
+	assert.Equal(t, iface.BeaconState(nil), state, "Empty cache returned an object")

 	require.NoError(t, c.MarkInProgress(r))

-	s, err = v1.InitializeFromProto(&ethpb.BeaconState{
+	state, err = v1.InitializeFromProto(&pb.BeaconState{
 		Slot: 10,
 	})
 	require.NoError(t, err)

-	require.NoError(t, c.Put(ctx, r, s))
+	require.NoError(t, c.Put(ctx, r, state))
 	require.NoError(t, c.MarkNotInProgress(r))

 	res, err := c.Get(ctx, r)
 	require.NoError(t, err)
-	assert.DeepEqual(t, res.CloneInnerState(), s.CloneInnerState(), "Expected equal protos to return from cache")
+	assert.DeepEqual(t, res.CloneInnerState(), state.CloneInnerState(), "Expected equal protos to return from cache")
 }
--- a/beacon-chain/cache/subnet_ids.go
+++ b/beacon-chain/cache/subnet_ids.go
@@ -7,9 +7,8 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/patrickmn/go-cache"
 	types "github.com/prysmaticlabs/eth2-types"
-	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/container/slice"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 )

 type subnetIDs struct {
@@ -28,8 +27,14 @@ func newSubnetIDs() *subnetIDs {
 	// Given a node can calculate committee assignments of current epoch and next epoch.
 	// Max size is set to 2 epoch length.
 	cacheSize := int(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().MaxCommitteesPerSlot * 2))
-	attesterCache := lruwrpr.New(cacheSize)
-	aggregatorCache := lruwrpr.New(cacheSize)
+	attesterCache, err := lru.New(cacheSize)
+	if err != nil {
+		panic(err)
+	}
+	aggregatorCache, err := lru.New(cacheSize)
+	if err != nil {
+		panic(err)
+	}
 	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	subLength := epochDuration * time.Duration(params.BeaconConfig().EpochsPerRandomSubnetSubscription)
 	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
@@ -44,7 +49,7 @@ func (s *subnetIDs) AddAttesterSubnetID(slot types.Slot, subnetID uint64) {
 	ids := []uint64{subnetID}
 	val, exists := s.attester.Get(slot)
 	if exists {
-		ids = slice.UnionUint64(append(val.([]uint64), ids...))
+		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
 	}
 	s.attester.Add(slot, ids)
 }
@@ -72,7 +77,7 @@ func (s *subnetIDs) AddAggregatorSubnetID(slot types.Slot, subnetID uint64) {
 	ids := []uint64{subnetID}
 	val, exists := s.aggregator.Get(slot)
 	if exists {
-		ids = slice.UnionUint64(append(val.([]uint64), ids...))
+		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
 	}
 	s.aggregator.Add(slot, ids)
 }
@@ -117,7 +122,7 @@ func (s *subnetIDs) GetAllSubnets() []uint64 {
 		}
 		committees = append(committees, v.Object.([]uint64)...)
 	}
-	return slice.SetUint64(committees)
+	return sliceutil.SetUint64(committees)
 }

 // AddPersistentCommittee adds the relevant committee for that particular validator along with its
--- a/beacon-chain/cache/subnet_ids_test.go
+++ b/beacon-chain/cache/subnet_ids_test.go
@@ -4,8 +4,8 @@ import (
 	"testing"

 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestSubnetIDsCache_RoundTrip(t *testing.T) {
--- a/beacon-chain/cache/sync_committee.go
+++ b/beacon-chain/cache/sync_committee.go
@@ -1,187 +0,0 @@
-// +build !libfuzzer
-
-package cache
-
-import (
-	"sync"
-
-	"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/state"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"k8s.io/client-go/tools/cache"
-)
-
-var (
-	maxSyncCommitteeSize = uint64(3) // Allows 3 forks to happen around `EPOCHS_PER_SYNC_COMMITTEE_PERIOD` boundary.
-
-	// SyncCommitteeCacheMiss tracks the number of committee requests that aren't present in the cache.
-	SyncCommitteeCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "sync_committee_index_cache_miss_total",
-		Help: "The number of committee requests that aren't present in the sync committee index cache.",
-	})
-	// SyncCommitteeCacheHit tracks the number of committee requests that are in the cache.
-	SyncCommitteeCacheHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "sync_committee_index_cache_hit_total",
-		Help: "The number of committee requests that are present in the sync committee index cache.",
-	})
-)
-
-// SyncCommitteeCache utilizes a FIFO cache to sufficiently cache validator position within sync committee.
-// It is thread safe with concurrent read write.
-type SyncCommitteeCache struct {
-	cache *cache.FIFO
-	lock  sync.RWMutex
-}
-
-// Index position of all validators in sync committee where `currentSyncCommitteeRoot` is the
-// key and `vIndexToPositionMap` is value. Inside `vIndexToPositionMap`, validator positions
-// are cached where key is the validator index and the value is the `positionInCommittee` struct.
-type syncCommitteeIndexPosition struct {
-	currentSyncCommitteeRoot [32]byte
-	vIndexToPositionMap      map[types.ValidatorIndex]*positionInCommittee
-}
-
-// Index position of individual validator of current period and next period sync committee.
-type positionInCommittee struct {
-	currentPeriod []types.CommitteeIndex
-	nextPeriod    []types.CommitteeIndex
-}
-
-// NewSyncCommittee initializes and returns a new SyncCommitteeCache.
-func NewSyncCommittee() *SyncCommitteeCache {
-	return &SyncCommitteeCache{
-		cache: cache.NewFIFO(keyFn),
-	}
-}
-
-// CurrentPeriodIndexPosition returns current period index position of a validator index with respect with
-// sync committee. If the input validator index has no assignment, an empty list will be returned.
-// If the input root does not exist in cache, `ErrNonExistingSyncCommitteeKey` is returned.
-// Manual checking of state for index position in state is recommended when `ErrNonExistingSyncCommitteeKey` is returned.
-func (s *SyncCommitteeCache) CurrentPeriodIndexPosition(root [32]byte, valIdx types.ValidatorIndex) ([]types.CommitteeIndex, error) {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	pos, err := s.idxPositionInCommittee(root, valIdx)
-	if err != nil {
-		return nil, err
-	}
-	if pos == nil {
-		return []types.CommitteeIndex{}, nil
-	}
-
-	return pos.currentPeriod, nil
-}
-
-// NextPeriodIndexPosition returns next period index position of a validator index in respect with sync committee.
-// If the input validator index has no assignment, an empty list will be returned.
-// If the input root does not exist in cache, `ErrNonExistingSyncCommitteeKey` is returned.
-// Manual checking of state for index position in state is recommended when `ErrNonExistingSyncCommitteeKey` is returned.
-func (s *SyncCommitteeCache) NextPeriodIndexPosition(root [32]byte, valIdx types.ValidatorIndex) ([]types.CommitteeIndex, error) {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	pos, err := s.idxPositionInCommittee(root, valIdx)
-	if err != nil {
-		return nil, err
-	}
-	if pos == nil {
-		return []types.CommitteeIndex{}, nil
-	}
-	return pos.nextPeriod, nil
-}
-
-// Helper function for `CurrentPeriodIndexPosition` and `NextPeriodIndexPosition` to return a mapping
-// of validator index to its index(s) position in the sync committee.
-func (s *SyncCommitteeCache) idxPositionInCommittee(
-	root [32]byte, valIdx types.ValidatorIndex,
-) (*positionInCommittee, error) {
-	obj, exists, err := s.cache.GetByKey(key(root))
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		SyncCommitteeCacheMiss.Inc()
-		return nil, ErrNonExistingSyncCommitteeKey
-	}
-	item, ok := obj.(*syncCommitteeIndexPosition)
-	if !ok {
-		return nil, errNotSyncCommitteeIndexPosition
-	}
-	idxInCommittee, ok := item.vIndexToPositionMap[valIdx]
-	if !ok {
-		SyncCommitteeCacheMiss.Inc()
-		return nil, nil
-	}
-	SyncCommitteeCacheHit.Inc()
-	return idxInCommittee, nil
-}
-
-// UpdatePositionsInCommittee updates caching of validators position in sync committee in respect to
-// current epoch and next epoch. This should be called when `current_sync_committee` and `next_sync_committee`
-// change and that happens every `EPOCHS_PER_SYNC_COMMITTEE_PERIOD`.
-func (s *SyncCommitteeCache) UpdatePositionsInCommittee(syncCommitteeBoundaryRoot [32]byte, st state.BeaconStateAltair) error {
-	csc, err := st.CurrentSyncCommittee()
-	if err != nil {
-		return err
-	}
-	positionsMap := make(map[types.ValidatorIndex]*positionInCommittee)
-	for i, pubkey := range csc.Pubkeys {
-		p := bytesutil.ToBytes48(pubkey)
-		validatorIndex, ok := st.ValidatorIndexByPubkey(p)
-		if !ok {
-			continue
-		}
-		if _, ok := positionsMap[validatorIndex]; !ok {
-			m := &positionInCommittee{currentPeriod: []types.CommitteeIndex{types.CommitteeIndex(i)}, nextPeriod: []types.CommitteeIndex{}}
-			positionsMap[validatorIndex] = m
-		} else {
-			positionsMap[validatorIndex].currentPeriod = append(positionsMap[validatorIndex].currentPeriod, types.CommitteeIndex(i))
-		}
-	}
-
-	nsc, err := st.NextSyncCommittee()
-	if err != nil {
-		return err
-	}
-	for i, pubkey := range nsc.Pubkeys {
-		p := bytesutil.ToBytes48(pubkey)
-		validatorIndex, ok := st.ValidatorIndexByPubkey(p)
-		if !ok {
-			continue
-		}
-		if _, ok := positionsMap[validatorIndex]; !ok {
-			m := &positionInCommittee{nextPeriod: []types.CommitteeIndex{types.CommitteeIndex(i)}, currentPeriod: []types.CommitteeIndex{}}
-			positionsMap[validatorIndex] = m
-		} else {
-			positionsMap[validatorIndex].nextPeriod = append(positionsMap[validatorIndex].nextPeriod, types.CommitteeIndex(i))
-		}
-	}
-
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if err := s.cache.Add(&syncCommitteeIndexPosition{
-		currentSyncCommitteeRoot: syncCommitteeBoundaryRoot,
-		vIndexToPositionMap:      positionsMap,
-	}); err != nil {
-		return err
-	}
-	trim(s.cache, maxSyncCommitteeSize)
-
-	return nil
-}
-
-// Given the `syncCommitteeIndexPosition` object, this returns the key of the object.
-// The key is the `currentSyncCommitteeRoot` within the field.
-// Error gets returned if input does not comply with `currentSyncCommitteeRoot` object.
-func keyFn(obj interface{}) (string, error) {
-	info, ok := obj.(*syncCommitteeIndexPosition)
-	if !ok {
-		return "", errNotSyncCommitteeIndexPosition
-	}
-
-	return string(info.currentSyncCommitteeRoot[:]), nil
-}
--- a/beacon-chain/cache/sync_committee_disabled.go
+++ b/beacon-chain/cache/sync_committee_disabled.go
@@ -1,32 +0,0 @@
-// +build libfuzzer
-
-package cache
-
-import (
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-)
-
-// FakeSyncCommitteeCache is a fake `SyncCommitteeCache` to satisfy fuzzing.
-type FakeSyncCommitteeCache struct {
-}
-
-// NewSyncCommittee initializes and returns a new SyncCommitteeCache.
-func NewSyncCommittee() *FakeSyncCommitteeCache {
-	return &FakeSyncCommitteeCache{}
-}
-
-// CurrentEpochIndexPosition -- fake.
-func (s *FakeSyncCommitteeCache) CurrentPeriodIndexPosition(root [32]byte, valIdx types.ValidatorIndex) ([]types.CommitteeIndex, error) {
-	return nil, nil
-}
-
-// NextEpochIndexPosition -- fake.
-func (s *FakeSyncCommitteeCache) NextPeriodIndexPosition(root [32]byte, valIdx types.ValidatorIndex) ([]types.CommitteeIndex, error) {
-	return nil, nil
-}
-
-// UpdatePositionsInCommittee -- fake.
-func (s *FakeSyncCommitteeCache) UpdatePositionsInCommittee(syncCommitteeBoundaryRoot [32]byte, state state.BeaconStateAltair) error {
-	return nil
-}
--- a/beacon-chain/cache/sync_committee_head_state.go
+++ b/beacon-chain/cache/sync_committee_head_state.go
@@ -1,55 +0,0 @@
-package cache
-
-import (
-	"sync"
-
-	lru "github.com/hashicorp/golang-lru"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
-)
-
-// SyncCommitteeHeadStateCache for the latest head state requested by a sync committee participant.
-type SyncCommitteeHeadStateCache struct {
-	cache *lru.Cache
-	lock  sync.RWMutex
-}
-
-// NewSyncCommitteeHeadState initializes a LRU cache for `SyncCommitteeHeadState` with size of 1.
-func NewSyncCommitteeHeadState() *SyncCommitteeHeadStateCache {
-	c := lruwrpr.New(1) // only need size of 1 to avoid redundant state copies, hashing, and slot processing.
-	return &SyncCommitteeHeadStateCache{cache: c}
-}
-
-// Put `slot` as key and `state` as value onto the cache.
-func (c *SyncCommitteeHeadStateCache) Put(slot types.Slot, st state.BeaconState) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	// Make sure that the provided state is non nil
-	// and is of the correct type.
-	if st == nil || st.IsNil() {
-		return ErrNilValueProvided
-	}
-	_, ok := st.(*stateAltair.BeaconState)
-	if !ok {
-		return ErrIncorrectType
-	}
-	c.cache.Add(slot, st)
-	return nil
-}
-
-// Get `state` using `slot` as key. Return nil if nothing is found.
-func (c *SyncCommitteeHeadStateCache) Get(slot types.Slot) (state.BeaconState, error) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	val, exists := c.cache.Get(slot)
-	if !exists {
-		return nil, ErrNotFound
-	}
-	st, ok := val.(*stateAltair.BeaconState)
-	if !ok {
-		return nil, ErrIncorrectType
-	}
-	return st, nil
-}
--- a/beacon-chain/cache/sync_committee_head_state_test.go
+++ b/beacon-chain/cache/sync_committee_head_state_test.go
@@ -1,102 +0,0 @@
-package cache
-
-import (
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestSyncCommitteeHeadState(t *testing.T) {
-	beaconState, err := v2.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	phase0State, err := v1.InitializeFromProto(&ethpb.BeaconState{
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	type put struct {
-		slot  types.Slot
-		state state.BeaconState
-	}
-	tests := []struct {
-		name       string
-		key        types.Slot
-		put        *put
-		want       state.BeaconState
-		wantErr    bool
-		wantPutErr bool
-	}{
-		{
-			name: "putting error in",
-			key:  types.Slot(1),
-			put: &put{
-				slot:  types.Slot(1),
-				state: nil,
-			},
-			wantPutErr: true,
-			wantErr:    true,
-		},
-		{
-			name: "putting invalid state in",
-			key:  types.Slot(1),
-			put: &put{
-				slot:  types.Slot(1),
-				state: phase0State,
-			},
-			wantPutErr: true,
-			wantErr:    true,
-		},
-		{
-			name:    "not found when empty cache",
-			key:     types.Slot(1),
-			wantErr: true,
-		},
-		{
-			name: "not found when non-existent key in non-empty cache",
-			key:  types.Slot(2),
-			put: &put{
-				slot:  types.Slot(1),
-				state: beaconState,
-			},
-			wantErr: true,
-		},
-		{
-			name: "found with key",
-			key:  types.Slot(1),
-			put: &put{
-				slot:  types.Slot(1),
-				state: beaconState,
-			},
-			want: beaconState,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			c := NewSyncCommitteeHeadState()
-			if tt.put != nil {
-				err := c.Put(tt.put.slot, tt.put.state)
-				if (err != nil) != tt.wantPutErr {
-					t.Fatalf("Put() error = %v, wantErr %v", err, tt.wantErr)
-				}
-			}
-			got, err := c.Get(tt.key)
-			if (err != nil) != tt.wantErr {
-				t.Fatalf("Get() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			require.DeepEqual(t, tt.want, got)
-		})
-	}
-}
--- a/beacon-chain/cache/sync_committee_test.go
+++ b/beacon-chain/cache/sync_committee_test.go
@@ -1,222 +0,0 @@
-package cache_test
-
-import (
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
-	numValidators := 101
-	deterministicState, _ := util.DeterministicGenesisStateAltair(t, uint64(numValidators))
-	pubKeys := make([][]byte, deterministicState.NumValidators())
-	for i, val := range deterministicState.Validators() {
-		pubKeys[i] = val.PublicKey
-	}
-	tests := []struct {
-		name                 string
-		currentSyncCommittee *ethpb.SyncCommittee
-		nextSyncCommittee    *ethpb.SyncCommittee
-		currentSyncMap       map[types.ValidatorIndex][]types.CommitteeIndex
-		nextSyncMap          map[types.ValidatorIndex][]types.CommitteeIndex
-	}{
-		{
-			name: "only current epoch",
-			currentSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[1], pubKeys[2], pubKeys[3], pubKeys[2], pubKeys[2],
-			}),
-			nextSyncCommittee: convertToCommittee([][]byte{}),
-			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {0},
-				2: {1, 3, 4},
-				3: {2},
-			},
-			nextSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {},
-				2: {},
-				3: {},
-			},
-		},
-		{
-			name:                 "only next epoch",
-			currentSyncCommittee: convertToCommittee([][]byte{}),
-			nextSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[1], pubKeys[2], pubKeys[3], pubKeys[2], pubKeys[2],
-			}),
-			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {},
-				2: {},
-				3: {},
-			},
-			nextSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {0},
-				2: {1, 3, 4},
-				3: {2},
-			},
-		},
-		{
-			name: "some current epoch and some next epoch",
-			currentSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[1],
-				pubKeys[2],
-				pubKeys[3],
-				pubKeys[2],
-				pubKeys[2],
-			}),
-			nextSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[7],
-				pubKeys[6],
-				pubKeys[5],
-				pubKeys[4],
-				pubKeys[7],
-			}),
-			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {0},
-				2: {1, 3, 4},
-				3: {2},
-			},
-			nextSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				7: {0, 4},
-				6: {1},
-				5: {2},
-				4: {3},
-			},
-		},
-		{
-			name: "some current epoch and some next epoch duplicated across",
-			currentSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[1],
-				pubKeys[2],
-				pubKeys[3],
-				pubKeys[2],
-				pubKeys[2],
-			}),
-			nextSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[2],
-				pubKeys[1],
-				pubKeys[3],
-				pubKeys[2],
-				pubKeys[1],
-			}),
-			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {0},
-				2: {1, 3, 4},
-				3: {2},
-			},
-			nextSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {1, 4},
-				2: {0, 3},
-				3: {2},
-			},
-		},
-		{
-			name: "all duplicated",
-			currentSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-			}),
-			nextSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-			}),
-			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				100: {0, 1, 2, 3},
-			},
-			nextSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				100: {0, 1, 2, 3},
-			},
-		},
-		{
-			name: "unknown keys",
-			currentSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-			}),
-			nextSyncCommittee: convertToCommittee([][]byte{
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-				pubKeys[100],
-			}),
-			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {},
-			},
-			nextSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
-				1: {},
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			s, _ := util.DeterministicGenesisStateAltair(t, uint64(numValidators))
-			require.NoError(t, s.SetCurrentSyncCommittee(tt.currentSyncCommittee))
-			require.NoError(t, s.SetNextSyncCommittee(tt.nextSyncCommittee))
-			cache := cache.NewSyncCommittee()
-			r := [32]byte{'a'}
-			require.NoError(t, cache.UpdatePositionsInCommittee(r, s))
-			for key, indices := range tt.currentSyncMap {
-				pos, err := cache.CurrentPeriodIndexPosition(r, key)
-				require.NoError(t, err)
-				require.DeepEqual(t, indices, pos)
-			}
-			for key, indices := range tt.nextSyncMap {
-				pos, err := cache.NextPeriodIndexPosition(r, key)
-				require.NoError(t, err)
-				require.DeepEqual(t, indices, pos)
-			}
-		})
-	}
-}
-
-func TestSyncCommitteeCache_RootDoesNotExist(t *testing.T) {
-	c := cache.NewSyncCommittee()
-	_, err := c.CurrentPeriodIndexPosition([32]byte{}, 0)
-	require.Equal(t, cache.ErrNonExistingSyncCommitteeKey, err)
-}
-
-func TestSyncCommitteeCache_CanRotate(t *testing.T) {
-	c := cache.NewSyncCommittee()
-	s, _ := util.DeterministicGenesisStateAltair(t, 64)
-	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{1}})))
-	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'a'}, s))
-	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{2}})))
-	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'b'}, s))
-	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{3}})))
-	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'c'}, s))
-	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{4}})))
-	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'d'}, s))
-
-	_, err := c.CurrentPeriodIndexPosition([32]byte{'a'}, 0)
-	require.Equal(t, cache.ErrNonExistingSyncCommitteeKey, err)
-
-	_, err = c.CurrentPeriodIndexPosition([32]byte{'c'}, 0)
-	require.NoError(t, err)
-}
-
-func convertToCommittee(inputKeys [][]byte) *ethpb.SyncCommittee {
-	var pubKeys [][]byte
-	for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSize; i++ {
-		if i < uint64(len(inputKeys)) {
-			pubKeys = append(pubKeys, bytesutil.PadTo(inputKeys[i], params.BeaconConfig().BLSPubkeyLength))
-		} else {
-			pubKeys = append(pubKeys, bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength))
-		}
-	}
-
-	return &ethpb.SyncCommittee{
-		Pubkeys:         pubKeys,
-		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
-	}
-}
--- a/beacon-chain/cache/sync_subnet_ids.go
+++ b/beacon-chain/cache/sync_subnet_ids.go
@@ -1,131 +0,0 @@
-package cache
-
-import (
-	"sync"
-	"time"
-
-	"github.com/patrickmn/go-cache"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/container/slice"
-	"github.com/prysmaticlabs/prysm/crypto/rand"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-)
-
-type syncSubnetIDs struct {
-	sCommittee    *cache.Cache
-	sCommiteeLock sync.RWMutex
-}
-
-// SyncSubnetIDs for sync committee participant.
-var SyncSubnetIDs = newSyncSubnetIDs()
-
-func newSyncSubnetIDs() *syncSubnetIDs {
-	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
-	// Set the default duration of a sync subnet index as the whole sync committee period.
-	subLength := epochDuration * time.Duration(params.BeaconConfig().EpochsPerSyncCommitteePeriod)
-	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
-	return &syncSubnetIDs{sCommittee: persistentCache}
-}
-
-// GetSyncCommitteeSubnets retrieves the sync committee subnet and expiration time of that validator's subscription.
-func (s *syncSubnetIDs) GetSyncCommitteeSubnets(pubkey []byte, epoch types.Epoch) ([]uint64, types.Epoch, bool, time.Time) {
-	s.sCommiteeLock.RLock()
-	defer s.sCommiteeLock.RUnlock()
-
-	id, duration, ok := s.sCommittee.GetWithExpiration(keyBuilder(pubkey, epoch))
-	if !ok {
-		return []uint64{}, 0, ok, time.Time{}
-	}
-	// Retrieve indices from the cache.
-	idxs, ok := id.([]uint64)
-	if !ok {
-		return []uint64{}, 0, ok, time.Time{}
-	}
-	// If no committees are saved, we return nothing.
-	if len(idxs) <= 1 {
-		return []uint64{}, 0, ok, time.Time{}
-	}
-
-	// Index 0 was used to store validator's join epoch. We do not
-	// return it to the caller.
-	// Index 1 and beyond were used to store subnets.
-	return idxs[1:], types.Epoch(idxs[0]), ok, duration
-}
-
-// GetAllSubnets retrieves all the non-expired subscribed subnets of all the validators
-// in the cache. This method also takes the epoch as an argument to only retrieve
-// assignments for epochs that have happened.
-func (s *syncSubnetIDs) GetAllSubnets(currEpoch types.Epoch) []uint64 {
-	s.sCommiteeLock.RLock()
-	defer s.sCommiteeLock.RUnlock()
-
-	itemsMap := s.sCommittee.Items()
-	var committees []uint64
-
-	for _, v := range itemsMap {
-		if v.Expired() {
-			continue
-		}
-		idxs, ok := v.Object.([]uint64)
-		if !ok {
-			continue
-		}
-		// We skip if we do not have a join
-		// epoch or any relevant committee indices.
-		if len(idxs) <= 1 {
-			continue
-		}
-		// Check if the subnet is valid in the current epoch. If our
-		// join epoch is still in the future we skip retrieving the
-		// relevant committee index.
-		if types.Epoch(idxs[0]) > currEpoch {
-			continue
-		}
-		// Ignore the first index as that represents the
-		// epoch of the validator's assignments.
-		committees = append(committees, idxs[1:]...)
-	}
-	return slice.SetUint64(committees)
-}
-
-// AddSyncCommitteeSubnets adds the relevant committee for that particular validator along with its
-// expiration period. An Epoch argument here denotes the epoch from which the sync committee subnets
-// will be active.
-func (s *syncSubnetIDs) AddSyncCommitteeSubnets(pubkey []byte, epoch types.Epoch, comIndex []uint64, duration time.Duration) {
-	s.sCommiteeLock.Lock()
-	defer s.sCommiteeLock.Unlock()
-	subComCount := params.BeaconConfig().SyncCommitteeSubnetCount
-	// To join a sync committee subnet, select a random number of epochs before the end of the
-	// current sync committee period between 1 and SYNC_COMMITTEE_SUBNET_COUNT, inclusive.
-	// This is to smoothing out the join and exiting of the subnets so not everyone surging at the same time.
-	diff := (rand.NewGenerator().Uint64() % subComCount) + 1
-	joinEpoch, err := epoch.SafeSub(diff)
-	if err != nil {
-		// If we underflow here, we simply set the value to join
-		// at 0.
-		joinEpoch = 0
-	}
-	// Append the epoch of the subnet into the first index here. The join epoch is a special
-	// value, it is the epoch at which a node is supposed to join the relevant subnets.
-	s.sCommittee.Set(keyBuilder(pubkey, epoch), append([]uint64{uint64(joinEpoch)}, comIndex...), duration)
-}
-
-// EmptyAllCaches empties out all the related caches and flushes any stored
-// entries on them. This should only ever be used for testing, in normal
-// production, handling of the relevant subnets for each role is done
-// separately.
-func (s *syncSubnetIDs) EmptyAllCaches() {
-	// Clear the cache.
-
-	s.sCommiteeLock.Lock()
-	s.sCommittee.Flush()
-	s.sCommiteeLock.Unlock()
-}
-
-// build a key composed of both the pubkey and epoch here. The epoch
-// here would be the 1st epoch of the sync committee period.
-func keyBuilder(pubkey []byte, epoch types.Epoch) string {
-	epochBytes := bytesutil.Bytes8(uint64(epoch))
-	return string(append(pubkey, epochBytes...))
-}
--- a/beacon-chain/cache/sync_subnet_ids_test.go
+++ b/beacon-chain/cache/sync_subnet_ids_test.go
@@ -1,57 +0,0 @@
-package cache
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestSyncSubnetIDsCache_Roundtrip(t *testing.T) {
-	c := newSyncSubnetIDs()
-
-	for i := 0; i < 20; i++ {
-		pubkey := [48]byte{byte(i)}
-		c.AddSyncCommitteeSubnets(pubkey[:], 100, []uint64{uint64(i)}, 0)
-	}
-
-	for i := uint64(0); i < 20; i++ {
-		pubkey := [48]byte{byte(i)}
-
-		idxs, _, ok, _ := c.GetSyncCommitteeSubnets(pubkey[:], 100)
-		if !ok {
-			t.Errorf("Couldn't find entry in cache for pubkey %#x", pubkey)
-			continue
-		}
-		require.Equal(t, i, idxs[0])
-	}
-	coms := c.GetAllSubnets(100)
-	assert.Equal(t, 20, len(coms))
-}
-
-func TestSyncSubnetIDsCache_ValidateCurrentEpoch(t *testing.T) {
-	c := newSyncSubnetIDs()
-
-	for i := 0; i < 20; i++ {
-		pubkey := [48]byte{byte(i)}
-		c.AddSyncCommitteeSubnets(pubkey[:], 100, []uint64{uint64(i)}, 0)
-	}
-
-	coms := c.GetAllSubnets(50)
-	assert.Equal(t, 0, len(coms))
-
-	for i := uint64(0); i < 20; i++ {
-		pubkey := [48]byte{byte(i)}
-
-		_, jEpoch, ok, _ := c.GetSyncCommitteeSubnets(pubkey[:], 100)
-		if !ok {
-			t.Errorf("Couldn't find entry in cache for pubkey %#x", pubkey)
-			continue
-		}
-		require.Equal(t, true, uint64(jEpoch) >= 100-params.BeaconConfig().SyncCommitteeSubnetCount)
-	}
-
-	coms = c.GetAllSubnets(99)
-	assert.Equal(t, 20, len(coms))
-}
--- a/beacon-chain/core/altair/BUILD.bazel
+++ b/beacon-chain/core/altair/BUILD.bazel
@@ -1,91 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "attestation.go",
-        "block.go",
-        "deposit.go",
-        "epoch_precompute.go",
-        "epoch_spec.go",
-        "reward.go",
-        "sync_committee.go",
-        "transition.go",
-        "upgrade.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/altair",
-    visibility = [
-        "//beacon-chain:__subpackages__",
-        "//testing/spectest:__subpackages__",
-        "//testing/util:__pkg__",
-        "//validator/client:__pkg__",
-    ],
-    deps = [
-        "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/epoch:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/p2p/types:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/v2:go_default_library",
-        "//config/params:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
-        "//proto/prysm/v1alpha1/block:go_default_library",
-        "//time/slots: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",
-        "@io_opencensus_go//trace:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "attestation_test.go",
-        "block_test.go",
-        "deposit_fuzz_test.go",
-        "deposit_test.go",
-        "epoch_precompute_test.go",
-        "epoch_spec_test.go",
-        "reward_test.go",
-        "sync_committee_test.go",
-        "transition_test.go",
-        "upgrade_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/core/epoch:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/p2p/types:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/v2:go_default_library",
-        "//config/params:go_default_library",
-        "//container/trie:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation: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",
-        "//time:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_google_gofuzz//:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)
--- a/beacon-chain/core/altair/attestation.go
+++ b/beacon-chain/core/altair/attestation.go
@@ -1,328 +0,0 @@
-package altair
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"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/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"go.opencensus.io/trace"
-)
-
-// ProcessAttestationsNoVerifySignature applies processing operations to a block's inner attestation
-// records. The only difference would be that the attestation signature would not be verified.
-func ProcessAttestationsNoVerifySignature(
-	ctx context.Context,
-	beaconState state.BeaconState,
-	b block.SignedBeaconBlock,
-) (state.BeaconState, error) {
-	if err := helpers.BeaconBlockIsNil(b); err != nil {
-		return nil, err
-	}
-	body := b.Block().Body()
-	totalBalance, err := helpers.TotalActiveBalance(beaconState)
-	if err != nil {
-		return nil, err
-	}
-	for idx, attestation := range body.Attestations() {
-		beaconState, err = ProcessAttestationNoVerifySignature(ctx, beaconState, attestation, totalBalance)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not verify attestation at index %d in block", idx)
-		}
-	}
-	return beaconState, nil
-}
-
-// ProcessAttestationNoVerifySignature processes the attestation without verifying the attestation signature. This
-// method is used to validate attestations whose signatures have already been verified or will be verified later.
-func ProcessAttestationNoVerifySignature(
-	ctx context.Context,
-	beaconState state.BeaconStateAltair,
-	att *ethpb.Attestation,
-	totalBalance uint64,
-) (state.BeaconStateAltair, error) {
-	ctx, span := trace.StartSpan(ctx, "altair.ProcessAttestationNoVerifySignature")
-	defer span.End()
-
-	if err := blocks.VerifyAttestationNoVerifySignature(ctx, beaconState, att); err != nil {
-		return nil, err
-	}
-
-	delay, err := beaconState.Slot().SafeSubSlot(att.Data.Slot)
-	if err != nil {
-		return nil, fmt.Errorf("att slot %d can't be greater than state slot %d", att.Data.Slot, beaconState.Slot())
-	}
-	participatedFlags, err := AttestationParticipationFlagIndices(beaconState, att.Data, delay)
-	if err != nil {
-		return nil, err
-	}
-	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.Data.Slot, att.Data.CommitteeIndex)
-	if err != nil {
-		return nil, err
-	}
-	indices, err := attestation.AttestingIndices(att.AggregationBits, committee)
-	if err != nil {
-		return nil, err
-	}
-
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.Data.Target.Epoch, indices, participatedFlags, totalBalance)
-}
-
-// SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards
-// the proposer in state.
-//
-// Spec code:
-//     # Update epoch participation flags
-//    if data.target.epoch == get_current_epoch(state):
-//        epoch_participation = state.current_epoch_participation
-//    else:
-//        epoch_participation = state.previous_epoch_participation
-//
-//    proposer_reward_numerator = 0
-//    for index in get_attesting_indices(state, data, attestation.aggregation_bits):
-//        for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
-//            if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
-//                epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-//                proposer_reward_numerator += get_base_reward(state, index) * weight
-//
-//    # Reward proposer
-//    proposer_reward_denominator = (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT) * WEIGHT_DENOMINATOR // PROPOSER_WEIGHT
-//    proposer_reward = Gwei(proposer_reward_numerator // proposer_reward_denominator)
-//    increase_balance(state, get_beacon_proposer_index(state), proposer_reward)
-func SetParticipationAndRewardProposer(
-	ctx context.Context,
-	beaconState state.BeaconState,
-	targetEpoch types.Epoch,
-	indices []uint64,
-	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
-	var epochParticipation []byte
-	currentEpoch := time.CurrentEpoch(beaconState)
-	var err error
-	if targetEpoch == currentEpoch {
-		epochParticipation, err = beaconState.CurrentEpochParticipation()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		epochParticipation, err = beaconState.PreviousEpochParticipation()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	proposerRewardNumerator, epochParticipation, err := EpochParticipation(beaconState, indices, epochParticipation, participatedFlags, totalBalance)
-	if err != nil {
-		return nil, err
-	}
-
-	if targetEpoch == currentEpoch {
-		if err := beaconState.SetCurrentParticipationBits(epochParticipation); err != nil {
-			return nil, err
-		}
-	} else {
-		if err := beaconState.SetPreviousParticipationBits(epochParticipation); err != nil {
-			return nil, err
-		}
-	}
-
-	if err := RewardProposer(ctx, beaconState, proposerRewardNumerator); err != nil {
-		return nil, err
-	}
-
-	return beaconState, nil
-}
-
-// HasValidatorFlag returns true if the flag at position has set.
-func HasValidatorFlag(flag, flagPosition uint8) (bool, error) {
-	if flagPosition > 7 {
-		return false, errors.New("flag position exceeds length")
-	}
-	return ((flag >> flagPosition) & 1) == 1, nil
-}
-
-// AddValidatorFlag adds new validator flag to existing one.
-func AddValidatorFlag(flag, flagPosition uint8) (uint8, error) {
-	if flagPosition > 7 {
-		return flag, errors.New("flag position exceeds length")
-	}
-	return flag | (1 << flagPosition), nil
-}
-
-// EpochParticipation sets and returns the proposer reward numerator and epoch participation.
-//
-// Spec code:
-//    proposer_reward_numerator = 0
-//    for index in get_attesting_indices(state, data, attestation.aggregation_bits):
-//        for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
-//            if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
-//                epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-//                proposer_reward_numerator += get_base_reward(state, index) * weight
-func EpochParticipation(beaconState state.BeaconState, indices []uint64, epochParticipation []byte, participatedFlags map[uint8]bool, totalBalance uint64) (uint64, []byte, error) {
-	cfg := params.BeaconConfig()
-	sourceFlagIndex := cfg.TimelySourceFlagIndex
-	targetFlagIndex := cfg.TimelyTargetFlagIndex
-	headFlagIndex := cfg.TimelyHeadFlagIndex
-	proposerRewardNumerator := uint64(0)
-	for _, index := range indices {
-		if index >= uint64(len(epochParticipation)) {
-			return 0, nil, fmt.Errorf("index %d exceeds participation length %d", index, len(epochParticipation))
-		}
-		br, err := BaseRewardWithTotalBalance(beaconState, types.ValidatorIndex(index), totalBalance)
-		if err != nil {
-			return 0, nil, err
-		}
-		has, err := HasValidatorFlag(epochParticipation[index], sourceFlagIndex)
-		if err != nil {
-			return 0, nil, err
-		}
-		if participatedFlags[sourceFlagIndex] && !has {
-			epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], sourceFlagIndex)
-			if err != nil {
-				return 0, nil, err
-			}
-			proposerRewardNumerator += br * cfg.TimelySourceWeight
-		}
-		has, err = HasValidatorFlag(epochParticipation[index], targetFlagIndex)
-		if err != nil {
-			return 0, nil, err
-		}
-		if participatedFlags[targetFlagIndex] && !has {
-			epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], targetFlagIndex)
-			if err != nil {
-				return 0, nil, err
-			}
-			proposerRewardNumerator += br * cfg.TimelyTargetWeight
-		}
-		has, err = HasValidatorFlag(epochParticipation[index], headFlagIndex)
-		if err != nil {
-			return 0, nil, err
-		}
-		if participatedFlags[headFlagIndex] && !has {
-			epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], headFlagIndex)
-			if err != nil {
-				return 0, nil, err
-			}
-			proposerRewardNumerator += br * cfg.TimelyHeadWeight
-		}
-	}
-
-	return proposerRewardNumerator, epochParticipation, nil
-}
-
-// RewardProposer rewards proposer by increasing proposer's balance with input reward numerator and calculated reward denominator.
-//
-// Spec code:
-//    proposer_reward_denominator = (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT) * WEIGHT_DENOMINATOR // PROPOSER_WEIGHT
-//    proposer_reward = Gwei(proposer_reward_numerator // proposer_reward_denominator)
-//    increase_balance(state, get_beacon_proposer_index(state), proposer_reward)
-func RewardProposer(ctx context.Context, beaconState state.BeaconState, proposerRewardNumerator uint64) error {
-	cfg := params.BeaconConfig()
-	d := (cfg.WeightDenominator - cfg.ProposerWeight) * cfg.WeightDenominator / cfg.ProposerWeight
-	proposerReward := proposerRewardNumerator / d
-	i, err := helpers.BeaconProposerIndex(ctx, beaconState)
-	if err != nil {
-		return err
-	}
-
-	return helpers.IncreaseBalance(beaconState, i, proposerReward)
-}
-
-// AttestationParticipationFlagIndices retrieves a map of attestation scoring based on Altair's participation flag indices.
-// This is used to facilitate process attestation during state transition and during upgrade to altair state.
-//
-// Spec code:
-// def get_attestation_participation_flag_indices(state: BeaconState,
-//                                               data: AttestationData,
-//                                               inclusion_delay: uint64) -> Sequence[int]:
-//    """
-//    Return the flag indices that are satisfied by an attestation.
-//    """
-//    if data.target.epoch == get_current_epoch(state):
-//        justified_checkpoint = state.current_justified_checkpoint
-//    else:
-//        justified_checkpoint = state.previous_justified_checkpoint
-//
-//    # Matching roots
-//    is_matching_source = data.source == justified_checkpoint
-//    is_matching_target = is_matching_source and data.target.root == get_block_root(state, data.target.epoch)
-//    is_matching_head = is_matching_target and data.beacon_block_root == get_block_root_at_slot(state, data.slot)
-//    assert is_matching_source
-//
-//    participation_flag_indices = []
-//    if is_matching_source and inclusion_delay <= integer_squareroot(SLOTS_PER_EPOCH):
-//        participation_flag_indices.append(TIMELY_SOURCE_FLAG_INDEX)
-//    if is_matching_target and inclusion_delay <= SLOTS_PER_EPOCH:
-//        participation_flag_indices.append(TIMELY_TARGET_FLAG_INDEX)
-//    if is_matching_head and inclusion_delay == MIN_ATTESTATION_INCLUSION_DELAY:
-//        participation_flag_indices.append(TIMELY_HEAD_FLAG_INDEX)
-//
-//    return participation_flag_indices
-func AttestationParticipationFlagIndices(beaconState state.BeaconStateAltair, data *ethpb.AttestationData, delay types.Slot) (map[uint8]bool, error) {
-	currEpoch := time.CurrentEpoch(beaconState)
-	var justifiedCheckpt *ethpb.Checkpoint
-	if data.Target.Epoch == currEpoch {
-		justifiedCheckpt = beaconState.CurrentJustifiedCheckpoint()
-	} else {
-		justifiedCheckpt = beaconState.PreviousJustifiedCheckpoint()
-	}
-
-	matchedSrc, matchedTgt, matchedHead, err := MatchingStatus(beaconState, data, justifiedCheckpt)
-	if err != nil {
-		return nil, err
-	}
-	if !matchedSrc {
-		return nil, errors.New("source epoch does not match")
-	}
-
-	participatedFlags := make(map[uint8]bool)
-	cfg := params.BeaconConfig()
-	sourceFlagIndex := cfg.TimelySourceFlagIndex
-	targetFlagIndex := cfg.TimelyTargetFlagIndex
-	headFlagIndex := cfg.TimelyHeadFlagIndex
-	slotsPerEpoch := cfg.SlotsPerEpoch
-	sqtRootSlots := cfg.SqrRootSlotsPerEpoch
-	if matchedSrc && delay <= sqtRootSlots {
-		participatedFlags[sourceFlagIndex] = true
-	}
-	matchedSrcTgt := matchedSrc && matchedTgt
-	if matchedSrcTgt && delay <= slotsPerEpoch {
-		participatedFlags[targetFlagIndex] = true
-	}
-	matchedSrcTgtHead := matchedHead && matchedSrcTgt
-	if matchedSrcTgtHead && delay == cfg.MinAttestationInclusionDelay {
-		participatedFlags[headFlagIndex] = true
-	}
-	return participatedFlags, nil
-}
-
-// MatchingStatus returns the matching statues for attestation data's source target and head.
-//
-// Spec code:
-//    is_matching_source = data.source == justified_checkpoint
-//    is_matching_target = is_matching_source and data.target.root == get_block_root(state, data.target.epoch)
-//    is_matching_head = is_matching_target and data.beacon_block_root == get_block_root_at_slot(state, data.slot)
-func MatchingStatus(beaconState state.BeaconState, data *ethpb.AttestationData, cp *ethpb.Checkpoint) (matchedSrc, matchedTgt, matchedHead bool, err error) {
-	matchedSrc = attestation.CheckPointIsEqual(data.Source, cp)
-
-	r, err := helpers.BlockRoot(beaconState, data.Target.Epoch)
-	if err != nil {
-		return false, false, false, err
-	}
-	matchedTgt = bytes.Equal(r, data.Target.Root)
-
-	r, err = helpers.BlockRootAtSlot(beaconState, data.Slot)
-	if err != nil {
-		return false, false, false, err
-	}
-	matchedHead = bytes.Equal(r, data.BeaconBlockRoot)
-	return
-}
--- a/beacon-chain/core/altair/attestation_test.go
+++ b/beacon-chain/core/altair/attestation_test.go
@@ -1,777 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	fuzz "github.com/google/gofuzz"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/math"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
-	attestations := []*ethpb.Attestation{
-		util.HydrateAttestation(&ethpb.Attestation{
-			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-				Slot:   5,
-			},
-		}),
-	}
-	b := util.NewBeaconBlockAltair()
-	b.Block = &ethpb.BeaconBlockAltair{
-		Body: &ethpb.BeaconBlockBodyAltair{
-			Attestations: attestations,
-		},
-	}
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
-
-	want := fmt.Sprintf(
-		"attestation slot %d + inclusion delay %d > state slot %d",
-		attestations[0].Data.Slot,
-		params.BeaconConfig().MinAttestationInclusionDelay,
-		beaconState.Slot(),
-	)
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.ErrorContains(t, want, err)
-}
-
-func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
-	att := util.HydrateAttestation(&ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
-			Target: &ethpb.Checkpoint{Epoch: 0}}})
-
-	b := util.NewBeaconBlockAltair()
-	b.Block = &ethpb.BeaconBlockAltair{
-		Body: &ethpb.BeaconBlockBodyAltair{
-			Attestations: []*ethpb.Attestation{att},
-		},
-	}
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
-	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().SlotsPerEpoch*4 + params.BeaconConfig().MinAttestationInclusionDelay)
-	require.NoError(t, err)
-	pfc := beaconState.PreviousJustifiedCheckpoint()
-	pfc.Root = []byte("hello-world")
-	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc))
-
-	want := fmt.Sprintf(
-		"expected target epoch (%d) to be the previous epoch (%d) or the current epoch (%d)",
-		att.Data.Target.Epoch,
-		time.PrevEpoch(beaconState),
-		time.CurrentEpoch(beaconState),
-	)
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.ErrorContains(t, want, err)
-}
-
-func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
-	attestations := []*ethpb.Attestation{
-		{
-			Data: &ethpb.AttestationData{
-				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-				Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-			},
-			AggregationBits: bitfield.Bitlist{0x09},
-		},
-	}
-	b := util.NewBeaconBlockAltair()
-	b.Block = &ethpb.BeaconBlockAltair{
-		Body: &ethpb.BeaconBlockBodyAltair{
-			Attestations: attestations,
-		},
-	}
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
-	require.NoError(t, beaconState.SetSlot(beaconState.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
-	cfc := beaconState.CurrentJustifiedCheckpoint()
-	cfc.Root = []byte("hello-world")
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
-
-	want := "source check point not equal to current justified checkpoint"
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.ErrorContains(t, want, err)
-	b.Block.Body.Attestations[0].Data.Source.Epoch = time.CurrentEpoch(beaconState)
-	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
-	wsb, err = wrapper.WrappedAltairSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.ErrorContains(t, want, err)
-}
-
-func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
-
-	aggBits := bitfield.NewBitlist(3)
-	aggBits.SetBitAt(0, true)
-	attestations := []*ethpb.Attestation{
-		{
-			Data: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-				Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
-				Slot:   params.BeaconConfig().SlotsPerEpoch,
-			},
-			AggregationBits: aggBits,
-		},
-	}
-	b := util.NewBeaconBlockAltair()
-	b.Block = &ethpb.BeaconBlockAltair{
-		Body: &ethpb.BeaconBlockBodyAltair{
-			Attestations: attestations,
-		},
-	}
-
-	err := beaconState.SetSlot(beaconState.Slot() + 2*params.BeaconConfig().SlotsPerEpoch)
-	require.NoError(t, err)
-	pfc := beaconState.PreviousJustifiedCheckpoint()
-	pfc.Root = []byte("hello-world")
-	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc))
-
-	want := "source check point not equal to previous justified checkpoint"
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.ErrorContains(t, want, err)
-	b.Block.Body.Attestations[0].Data.Source.Epoch = time.PrevEpoch(beaconState)
-	b.Block.Body.Attestations[0].Data.Target.Epoch = time.PrevEpoch(beaconState)
-	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
-	wsb, err = wrapper.WrappedAltairSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.ErrorContains(t, want, err)
-}
-
-func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
-
-	aggBits := bitfield.NewBitlist(4)
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
-			Target: &ethpb.Checkpoint{Epoch: 0}},
-		AggregationBits: aggBits,
-	}
-
-	b := util.NewBeaconBlockAltair()
-	b.Block = &ethpb.BeaconBlockAltair{
-		Body: &ethpb.BeaconBlockBodyAltair{
-			Attestations: []*ethpb.Attestation{att},
-		},
-	}
-
-	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
-	require.NoError(t, err)
-
-	cfc := beaconState.CurrentJustifiedCheckpoint()
-	cfc.Root = []byte("hello-world")
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
-
-	expected := "failed to verify aggregation bitfield: wanted participants bitfield length 3, got: 4"
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.ErrorContains(t, expected, err)
-}
-
-func TestProcessAttestations_OK(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, 100)
-
-	aggBits := bitfield.NewBitlist(3)
-	aggBits.SetBitAt(0, true)
-	var mockRoot [32]byte
-	copy(mockRoot[:], "hello-world")
-	att := util.HydrateAttestation(&ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Root: mockRoot[:]},
-			Target: &ethpb.Checkpoint{Root: mockRoot[:]},
-		},
-		AggregationBits: aggBits,
-	})
-
-	cfc := beaconState.CurrentJustifiedCheckpoint()
-	cfc.Root = mockRoot[:]
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
-
-	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
-	require.NoError(t, err)
-	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
-	require.NoError(t, err)
-	sigs := make([]bls.Signature, len(attestingIndices))
-	for i, indice := range attestingIndices {
-		sb, err := signing.ComputeDomainAndSign(beaconState, 0, att.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
-		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
-		require.NoError(t, err)
-		sigs[i] = sig
-	}
-	att.Signature = bls.AggregateSignatures(sigs).Marshal()
-
-	block := util.NewBeaconBlockAltair()
-	block.Block.Body.Attestations = []*ethpb.Attestation{att}
-
-	err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
-	require.NoError(t, err)
-}
-
-func TestProcessAttestationNoVerify_SourceTargetHead(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, 64)
-	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
-	require.NoError(t, err)
-
-	aggBits := bitfield.NewBitlist(2)
-	aggBits.SetBitAt(0, true)
-	aggBits.SetBitAt(1, true)
-	r, err := helpers.BlockRootAtSlot(beaconState, 0)
-	require.NoError(t, err)
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			BeaconBlockRoot: r,
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-		},
-		AggregationBits: aggBits,
-	}
-	zeroSig := [96]byte{}
-	att.Signature = zeroSig[:]
-
-	ckp := beaconState.CurrentJustifiedCheckpoint()
-	copy(ckp.Root, make([]byte, 32))
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
-
-	b, err := helpers.TotalActiveBalance(beaconState)
-	require.NoError(t, err)
-	beaconState, err = altair.ProcessAttestationNoVerifySignature(context.Background(), beaconState, att, b)
-	require.NoError(t, err)
-
-	p, err := beaconState.CurrentEpochParticipation()
-	require.NoError(t, err)
-
-	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
-	require.NoError(t, err)
-	indices, err := attestation.AttestingIndices(att.AggregationBits, committee)
-	require.NoError(t, err)
-	for _, index := range indices {
-		has, err := altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelyHeadFlagIndex)
-		require.NoError(t, err)
-		require.Equal(t, true, has)
-		has, err = altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelySourceFlagIndex)
-		require.NoError(t, err)
-		require.Equal(t, true, has)
-		has, err = altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelyTargetFlagIndex)
-		require.NoError(t, err)
-		require.Equal(t, true, has)
-	}
-}
-
-func TestValidatorFlag_Has(t *testing.T) {
-	tests := []struct {
-		name     string
-		set      uint8
-		expected []uint8
-	}{
-		{name: "none",
-			set:      0,
-			expected: []uint8{},
-		},
-		{
-			name:     "source",
-			set:      1,
-			expected: []uint8{params.BeaconConfig().TimelySourceFlagIndex},
-		},
-		{
-			name:     "target",
-			set:      2,
-			expected: []uint8{params.BeaconConfig().TimelyTargetFlagIndex},
-		},
-		{
-			name:     "head",
-			set:      4,
-			expected: []uint8{params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:     "source, target",
-			set:      3,
-			expected: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex},
-		},
-		{
-			name:     "source, head",
-			set:      5,
-			expected: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:     "target, head",
-			set:      6,
-			expected: []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex},
-		},
-		{
-			name:     "source, target, head",
-			set:      7,
-			expected: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			for _, f := range tt.expected {
-				has, err := altair.HasValidatorFlag(tt.set, f)
-				require.NoError(t, err)
-				require.Equal(t, true, has)
-			}
-		})
-	}
-}
-
-func TestValidatorFlag_Has_ExceedsLength(t *testing.T) {
-	_, err := altair.HasValidatorFlag(0, 8)
-	require.ErrorContains(t, "flag position exceeds length", err)
-}
-
-func TestValidatorFlag_Add(t *testing.T) {
-	tests := []struct {
-		name          string
-		set           []uint8
-		expectedTrue  []uint8
-		expectedFalse []uint8
-	}{
-		{name: "none",
-			set:           []uint8{},
-			expectedTrue:  []uint8{},
-			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:          "source",
-			set:           []uint8{params.BeaconConfig().TimelySourceFlagIndex},
-			expectedTrue:  []uint8{params.BeaconConfig().TimelySourceFlagIndex},
-			expectedFalse: []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:          "source, target",
-			set:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex},
-			expectedTrue:  []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex},
-			expectedFalse: []uint8{params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:          "source, target, head",
-			set:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-			expectedTrue:  []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-			expectedFalse: []uint8{},
-		},
-	}
-	var err error
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			b := uint8(0)
-			for _, f := range tt.set {
-				b, err = altair.AddValidatorFlag(b, f)
-				require.NoError(t, err)
-			}
-			for _, f := range tt.expectedFalse {
-				has, err := altair.HasValidatorFlag(b, f)
-				require.NoError(t, err)
-				require.Equal(t, false, has)
-			}
-			for _, f := range tt.expectedTrue {
-				has, err := altair.HasValidatorFlag(b, f)
-				require.NoError(t, err)
-				require.Equal(t, true, has)
-			}
-		})
-	}
-}
-
-func TestValidatorFlag_Add_ExceedsLength(t *testing.T) {
-	_, err := altair.AddValidatorFlag(0, 8)
-	require.ErrorContains(t, "flag position exceeds length", err)
-}
-
-func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
-	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethpb.BeaconStateAltair{}
-	b := &ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}
-	for i := 0; i < 10000; i++ {
-		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(b)
-		if b.Block == nil {
-			b.Block = &ethpb.BeaconBlockAltair{}
-		}
-		s, err := stateAltair.InitializeFromProtoUnsafe(state)
-		require.NoError(t, err)
-		wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := altair.ProcessAttestationsNoVerifySignature(context.Background(), s, wsb)
-		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
-		}
-	}
-}
-
-func TestSetParticipationAndRewardProposer(t *testing.T) {
-	cfg := params.BeaconConfig()
-	sourceFlagIndex := cfg.TimelySourceFlagIndex
-	targetFlagIndex := cfg.TimelyTargetFlagIndex
-	headFlagIndex := cfg.TimelyHeadFlagIndex
-	tests := []struct {
-		name                string
-		indices             []uint64
-		epochParticipation  []byte
-		participatedFlags   map[uint8]bool
-		epoch               types.Epoch
-		wantedBalance       uint64
-		wantedParticipation []byte
-	}{
-		{name: "none participated",
-			indices: []uint64{}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: false,
-				targetFlagIndex: false,
-				headFlagIndex:   false,
-			},
-			wantedParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0},
-			wantedBalance:       32000000000,
-		},
-		{name: "some participated without flags",
-			indices: []uint64{0, 1, 2, 3}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: false,
-				targetFlagIndex: false,
-				headFlagIndex:   false,
-			},
-			wantedParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0},
-			wantedBalance:       32000000000,
-		},
-		{name: "some participated with some flags",
-			indices: []uint64{0, 1, 2, 3}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   false,
-			},
-			wantedParticipation: []byte{3, 3, 3, 3, 0, 0, 0, 0},
-			wantedBalance:       32000090342,
-		},
-		{name: "all participated with some flags",
-			indices: []uint64{0, 1, 2, 3, 4, 5, 6, 7}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: false,
-				headFlagIndex:   false,
-			},
-			wantedParticipation: []byte{1, 1, 1, 1, 1, 1, 1, 1},
-			wantedBalance:       32000063240,
-		},
-		{name: "all participated with all flags",
-			indices: []uint64{0, 1, 2, 3, 4, 5, 6, 7}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   true,
-			},
-			wantedParticipation: []byte{7, 7, 7, 7, 7, 7, 7, 7},
-			wantedBalance:       32000243925,
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-			require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-
-			currentEpoch := time.CurrentEpoch(beaconState)
-			if test.epoch == currentEpoch {
-				require.NoError(t, beaconState.SetCurrentParticipationBits(test.epochParticipation))
-			} else {
-				require.NoError(t, beaconState.SetPreviousParticipationBits(test.epochParticipation))
-			}
-
-			b, err := helpers.TotalActiveBalance(beaconState)
-			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(context.Background(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
-			require.NoError(t, err)
-
-			i, err := helpers.BeaconProposerIndex(context.Background(), st)
-			require.NoError(t, err)
-			b, err = beaconState.BalanceAtIndex(i)
-			require.NoError(t, err)
-			require.Equal(t, test.wantedBalance, b)
-
-			if test.epoch == currentEpoch {
-				p, err := beaconState.CurrentEpochParticipation()
-				require.NoError(t, err)
-				require.DeepSSZEqual(t, test.wantedParticipation, p)
-			} else {
-				p, err := beaconState.PreviousEpochParticipation()
-				require.NoError(t, err)
-				require.DeepSSZEqual(t, test.wantedParticipation, p)
-			}
-		})
-	}
-}
-
-func TestEpochParticipation(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	cfg := params.BeaconConfig()
-	sourceFlagIndex := cfg.TimelySourceFlagIndex
-	targetFlagIndex := cfg.TimelyTargetFlagIndex
-	headFlagIndex := cfg.TimelyHeadFlagIndex
-	tests := []struct {
-		name                     string
-		indices                  []uint64
-		epochParticipation       []byte
-		participatedFlags        map[uint8]bool
-		wantedNumerator          uint64
-		wantedEpochParticipation []byte
-	}{
-		{name: "none participated",
-			indices: []uint64{}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: false,
-				targetFlagIndex: false,
-				headFlagIndex:   false,
-			},
-			wantedNumerator:          0,
-			wantedEpochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0},
-		},
-		{name: "some participated without flags",
-			indices: []uint64{0, 1, 2, 3}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: false,
-				targetFlagIndex: false,
-				headFlagIndex:   false,
-			},
-			wantedNumerator:          0,
-			wantedEpochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0},
-		},
-		{name: "some participated with some flags",
-			indices: []uint64{0, 1, 2, 3}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   false,
-			},
-			wantedNumerator:          40473600,
-			wantedEpochParticipation: []byte{3, 3, 3, 3, 0, 0, 0, 0},
-		},
-		{name: "all participated with some flags",
-			indices: []uint64{0, 1, 2, 3, 4, 5, 6, 7}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: false,
-				headFlagIndex:   false,
-			},
-			wantedNumerator:          28331520,
-			wantedEpochParticipation: []byte{1, 1, 1, 1, 1, 1, 1, 1},
-		},
-		{name: "all participated with all flags",
-			indices: []uint64{0, 1, 2, 3, 4, 5, 6, 7}, epochParticipation: []byte{0, 0, 0, 0, 0, 0, 0, 0}, participatedFlags: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   true,
-			},
-			wantedNumerator:          109278720,
-			wantedEpochParticipation: []byte{7, 7, 7, 7, 7, 7, 7, 7},
-		},
-	}
-	for _, test := range tests {
-		b, err := helpers.TotalActiveBalance(beaconState)
-		require.NoError(t, err)
-		n, p, err := altair.EpochParticipation(beaconState, test.indices, test.epochParticipation, test.participatedFlags, b)
-		require.NoError(t, err)
-		require.Equal(t, test.wantedNumerator, n)
-		require.DeepSSZEqual(t, test.wantedEpochParticipation, p)
-	}
-}
-
-func TestRewardProposer(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	tests := []struct {
-		rewardNumerator uint64
-		want            uint64
-	}{
-		{rewardNumerator: 1, want: 32000000000},
-		{rewardNumerator: 10000, want: 32000000022},
-		{rewardNumerator: 1000000, want: 32000002254},
-		{rewardNumerator: 1000000000, want: 32002234396},
-		{rewardNumerator: 1000000000000, want: 34234377253},
-	}
-	for _, test := range tests {
-		require.NoError(t, altair.RewardProposer(context.Background(), beaconState, test.rewardNumerator))
-		i, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
-		require.NoError(t, err)
-		b, err := beaconState.BalanceAtIndex(i)
-		require.NoError(t, err)
-		require.Equal(t, test.want, b)
-	}
-}
-
-func TestAttestationParticipationFlagIndices(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	cfg := params.BeaconConfig()
-	sourceFlagIndex := cfg.TimelySourceFlagIndex
-	targetFlagIndex := cfg.TimelyTargetFlagIndex
-	headFlagIndex := cfg.TimelyHeadFlagIndex
-
-	tests := []struct {
-		name                 string
-		inputState           state.BeaconState
-		inputData            *ethpb.AttestationData
-		inputDelay           types.Slot
-		participationIndices map[uint8]bool
-	}{
-		{
-			name: "none",
-			inputState: func() state.BeaconState {
-				return beaconState
-			}(),
-			inputData: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-				Target: &ethpb.Checkpoint{},
-			},
-			inputDelay:           params.BeaconConfig().SlotsPerEpoch,
-			participationIndices: map[uint8]bool{},
-		},
-		{
-			name: "participated source",
-			inputState: func() state.BeaconState {
-				return beaconState
-			}(),
-			inputData: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-				Target: &ethpb.Checkpoint{},
-			},
-			inputDelay: types.Slot(math.IntegerSquareRoot(uint64(cfg.SlotsPerEpoch)) - 1),
-			participationIndices: map[uint8]bool{
-				sourceFlagIndex: true,
-			},
-		},
-		{
-			name: "participated source and target",
-			inputState: func() state.BeaconState {
-				return beaconState
-			}(),
-			inputData: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-				Target: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-			},
-			inputDelay: types.Slot(math.IntegerSquareRoot(uint64(cfg.SlotsPerEpoch)) - 1),
-			participationIndices: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-			},
-		},
-		{
-			name: "participated source and target and head",
-			inputState: func() state.BeaconState {
-				return beaconState
-			}(),
-			inputData: &ethpb.AttestationData{
-				BeaconBlockRoot: params.BeaconConfig().ZeroHash[:],
-				Source:          &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-				Target:          &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-			},
-			inputDelay: 1,
-			participationIndices: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   true,
-			},
-		},
-	}
-
-	for _, test := range tests {
-		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
-		require.NoError(t, err)
-		require.DeepEqual(t, test.participationIndices, flagIndices)
-	}
-}
-
-func TestMatchingStatus(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	tests := []struct {
-		name          string
-		inputState    state.BeaconState
-		inputData     *ethpb.AttestationData
-		inputCheckpt  *ethpb.Checkpoint
-		matchedSource bool
-		matchedTarget bool
-		matchedHead   bool
-	}{
-		{
-			name:       "non matched",
-			inputState: beaconState,
-			inputData: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{Epoch: 1},
-				Target: &ethpb.Checkpoint{},
-			},
-			inputCheckpt: &ethpb.Checkpoint{},
-		},
-		{
-			name:       "source matched",
-			inputState: beaconState,
-			inputData: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{},
-				Target: &ethpb.Checkpoint{},
-			},
-			inputCheckpt:  &ethpb.Checkpoint{},
-			matchedSource: true,
-		},
-		{
-			name:       "target matched",
-			inputState: beaconState,
-			inputData: &ethpb.AttestationData{
-				Source: &ethpb.Checkpoint{Epoch: 1},
-				Target: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-			},
-			inputCheckpt:  &ethpb.Checkpoint{},
-			matchedTarget: true,
-		},
-		{
-			name:       "head matched",
-			inputState: beaconState,
-			inputData: &ethpb.AttestationData{
-				Source:          &ethpb.Checkpoint{Epoch: 1},
-				Target:          &ethpb.Checkpoint{},
-				BeaconBlockRoot: params.BeaconConfig().ZeroHash[:],
-			},
-			inputCheckpt: &ethpb.Checkpoint{},
-			matchedHead:  true,
-		},
-		{
-			name:       "everything matched",
-			inputState: beaconState,
-			inputData: &ethpb.AttestationData{
-				Source:          &ethpb.Checkpoint{},
-				Target:          &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
-				BeaconBlockRoot: params.BeaconConfig().ZeroHash[:],
-			},
-			inputCheckpt:  &ethpb.Checkpoint{},
-			matchedSource: true,
-			matchedTarget: true,
-			matchedHead:   true,
-		},
-	}
-
-	for _, test := range tests {
-		src, tgt, head, err := altair.MatchingStatus(test.inputState, test.inputData, test.inputCheckpt)
-		require.NoError(t, err)
-		require.Equal(t, test.matchedSource, src)
-		require.Equal(t, test.matchedTarget, tgt)
-		require.Equal(t, test.matchedHead, head)
-	}
-}
--- a/beacon-chain/core/altair/block.go
+++ b/beacon-chain/core/altair/block.go
@@ -1,178 +0,0 @@
-package altair
-
-import (
-	"context"
-	"errors"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	p2pType "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-// ProcessSyncAggregate verifies sync committee aggregate signature signing over the previous slot block root.
-//
-// Spec code:
-// def process_sync_aggregate(state: BeaconState, sync_aggregate: SyncAggregate) -> None:
-//    # Verify sync committee aggregate signature signing over the previous slot block root
-//    committee_pubkeys = state.current_sync_committee.pubkeys
-//    participant_pubkeys = [pubkey for pubkey, bit in zip(committee_pubkeys, sync_aggregate.sync_committee_bits) if bit]
-//    previous_slot = max(state.slot, Slot(1)) - Slot(1)
-//    domain = get_domain(state, DOMAIN_SYNC_COMMITTEE, compute_epoch_at_slot(previous_slot))
-//    signing_root = compute_signing_root(get_block_root_at_slot(state, previous_slot), domain)
-//    assert eth2_fast_aggregate_verify(participant_pubkeys, signing_root, sync_aggregate.sync_committee_signature)
-//
-//    # Compute participant and proposer rewards
-//    total_active_increments = get_total_active_balance(state) // EFFECTIVE_BALANCE_INCREMENT
-//    total_base_rewards = Gwei(get_base_reward_per_increment(state) * total_active_increments)
-//    max_participant_rewards = Gwei(total_base_rewards * SYNC_REWARD_WEIGHT // WEIGHT_DENOMINATOR // SLOTS_PER_EPOCH)
-//    participant_reward = Gwei(max_participant_rewards // SYNC_COMMITTEE_SIZE)
-//    proposer_reward = Gwei(participant_reward * PROPOSER_WEIGHT // (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT))
-//
-//    # Apply participant and proposer rewards
-//    all_pubkeys = [v.pubkey for v in state.validators]
-//    committee_indices = [ValidatorIndex(all_pubkeys.index(pubkey)) for pubkey in state.current_sync_committee.pubkeys]
-//    for participant_index, participation_bit in zip(committee_indices, sync_aggregate.sync_committee_bits):
-//        if participation_bit:
-//            increase_balance(state, participant_index, participant_reward)
-//            increase_balance(state, get_beacon_proposer_index(state), proposer_reward)
-//        else:
-//            decrease_balance(state, participant_index, participant_reward)
-func ProcessSyncAggregate(ctx context.Context, s state.BeaconStateAltair, sync *ethpb.SyncAggregate) (state.BeaconStateAltair, error) {
-	votedKeys, votedIndices, didntVoteIndices, err := FilterSyncCommitteeVotes(s, sync)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := VerifySyncCommitteeSig(s, votedKeys, sync.SyncCommitteeSignature); err != nil {
-		return nil, err
-	}
-
-	return ApplySyncRewardsPenalties(ctx, s, votedIndices, didntVoteIndices)
-}
-
-// FilterSyncCommitteeVotes filters the validator public keys and indices for the ones that voted and didn't vote.
-func FilterSyncCommitteeVotes(s state.BeaconStateAltair, sync *ethpb.SyncAggregate) (
-	votedKeys []bls.PublicKey,
-	votedIndices []types.ValidatorIndex,
-	didntVoteIndices []types.ValidatorIndex,
-	err error) {
-	currentSyncCommittee, err := s.CurrentSyncCommittee()
-	if err != nil {
-		return nil, nil, nil, err
-	}
-	if currentSyncCommittee == nil {
-		return nil, nil, nil, errors.New("nil current sync committee in state")
-	}
-	committeeKeys := currentSyncCommittee.Pubkeys
-	if sync.SyncCommitteeBits.Len() > uint64(len(committeeKeys)) {
-		return nil, nil, nil, errors.New("bits length exceeds committee length")
-	}
-	votedKeys = make([]bls.PublicKey, 0, len(committeeKeys))
-	votedIndices = make([]types.ValidatorIndex, 0, len(committeeKeys))
-	didntVoteIndices = make([]types.ValidatorIndex, 0) // No allocation. Expect most votes.
-
-	for i := uint64(0); i < sync.SyncCommitteeBits.Len(); i++ {
-		vIdx, exists := s.ValidatorIndexByPubkey(bytesutil.ToBytes48(committeeKeys[i]))
-		// Impossible scenario.
-		if !exists {
-			return nil, nil, nil, errors.New("validator public key does not exist in state")
-		}
-
-		if sync.SyncCommitteeBits.BitAt(i) {
-			pubKey, err := bls.PublicKeyFromBytes(committeeKeys[i])
-			if err != nil {
-				return nil, nil, nil, err
-			}
-			votedKeys = append(votedKeys, pubKey)
-			votedIndices = append(votedIndices, vIdx)
-		} else {
-			didntVoteIndices = append(didntVoteIndices, vIdx)
-		}
-	}
-	return
-}
-
-// VerifySyncCommitteeSig verifies sync committee signature `syncSig` is valid with respect to public keys `syncKeys`.
-func VerifySyncCommitteeSig(s state.BeaconStateAltair, syncKeys []bls.PublicKey, syncSig []byte) error {
-	ps := slots.PrevSlot(s.Slot())
-	d, err := signing.Domain(s.Fork(), slots.ToEpoch(ps), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorRoot())
-	if err != nil {
-		return err
-	}
-	pbr, err := helpers.BlockRootAtSlot(s, ps)
-	if err != nil {
-		return err
-	}
-	sszBytes := p2pType.SSZBytes(pbr)
-	r, err := signing.ComputeSigningRoot(&sszBytes, d)
-	if err != nil {
-		return err
-	}
-	sig, err := bls.SignatureFromBytes(syncSig)
-	if err != nil {
-		return err
-	}
-	if !sig.Eth2FastAggregateVerify(syncKeys, r) {
-		return errors.New("invalid sync committee signature")
-	}
-	return nil
-}
-
-// ApplySyncRewardsPenalties applies rewards and penalties for proposer and sync committee participants.
-func ApplySyncRewardsPenalties(ctx context.Context, s state.BeaconStateAltair, votedIndices, didntVoteIndices []types.ValidatorIndex) (state.BeaconStateAltair, error) {
-	activeBalance, err := helpers.TotalActiveBalance(s)
-	if err != nil {
-		return nil, err
-	}
-	proposerReward, participantReward, err := SyncRewards(activeBalance)
-	if err != nil {
-		return nil, err
-	}
-
-	// Apply sync committee rewards.
-	earnedProposerReward := uint64(0)
-	for _, index := range votedIndices {
-		if err := helpers.IncreaseBalance(s, index, participantReward); err != nil {
-			return nil, err
-		}
-		earnedProposerReward += proposerReward
-	}
-	// Apply proposer rewards.
-	proposerIndex, err := helpers.BeaconProposerIndex(ctx, s)
-	if err != nil {
-		return nil, err
-	}
-	if err := helpers.IncreaseBalance(s, proposerIndex, earnedProposerReward); err != nil {
-		return nil, err
-	}
-	// Apply sync committee penalties.
-	for _, index := range didntVoteIndices {
-		if err := helpers.DecreaseBalance(s, index, participantReward); err != nil {
-			return nil, err
-		}
-	}
-
-	return s, nil
-}
-
-// SyncRewards returns the proposer reward and the sync participant reward given the total active balance in state.
-func SyncRewards(activeBalance uint64) (proposerReward, participantReward uint64, err error) {
-	cfg := params.BeaconConfig()
-	totalActiveIncrements := activeBalance / cfg.EffectiveBalanceIncrement
-	baseRewardPerInc, err := BaseRewardPerIncrement(activeBalance)
-	if err != nil {
-		return 0, 0, err
-	}
-	totalBaseRewards := baseRewardPerInc * totalActiveIncrements
-	maxParticipantRewards := totalBaseRewards * cfg.SyncRewardWeight / cfg.WeightDenominator / uint64(cfg.SlotsPerEpoch)
-	participantReward = maxParticipantRewards / cfg.SyncCommitteeSize
-	proposerReward = participantReward * cfg.ProposerWeight / (cfg.WeightDenominator - cfg.ProposerWeight)
-	return
-}
--- a/beacon-chain/core/altair/block_test.go
+++ b/beacon-chain/core/altair/block_test.go
@@ -1,320 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"math"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	p2pType "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
-
-	syncBits := bitfield.NewBitvector512()
-	for i := range syncBits {
-		syncBits[i] = 0xff
-	}
-	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
-	require.NoError(t, err)
-	ps := slots.PrevSlot(beaconState.Slot())
-	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)
-	require.NoError(t, err)
-	sigs := make([]bls.Signature, len(indices))
-	for i, indice := range indices {
-		b := p2pType.SSZBytes(pbr)
-		sb, err := signing.ComputeDomainAndSign(beaconState, time.CurrentEpoch(beaconState), &b, params.BeaconConfig().DomainSyncCommittee, privKeys[indice])
-		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
-		require.NoError(t, err)
-		sigs[i] = sig
-	}
-	aggregatedSig := bls.AggregateSignatures(sigs).Marshal()
-	syncAggregate := &ethpb.SyncAggregate{
-		SyncCommitteeBits:      syncBits,
-		SyncCommitteeSignature: aggregatedSig,
-	}
-
-	beaconState, err = altair.ProcessSyncAggregate(context.Background(), beaconState, syncAggregate)
-	require.NoError(t, err)
-
-	// Use a non-sync committee index to compare profitability.
-	syncCommittee := make(map[types.ValidatorIndex]bool)
-	for _, index := range indices {
-		syncCommittee[index] = true
-	}
-	nonSyncIndex := types.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerCommittee + 1)
-	for i := types.ValidatorIndex(0); uint64(i) < params.BeaconConfig().MaxValidatorsPerCommittee; i++ {
-		if !syncCommittee[i] {
-			nonSyncIndex = i
-			break
-		}
-	}
-
-	// Sync committee should be more profitable than non sync committee
-	balances := beaconState.Balances()
-	require.Equal(t, true, balances[indices[0]] > balances[nonSyncIndex])
-
-	// Proposer should be more profitable than rest of the sync committee
-	proposerIndex, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
-	require.NoError(t, err)
-	require.Equal(t, true, balances[proposerIndex] > balances[indices[0]])
-
-	// Sync committee should have the same profits, except you are a proposer
-	for i := 1; i < len(indices); i++ {
-		if proposerIndex == indices[i-1] || proposerIndex == indices[i] {
-			continue
-		}
-		require.Equal(t, balances[indices[i-1]], balances[indices[i]])
-	}
-
-	// Increased balance validator count should equal to sync committee count
-	increased := uint64(0)
-	for _, balance := range balances {
-		if balance > params.BeaconConfig().MaxEffectiveBalance {
-			increased++
-		}
-	}
-	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, increased)
-}
-
-func TestProcessSyncCommittee_MixParticipation_BadSignature(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
-
-	syncBits := bitfield.NewBitvector512()
-	for i := range syncBits {
-		syncBits[i] = 0xAA
-	}
-	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
-	require.NoError(t, err)
-	ps := slots.PrevSlot(beaconState.Slot())
-	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)
-	require.NoError(t, err)
-	sigs := make([]bls.Signature, len(indices))
-	for i, indice := range indices {
-		b := p2pType.SSZBytes(pbr)
-		sb, err := signing.ComputeDomainAndSign(beaconState, time.CurrentEpoch(beaconState), &b, params.BeaconConfig().DomainSyncCommittee, privKeys[indice])
-		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
-		require.NoError(t, err)
-		sigs[i] = sig
-	}
-	aggregatedSig := bls.AggregateSignatures(sigs).Marshal()
-	syncAggregate := &ethpb.SyncAggregate{
-		SyncCommitteeBits:      syncBits,
-		SyncCommitteeSignature: aggregatedSig,
-	}
-
-	_, err = altair.ProcessSyncAggregate(context.Background(), beaconState, syncAggregate)
-	require.ErrorContains(t, "invalid sync committee signature", err)
-}
-
-func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
-
-	syncBits := bitfield.NewBitvector512()
-	for i := range syncBits {
-		syncBits[i] = 0xAA
-	}
-	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
-	require.NoError(t, err)
-	ps := slots.PrevSlot(beaconState.Slot())
-	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)
-	require.NoError(t, err)
-	sigs := make([]bls.Signature, 0, len(indices))
-	for i, indice := range indices {
-		if syncBits.BitAt(uint64(i)) {
-			b := p2pType.SSZBytes(pbr)
-			sb, err := signing.ComputeDomainAndSign(beaconState, time.CurrentEpoch(beaconState), &b, params.BeaconConfig().DomainSyncCommittee, privKeys[indice])
-			require.NoError(t, err)
-			sig, err := bls.SignatureFromBytes(sb)
-			require.NoError(t, err)
-			sigs = append(sigs, sig)
-		}
-	}
-	aggregatedSig := bls.AggregateSignatures(sigs).Marshal()
-	syncAggregate := &ethpb.SyncAggregate{
-		SyncCommitteeBits:      syncBits,
-		SyncCommitteeSignature: aggregatedSig,
-	}
-
-	_, err = altair.ProcessSyncAggregate(context.Background(), beaconState, syncAggregate)
-	require.NoError(t, err)
-}
-
-func TestProcessSyncCommittee_FilterSyncCommitteeVotes(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
-
-	syncBits := bitfield.NewBitvector512()
-	for i := range syncBits {
-		syncBits[i] = 0xAA
-	}
-	syncAggregate := &ethpb.SyncAggregate{
-		SyncCommitteeBits: syncBits,
-	}
-
-	votedKeys, votedIndices, didntVoteIndices, err := altair.FilterSyncCommitteeVotes(beaconState, syncAggregate)
-	require.NoError(t, err)
-	votedMap := make(map[[48]byte]bool)
-	for _, key := range votedKeys {
-		votedMap[bytesutil.ToBytes48(key.Marshal())] = true
-	}
-	require.Equal(t, int(syncBits.Len()/2), len(votedKeys))
-	require.Equal(t, int(syncBits.Len()/2), len(votedIndices))
-	require.Equal(t, int(syncBits.Len()/2), len(didntVoteIndices))
-
-	for i := 0; i < len(syncBits); i++ {
-		if syncBits.BitAt(uint64(i)) {
-			pk := beaconState.PubkeyAtIndex(votedIndices[i])
-			require.DeepEqual(t, true, votedMap[pk])
-		} else {
-			pk := beaconState.PubkeyAtIndex(didntVoteIndices[i])
-			require.DeepEqual(t, false, votedMap[pk])
-		}
-	}
-}
-
-func Test_VerifySyncCommitteeSig(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
-
-	syncBits := bitfield.NewBitvector512()
-	for i := range syncBits {
-		syncBits[i] = 0xff
-	}
-	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
-	require.NoError(t, err)
-	ps := slots.PrevSlot(beaconState.Slot())
-	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)
-	require.NoError(t, err)
-	sigs := make([]bls.Signature, len(indices))
-	pks := make([]bls.PublicKey, len(indices))
-	for i, indice := range indices {
-		b := p2pType.SSZBytes(pbr)
-		sb, err := signing.ComputeDomainAndSign(beaconState, time.CurrentEpoch(beaconState), &b, params.BeaconConfig().DomainSyncCommittee, privKeys[indice])
-		require.NoError(t, err)
-		sig, err := bls.SignatureFromBytes(sb)
-		require.NoError(t, err)
-		sigs[i] = sig
-		pks[i] = privKeys[indice].PublicKey()
-	}
-	aggregatedSig := bls.AggregateSignatures(sigs).Marshal()
-
-	blsKey, err := bls.RandKey()
-	require.NoError(t, err)
-	require.ErrorContains(t, "invalid sync committee signature", altair.VerifySyncCommitteeSig(beaconState, pks, blsKey.Sign([]byte{'m', 'e', 'o', 'w'}).Marshal()))
-
-	require.NoError(t, altair.VerifySyncCommitteeSig(beaconState, pks, aggregatedSig))
-}
-
-func Test_ApplySyncRewardsPenalties(t *testing.T) {
-	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	beaconState, err := altair.ApplySyncRewardsPenalties(context.Background(), beaconState,
-		[]types.ValidatorIndex{0, 1}, // voted
-		[]types.ValidatorIndex{2, 3}) // didn't vote
-	require.NoError(t, err)
-	balances := beaconState.Balances()
-	require.Equal(t, uint64(32000000988), balances[0])
-	require.Equal(t, balances[0], balances[1])
-	require.Equal(t, uint64(31999999012), balances[2])
-	require.Equal(t, balances[2], balances[3])
-	proposerIndex, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
-	require.NoError(t, err)
-	require.Equal(t, uint64(32000000282), balances[proposerIndex])
-}
-
-func Test_SyncRewards(t *testing.T) {
-	tests := []struct {
-		name                  string
-		activeBalance         uint64
-		wantProposerReward    uint64
-		wantParticipantReward uint64
-		errString             string
-	}{
-		{
-			name:                  "active balance is 0",
-			activeBalance:         0,
-			wantProposerReward:    0,
-			wantParticipantReward: 0,
-			errString:             "active balance can't be 0",
-		},
-		{
-			name:                  "active balance is 1",
-			activeBalance:         1,
-			wantProposerReward:    0,
-			wantParticipantReward: 0,
-			errString:             "",
-		},
-		{
-			name:                  "active balance is 1eth",
-			activeBalance:         params.BeaconConfig().EffectiveBalanceIncrement,
-			wantProposerReward:    0,
-			wantParticipantReward: 3,
-			errString:             "",
-		},
-		{
-			name:                  "active balance is 32eth",
-			activeBalance:         params.BeaconConfig().MaxEffectiveBalance,
-			wantProposerReward:    3,
-			wantParticipantReward: 21,
-			errString:             "",
-		},
-		{
-			name:                  "active balance is 32eth * 1m validators",
-			activeBalance:         params.BeaconConfig().MaxEffectiveBalance * 1e9,
-			wantProposerReward:    62780,
-			wantParticipantReward: 439463,
-			errString:             "",
-		},
-		{
-			name:                  "active balance is max uint64",
-			activeBalance:         math.MaxUint64,
-			wantProposerReward:    70368,
-			wantParticipantReward: 492581,
-			errString:             "",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			proposerReward, participarntReward, err := altair.SyncRewards(tt.activeBalance)
-			if (err != nil) && (tt.errString != "") {
-				require.ErrorContains(t, tt.errString, err)
-				return
-			}
-			require.Equal(t, tt.wantProposerReward, proposerReward)
-			require.Equal(t, tt.wantParticipantReward, participarntReward)
-		})
-	}
-}
--- a/beacon-chain/core/altair/deposit.go
+++ b/beacon-chain/core/altair/deposit.go
@@ -1,55 +0,0 @@
-package altair
-
-import (
-	"context"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-// ProcessDeposits processes validator deposits for beacon state Altair.
-func ProcessDeposits(
-	ctx context.Context,
-	beaconState state.BeaconStateAltair,
-	deposits []*ethpb.Deposit,
-) (state.BeaconStateAltair, error) {
-	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, deposit := range deposits {
-		if deposit == nil || deposit.Data == nil {
-			return nil, errors.New("got a nil deposit in block")
-		}
-		beaconState, err = ProcessDeposit(ctx, beaconState, deposit, batchVerified)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
-		}
-	}
-	return beaconState, nil
-}
-
-// ProcessDeposit processes validator deposit for beacon state Altair.
-func ProcessDeposit(ctx context.Context, beaconState state.BeaconStateAltair, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconStateAltair, error) {
-	beaconState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature)
-	if err != nil {
-		return nil, err
-	}
-	if isNewValidator {
-		if err := beaconState.AppendInactivityScore(0); err != nil {
-			return nil, err
-		}
-		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return nil, err
-		}
-		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
-			return nil, err
-		}
-	}
-
-	return beaconState, nil
-}
--- a/beacon-chain/core/altair/deposit_fuzz_test.go
+++ b/beacon-chain/core/altair/deposit_fuzz_test.go
@@ -1,48 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"testing"
-
-	fuzz "github.com/google/gofuzz"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestFuzzProcessDeposits_10000(t *testing.T) {
-	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethpb.BeaconStateAltair{}
-	deposits := make([]*ethpb.Deposit, 100)
-	ctx := context.Background()
-	for i := 0; i < 10000; i++ {
-		fuzzer.Fuzz(state)
-		for i := range deposits {
-			fuzzer.Fuzz(deposits[i])
-		}
-		s, err := stateAltair.InitializeFromProtoUnsafe(state)
-		require.NoError(t, err)
-		r, err := altair.ProcessDeposits(ctx, s, deposits)
-		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposits)
-		}
-	}
-}
-
-func TestFuzzProcessDeposit_10000(t *testing.T) {
-	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethpb.BeaconStateAltair{}
-	deposit := &ethpb.Deposit{}
-
-	for i := 0; i < 10000; i++ {
-		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(deposit)
-		s, err := stateAltair.InitializeFromProtoUnsafe(state)
-		require.NoError(t, err)
-		r, err := altair.ProcessDeposit(context.Background(), s, deposit, true)
-		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
-		}
-	}
-}
--- a/beacon-chain/core/altair/deposit_test.go
+++ b/beacon-chain/core/altair/deposit_test.go
@@ -1,245 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/container/trie"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
-	// Same validator created 3 valid deposits within the same block
-	dep, _, err := util.DeterministicDepositsAndKeysSameValidator(3)
-	require.NoError(t, err)
-	eth1Data, err := util.DeterministicEth1Data(len(dep))
-	require.NoError(t, err)
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, err := altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{dep[0], dep[1], dep[2]})
-	require.NoError(t, err, "Expected block deposits to process correctly")
-	require.Equal(t, 2, len(newState.Validators()), "Incorrect validator count")
-}
-
-func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
-			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, 96),
-		},
-	}
-	leaf, err := deposit.Data.HashTreeRoot()
-	require.NoError(t, err)
-
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	beaconState, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: []byte{0},
-			BlockHash:   []byte{1},
-		},
-	})
-	require.NoError(t, err)
-	want := "deposit root did not verify"
-	_, err = altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{deposit})
-	require.ErrorContains(t, want, err)
-}
-
-func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
-	dep, _, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	eth1Data, err := util.DeterministicEth1Data(len(dep))
-	require.NoError(t, err)
-
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, err := altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{dep[0]})
-	require.NoError(t, err, "Expected block deposits to process correctly")
-	if newState.Balances()[1] != dep[0].Data.Amount {
-		t.Errorf(
-			"Expected state validator balances index 0 to equal %d, received %d",
-			dep[0].Data.Amount,
-			newState.Balances()[1],
-		)
-	}
-}
-
-func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             sk.PublicKey().Marshal(),
-			Amount:                1000,
-			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, 96),
-		},
-	}
-	sr, err := signing.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	deposit.Data.Signature = sig.Marshal()
-	leaf, err := deposit.Data.HashTreeRoot()
-	require.NoError(t, err)
-
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	registry := []*ethpb.Validator{
-		{
-			PublicKey: []byte{1, 2, 3},
-		},
-		{
-			PublicKey:             sk.PublicKey().Marshal(),
-			WithdrawalCredentials: []byte{1},
-		},
-	}
-	balances := []uint64{0, 50}
-	root := depositTrie.HashTreeRoot()
-	beaconState, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: root[:],
-			BlockHash:   root[:],
-		},
-	})
-	require.NoError(t, err)
-	newState, err := altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{deposit})
-	require.NoError(t, err, "Process deposit failed")
-	require.Equal(t, uint64(1000+50), newState.Balances()[1], "Expected balance at index 1 to be 1050")
-}
-
-func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
-	// Similar to TestProcessDeposits_AddsNewValidatorDeposit except that this test directly calls ProcessDeposit
-	dep, _, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	eth1Data, err := util.DeterministicEth1Data(len(dep))
-	require.NoError(t, err)
-
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, err := altair.ProcessDeposit(context.Background(), beaconState, dep[0], true)
-	require.NoError(t, err, "Process deposit failed")
-	require.Equal(t, 2, len(newState.Validators()), "Expected validator list to have length 2")
-	require.Equal(t, 2, len(newState.Balances()), "Expected validator balances list to have length 2")
-	if newState.Balances()[1] != dep[0].Data.Amount {
-		t.Errorf(
-			"Expected state validator balances index 1 to equal %d, received %d",
-			dep[0].Data.Amount,
-			newState.Balances()[1],
-		)
-	}
-}
-
-func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
-	// Same test settings as in TestProcessDeposit_AddsNewValidatorDeposit, except that we use an invalid signature
-	dep, _, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	dep[0].Data.Signature = make([]byte, 96)
-	trie, _, err := util.DepositTrieFromDeposits(dep)
-	require.NoError(t, err)
-	root := trie.HashTreeRoot()
-	eth1Data := &ethpb.Eth1Data{
-		DepositRoot:  root[:],
-		DepositCount: 1,
-	}
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, err := altair.ProcessDeposit(context.Background(), beaconState, dep[0], true)
-	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
-
-	if newState.Eth1DepositIndex() != 1 {
-		t.Errorf(
-			"Expected Eth1DepositIndex to be increased by 1 after processing an invalid deposit, received change: %v",
-			newState.Eth1DepositIndex(),
-		)
-	}
-	if len(newState.Validators()) != 1 {
-		t.Errorf("Expected validator list to have length 1, received: %v", len(newState.Validators()))
-	}
-	if len(newState.Balances()) != 1 {
-		t.Errorf("Expected validator balances list to have length 1, received: %v", len(newState.Balances()))
-	}
-	if newState.Balances()[0] != 0 {
-		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
-	}
-}
--- a/beacon-chain/core/altair/epoch_precompute.go
+++ b/beacon-chain/core/altair/epoch_precompute.go
@@ -1,341 +0,0 @@
-package altair
-
-import (
-	"context"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
-	"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/config/params"
-	"github.com/prysmaticlabs/prysm/math"
-	"go.opencensus.io/trace"
-)
-
-// InitializePrecomputeValidators precomputes individual validator for its attested balances and the total sum of validators attested balances of the epoch.
-func InitializePrecomputeValidators(ctx context.Context, beaconState state.BeaconStateAltair) ([]*precompute.Validator, *precompute.Balance, error) {
-	_, span := trace.StartSpan(ctx, "altair.InitializePrecomputeValidators")
-	defer span.End()
-	vals := make([]*precompute.Validator, beaconState.NumValidators())
-	bal := &precompute.Balance{}
-	prevEpoch := time.PrevEpoch(beaconState)
-	currentEpoch := time.CurrentEpoch(beaconState)
-	inactivityScores, err := beaconState.InactivityScores()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// This shouldn't happen with a correct beacon state,
-	// but rather be safe to defend against index out of bound panics.
-	if beaconState.NumValidators() != len(inactivityScores) {
-		return nil, nil, errors.New("num of validators is different than num of inactivity scores")
-	}
-	if err := beaconState.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
-		// Set validator's balance, inactivity score and slashed/withdrawable status.
-		v := &precompute.Validator{
-			CurrentEpochEffectiveBalance: val.EffectiveBalance(),
-			InactivityScore:              inactivityScores[idx],
-			IsSlashed:                    val.Slashed(),
-			IsWithdrawableCurrentEpoch:   currentEpoch >= val.WithdrawableEpoch(),
-		}
-		// Set validator's active status for current epoch.
-		if helpers.IsActiveValidatorUsingTrie(val, currentEpoch) {
-			v.IsActiveCurrentEpoch = true
-			bal.ActiveCurrentEpoch, err = math.Add64(bal.ActiveCurrentEpoch, val.EffectiveBalance())
-			if err != nil {
-				return err
-			}
-		}
-		// Set validator's active status for preivous epoch.
-		if helpers.IsActiveValidatorUsingTrie(val, prevEpoch) {
-			v.IsActivePrevEpoch = true
-			bal.ActivePrevEpoch, err = math.Add64(bal.ActivePrevEpoch, val.EffectiveBalance())
-			if err != nil {
-				return err
-			}
-		}
-		vals[idx] = v
-		return nil
-	}); err != nil {
-		return nil, nil, errors.Wrap(err, "could not read every validator")
-	}
-	return vals, bal, nil
-}
-
-// ProcessInactivityScores of beacon chain. This updates inactivity scores of beacon chain and
-// updates the precompute validator struct for later processing. The inactivity scores work as following:
-// For fully inactive validators and perfect active validators, the effect is the same as before Altair.
-// For a validator is inactive and the chain fails to finalize, the inactivity score increases by a fixed number, the total loss after N epochs is proportional to N**2/2.
-// For imperfectly active validators. The inactivity score's behavior is specified by this function:
-//    If a validator fails to submit an attestation with the correct target, their inactivity score goes up by 4.
-//    If they successfully submit an attestation with the correct source and target, their inactivity score drops by 1
-//    If the chain has recently finalized, each validator's score drops by 16.
-func ProcessInactivityScores(
-	ctx context.Context,
-	beaconState state.BeaconState,
-	vals []*precompute.Validator,
-) (state.BeaconState, []*precompute.Validator, error) {
-	_, span := trace.StartSpan(ctx, "altair.ProcessInactivityScores")
-	defer span.End()
-
-	cfg := params.BeaconConfig()
-	if time.CurrentEpoch(beaconState) == cfg.GenesisEpoch {
-		return beaconState, vals, nil
-	}
-
-	inactivityScores, err := beaconState.InactivityScores()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	bias := cfg.InactivityScoreBias
-	recoveryRate := cfg.InactivityScoreRecoveryRate
-	prevEpoch := time.PrevEpoch(beaconState)
-	finalizedEpoch := beaconState.FinalizedCheckpointEpoch()
-	for i, v := range vals {
-		if !precompute.EligibleForRewards(v) {
-			continue
-		}
-
-		if v.IsPrevEpochTargetAttester && !v.IsSlashed {
-			// Decrease inactivity score when validator gets target correct.
-			if v.InactivityScore > 0 {
-				v.InactivityScore -= 1
-			}
-		} else {
-			v.InactivityScore, err = math.Add64(v.InactivityScore, bias)
-			if err != nil {
-				return nil, nil, err
-			}
-		}
-
-		if !helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch) {
-			score := recoveryRate
-			// Prevents underflow below 0.
-			if score > v.InactivityScore {
-				score = v.InactivityScore
-			}
-			v.InactivityScore -= score
-		}
-		inactivityScores[i] = v.InactivityScore
-	}
-
-	if err := beaconState.SetInactivityScores(inactivityScores); err != nil {
-		return nil, nil, err
-	}
-
-	return beaconState, vals, nil
-}
-
-// ProcessEpochParticipation processes the epoch participation in state and updates individual validator's pre computes,
-// it also tracks and updates epoch attesting balances.
-// Spec code:
-// if epoch == get_current_epoch(state):
-//        epoch_participation = state.current_epoch_participation
-//    else:
-//        epoch_participation = state.previous_epoch_participation
-//    active_validator_indices = get_active_validator_indices(state, epoch)
-//    participating_indices = [i for i in active_validator_indices if has_flag(epoch_participation[i], flag_index)]
-//    return set(filter(lambda index: not state.validators[index].slashed, participating_indices))
-func ProcessEpochParticipation(
-	ctx context.Context,
-	beaconState state.BeaconState,
-	bal *precompute.Balance,
-	vals []*precompute.Validator,
-) ([]*precompute.Validator, *precompute.Balance, error) {
-	_, span := trace.StartSpan(ctx, "altair.ProcessEpochParticipation")
-	defer span.End()
-
-	cp, err := beaconState.CurrentEpochParticipation()
-	if err != nil {
-		return nil, nil, err
-	}
-	cfg := params.BeaconConfig()
-	targetIdx := cfg.TimelyTargetFlagIndex
-	sourceIdx := cfg.TimelySourceFlagIndex
-	headIdx := cfg.TimelyHeadFlagIndex
-	for i, b := range cp {
-		has, err := HasValidatorFlag(b, sourceIdx)
-		if err != nil {
-			return nil, nil, err
-		}
-		if has && vals[i].IsActiveCurrentEpoch {
-			vals[i].IsCurrentEpochAttester = true
-		}
-		has, err = HasValidatorFlag(b, targetIdx)
-		if err != nil {
-			return nil, nil, err
-		}
-		if has && vals[i].IsActiveCurrentEpoch {
-			vals[i].IsCurrentEpochAttester = true
-			vals[i].IsCurrentEpochTargetAttester = true
-		}
-	}
-	pp, err := beaconState.PreviousEpochParticipation()
-	if err != nil {
-		return nil, nil, err
-	}
-	for i, b := range pp {
-		has, err := HasValidatorFlag(b, sourceIdx)
-		if err != nil {
-			return nil, nil, err
-		}
-		if has && vals[i].IsActivePrevEpoch {
-			vals[i].IsPrevEpochAttester = true
-			vals[i].IsPrevEpochSourceAttester = true
-		}
-		has, err = HasValidatorFlag(b, targetIdx)
-		if err != nil {
-			return nil, nil, err
-		}
-		if has && vals[i].IsActivePrevEpoch {
-			vals[i].IsPrevEpochAttester = true
-			vals[i].IsPrevEpochTargetAttester = true
-		}
-		has, err = HasValidatorFlag(b, headIdx)
-		if err != nil {
-			return nil, nil, err
-		}
-		if has && vals[i].IsActivePrevEpoch {
-			vals[i].IsPrevEpochHeadAttester = true
-		}
-	}
-	bal = precompute.UpdateBalance(vals, bal, beaconState.Version())
-	return vals, bal, nil
-}
-
-// ProcessRewardsAndPenaltiesPrecompute processes the rewards and penalties of individual validator.
-// This is an optimized version by passing in precomputed validator attesting records and and total epoch balances.
-func ProcessRewardsAndPenaltiesPrecompute(
-	beaconState state.BeaconStateAltair,
-	bal *precompute.Balance,
-	vals []*precompute.Validator,
-) (state.BeaconStateAltair, error) {
-	// Don't process rewards and penalties in genesis epoch.
-	cfg := params.BeaconConfig()
-	if time.CurrentEpoch(beaconState) == cfg.GenesisEpoch {
-		return beaconState, nil
-	}
-
-	numOfVals := beaconState.NumValidators()
-	// Guard against an out-of-bounds using validator balance precompute.
-	if len(vals) != numOfVals || len(vals) != beaconState.BalancesLength() {
-		return beaconState, errors.New("validator registries not the same length as state's validator registries")
-	}
-
-	attsRewards, attsPenalties, err := AttestationsDelta(beaconState, bal, vals)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get attestation delta")
-	}
-
-	balances := beaconState.Balances()
-	for i := 0; i < numOfVals; i++ {
-		vals[i].BeforeEpochTransitionBalance = balances[i]
-
-		// Compute the post balance of the validator after accounting for the
-		// attester and proposer rewards and penalties.
-		balances[i], err = helpers.IncreaseBalanceWithVal(balances[i], attsRewards[i])
-		if err != nil {
-			return nil, err
-		}
-		balances[i] = helpers.DecreaseBalanceWithVal(balances[i], attsPenalties[i])
-
-		vals[i].AfterEpochTransitionBalance = balances[i]
-	}
-
-	if err := beaconState.SetBalances(balances); err != nil {
-		return nil, errors.Wrap(err, "could not set validator balances")
-	}
-
-	return beaconState, nil
-}
-
-// AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the
-// voting records.
-func AttestationsDelta(beaconState state.BeaconStateAltair, bal *precompute.Balance, vals []*precompute.Validator) (rewards, penalties []uint64, err error) {
-	numOfVals := beaconState.NumValidators()
-	rewards = make([]uint64, numOfVals)
-	penalties = make([]uint64, numOfVals)
-
-	cfg := params.BeaconConfig()
-	prevEpoch := time.PrevEpoch(beaconState)
-	finalizedEpoch := beaconState.FinalizedCheckpointEpoch()
-	increment := cfg.EffectiveBalanceIncrement
-	factor := cfg.BaseRewardFactor
-	baseRewardMultiplier := increment * factor / math.IntegerSquareRoot(bal.ActiveCurrentEpoch)
-	leak := helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch)
-	inactivityDenominator := cfg.InactivityScoreBias * cfg.InactivityPenaltyQuotientAltair
-
-	for i, v := range vals {
-		rewards[i], penalties[i], err = attestationDelta(bal, v, baseRewardMultiplier, inactivityDenominator, leak)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-
-	return rewards, penalties, nil
-}
-
-func attestationDelta(
-	bal *precompute.Balance,
-	val *precompute.Validator,
-	baseRewardMultiplier, inactivityDenominator uint64,
-	inactivityLeak bool) (reward, penalty uint64, err error) {
-	eligible := val.IsActivePrevEpoch || (val.IsSlashed && !val.IsWithdrawableCurrentEpoch)
-	// Per spec `ActiveCurrentEpoch` can't be 0 to process attestation delta.
-	if !eligible || bal.ActiveCurrentEpoch == 0 {
-		return 0, 0, nil
-	}
-
-	cfg := params.BeaconConfig()
-	increment := cfg.EffectiveBalanceIncrement
-	effectiveBalance := val.CurrentEpochEffectiveBalance
-	baseReward := (effectiveBalance / increment) * baseRewardMultiplier
-	activeIncrement := bal.ActiveCurrentEpoch / increment
-
-	weightDenominator := cfg.WeightDenominator
-	srcWeight := cfg.TimelySourceWeight
-	tgtWeight := cfg.TimelyTargetWeight
-	headWeight := cfg.TimelyHeadWeight
-	reward, penalty = uint64(0), uint64(0)
-	// Process source reward / penalty
-	if val.IsPrevEpochSourceAttester && !val.IsSlashed {
-		if !inactivityLeak {
-			n := baseReward * srcWeight * (bal.PrevEpochAttested / increment)
-			reward += n / (activeIncrement * weightDenominator)
-		}
-	} else {
-		penalty += baseReward * srcWeight / weightDenominator
-	}
-
-	// Process target reward / penalty
-	if val.IsPrevEpochTargetAttester && !val.IsSlashed {
-		if !inactivityLeak {
-			n := baseReward * tgtWeight * (bal.PrevEpochTargetAttested / increment)
-			reward += n / (activeIncrement * weightDenominator)
-		}
-	} else {
-		penalty += baseReward * tgtWeight / weightDenominator
-	}
-
-	// Process head reward / penalty
-	if val.IsPrevEpochHeadAttester && !val.IsSlashed {
-		if !inactivityLeak {
-			n := baseReward * headWeight * (bal.PrevEpochHeadAttested / increment)
-			reward += n / (activeIncrement * weightDenominator)
-		}
-	}
-
-	// Process finality delay penalty
-	// Apply an additional penalty to validators that did not vote on the correct target or slashed
-	if !val.IsPrevEpochTargetAttester || val.IsSlashed {
-		n, err := math.Mul64(effectiveBalance, val.InactivityScore)
-		if err != nil {
-			return 0, 0, err
-		}
-		penalty += n / inactivityDenominator
-	}
-
-	return reward, penalty, nil
-}
--- a/beacon-chain/core/altair/epoch_precompute_test.go
+++ b/beacon-chain/core/altair/epoch_precompute_test.go
@@ -1,457 +0,0 @@
-package altair
-
-import (
-	"context"
-	"math"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestInitializeEpochValidators_Ok(t *testing.T) {
-	ffe := params.BeaconConfig().FarFutureEpoch
-	s, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Slot: params.BeaconConfig().SlotsPerEpoch,
-		// Validator 0 is slashed
-		// Validator 1 is withdrawable
-		// Validator 2 is active prev epoch and current epoch
-		// Validator 3 is active prev epoch
-		Validators: []*ethpb.Validator{
-			{Slashed: true, WithdrawableEpoch: ffe, EffectiveBalance: 100},
-			{EffectiveBalance: 100},
-			{WithdrawableEpoch: ffe, ExitEpoch: ffe, EffectiveBalance: 100},
-			{WithdrawableEpoch: ffe, ExitEpoch: 1, EffectiveBalance: 100},
-		},
-		InactivityScores: []uint64{0, 1, 2, 3},
-	})
-	require.NoError(t, err)
-	v, b, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	assert.DeepEqual(t, &precompute.Validator{
-		IsSlashed:                    true,
-		CurrentEpochEffectiveBalance: 100,
-		InactivityScore:              0,
-	}, v[0], "Incorrect validator 0 status")
-	assert.DeepEqual(t, &precompute.Validator{
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: 100,
-		InactivityScore:              1,
-	}, v[1], "Incorrect validator 1 status")
-	assert.DeepEqual(t, &precompute.Validator{
-		IsActivePrevEpoch:            true,
-		IsActiveCurrentEpoch:         true,
-		CurrentEpochEffectiveBalance: 100,
-		InactivityScore:              2,
-	}, v[2], "Incorrect validator 2 status")
-	assert.DeepEqual(t, &precompute.Validator{
-		IsActivePrevEpoch:            true,
-		CurrentEpochEffectiveBalance: 100,
-		InactivityScore:              3,
-	}, v[3], "Incorrect validator 3 status")
-
-	wantedBalances := &precompute.Balance{
-		ActiveCurrentEpoch: 100,
-		ActivePrevEpoch:    200,
-	}
-	assert.DeepEqual(t, wantedBalances, b, "Incorrect wanted balance")
-}
-
-func TestInitializeEpochValidators_Overflow(t *testing.T) {
-	ffe := params.BeaconConfig().FarFutureEpoch
-	s, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Slot: params.BeaconConfig().SlotsPerEpoch,
-		Validators: []*ethpb.Validator{
-			{WithdrawableEpoch: ffe, ExitEpoch: ffe, EffectiveBalance: math.MaxUint64},
-			{WithdrawableEpoch: ffe, ExitEpoch: ffe, EffectiveBalance: math.MaxUint64},
-		},
-		InactivityScores: []uint64{0, 1},
-	})
-	require.NoError(t, err)
-	_, _, err = InitializePrecomputeValidators(context.Background(), s)
-	require.ErrorContains(t, "could not read every validator: addition overflows", err)
-}
-
-func TestInitializeEpochValidators_BadState(t *testing.T) {
-	s, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Validators:       []*ethpb.Validator{{}},
-		InactivityScores: []uint64{},
-	})
-	require.NoError(t, err)
-	_, _, err = InitializePrecomputeValidators(context.Background(), s)
-	require.ErrorContains(t, "num of validators is different than num of inactivity scores", err)
-}
-
-func TestProcessEpochParticipation(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	require.DeepEqual(t, &precompute.Validator{
-		IsActiveCurrentEpoch:         true,
-		IsActivePrevEpoch:            true,
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-	}, validators[0])
-	require.DeepEqual(t, &precompute.Validator{
-		IsActiveCurrentEpoch:         true,
-		IsActivePrevEpoch:            true,
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-		IsCurrentEpochAttester:       true,
-		IsPrevEpochAttester:          true,
-		IsPrevEpochSourceAttester:    true,
-	}, validators[1])
-	require.DeepEqual(t, &precompute.Validator{
-		IsActiveCurrentEpoch:         true,
-		IsActivePrevEpoch:            true,
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-		IsCurrentEpochAttester:       true,
-		IsPrevEpochAttester:          true,
-		IsPrevEpochSourceAttester:    true,
-		IsCurrentEpochTargetAttester: true,
-		IsPrevEpochTargetAttester:    true,
-	}, validators[2])
-	require.DeepEqual(t, &precompute.Validator{
-		IsActiveCurrentEpoch:         true,
-		IsActivePrevEpoch:            true,
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-		IsCurrentEpochAttester:       true,
-		IsPrevEpochAttester:          true,
-		IsPrevEpochSourceAttester:    true,
-		IsCurrentEpochTargetAttester: true,
-		IsPrevEpochTargetAttester:    true,
-		IsPrevEpochHeadAttester:      true,
-	}, validators[3])
-	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance*3, balance.PrevEpochAttested)
-	require.Equal(t, balance.CurrentEpochTargetAttested, params.BeaconConfig().MaxEffectiveBalance*2)
-	require.Equal(t, balance.PrevEpochTargetAttested, params.BeaconConfig().MaxEffectiveBalance*2)
-	require.Equal(t, balance.PrevEpochHeadAttested, params.BeaconConfig().MaxEffectiveBalance*1)
-}
-
-func TestProcessEpochParticipation_InactiveValidator(t *testing.T) {
-	generateParticipation := func(flags ...uint8) byte {
-		b := byte(0)
-		var err error
-		for _, flag := range flags {
-			b, err = AddValidatorFlag(b, flag)
-			require.NoError(t, err)
-		}
-		return b
-	}
-	st, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Slot: 2 * params.BeaconConfig().SlotsPerEpoch,
-		Validators: []*ethpb.Validator{
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},                                                  // Inactive
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: 2},                                    // Inactive current epoch, active previous epoch
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch}, // Active
-		},
-		CurrentEpochParticipation: []byte{
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex),
-		},
-		PreviousEpochParticipation: []byte{
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex),
-		},
-		InactivityScores: []uint64{0, 0, 0},
-	})
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), st)
-	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(context.Background(), st, balance, validators)
-	require.NoError(t, err)
-	require.DeepEqual(t, &precompute.Validator{
-		IsActiveCurrentEpoch:         false,
-		IsActivePrevEpoch:            false,
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-	}, validators[0])
-	require.DeepEqual(t, &precompute.Validator{
-		IsActiveCurrentEpoch:         false,
-		IsActivePrevEpoch:            true,
-		IsPrevEpochAttester:          true,
-		IsPrevEpochSourceAttester:    true,
-		IsPrevEpochTargetAttester:    true,
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-	}, validators[1])
-	require.DeepEqual(t, &precompute.Validator{
-		IsActiveCurrentEpoch:         true,
-		IsActivePrevEpoch:            true,
-		IsWithdrawableCurrentEpoch:   true,
-		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-		IsCurrentEpochAttester:       true,
-		IsPrevEpochAttester:          true,
-		IsPrevEpochSourceAttester:    true,
-		IsCurrentEpochTargetAttester: true,
-		IsPrevEpochTargetAttester:    true,
-		IsPrevEpochHeadAttester:      true,
-	}, validators[2])
-	require.Equal(t, balance.PrevEpochAttested, 2*params.BeaconConfig().MaxEffectiveBalance)
-	require.Equal(t, balance.CurrentEpochTargetAttested, params.BeaconConfig().MaxEffectiveBalance)
-	require.Equal(t, balance.PrevEpochTargetAttested, 2*params.BeaconConfig().MaxEffectiveBalance)
-	require.Equal(t, balance.PrevEpochHeadAttested, params.BeaconConfig().MaxEffectiveBalance)
-}
-
-func TestAttestationsDelta(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	rewards, penalties, err := AttestationsDelta(s, balance, validators)
-	require.NoError(t, err)
-
-	// Reward amount should increase as validator index increases due to setup.
-	for i := 1; i < len(rewards); i++ {
-		require.Equal(t, true, rewards[i] > rewards[i-1])
-	}
-
-	// Penalty amount should decrease as validator index increases due to setup.
-	for i := 1; i < len(penalties); i++ {
-		require.Equal(t, true, penalties[i] <= penalties[i-1])
-	}
-
-	// First index should have 0 reward.
-	require.Equal(t, uint64(0), rewards[0])
-	// Last index should have 0 penalty.
-	require.Equal(t, uint64(0), penalties[len(penalties)-1])
-}
-
-func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	s, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, validators)
-	require.NoError(t, err)
-
-	balances := s.Balances()
-	// Reward amount should increase as validator index increases due to setup.
-	for i := 1; i < len(balances); i++ {
-		require.Equal(t, true, balances[i] >= balances[i-1])
-	}
-
-	wanted := make([]uint64, s.NumValidators())
-	rewards, penalties, err := AttestationsDelta(s, balance, validators)
-	require.NoError(t, err)
-	for i := range rewards {
-		wanted[i] += rewards[i]
-	}
-	for i := range penalties {
-		if wanted[i] > penalties[i] {
-			wanted[i] -= penalties[i]
-		} else {
-			wanted[i] = 0
-		}
-	}
-	require.DeepEqual(t, wanted, balances)
-}
-
-func TestProcessRewardsAndPenaltiesPrecompute_InactivityLeak(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	sCopy := s.Copy()
-	s, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, validators)
-	require.NoError(t, err)
-
-	// Copied state where finality happened long ago
-	require.NoError(t, sCopy.SetSlot(params.BeaconConfig().SlotsPerEpoch*1000))
-	sCopy, err = ProcessRewardsAndPenaltiesPrecompute(sCopy, balance, validators)
-	require.NoError(t, err)
-
-	balances := s.Balances()
-	inactivityBalances := sCopy.Balances()
-	// Balances decreased to 0 due to inactivity
-	require.Equal(t, uint64(2101898), balances[2])
-	require.Equal(t, uint64(2414946), balances[3])
-	require.Equal(t, uint64(0), inactivityBalances[2])
-	require.Equal(t, uint64(0), inactivityBalances[3])
-}
-
-func TestProcessInactivityScores_CanProcessInactivityLeak(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	defaultScore := uint64(5)
-	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(params.BeaconConfig().MinEpochsToInactivityPenalty+2)))
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
-	require.NoError(t, err)
-	inactivityScores, err := s.InactivityScores()
-	require.NoError(t, err)
-	// V0 and V1 didn't vote head. V2 and V3 did.
-	require.Equal(t, defaultScore+params.BeaconConfig().InactivityScoreBias, inactivityScores[0])
-	require.Equal(t, defaultScore+params.BeaconConfig().InactivityScoreBias, inactivityScores[1])
-	require.Equal(t, defaultScore-1, inactivityScores[2])
-	require.Equal(t, defaultScore-1, inactivityScores[3])
-}
-
-func TestProcessInactivityScores_GenesisEpoch(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	defaultScore := uint64(10)
-	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	require.NoError(t, s.SetSlot(params.BeaconConfig().GenesisSlot))
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
-	require.NoError(t, err)
-	inactivityScores, err := s.InactivityScores()
-	require.NoError(t, err)
-	require.Equal(t, defaultScore, inactivityScores[0])
-	require.Equal(t, defaultScore, inactivityScores[1])
-	require.Equal(t, defaultScore, inactivityScores[2])
-	require.Equal(t, defaultScore, inactivityScores[3])
-}
-
-func TestProcessInactivityScores_CanProcessNonInactivityLeak(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	defaultScore := uint64(5)
-	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
-	require.NoError(t, err)
-	inactivityScores, err := s.InactivityScores()
-	require.NoError(t, err)
-
-	require.Equal(t, uint64(0), inactivityScores[0])
-	require.Equal(t, uint64(0), inactivityScores[1])
-	require.Equal(t, uint64(0), inactivityScores[2])
-	require.Equal(t, uint64(0), inactivityScores[3])
-}
-
-func TestProcessRewardsAndPenaltiesPrecompute_GenesisEpoch(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	require.NoError(t, s.SetSlot(0))
-	s, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, validators)
-	require.NoError(t, err)
-
-	balances := s.Balances()
-	// Nothing should happen at genesis epoch
-	require.Equal(t, uint64(0), balances[0])
-	for i := 1; i < len(balances); i++ {
-		require.Equal(t, true, balances[i] == balances[i-1])
-	}
-}
-
-func TestProcessRewardsAndPenaltiesPrecompute_BadState(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	_, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	_, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, []*precompute.Validator{})
-	require.ErrorContains(t, "validator registries not the same length as state's validator registries", err)
-}
-
-func TestProcessInactivityScores_NonEligibleValidator(t *testing.T) {
-	s, err := testState()
-	require.NoError(t, err)
-	defaultScore := uint64(5)
-	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-
-	// v0 is eligible (not active previous epoch, slashed and not withdrawable)
-	validators[0].IsActivePrevEpoch = false
-	validators[0].IsSlashed = true
-	validators[0].IsWithdrawableCurrentEpoch = false
-
-	// v1 is not eligible (not active previous epoch, not slashed and not withdrawable)
-	validators[1].IsActivePrevEpoch = false
-	validators[1].IsSlashed = false
-	validators[1].IsWithdrawableCurrentEpoch = false
-
-	// v2 is not eligible (not active previous epoch, slashed and withdrawable)
-	validators[2].IsActivePrevEpoch = false
-	validators[2].IsSlashed = true
-	validators[2].IsWithdrawableCurrentEpoch = true
-
-	// v3 is eligible (active previous epoch)
-	validators[3].IsActivePrevEpoch = true
-
-	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
-	require.NoError(t, err)
-	inactivityScores, err := s.InactivityScores()
-	require.NoError(t, err)
-
-	require.Equal(t, uint64(0), inactivityScores[0])
-	require.Equal(t, defaultScore, inactivityScores[1]) // Should remain unchanged
-	require.Equal(t, defaultScore, inactivityScores[2]) // Should remain unchanged
-	require.Equal(t, uint64(0), inactivityScores[3])
-}
-
-func testState() (state.BeaconState, error) {
-	generateParticipation := func(flags ...uint8) byte {
-		b := byte(0)
-		var err error
-		for _, flag := range flags {
-			b, err = AddValidatorFlag(b, flag)
-			if err != nil {
-				return 0
-			}
-		}
-		return b
-	}
-	return stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Slot: 2 * params.BeaconConfig().SlotsPerEpoch,
-		Validators: []*ethpb.Validator{
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-		},
-		CurrentEpochParticipation: []byte{
-			0,
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex),
-		},
-		PreviousEpochParticipation: []byte{
-			0,
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex),
-		},
-		InactivityScores: []uint64{0, 0, 0, 0},
-		Balances:         []uint64{0, 0, 0, 0},
-	})
-}
--- a/beacon-chain/core/altair/epoch_spec.go
+++ b/beacon-chain/core/altair/epoch_spec.go
@@ -1,63 +0,0 @@
-package altair
-
-import (
-	"context"
-
-	"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/config/params"
-	log "github.com/sirupsen/logrus"
-)
-
-// ProcessSyncCommitteeUpdates  processes sync client committee updates for the beacon state.
-//
-// Spec code:
-// def process_sync_committee_updates(state: BeaconState) -> None:
-//    next_epoch = get_current_epoch(state) + Epoch(1)
-//    if next_epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0:
-//        state.current_sync_committee = state.next_sync_committee
-//        state.next_sync_committee = get_next_sync_committee(state)
-func ProcessSyncCommitteeUpdates(ctx context.Context, beaconState state.BeaconStateAltair) (state.BeaconStateAltair, error) {
-	nextEpoch := time.NextEpoch(beaconState)
-	if nextEpoch%params.BeaconConfig().EpochsPerSyncCommitteePeriod == 0 {
-		nextSyncCommittee, err := beaconState.NextSyncCommittee()
-		if err != nil {
-			return nil, err
-		}
-		if err := beaconState.SetCurrentSyncCommittee(nextSyncCommittee); err != nil {
-			return nil, err
-		}
-		nextSyncCommittee, err = NextSyncCommittee(ctx, beaconState)
-		if err != nil {
-			return nil, err
-		}
-		if err := beaconState.SetNextSyncCommittee(nextSyncCommittee); err != nil {
-			return nil, err
-		}
-		if err := helpers.UpdateSyncCommitteeCache(beaconState); err != nil {
-			log.WithError(err).Error("Could not update sync committee cache")
-		}
-	}
-	return beaconState, nil
-}
-
-// ProcessParticipationFlagUpdates processes participation flag updates by rotating current to previous.
-//
-// Spec code:
-// def process_participation_flag_updates(state: BeaconState) -> None:
-//    state.previous_epoch_participation = state.current_epoch_participation
-//    state.current_epoch_participation = [ParticipationFlags(0b0000_0000) for _ in range(len(state.validators))]
-func ProcessParticipationFlagUpdates(beaconState state.BeaconStateAltair) (state.BeaconStateAltair, error) {
-	c, err := beaconState.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	if err := beaconState.SetPreviousParticipationBits(c); err != nil {
-		return nil, err
-	}
-	if err := beaconState.SetCurrentParticipationBits(make([]byte, beaconState.NumValidators())); err != nil {
-		return nil, err
-	}
-	return beaconState, nil
-}
--- a/beacon-chain/core/altair/epoch_spec_test.go
+++ b/beacon-chain/core/altair/epoch_spec_test.go
@@ -1,197 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"fmt"
-	"math"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	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"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	h := &ethpb.BeaconBlockHeader{
-		StateRoot:  bytesutil.PadTo([]byte{'a'}, 32),
-		ParentRoot: bytesutil.PadTo([]byte{'b'}, 32),
-		BodyRoot:   bytesutil.PadTo([]byte{'c'}, 32),
-	}
-	require.NoError(t, s.SetLatestBlockHeader(h))
-	postState, err := altair.ProcessSyncCommitteeUpdates(context.Background(), s)
-	require.NoError(t, err)
-	current, err := postState.CurrentSyncCommittee()
-	require.NoError(t, err)
-	next, err := postState.NextSyncCommittee()
-	require.NoError(t, err)
-	require.DeepEqual(t, current, next)
-
-	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-	postState, err = altair.ProcessSyncCommitteeUpdates(context.Background(), s)
-	require.NoError(t, err)
-	c, err := postState.CurrentSyncCommittee()
-	require.NoError(t, err)
-	n, err := postState.NextSyncCommittee()
-	require.NoError(t, err)
-	require.DeepEqual(t, current, c)
-	require.DeepEqual(t, next, n)
-
-	require.NoError(t, s.SetSlot(types.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*params.BeaconConfig().SlotsPerEpoch-1))
-	postState, err = altair.ProcessSyncCommitteeUpdates(context.Background(), s)
-	require.NoError(t, err)
-	c, err = postState.CurrentSyncCommittee()
-	require.NoError(t, err)
-	n, err = postState.NextSyncCommittee()
-	require.NoError(t, err)
-	require.NotEqual(t, current, c)
-	require.NotEqual(t, next, n)
-	require.DeepEqual(t, next, c)
-
-	// Test boundary condition.
-	slot := params.BeaconConfig().SlotsPerEpoch * types.Slot(time.CurrentEpoch(s)+params.BeaconConfig().EpochsPerSyncCommitteePeriod)
-	require.NoError(t, s.SetSlot(slot))
-	boundaryCommittee, err := altair.NextSyncCommittee(context.Background(), s)
-	require.NoError(t, err)
-	require.DeepNotEqual(t, boundaryCommittee, n)
-}
-
-func TestProcessParticipationFlagUpdates_CanRotate(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	c, err := s.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.DeepEqual(t, make([]byte, params.BeaconConfig().MaxValidatorsPerCommittee), c)
-	p, err := s.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepEqual(t, make([]byte, params.BeaconConfig().MaxValidatorsPerCommittee), p)
-
-	newC := []byte{'a'}
-	newP := []byte{'b'}
-	require.NoError(t, s.SetCurrentParticipationBits(newC))
-	require.NoError(t, s.SetPreviousParticipationBits(newP))
-	c, err = s.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.DeepEqual(t, newC, c)
-	p, err = s.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepEqual(t, newP, p)
-
-	s, err = altair.ProcessParticipationFlagUpdates(s)
-	require.NoError(t, err)
-	c, err = s.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.DeepEqual(t, make([]byte, params.BeaconConfig().MaxValidatorsPerCommittee), c)
-	p, err = s.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepEqual(t, newC, p)
-}
-
-func TestProcessSlashings_NotSlashed(t *testing.T) {
-	base := &ethpb.BeaconStateAltair{
-		Slot:       0,
-		Validators: []*ethpb.Validator{{Slashed: true}},
-		Balances:   []uint64{params.BeaconConfig().MaxEffectiveBalance},
-		Slashings:  []uint64{0, 1e9},
-	}
-	s, err := stateAltair.InitializeFromProto(base)
-	require.NoError(t, err)
-	newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
-	require.NoError(t, err)
-	wanted := params.BeaconConfig().MaxEffectiveBalance
-	assert.Equal(t, wanted, newState.Balances()[0], "Unexpected slashed balance")
-}
-
-func TestProcessSlashings_SlashedLess(t *testing.T) {
-	tests := []struct {
-		state *ethpb.BeaconStateAltair
-		want  uint64
-	}{
-		{
-			state: &ethpb.BeaconStateAltair{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance}},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
-				Slashings: []uint64{0, 1e9},
-			},
-			want: uint64(30000000000),
-		},
-		{
-			state: &ethpb.BeaconStateAltair{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-				},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
-				Slashings: []uint64{0, 1e9},
-			},
-			want: uint64(31000000000),
-		},
-		{
-			state: &ethpb.BeaconStateAltair{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-				},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
-				Slashings: []uint64{0, 2 * 1e9},
-			},
-			want: uint64(30000000000),
-		},
-		{
-			state: &ethpb.BeaconStateAltair{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement}},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
-				Slashings: []uint64{0, 1e9},
-			},
-			want: uint64(29000000000),
-		},
-	}
-
-	for i, tt := range tests {
-		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			helpers.ClearCache()
-			original := proto.Clone(tt.state)
-			s, err := stateAltair.InitializeFromProto(tt.state)
-			require.NoError(t, err)
-			newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
-			require.NoError(t, err)
-			assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
-		})
-	}
-}
-
-func TestProcessSlashings_BadValue(t *testing.T) {
-	base := &ethpb.BeaconStateAltair{
-		Slot:       0,
-		Validators: []*ethpb.Validator{{Slashed: true}},
-		Balances:   []uint64{params.BeaconConfig().MaxEffectiveBalance},
-		Slashings:  []uint64{math.MaxUint64, 1e9},
-	}
-	s, err := stateAltair.InitializeFromProto(base)
-	require.NoError(t, err)
-	_, err = epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
-	require.ErrorContains(t, "addition overflows", err)
-}
--- a/beacon-chain/core/altair/reward.go
+++ b/beacon-chain/core/altair/reward.go
@@ -1,60 +0,0 @@
-package altair
-
-import (
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/math"
-)
-
-// BaseReward takes state and validator index and calculate
-// individual validator's base reward.
-//
-// Spec code:
-//  def get_base_reward(state: BeaconState, index: ValidatorIndex) -> Gwei:
-//    """
-//    Return the base reward for the validator defined by ``index`` with respect to the current ``state``.
-//
-//    Note: An optimally performing validator can earn one base reward per epoch over a long time horizon.
-//    This takes into account both per-epoch (e.g. attestation) and intermittent duties (e.g. block proposal
-//    and sync committees).
-//    """
-//    increments = state.validators[index].effective_balance // EFFECTIVE_BALANCE_INCREMENT
-//    return Gwei(increments * get_base_reward_per_increment(state))
-func BaseReward(s state.ReadOnlyBeaconState, index types.ValidatorIndex) (uint64, error) {
-	totalBalance, err := helpers.TotalActiveBalance(s)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not calculate active balance")
-	}
-	return BaseRewardWithTotalBalance(s, index, totalBalance)
-}
-
-// BaseRewardWithTotalBalance calculates the base reward with the provided total balance.
-func BaseRewardWithTotalBalance(s state.ReadOnlyBeaconState, index types.ValidatorIndex, totalBalance uint64) (uint64, error) {
-	val, err := s.ValidatorAtIndexReadOnly(index)
-	if err != nil {
-		return 0, err
-	}
-	cfg := params.BeaconConfig()
-	increments := val.EffectiveBalance() / cfg.EffectiveBalanceIncrement
-	baseRewardPerInc, err := BaseRewardPerIncrement(totalBalance)
-	if err != nil {
-		return 0, err
-	}
-	return increments * baseRewardPerInc, nil
-}
-
-// BaseRewardPerIncrement of the beacon state
-//
-// Spec code:
-// def get_base_reward_per_increment(state: BeaconState) -> Gwei:
-//    return Gwei(EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR // integer_squareroot(get_total_active_balance(state)))
-func BaseRewardPerIncrement(activeBalance uint64) (uint64, error) {
-	if activeBalance == 0 {
-		return 0, errors.New("active balance can't be 0")
-	}
-	cfg := params.BeaconConfig()
-	return cfg.EffectiveBalanceIncrement * cfg.BaseRewardFactor / math.IntegerSquareRoot(activeBalance), nil
-}
--- a/beacon-chain/core/altair/reward_test.go
+++ b/beacon-chain/core/altair/reward_test.go
@@ -1,193 +0,0 @@
-package altair_test
-
-import (
-	"math"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func Test_BaseReward(t *testing.T) {
-	genState := func(valCount uint64) state.ReadOnlyBeaconState {
-		s, _ := util.DeterministicGenesisStateAltair(t, valCount)
-		return s
-	}
-	tests := []struct {
-		name      string
-		valIdx    types.ValidatorIndex
-		st        state.ReadOnlyBeaconState
-		want      uint64
-		errString string
-	}{
-		{
-			name:      "unknown validator",
-			valIdx:    2,
-			st:        genState(1),
-			want:      0,
-			errString: "index 2 out of range",
-		},
-		{
-			name:      "active balance is 32eth",
-			valIdx:    0,
-			st:        genState(1),
-			want:      11448672,
-			errString: "",
-		},
-		{
-			name:      "active balance is 32eth * target committee size",
-			valIdx:    0,
-			st:        genState(params.BeaconConfig().TargetCommitteeSize),
-			want:      1011904,
-			errString: "",
-		},
-		{
-			name:      "active balance is 32eth * max validator per  committee size",
-			valIdx:    0,
-			st:        genState(params.BeaconConfig().MaxValidatorsPerCommittee),
-			want:      252960,
-			errString: "",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := altair.BaseReward(tt.st, tt.valIdx)
-			if (err != nil) && (tt.errString != "") {
-				require.ErrorContains(t, tt.errString, err)
-				return
-			}
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func Test_BaseRewardWithTotalBalance(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateAltair(t, 1)
-	tests := []struct {
-		name          string
-		valIdx        types.ValidatorIndex
-		activeBalance uint64
-		want          uint64
-		errString     string
-	}{
-		{
-			name:          "active balance is 0",
-			valIdx:        0,
-			activeBalance: 0,
-			want:          0,
-			errString:     "active balance can't be 0",
-		},
-		{
-			name:          "unknown validator",
-			valIdx:        2,
-			activeBalance: 1,
-			want:          0,
-			errString:     "index 2 out of range",
-		},
-		{
-			name:          "active balance is 1",
-			valIdx:        0,
-			activeBalance: 1,
-			want:          2048000000000,
-			errString:     "",
-		},
-		{
-			name:          "active balance is 1eth",
-			valIdx:        0,
-			activeBalance: params.BeaconConfig().EffectiveBalanceIncrement,
-			want:          64765024,
-			errString:     "",
-		},
-		{
-			name:          "active balance is 32eth",
-			valIdx:        0,
-			activeBalance: params.BeaconConfig().MaxEffectiveBalance,
-			want:          11448672,
-			errString:     "",
-		},
-		{
-			name:          "active balance is 32eth * 1m validators",
-			valIdx:        0,
-			activeBalance: params.BeaconConfig().MaxEffectiveBalance * 1e9,
-			want:          544,
-			errString:     "",
-		},
-		{
-			name:          "active balance is max uint64",
-			valIdx:        0,
-			activeBalance: math.MaxUint64,
-			want:          448,
-			errString:     "",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := altair.BaseRewardWithTotalBalance(s, tt.valIdx, tt.activeBalance)
-			if (err != nil) && (tt.errString != "") {
-				require.ErrorContains(t, tt.errString, err)
-				return
-			}
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func Test_BaseRewardPerIncrement(t *testing.T) {
-	tests := []struct {
-		name          string
-		activeBalance uint64
-		want          uint64
-		errString     string
-	}{
-		{
-			name:          "active balance is 0",
-			activeBalance: 0,
-			want:          0,
-			errString:     "active balance can't be 0",
-		},
-		{
-			name:          "active balance is 1",
-			activeBalance: 1,
-			want:          64000000000,
-			errString:     "",
-		},
-		{
-			name:          "active balance is 1eth",
-			activeBalance: params.BeaconConfig().EffectiveBalanceIncrement,
-			want:          2023907,
-			errString:     "",
-		},
-		{
-			name:          "active balance is 32eth",
-			activeBalance: params.BeaconConfig().MaxEffectiveBalance,
-			want:          357771,
-			errString:     "",
-		},
-		{
-			name:          "active balance is 32eth * 1m validators",
-			activeBalance: params.BeaconConfig().MaxEffectiveBalance * 1e9,
-			want:          17,
-			errString:     "",
-		},
-		{
-			name:          "active balance is max uint64",
-			activeBalance: math.MaxUint64,
-			want:          14,
-			errString:     "",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := altair.BaseRewardPerIncrement(tt.activeBalance)
-			if (err != nil) && (tt.errString != "") {
-				require.ErrorContains(t, tt.errString, err)
-				return
-			}
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
--- a/beacon-chain/core/altair/sync_committee.go
+++ b/beacon-chain/core/altair/sync_committee.go
@@ -1,223 +0,0 @@
-package altair
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	coreTime "github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/crypto/hash"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/math"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-const maxRandomByte = uint64(1<<8 - 1)
-
-// ValidateNilSyncContribution validates the following fields are not nil:
-// -the contribution and proof itself
-// -the message within contribution and proof
-// -the contribution within contribution and proof
-// -the aggregation bits within contribution
-func ValidateNilSyncContribution(s *ethpb.SignedContributionAndProof) error {
-	if s == nil {
-		return errors.New("signed message can't be nil")
-	}
-	if s.Message == nil {
-		return errors.New("signed contribution's message can't be nil")
-	}
-	if s.Message.Contribution == nil {
-		return errors.New("inner contribution can't be nil")
-	}
-	if s.Message.Contribution.AggregationBits == nil {
-		return errors.New("contribution's bitfield can't be nil")
-	}
-	return nil
-}
-
-// NextSyncCommittee returns the next sync committee for a given state.
-//
-// Spec code:
-// def get_next_sync_committee(state: BeaconState) -> SyncCommittee:
-//    """
-//    Return the next sync committee, with possible pubkey duplicates.
-//    """
-//    indices = get_next_sync_committee_indices(state)
-//    pubkeys = [state.validators[index].pubkey for index in indices]
-//    aggregate_pubkey = bls.AggregatePKs(pubkeys)
-//    return SyncCommittee(pubkeys=pubkeys, aggregate_pubkey=aggregate_pubkey)
-func NextSyncCommittee(ctx context.Context, s state.BeaconStateAltair) (*ethpb.SyncCommittee, error) {
-	indices, err := NextSyncCommitteeIndices(ctx, s)
-	if err != nil {
-		return nil, err
-	}
-	pubkeys := make([][]byte, len(indices))
-	for i, index := range indices {
-		p := s.PubkeyAtIndex(index)
-		pubkeys[i] = p[:]
-	}
-	aggregated, err := bls.AggregatePublicKeys(pubkeys)
-	if err != nil {
-		return nil, err
-	}
-	return &ethpb.SyncCommittee{
-		Pubkeys:         pubkeys,
-		AggregatePubkey: aggregated.Marshal(),
-	}, nil
-}
-
-// NextSyncCommitteeIndices returns the next sync committee indices for a given state.
-//
-// Spec code:
-// def get_next_sync_committee_indices(state: BeaconState) -> Sequence[ValidatorIndex]:
-//    """
-//    Return the sync committee indices, with possible duplicates, for the next sync committee.
-//    """
-//    epoch = Epoch(get_current_epoch(state) + 1)
-//
-//    MAX_RANDOM_BYTE = 2**8 - 1
-//    active_validator_indices = get_active_validator_indices(state, epoch)
-//    active_validator_count = uint64(len(active_validator_indices))
-//    seed = get_seed(state, epoch, DOMAIN_SYNC_COMMITTEE)
-//    i = 0
-//    sync_committee_indices: List[ValidatorIndex] = []
-//    while len(sync_committee_indices) < SYNC_COMMITTEE_SIZE:
-//        shuffled_index = compute_shuffled_index(uint64(i % active_validator_count), active_validator_count, seed)
-//        candidate_index = active_validator_indices[shuffled_index]
-//        random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
-//        effective_balance = state.validators[candidate_index].effective_balance
-//        if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:
-//            sync_committee_indices.append(candidate_index)
-//        i += 1
-//    return sync_committee_indices
-func NextSyncCommitteeIndices(ctx context.Context, s state.BeaconStateAltair) ([]types.ValidatorIndex, error) {
-	epoch := coreTime.NextEpoch(s)
-	indices, err := helpers.ActiveValidatorIndices(ctx, s, epoch)
-	if err != nil {
-		return nil, err
-	}
-	seed, err := helpers.Seed(s, epoch, params.BeaconConfig().DomainSyncCommittee)
-	if err != nil {
-		return nil, err
-	}
-	count := uint64(len(indices))
-	cfg := params.BeaconConfig()
-	syncCommitteeSize := cfg.SyncCommitteeSize
-	cIndices := make([]types.ValidatorIndex, 0, syncCommitteeSize)
-	hashFunc := hash.CustomSHA256Hasher()
-
-	for i := types.ValidatorIndex(0); uint64(len(cIndices)) < params.BeaconConfig().SyncCommitteeSize; i++ {
-		if ctx.Err() != nil {
-			return nil, ctx.Err()
-		}
-
-		sIndex, err := helpers.ComputeShuffledIndex(i.Mod(count), count, seed, true)
-		if err != nil {
-			return nil, err
-		}
-
-		b := append(seed[:], bytesutil.Bytes8(uint64(i.Div(32)))...)
-		randomByte := hashFunc(b)[i%32]
-		cIndex := indices[sIndex]
-		v, err := s.ValidatorAtIndexReadOnly(cIndex)
-		if err != nil {
-			return nil, err
-		}
-
-		effectiveBal := v.EffectiveBalance()
-		if effectiveBal*maxRandomByte >= cfg.MaxEffectiveBalance*uint64(randomByte) {
-			cIndices = append(cIndices, cIndex)
-		}
-	}
-
-	return cIndices, nil
-}
-
-// SyncSubCommitteePubkeys returns the pubkeys participating in a sync subcommittee.
-//
-// def get_sync_subcommittee_pubkeys(state: BeaconState, subcommittee_index: uint64) -> Sequence[BLSPubkey]:
-//    # Committees assigned to `slot` sign for `slot - 1`
-//    # This creates the exceptional logic below when transitioning between sync committee periods
-//    next_slot_epoch = compute_epoch_at_slot(Slot(state.slot + 1))
-//    if compute_sync_committee_period(get_current_epoch(state)) == compute_sync_committee_period(next_slot_epoch):
-//        sync_committee = state.current_sync_committee
-//    else:
-//        sync_committee = state.next_sync_committee
-//
-//    # Return pubkeys for the subcommittee index
-//    sync_subcommittee_size = SYNC_COMMITTEE_SIZE // SYNC_COMMITTEE_SUBNET_COUNT
-//    i = subcommittee_index * sync_subcommittee_size
-//    return sync_committee.pubkeys[i:i + sync_subcommittee_size]
-func SyncSubCommitteePubkeys(syncCommittee *ethpb.SyncCommittee, subComIdx types.CommitteeIndex) ([][]byte, error) {
-	cfg := params.BeaconConfig()
-	subCommSize := cfg.SyncCommitteeSize / cfg.SyncCommitteeSubnetCount
-	i := uint64(subComIdx) * subCommSize
-	endOfSubCom := i + subCommSize
-	pubkeyLen := uint64(len(syncCommittee.Pubkeys))
-	if endOfSubCom > pubkeyLen {
-		return nil, errors.Errorf("end index is larger than array length: %d > %d", endOfSubCom, pubkeyLen)
-	}
-	return syncCommittee.Pubkeys[i:endOfSubCom], nil
-}
-
-// IsSyncCommitteeAggregator checks whether the provided signature is for a valid
-// aggregator.
-//
-// def is_sync_committee_aggregator(signature: BLSSignature) -> bool:
-//    modulo = max(1, SYNC_COMMITTEE_SIZE // SYNC_COMMITTEE_SUBNET_COUNT // TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE)
-//    return bytes_to_uint64(hash(signature)[0:8]) % modulo == 0
-func IsSyncCommitteeAggregator(sig []byte) (bool, error) {
-	if len(sig) != params.BeaconConfig().BLSSignatureLength {
-		return false, errors.New("incorrect sig length")
-	}
-
-	cfg := params.BeaconConfig()
-	modulo := math.Max(1, cfg.SyncCommitteeSize/cfg.SyncCommitteeSubnetCount/cfg.TargetAggregatorsPerSyncSubcommittee)
-	hashedSig := hash.Hash(sig)
-	return bytesutil.FromBytes8(hashedSig[:8])%modulo == 0, nil
-}
-
-// ValidateSyncMessageTime validates sync message to ensure that the provided slot is valid.
-func ValidateSyncMessageTime(slot types.Slot, genesisTime time.Time, clockDisparity time.Duration) error {
-	if err := slots.ValidateClock(slot, uint64(genesisTime.Unix())); err != nil {
-		return err
-	}
-	messageTime, err := slots.ToTime(uint64(genesisTime.Unix()), slot)
-	if err != nil {
-		return err
-	}
-	currentSlot := slots.Since(genesisTime)
-	slotStartTime, err := slots.ToTime(uint64(genesisTime.Unix()), currentSlot)
-	if err != nil {
-		return err
-	}
-
-	lowestSlotBound := slotStartTime.Add(-clockDisparity)
-	currentLowerBound := time.Now().Add(-clockDisparity)
-	// In the event the Slot's start time, is before the
-	// current allowable bound, we set the slot's start
-	// time as the bound.
-	if slotStartTime.Before(currentLowerBound) {
-		lowestSlotBound = slotStartTime
-	}
-
-	lowerBound := lowestSlotBound
-	upperBound := time.Now().Add(clockDisparity)
-	// Verify sync message slot is within the time range.
-	if messageTime.Before(lowerBound) || messageTime.After(upperBound) {
-		return fmt.Errorf(
-			"sync message slot %d not within allowable range of %d to %d (current slot)",
-			slot,
-			uint64(lowerBound.Unix()-genesisTime.Unix())/params.BeaconConfig().SecondsPerSlot,
-			uint64(upperBound.Unix()-genesisTime.Unix())/params.BeaconConfig().SecondsPerSlot,
-		)
-	}
-	return nil
-}
--- a/beacon-chain/core/altair/sync_committee_test.go
+++ b/beacon-chain/core/altair/sync_committee_test.go
@@ -1,402 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	prysmTime "github.com/prysmaticlabs/prysm/time"
-)
-
-func TestSyncCommitteeIndices_CanGet(t *testing.T) {
-	getState := func(t *testing.T, count uint64) *stateAltair.BeaconState {
-		validators := make([]*ethpb.Validator, count)
-		for i := 0; i < len(validators); i++ {
-			validators[i] = &ethpb.Validator{
-				ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-				EffectiveBalance: params.BeaconConfig().MinDepositAmount,
-			}
-		}
-		state, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-			Validators:  validators,
-			RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		})
-		require.NoError(t, err)
-		return state
-	}
-
-	type args struct {
-		state *stateAltair.BeaconState
-		epoch types.Epoch
-	}
-	tests := []struct {
-		name      string
-		args      args
-		wantErr   bool
-		errString string
-	}{
-		{
-			name: "nil state",
-			args: args{
-				state: nil,
-			},
-			wantErr:   true,
-			errString: "nil inner state",
-		},
-		{
-			name: "genesis validator count, epoch 0",
-			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name: "genesis validator count, epoch 100",
-			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 100,
-			},
-			wantErr: false,
-		},
-		{
-			name: "less than optimal validator count, epoch 100",
-			args: args{
-				state: getState(t, params.BeaconConfig().MaxValidatorsPerCommittee),
-				epoch: 100,
-			},
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			helpers.ClearCache()
-			got, err := altair.NextSyncCommitteeIndices(context.Background(), tt.args.state)
-			if tt.wantErr {
-				require.ErrorContains(t, tt.errString, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, int(params.BeaconConfig().SyncCommitteeSize), len(got))
-			}
-		})
-	}
-}
-
-func TestSyncCommitteeIndices_DifferentPeriods(t *testing.T) {
-	helpers.ClearCache()
-	getState := func(t *testing.T, count uint64) *stateAltair.BeaconState {
-		validators := make([]*ethpb.Validator, count)
-		for i := 0; i < len(validators); i++ {
-			validators[i] = &ethpb.Validator{
-				ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-				EffectiveBalance: params.BeaconConfig().MinDepositAmount,
-			}
-		}
-		state, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-			Validators:  validators,
-			RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		})
-		require.NoError(t, err)
-		return state
-	}
-
-	state := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	got1, err := altair.NextSyncCommitteeIndices(context.Background(), state)
-	require.NoError(t, err)
-	require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-	got2, err := altair.NextSyncCommitteeIndices(context.Background(), state)
-	require.NoError(t, err)
-	require.DeepNotEqual(t, got1, got2)
-	require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod)))
-	got2, err = altair.NextSyncCommitteeIndices(context.Background(), state)
-	require.NoError(t, err)
-	require.DeepNotEqual(t, got1, got2)
-	require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(2*params.BeaconConfig().EpochsPerSyncCommitteePeriod)))
-	got2, err = altair.NextSyncCommitteeIndices(context.Background(), state)
-	require.NoError(t, err)
-	require.DeepNotEqual(t, got1, got2)
-}
-
-func TestSyncCommittee_CanGet(t *testing.T) {
-	getState := func(t *testing.T, count uint64) *stateAltair.BeaconState {
-		validators := make([]*ethpb.Validator, count)
-		for i := 0; i < len(validators); i++ {
-			blsKey, err := bls.RandKey()
-			require.NoError(t, err)
-			validators[i] = &ethpb.Validator{
-				ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-				EffectiveBalance: params.BeaconConfig().MinDepositAmount,
-				PublicKey:        blsKey.PublicKey().Marshal(),
-			}
-		}
-		state, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-			Validators:  validators,
-			RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		})
-		require.NoError(t, err)
-		return state
-	}
-
-	type args struct {
-		state *stateAltair.BeaconState
-		epoch types.Epoch
-	}
-	tests := []struct {
-		name      string
-		args      args
-		wantErr   bool
-		errString string
-	}{
-		{
-			name: "nil state",
-			args: args{
-				state: nil,
-			},
-			wantErr:   true,
-			errString: "nil inner state",
-		},
-		{
-			name: "genesis validator count, epoch 0",
-			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name: "genesis validator count, epoch 100",
-			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 100,
-			},
-			wantErr: false,
-		},
-		{
-			name: "less than optimal validator count, epoch 100",
-			args: args{
-				state: getState(t, params.BeaconConfig().MaxValidatorsPerCommittee),
-				epoch: 100,
-			},
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			helpers.ClearCache()
-			if !tt.wantErr {
-				require.NoError(t, tt.args.state.SetSlot(types.Slot(tt.args.epoch)*params.BeaconConfig().SlotsPerEpoch))
-			}
-			got, err := altair.NextSyncCommittee(context.Background(), tt.args.state)
-			if tt.wantErr {
-				require.ErrorContains(t, tt.errString, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, int(params.BeaconConfig().SyncCommitteeSize), len(got.Pubkeys))
-				require.Equal(t, params.BeaconConfig().BLSPubkeyLength, len(got.AggregatePubkey))
-			}
-		})
-	}
-}
-
-func TestValidateNilSyncContribution(t *testing.T) {
-	tests := []struct {
-		name    string
-		s       *ethpb.SignedContributionAndProof
-		wantErr bool
-	}{
-		{
-			name:    "nil object",
-			s:       nil,
-			wantErr: true,
-		},
-		{
-			name:    "nil message",
-			s:       &ethpb.SignedContributionAndProof{},
-			wantErr: true,
-		},
-		{
-			name:    "nil contribution",
-			s:       &ethpb.SignedContributionAndProof{Message: &ethpb.ContributionAndProof{}},
-			wantErr: true,
-		},
-		{
-			name: "nil bitfield",
-			s: &ethpb.SignedContributionAndProof{
-				Message: &ethpb.ContributionAndProof{
-					Contribution: &ethpb.SyncCommitteeContribution{},
-				}},
-			wantErr: true,
-		},
-		{
-			name: "non nil sync contribution",
-			s: &ethpb.SignedContributionAndProof{
-				Message: &ethpb.ContributionAndProof{
-					Contribution: &ethpb.SyncCommitteeContribution{
-						AggregationBits: []byte{},
-					},
-				}},
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := altair.ValidateNilSyncContribution(tt.s); (err != nil) != tt.wantErr {
-				t.Errorf("ValidateNilSyncContribution() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestSyncSubCommitteePubkeys_CanGet(t *testing.T) {
-	helpers.ClearCache()
-	state := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	com, err := altair.NextSyncCommittee(context.Background(), state)
-	require.NoError(t, err)
-	sub, err := altair.SyncSubCommitteePubkeys(com, 0)
-	require.NoError(t, err)
-	subCommSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
-	require.Equal(t, int(subCommSize), len(sub))
-	require.DeepSSZEqual(t, com.Pubkeys[0:subCommSize], sub)
-
-	sub, err = altair.SyncSubCommitteePubkeys(com, 1)
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, com.Pubkeys[subCommSize:2*subCommSize], sub)
-
-	sub, err = altair.SyncSubCommitteePubkeys(com, 2)
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, com.Pubkeys[2*subCommSize:3*subCommSize], sub)
-
-	sub, err = altair.SyncSubCommitteePubkeys(com, 3)
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, com.Pubkeys[3*subCommSize:], sub)
-
-}
-
-func Test_ValidateSyncMessageTime(t *testing.T) {
-	if params.BeaconNetworkConfig().MaximumGossipClockDisparity < 200*time.Millisecond {
-		t.Fatal("This test expects the maximum clock disparity to be at least 200ms")
-	}
-
-	type args struct {
-		syncMessageSlot types.Slot
-		genesisTime     time.Time
-	}
-	tests := []struct {
-		name      string
-		args      args
-		wantedErr string
-	}{
-		{
-			name: "sync_message.slot == current_slot",
-			args: args{
-				syncMessageSlot: 15,
-				genesisTime:     prysmTime.Now().Add(-15 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
-			},
-		},
-		{
-			name: "sync_message.slot == current_slot, received in middle of slot",
-			args: args{
-				syncMessageSlot: 15,
-				genesisTime: prysmTime.Now().Add(
-					-15 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second,
-				).Add(-(time.Duration(params.BeaconConfig().SecondsPerSlot/2) * time.Second)),
-			},
-		},
-		{
-			name: "sync_message.slot == current_slot, received 200ms early",
-			args: args{
-				syncMessageSlot: 16,
-				genesisTime: prysmTime.Now().Add(
-					-16 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second,
-				).Add(-200 * time.Millisecond),
-			},
-		},
-		{
-			name: "sync_message.slot > current_slot",
-			args: args{
-				syncMessageSlot: 16,
-				genesisTime:     prysmTime.Now().Add(-(15 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)),
-			},
-			wantedErr: "sync message slot 16 not within allowable range of",
-		},
-		{
-			name: "sync_message.slot == current_slot+CLOCK_DISPARITY",
-			args: args{
-				syncMessageSlot: 100,
-				genesisTime:     prysmTime.Now().Add(-(100*time.Duration(params.BeaconConfig().SecondsPerSlot)*time.Second - params.BeaconNetworkConfig().MaximumGossipClockDisparity)),
-			},
-			wantedErr: "",
-		},
-		{
-			name: "sync_message.slot == current_slot+CLOCK_DISPARITY-1000ms",
-			args: args{
-				syncMessageSlot: 100,
-				genesisTime:     prysmTime.Now().Add(-(100 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second) + params.BeaconNetworkConfig().MaximumGossipClockDisparity + 1000*time.Millisecond),
-			},
-			wantedErr: "sync message slot 100 not within allowable range of",
-		},
-		{
-			name: "sync_message.slot == current_slot-CLOCK_DISPARITY",
-			args: args{
-				syncMessageSlot: 100,
-				genesisTime:     prysmTime.Now().Add(-(100*time.Duration(params.BeaconConfig().SecondsPerSlot)*time.Second + params.BeaconNetworkConfig().MaximumGossipClockDisparity)),
-			},
-			wantedErr: "",
-		},
-		{
-			name: "sync_message.slot > current_slot+CLOCK_DISPARITY",
-			args: args{
-				syncMessageSlot: 101,
-				genesisTime:     prysmTime.Now().Add(-(100*time.Duration(params.BeaconConfig().SecondsPerSlot)*time.Second + params.BeaconNetworkConfig().MaximumGossipClockDisparity)),
-			},
-			wantedErr: "sync message slot 101 not within allowable range of",
-		},
-		{
-			name: "sync_message.slot is well beyond current slot",
-			args: args{
-				syncMessageSlot: 1 << 32,
-				genesisTime:     prysmTime.Now().Add(-15 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
-			},
-			wantedErr: "which exceeds max allowed value relative to the local clock",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := altair.ValidateSyncMessageTime(tt.args.syncMessageSlot, tt.args.genesisTime,
-				params.BeaconNetworkConfig().MaximumGossipClockDisparity)
-			if tt.wantedErr != "" {
-				assert.ErrorContains(t, tt.wantedErr, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
-func getState(t *testing.T, count uint64) *stateAltair.BeaconState {
-	validators := make([]*ethpb.Validator, count)
-	for i := 0; i < len(validators); i++ {
-		blsKey, err := bls.RandKey()
-		require.NoError(t, err)
-		validators[i] = &ethpb.Validator{
-			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance: params.BeaconConfig().MinDepositAmount,
-			PublicKey:        blsKey.PublicKey().Marshal(),
-		}
-	}
-	state, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Validators:  validators,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
-	return state
-}
--- a/beacon-chain/core/altair/transition.go
+++ b/beacon-chain/core/altair/transition.go
@@ -1,111 +0,0 @@
-package altair
-
-import (
-	"context"
-
-	"github.com/pkg/errors"
-	e "github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"go.opencensus.io/trace"
-)
-
-// ProcessEpoch describes the per epoch operations that are performed on the beacon state.
-// It's optimized by pre computing validator attested info and epoch total/attested balances upfront.
-//
-// Spec code:
-// def process_epoch(state: BeaconState) -> None:
-//    process_justification_and_finalization(state)  # [Modified in Altair]
-//    process_inactivity_updates(state)  # [New in Altair]
-//    process_rewards_and_penalties(state)  # [Modified in Altair]
-//    process_registry_updates(state)
-//    process_slashings(state)  # [Modified in Altair]
-//    process_eth1_data_reset(state)
-//    process_effective_balance_updates(state)
-//    process_slashings_reset(state)
-//    process_randao_mixes_reset(state)
-//    process_historical_roots_update(state)
-//    process_participation_flag_updates(state)  # [New in Altair]
-//    process_sync_committee_updates(state)  # [New in Altair]
-func ProcessEpoch(ctx context.Context, state state.BeaconStateAltair) (state.BeaconStateAltair, error) {
-	ctx, span := trace.StartSpan(ctx, "altair.ProcessEpoch")
-	defer span.End()
-
-	if state == nil || state.IsNil() {
-		return nil, errors.New("nil state")
-	}
-	vp, bp, err := InitializePrecomputeValidators(ctx, state)
-	if err != nil {
-		return nil, err
-	}
-
-	// New in Altair.
-	vp, bp, err = ProcessEpochParticipation(ctx, state, bp, vp)
-	if err != nil {
-		return nil, err
-	}
-
-	state, err = precompute.ProcessJustificationAndFinalizationPreCompute(state, bp)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process justification")
-	}
-
-	// New in Altair.
-	state, vp, err = ProcessInactivityScores(ctx, state, vp)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process inactivity updates")
-	}
-
-	// New in Altair.
-	state, err = ProcessRewardsAndPenaltiesPrecompute(state, bp, vp)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process rewards and penalties")
-	}
-
-	state, err = e.ProcessRegistryUpdates(ctx, state)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process registry updates")
-	}
-
-	// Modified in Altair.
-	state, err = e.ProcessSlashings(state, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
-	if err != nil {
-		return nil, err
-	}
-
-	state, err = e.ProcessEth1DataReset(state)
-	if err != nil {
-		return nil, err
-	}
-	state, err = e.ProcessEffectiveBalanceUpdates(state)
-	if err != nil {
-		return nil, err
-	}
-	state, err = e.ProcessSlashingsReset(state)
-	if err != nil {
-		return nil, err
-	}
-	state, err = e.ProcessRandaoMixesReset(state)
-	if err != nil {
-		return nil, err
-	}
-	state, err = e.ProcessHistoricalRootsUpdate(state)
-	if err != nil {
-		return nil, err
-	}
-
-	// New in Altair.
-	state, err = ProcessParticipationFlagUpdates(state)
-	if err != nil {
-		return nil, err
-	}
-
-	// New in Altair.
-	state, err = ProcessSyncCommitteeUpdates(ctx, state)
-	if err != nil {
-		return nil, err
-	}
-
-	return state, nil
-}
--- a/beacon-chain/core/altair/transition_test.go
+++ b/beacon-chain/core/altair/transition_test.go
@@ -1,43 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestProcessEpoch_CanProcess(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
-	newState, err := altair.ProcessEpoch(context.Background(), st)
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), newState.Slashings()[2], "Unexpected slashed balance")
-
-	b := st.Balances()
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(b)))
-	require.Equal(t, uint64(31999841265), b[0])
-
-	s, err := st.InactivityScores()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(s)))
-
-	p, err := st.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
-
-	p, err = st.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
-
-	sc, err := st.CurrentSyncCommittee()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
-
-	sc, err = st.NextSyncCommittee()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
-}
--- a/beacon-chain/core/altair/upgrade.go
+++ b/beacon-chain/core/altair/upgrade.go
@@ -1,202 +0,0 @@
-package altair
-
-import (
-	"context"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	statealtair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-)
-
-// UpgradeToAltair updates input state to return the version Altair state.
-//
-// Spec code:
-// def upgrade_to_altair(pre: phase0.BeaconState) -> BeaconState:
-//    epoch = phase0.get_current_epoch(pre)
-//    post = BeaconState(
-//        # Versioning
-//        genesis_time=pre.genesis_time,
-//        genesis_validators_root=pre.genesis_validators_root,
-//        slot=pre.slot,
-//        fork=Fork(
-//            previous_version=pre.fork.current_version,
-//            current_version=ALTAIR_FORK_VERSION,
-//            epoch=epoch,
-//        ),
-//        # History
-//        latest_block_header=pre.latest_block_header,
-//        block_roots=pre.block_roots,
-//        state_roots=pre.state_roots,
-//        historical_roots=pre.historical_roots,
-//        # Eth1
-//        eth1_data=pre.eth1_data,
-//        eth1_data_votes=pre.eth1_data_votes,
-//        eth1_deposit_index=pre.eth1_deposit_index,
-//        # Registry
-//        validators=pre.validators,
-//        balances=pre.balances,
-//        # Randomness
-//        randao_mixes=pre.randao_mixes,
-//        # Slashings
-//        slashings=pre.slashings,
-//        # Participation
-//        previous_epoch_participation=[ParticipationFlags(0b0000_0000) for _ in range(len(pre.validators))],
-//        current_epoch_participation=[ParticipationFlags(0b0000_0000) for _ in range(len(pre.validators))],
-//        # Finality
-//        justification_bits=pre.justification_bits,
-//        previous_justified_checkpoint=pre.previous_justified_checkpoint,
-//        current_justified_checkpoint=pre.current_justified_checkpoint,
-//        finalized_checkpoint=pre.finalized_checkpoint,
-//        # Inactivity
-//        inactivity_scores=[uint64(0) for _ in range(len(pre.validators))],
-//    )
-//    # Fill in previous epoch participation from the pre state's pending attestations
-//    translate_participation(post, pre.previous_epoch_attestations)
-//
-//    # Fill in sync committees
-//    # Note: A duplicate committee is assigned for the current and next committee at the fork boundary
-//    post.current_sync_committee = get_next_sync_committee(post)
-//    post.next_sync_committee = get_next_sync_committee(post)
-//    return post
-func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.BeaconStateAltair, error) {
-	epoch := time.CurrentEpoch(state)
-
-	numValidators := state.NumValidators()
-	s := &ethpb.BeaconStateAltair{
-		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: state.GenesisValidatorRoot(),
-		Slot:                  state.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: state.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().AltairForkVersion,
-			Epoch:           epoch,
-		},
-		LatestBlockHeader:           state.LatestBlockHeader(),
-		BlockRoots:                  state.BlockRoots(),
-		StateRoots:                  state.StateRoots(),
-		HistoricalRoots:             state.HistoricalRoots(),
-		Eth1Data:                    state.Eth1Data(),
-		Eth1DataVotes:               state.Eth1DataVotes(),
-		Eth1DepositIndex:            state.Eth1DepositIndex(),
-		Validators:                  state.Validators(),
-		Balances:                    state.Balances(),
-		RandaoMixes:                 state.RandaoMixes(),
-		Slashings:                   state.Slashings(),
-		PreviousEpochParticipation:  make([]byte, numValidators),
-		CurrentEpochParticipation:   make([]byte, numValidators),
-		JustificationBits:           state.JustificationBits(),
-		PreviousJustifiedCheckpoint: state.PreviousJustifiedCheckpoint(),
-		CurrentJustifiedCheckpoint:  state.CurrentJustifiedCheckpoint(),
-		FinalizedCheckpoint:         state.FinalizedCheckpoint(),
-		InactivityScores:            make([]uint64, numValidators),
-	}
-
-	newState, err := statealtair.InitializeFromProto(s)
-	if err != nil {
-		return nil, err
-	}
-	prevEpochAtts, err := state.PreviousEpochAttestations()
-	if err != nil {
-		return nil, err
-	}
-	newState, err = TranslateParticipation(ctx, newState, prevEpochAtts)
-	if err != nil {
-		return nil, err
-	}
-
-	committee, err := NextSyncCommittee(ctx, newState)
-	if err != nil {
-		return nil, err
-	}
-	if err := newState.SetCurrentSyncCommittee(committee); err != nil {
-		return nil, err
-	}
-	if err := newState.SetNextSyncCommittee(committee); err != nil {
-		return nil, err
-	}
-	return newState, nil
-}
-
-// TranslateParticipation translates pending attestations into participation bits, then inserts the bits into beacon state.
-// This is helper function to convert phase 0 beacon state(pending_attestations) to Altair beacon state(participation_bits).
-//
-// Spec code:
-// def translate_participation(state: BeaconState, pending_attestations: Sequence[phase0.PendingAttestation]) -> None:
-//    for attestation in pending_attestations:
-//        data = attestation.data
-//        inclusion_delay = attestation.inclusion_delay
-//        # Translate attestation inclusion info to flag indices
-//        participation_flag_indices = get_attestation_participation_flag_indices(state, data, inclusion_delay)
-//
-//        # Apply flags to all attesting validators
-//        epoch_participation = state.previous_epoch_participation
-//        for index in get_attesting_indices(state, data, attestation.aggregation_bits):
-//            for flag_index in participation_flag_indices:
-//                epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-func TranslateParticipation(ctx context.Context, state *statealtair.BeaconState, atts []*ethpb.PendingAttestation) (*statealtair.BeaconState, error) {
-	epochParticipation, err := state.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-
-	for _, att := range atts {
-		participatedFlags, err := AttestationParticipationFlagIndices(state, att.Data, att.InclusionDelay)
-		if err != nil {
-			return nil, err
-		}
-		committee, err := helpers.BeaconCommitteeFromState(ctx, state, att.Data.Slot, att.Data.CommitteeIndex)
-		if err != nil {
-			return nil, err
-		}
-		indices, err := attestation.AttestingIndices(att.AggregationBits, committee)
-		if err != nil {
-			return nil, err
-		}
-		cfg := params.BeaconConfig()
-		sourceFlagIndex := cfg.TimelySourceFlagIndex
-		targetFlagIndex := cfg.TimelyTargetFlagIndex
-		headFlagIndex := cfg.TimelyHeadFlagIndex
-		for _, index := range indices {
-			has, err := HasValidatorFlag(epochParticipation[index], sourceFlagIndex)
-			if err != nil {
-				return nil, err
-			}
-			if participatedFlags[sourceFlagIndex] && !has {
-				epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], sourceFlagIndex)
-				if err != nil {
-					return nil, err
-				}
-			}
-			has, err = HasValidatorFlag(epochParticipation[index], targetFlagIndex)
-			if err != nil {
-				return nil, err
-			}
-			if participatedFlags[targetFlagIndex] && !has {
-				epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], targetFlagIndex)
-				if err != nil {
-					return nil, err
-				}
-			}
-			has, err = HasValidatorFlag(epochParticipation[index], headFlagIndex)
-			if err != nil {
-				return nil, err
-			}
-			if participatedFlags[headFlagIndex] && !has {
-				epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], headFlagIndex)
-				if err != nil {
-					return nil, err
-				}
-			}
-		}
-	}
-
-	if err := state.SetPreviousParticipationBits(epochParticipation); err != nil {
-		return nil, err
-	}
-
-	return state, nil
-}
--- a/beacon-chain/core/altair/upgrade_test.go
+++ b/beacon-chain/core/altair/upgrade_test.go
@@ -1,122 +0,0 @@
-package altair_test
-
-import (
-	"context"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func TestTranslateParticipation(t *testing.T) {
-	ctx := context.Background()
-	s, _ := util.DeterministicGenesisStateAltair(t, 64)
-	st, ok := s.(*stateAltair.BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, st.SetSlot(st.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
-
-	var err error
-	newState, err := altair.TranslateParticipation(ctx, st, nil)
-	require.NoError(t, err)
-	participation, err := newState.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, 64), participation)
-
-	aggBits := bitfield.NewBitlist(2)
-	aggBits.SetBitAt(0, true)
-	aggBits.SetBitAt(1, true)
-	r, err := helpers.BlockRootAtSlot(s, 0)
-	require.NoError(t, err)
-	var pendingAtts []*ethpb.PendingAttestation
-	for i := 0; i < 3; i++ {
-		pendingAtts = append(pendingAtts, &ethpb.PendingAttestation{
-			Data: &ethpb.AttestationData{
-				CommitteeIndex:  types.CommitteeIndex(i),
-				BeaconBlockRoot: r,
-				Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-				Target:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
-			},
-			AggregationBits: aggBits,
-			InclusionDelay:  1,
-		})
-	}
-
-	newState, err = altair.TranslateParticipation(ctx, newState, pendingAtts)
-	require.NoError(t, err)
-	participation, err = newState.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepNotSSZEqual(t, make([]byte, 64), participation)
-
-	committee, err := helpers.BeaconCommitteeFromState(ctx, st, pendingAtts[0].Data.Slot, pendingAtts[0].Data.CommitteeIndex)
-	require.NoError(t, err)
-	indices, err := attestation.AttestingIndices(pendingAtts[0].AggregationBits, committee)
-	require.NoError(t, err)
-	for _, index := range indices {
-		has, err := altair.HasValidatorFlag(participation[index], params.BeaconConfig().TimelySourceFlagIndex)
-		require.NoError(t, err)
-		require.Equal(t, true, has)
-		has, err = altair.HasValidatorFlag(participation[index], params.BeaconConfig().TimelyTargetFlagIndex)
-		require.NoError(t, err)
-		require.Equal(t, true, has)
-		has, err = altair.HasValidatorFlag(participation[index], params.BeaconConfig().TimelyHeadFlagIndex)
-		require.NoError(t, err)
-		require.Equal(t, true, has)
-	}
-}
-
-func TestUpgradeToAltair(t *testing.T) {
-	st, _ := util.DeterministicGenesisState(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	preForkState := st.Copy()
-	aState, err := altair.UpgradeToAltair(context.Background(), st)
-	require.NoError(t, err)
-
-	require.Equal(t, preForkState.GenesisTime(), aState.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorRoot(), aState.GenesisValidatorRoot())
-	require.Equal(t, preForkState.Slot(), aState.Slot())
-	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), aState.LatestBlockHeader())
-	require.DeepSSZEqual(t, preForkState.BlockRoots(), aState.BlockRoots())
-	require.DeepSSZEqual(t, preForkState.StateRoots(), aState.StateRoots())
-	require.DeepSSZEqual(t, preForkState.HistoricalRoots(), aState.HistoricalRoots())
-	require.DeepSSZEqual(t, preForkState.Eth1Data(), aState.Eth1Data())
-	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), aState.Eth1DataVotes())
-	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), aState.Eth1DepositIndex())
-	require.DeepSSZEqual(t, preForkState.Validators(), aState.Validators())
-	require.DeepSSZEqual(t, preForkState.Balances(), aState.Balances())
-	require.DeepSSZEqual(t, preForkState.RandaoMixes(), aState.RandaoMixes())
-	require.DeepSSZEqual(t, preForkState.Slashings(), aState.Slashings())
-	require.DeepSSZEqual(t, preForkState.JustificationBits(), aState.JustificationBits())
-	require.DeepSSZEqual(t, preForkState.PreviousJustifiedCheckpoint(), aState.PreviousJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.CurrentJustifiedCheckpoint(), aState.CurrentJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.FinalizedCheckpoint(), aState.FinalizedCheckpoint())
-	numValidators := aState.NumValidators()
-	p, err := aState.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-	p, err = aState.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-	s, err := aState.InactivityScores()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]uint64, numValidators), s)
-
-	f := aState.Fork()
-	require.DeepSSZEqual(t, &ethpb.Fork{
-		PreviousVersion: st.Fork().CurrentVersion,
-		CurrentVersion:  params.BeaconConfig().AltairForkVersion,
-		Epoch:           time.CurrentEpoch(st),
-	}, f)
-	csc, err := aState.CurrentSyncCommittee()
-	require.NoError(t, err)
-	nsc, err := aState.NextSyncCommittee()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, nsc, csc)
-}
--- a/beacon-chain/core/blocks/BUILD.bazel
+++ b/beacon-chain/core/blocks/BUILD.bazel
@@ -18,32 +18,29 @@ go_library(
    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks",
    visibility = [
        "//beacon-chain:__subpackages__",
-        "//testing/fuzz:__pkg__",
-        "//testing/spectest:__subpackages__",
-        "//testing/util:__pkg__",
-        "//validator:__subpackages__",
+        "//fuzz:__pkg__",
+        "//shared/testutil:__pkg__",
+        "//spectest:__subpackages__",
+        "//validator/accounts:__pkg__",
    ],
    deps = [
        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
        "//beacon-chain/core/validators:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/params:go_default_library",
-        "//container/slice:go_default_library",
-        "//container/trie:go_default_library",
-        "//contracts/deposit:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
-        "//network/forks:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
-        "//proto/prysm/v1alpha1/block:go_default_library",
-        "//proto/prysm/v1alpha1/slashings:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
+        "//beacon-chain/state/interface:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//proto/interfaces:go_default_library",
+        "//shared/attestationutil:go_default_library",
+        "//shared/bls:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/copyutil:go_default_library",
+        "//shared/depositutil:go_default_library",
+        "//shared/hashutil:go_default_library",
+        "//shared/mathutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/slashutil:go_default_library",
+        "//shared/sliceutil:go_default_library",
+        "//shared/trieutil: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",
@@ -69,32 +66,30 @@ go_test(
        "proposer_slashing_regression_test.go",
        "proposer_slashing_test.go",
        "randao_test.go",
-        "signature_test.go",
    ],
    data = glob(["testdata/**"]),
    embed = [":go_default_library"],
    shard_count = 2,
    deps = [
        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
        "//beacon-chain/core/validators:go_default_library",
        "//beacon-chain/p2p/types:go_default_library",
-        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/interface:go_default_library",
        "//beacon-chain/state/v1:go_default_library",
-        "//config/params:go_default_library",
-        "//container/trie:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
-        "//proto/prysm/v1alpha1/attestation/aggregation:go_default_library",
-        "//proto/prysm/v1alpha1/attestation/aggregation/attestations: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",
-        "//time/slots:go_default_library",
+        "//proto/beacon/p2p/v1:go_default_library",
+        "//proto/eth/v1alpha1:go_default_library",
+        "//proto/eth/v1alpha1/wrapper:go_default_library",
+        "//shared/aggregation:go_default_library",
+        "//shared/aggregation/attestations:go_default_library",
+        "//shared/attestationutil:go_default_library",
+        "//shared/bls:go_default_library",
+        "//shared/bytesutil:go_default_library",
+        "//shared/copyutil:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
+        "//shared/trieutil:go_default_library",
        "@com_github_google_gofuzz//:go_default_library",
        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .2.1
 .7.0