Correctly filter sync committee message at period boundary (#9626)

* Add head sync committee indices with slot consideration

* Apply rpc

* Apply sync

* Update tests

* Update mock.go

* Update sync_committee_test.go

* Update validator_test.go

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>

.bazelrc

@@ -21,31 +21,18 @@ run --host_force_python=PY2
 build --sandbox_default_allow_network=false
 
 # Stamp binaries with git information
-build --workspace_status_command=./scripts/workspace_status.sh
+build --workspace_status_command=./hack/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
 

.buildkite-bazelrc

@@ -43,3 +43,7 @@ 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

.github/workflows/go.yml

@@ -31,6 +31,10 @@ jobs:
         with:
           goimports-path: ./
 
+      - name: Gosec security scanner
+        uses: securego/gosec@master
+        with:
+          args: '-exclude-dir=crypto/bls/herumi ./...'
   build:
     name: Build
     runs-on: ubuntu-latest

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
-./scripts/update-go-pbs.sh
-./scripts/update-go-ssz.sh
+./hack/update-go-pbs.sh
+./hack/update-go-ssz.sh
 ```
 
 *Recommendation: Use go build only for local development and use bazel build for production.*

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/eth2.0-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/consensus-specs/tree/v1.0.0)
 [![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
 
 This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the [Ethereum Consensus](https://ethereum.org/en/eth2/) specification, developed by [Prysmatic Labs](https://prysmaticlabs.com). See the [Changelog](https://github.com/prysmaticlabs/prysm/releases) for details of the latest releases and upcoming breaking changes.

SECURITY.md

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

WORKSPACE

@@ -197,8 +197,12 @@ filegroup(
     url = "https://github.com/eth2-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
+consensus_spec_version = "v1.1.0-beta.4"
+
+bls_test_version = "v0.1.1"
+
 http_archive(
-    name = "eth2_spec_tests_general",
+    name = "consensus_spec_tests_general",
     build_file_content = """
 filegroup(
     name = "test_data",
@@ -209,12 +213,12 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "deacc076365c727d653ac064894ecf0d1b0a675d86704dc8de271259f6a7314b",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v1.1.0-alpha.3/general.tar.gz",
+    sha256 = "d2d501453cf29777896a5f9ae52e93921f34330e57fcc5b55e4982d4795236b9",
+    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
 http_archive(
-    name = "eth2_spec_tests_minimal",
+    name = "consensus_spec_tests_minimal",
     build_file_content = """
 filegroup(
     name = "test_data",
@@ -225,12 +229,12 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "6e9886af3d2f024e563249d70388129e28e3e92f742f289238ed9b7ec7a7f930",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v1.1.0-alpha.3/minimal.tar.gz",
+    sha256 = "b152f1f03a4fdacd1882fe867bdfbd5067e74ed3c532bd01d81e7adf6cc3737a",
+    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
 http_archive(
-    name = "eth2_spec_tests_mainnet",
+    name = "consensus_spec_tests_mainnet",
     build_file_content = """
 filegroup(
     name = "test_data",
@@ -241,8 +245,55 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "a7b3d0ffc02a567250f424d69b2474fdc9477cd56eada60af7474560b46a8527",
-    url = "https://github.com/ethereum/eth2.0-spec-tests/releases/download/v1.1.0-alpha.3/mainnet.tar.gz",
+    sha256 = "6046f89c679a9ffda217dee6f021eb7c4fe91aad6ff940fae4d2cf894cc61cbb",
+    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 = "26a0a2c3022a3c5354f3204c7e441580df2e585dbde22a43a1d43f885b3a221c",
+    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",
 )
 
 http_archive(
@@ -262,27 +313,6 @@ 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",

api/gateway/BUILD.bazel

@@ -10,15 +10,15 @@ go_library(
         "log.go",
         "param_handling.go",
     ],
-    importpath = "github.com/prysmaticlabs/prysm/shared/gateway",
+    importpath = "github.com/prysmaticlabs/prysm/api/gateway",
     visibility = [
         "//beacon-chain:__subpackages__",
         "//validator:__subpackages__",
     ],
     deps = [
-        "//shared:go_default_library",
+        "//api/grpc:go_default_library",
+        "//runtime:go_default_library",
         "//shared/bytesutil:go_default_library",
-        "//shared/grpcutils:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_gorilla_mux//:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
@@ -41,8 +41,8 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api/grpc:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
-        "//shared/grpcutils:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
         "@com_github_gorilla_mux//:go_default_library",

api/gateway/api_middleware.go

@@ -27,14 +27,22 @@ type EndpointFactory interface {
 
 // 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.
-	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.
-	GetResponse        interface{}    // The struct corresponding to the JSON structure used in a GET response.
-	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.
+	Path               string          // The path of the HTTP endpoint.
+	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.
+	GetResponse        interface{}     // The struct corresponding to the JSON structure used in a GET response.
+	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.
+}
+
+// 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.
@@ -51,11 +59,12 @@ type Hook = func(endpoint Endpoint, w http.ResponseWriter, req *http.Request) Er
 // 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 handlers/hooks that can be used to amend the default request/response cycle with custom logic for a specific endpoint.
+// HookCollection contains hooks that can be used to amend the default request/response cycle with custom logic for a specific endpoint.
 type HookCollection struct {
-	CustomHandlers                            []CustomHandler
-	OnPostStart                               []Hook
-	OnPostDeserializeRequestBodyIntoContainer []Hook
+	OnPreDeserializeRequestBodyIntoContainer      []Hook
+	OnPostDeserializeRequestBodyIntoContainer     []Hook
+	OnPreDeserializeGrpcResponseBodyIntoContainer []func([]byte, interface{}) (bool, ErrorJson)
+	OnPreSerializeMiddlewareResponseIntoJson      []func(interface{}) (bool, []byte, ErrorJson)
 }
 
 // fieldProcessor applies the processing function f to a value when the tag is present on the field.
@@ -83,14 +92,14 @@ func (m *ApiProxyMiddleware) handleApiPath(path string, endpointFactory Endpoint
 			WriteError(w, errJson, nil)
 		}
 
-		for _, handler := range endpoint.Hooks.CustomHandlers {
+		for _, handler := range endpoint.CustomHandlers {
 			if handler(m, *endpoint, w, req) {
 				return
 			}
 		}
 
 		if req.Method == "POST" {
-			for _, hook := range endpoint.Hooks.OnPostStart {
+			for _, hook := range endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer {
 				if errJson := hook(*endpoint, w, req); errJson != nil {
 					WriteError(w, errJson, nil)
 					return
@@ -149,23 +158,54 @@ func (m *ApiProxyMiddleware) handleApiPath(path string, endpointFactory Endpoint
 			} else {
 				response = endpoint.PostResponse
 			}
-			if errJson := DeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, response); errJson != nil {
-				WriteError(w, errJson, nil)
-				return
+
+			runDefault := true
+			for _, hook := range endpoint.Hooks.OnPreDeserializeGrpcResponseBodyIntoContainer {
+				ok, errJson := hook(grpcResponseBody, response)
+				if errJson != nil {
+					WriteError(w, errJson, nil)
+					return
+				}
+				if ok {
+					runDefault = false
+					break
+				}
 			}
+			if runDefault {
+				if errJson := DeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, response); errJson != nil {
+					WriteError(w, errJson, nil)
+					return
+				}
+			}
+
 			if errJson := ProcessMiddlewareResponseFields(response); errJson != nil {
 				WriteError(w, errJson, nil)
 				return
 			}
-			var errJson ErrorJson
-			responseJson, errJson = SerializeMiddlewareResponseIntoJson(response)
-			if errJson != nil {
-				WriteError(w, errJson, nil)
-				return
+
+			var ok bool
+			runDefault = true
+			for _, hook := range endpoint.Hooks.OnPreSerializeMiddlewareResponseIntoJson {
+				ok, responseJson, errJson = hook(response)
+				if errJson != nil {
+					WriteError(w, errJson, nil)
+					return
+				}
+				if ok {
+					runDefault = false
+					break
+				}
+			}
+			if runDefault {
+				responseJson, errJson = SerializeMiddlewareResponseIntoJson(response)
+				if errJson != nil {
+					WriteError(w, errJson, nil)
+					return
+				}
 			}
 		}
 
-		if errJson := WriteMiddlewareResponseHeadersAndBody(req, grpcResponse, responseJson, w); errJson != nil {
+		if errJson := WriteMiddlewareResponseHeadersAndBody(grpcResponse, responseJson, w); errJson != nil {
 			WriteError(w, errJson, nil)
 			return
 		}

api/gateway/api_middleware_processing.go

@@ -15,7 +15,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/shared/grpcutils"
+	"github.com/prysmaticlabs/prysm/api/grpc"
 	"github.com/wealdtech/go-bytesutil"
 )
 
@@ -154,12 +154,12 @@ func SerializeMiddlewareResponseIntoJson(responseContainer interface{}) (jsonRes
 }
 
 // WriteMiddlewareResponseHeadersAndBody populates headers and the body of the final response.
-func WriteMiddlewareResponseHeadersAndBody(req *http.Request, grpcResp *http.Response, responseJson []byte, w http.ResponseWriter) ErrorJson {
+func WriteMiddlewareResponseHeadersAndBody(grpcResp *http.Response, responseJson []byte, w http.ResponseWriter) ErrorJson {
 	var statusCodeHeader string
 	for h, vs := range grpcResp.Header {
 		// We don't want to expose any gRPC metadata in the HTTP response, so we skip forwarding metadata headers.
 		if strings.HasPrefix(h, "Grpc-Metadata") {
-			if h == "Grpc-Metadata-"+grpcutils.HttpCodeMetadataKey {
+			if h == "Grpc-Metadata-"+grpc.HttpCodeMetadataKey {
 				statusCodeHeader = vs[0]
 			}
 		} else {
@@ -168,7 +168,7 @@ func WriteMiddlewareResponseHeadersAndBody(req *http.Request, grpcResp *http.Res
 			}
 		}
 	}
-	if responseJson != nil {
+	if !GrpcResponseIsEmpty(responseJson) {
 		w.Header().Set("Content-Length", strconv.Itoa(len(responseJson)))
 		if statusCodeHeader != "" {
 			code, err := strconv.Atoi(statusCodeHeader)
@@ -183,6 +183,7 @@ func WriteMiddlewareResponseHeadersAndBody(req *http.Request, grpcResp *http.Res
 			return InternalServerErrorWithMessage(err, "could not write response message")
 		}
 	} else {
+		w.Header().Set("Content-Length", "0")
 		w.WriteHeader(grpcResp.StatusCode)
 	}
 	return nil
@@ -192,7 +193,7 @@ func WriteMiddlewareResponseHeadersAndBody(req *http.Request, grpcResp *http.Res
 func WriteError(w http.ResponseWriter, errJson ErrorJson, responseHeader http.Header) {
 	// Include custom error in the error JSON.
 	if responseHeader != nil {
-		customError, ok := responseHeader["Grpc-Metadata-"+grpcutils.CustomErrorMetadataKey]
+		customError, ok := responseHeader["Grpc-Metadata-"+grpc.CustomErrorMetadataKey]
 		if ok {
 			// Assume header has only one value and read the 0 index.
 			if err := json.Unmarshal([]byte(customError[0]), errJson); err != nil {
@@ -293,6 +294,9 @@ func hexToBase64Processor(v reflect.Value) error {
 }
 
 func base64ToHexProcessor(v reflect.Value) error {
+	if v.String() == "" {
+		return nil
+	}
 	b, err := base64.StdEncoding.DecodeString(v.String())
 	if err != nil {
 		return err

api/gateway/api_middleware_processing_test.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/grpcutils"
+	"github.com/prysmaticlabs/prysm/api/grpc"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"github.com/sirupsen/logrus/hooks/test"
@@ -261,14 +261,11 @@ func TestSerializeMiddlewareResponseIntoJson(t *testing.T) {
 }
 
 func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
-	var body bytes.Buffer
-
 	t.Run("GET", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", &body)
 		response := &http.Response{
 			Header: http.Header{
 				"Foo": []string{"foo"},
-				"Grpc-Metadata-" + grpcutils.HttpCodeMetadataKey: []string{"204"},
+				"Grpc-Metadata-" + grpc.HttpCodeMetadataKey: []string{"204"},
 			},
 		}
 		container := defaultResponseContainer()
@@ -277,7 +274,7 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
-		errJson := WriteMiddlewareResponseHeadersAndBody(request, response, responseJson, writer)
+		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
 		require.Equal(t, true, errJson == nil)
 		v, ok := writer.Header()["Foo"]
 		require.Equal(t, true, ok, "header not found")
@@ -292,7 +289,6 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 	})
 
 	t.Run("GET_no_grpc_status_code_header", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", &body)
 		response := &http.Response{
 			Header:     http.Header{},
 			StatusCode: 204,
@@ -302,33 +298,31 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		require.NoError(t, err)
 		writer := httptest.NewRecorder()
 
-		errJson := WriteMiddlewareResponseHeadersAndBody(request, response, responseJson, writer)
+		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
 		require.Equal(t, true, errJson == nil)
 		assert.Equal(t, 204, writer.Code)
 	})
 
 	t.Run("GET_invalid_status_code", func(t *testing.T) {
-		request := httptest.NewRequest("GET", "http://foo.example", &body)
 		response := &http.Response{
 			Header: http.Header{},
 		}
 
 		// Set invalid status code.
-		response.Header["Grpc-Metadata-"+grpcutils.HttpCodeMetadataKey] = []string{"invalid"}
+		response.Header["Grpc-Metadata-"+grpc.HttpCodeMetadataKey] = []string{"invalid"}
 
 		container := defaultResponseContainer()
 		responseJson, err := json.Marshal(container)
 		require.NoError(t, err)
 		writer := httptest.NewRecorder()
 
-		errJson := WriteMiddlewareResponseHeadersAndBody(request, response, responseJson, writer)
+		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
 		require.Equal(t, false, errJson == nil)
 		assert.Equal(t, true, strings.Contains(errJson.Msg(), "could not parse status code"))
 		assert.Equal(t, http.StatusInternalServerError, errJson.StatusCode())
 	})
 
 	t.Run("POST", func(t *testing.T) {
-		request := httptest.NewRequest("POST", "http://foo.example", &body)
 		response := &http.Response{
 			Header:     http.Header{},
 			StatusCode: 204,
@@ -338,13 +332,12 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		require.NoError(t, err)
 		writer := httptest.NewRecorder()
 
-		errJson := WriteMiddlewareResponseHeadersAndBody(request, response, responseJson, writer)
+		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
 		require.Equal(t, true, errJson == nil)
 		assert.Equal(t, 204, writer.Code)
 	})
 
 	t.Run("POST_with_response_body", func(t *testing.T) {
-		request := httptest.NewRequest("POST", "http://foo.example", &body)
 		response := &http.Response{
 			Header:     http.Header{},
 			StatusCode: 204,
@@ -355,17 +348,34 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
-		errJson := WriteMiddlewareResponseHeadersAndBody(request, response, responseJson, writer)
+		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
 		require.Equal(t, true, errJson == nil)
 		assert.Equal(t, 204, writer.Code)
 		assert.DeepEqual(t, responseJson, writer.Body.Bytes())
 	})
+
+	t.Run("POST_with_empty_json_body", func(t *testing.T) {
+		response := &http.Response{
+			Header:     http.Header{},
+			StatusCode: 204,
+		}
+		responseJson, err := json.Marshal(struct{}{})
+		require.NoError(t, err)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		errJson := WriteMiddlewareResponseHeadersAndBody(response, responseJson, writer)
+		require.Equal(t, true, errJson == nil)
+		assert.Equal(t, 204, writer.Code)
+		assert.DeepEqual(t, []byte(nil), writer.Body.Bytes())
+		assert.Equal(t, "0", writer.Header()["Content-Length"][0])
+	})
 }
 
 func TestWriteError(t *testing.T) {
 	t.Run("ok", func(t *testing.T) {
 		responseHeader := http.Header{
-			"Grpc-Metadata-" + grpcutils.CustomErrorMetadataKey: []string{"{\"CustomField\":\"bar\"}"},
+			"Grpc-Metadata-" + grpc.CustomErrorMetadataKey: []string{"{\"CustomField\":\"bar\"}"},
 		}
 		errJson := &testErrorJson{
 			Message: "foo",
@@ -395,7 +405,7 @@ func TestWriteError(t *testing.T) {
 		logHook := test.NewGlobal()
 
 		responseHeader := http.Header{
-			"Grpc-Metadata-" + grpcutils.CustomErrorMetadataKey: []string{"invalid"},
+			"Grpc-Metadata-" + grpc.CustomErrorMetadataKey: []string{"invalid"},
 		}
 
 		WriteError(httptest.NewRecorder(), &testErrorJson{}, responseHeader)

api/gateway/gateway.go

@@ -12,14 +12,14 @@ import (
 
 	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/shared"
+	"github.com/prysmaticlabs/prysm/runtime"
 	"github.com/rs/cors"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/connectivity"
 	"google.golang.org/grpc/credentials"
 )
 
-var _ shared.Service = (*Gateway)(nil)
+var _ runtime.Service = (*Gateway)(nil)
 
 // PbMux serves grpc-gateway requests for selected patterns using registered protobuf handlers.
 type PbMux struct {

api/gateway/param_handling.go

@@ -28,11 +28,8 @@ segmentsLoop:
 
 			routeVar := mux.Vars(req)[s[1:len(s)-1]]
 			bRouteVar := []byte(routeVar)
-			isHex, err := butil.IsHex(bRouteVar)
-			if err != nil {
-				return InternalServerErrorWithMessage(err, "could not process URL parameter")
-			}
-			if isHex {
+			if butil.IsHex(bRouteVar) {
+				var err error
 				bRouteVar, err = bytesutil.FromHexString(string(bRouteVar))
 				if err != nil {
 					return InternalServerErrorWithMessage(err, "could not process URL parameter")
@@ -64,11 +61,8 @@ func HandleQueryParameters(req *http.Request, params []QueryParam) ErrorJson {
 					queryParams.Del(key)
 					for _, v := range vals {
 						b := []byte(v)
-						isHex, err := butil.IsHex(b)
-						if err != nil {
-							return InternalServerErrorWithMessage(err, "could not process query parameter")
-						}
-						if isHex {
+						if butil.IsHex(b) {
+							var err error
 							b, err = bytesutil.FromHexString(v)
 							if err != nil {
 								return InternalServerErrorWithMessage(err, "could not process query parameter")

api/grpc/BUILD.bazel

@@ -6,7 +6,7 @@ go_library(
         "grpcutils.go",
         "parameters.go",
     ],
-    importpath = "github.com/prysmaticlabs/prysm/shared/grpcutils",
+    importpath = "github.com/prysmaticlabs/prysm/api/grpc",
     visibility = ["//visibility:public"],
     deps = [
         "@com_github_sirupsen_logrus//:go_default_library",

api/grpc/grpcutils.go

@@ -1,4 +1,4 @@
-package grpcutils
+package grpc
 
 import (
 	"context"

api/grpc/grpcutils_test.go

@@ -1,4 +1,4 @@
-package grpcutils
+package grpc
 
 import (
 	"context"

api/grpc/parameters.go

@@ -1,4 +1,4 @@
-package grpcutils
+package grpc
 
 // CustomErrorMetadataKey is the name of the metadata key storing additional error information.
 // Metadata value is expected to be a byte-encoded JSON object.

api/pagination/BUILD.bazel

@@ -3,7 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = ["pagination.go"],
-    importpath = "github.com/prysmaticlabs/prysm/shared/pagination",
+    importpath = "github.com/prysmaticlabs/prysm/api/pagination",
     visibility = ["//visibility:public"],
     deps = [
         "//shared/params:go_default_library",

api/pagination/pagination_test.go

@@ -3,7 +3,7 @@ package pagination_test
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/pagination"
+	"github.com/prysmaticlabs/prysm/api/pagination"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

async/BUILD.bazel

@@ -3,23 +3,28 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "debounce.go",
+        "every.go",
         "multilock.go",
         "scatter.go",
     ],
-    importpath = "github.com/prysmaticlabs/prysm/shared/mputil",
+    importpath = "github.com/prysmaticlabs/prysm/async",
     visibility = ["//visibility:public"],
+    deps = ["@com_github_sirupsen_logrus//:go_default_library"],
 )
 
 go_test(
     name = "go_default_test",
-    size = "small",
     srcs = [
         "benchmark_test.go",
+        "debounce_test.go",
+        "every_test.go",
         "multilock_test.go",
         "scatter_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
+        "//shared/testutil:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

async/abool/BUILD.bazel

@@ -3,7 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = ["abool.go"],
-    importpath = "github.com/prysmaticlabs/prysm/shared/abool",
+    importpath = "github.com/prysmaticlabs/prysm/async/abool",
     visibility = ["//visibility:public"],
 )
 

async/benchmark_test.go

@@ -1,4 +1,4 @@
-package mputil_test
+package async_test
 
 import (
 	"crypto/rand"
@@ -6,7 +6,7 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/mputil"
+	"github.com/prysmaticlabs/prysm/async"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	log "github.com/sirupsen/logrus"
 )
@@ -52,7 +52,7 @@ func BenchmarkHash(b *testing.B) {
 func BenchmarkHashMP(b *testing.B) {
 	output := make([][]byte, len(input))
 	for i := 0; i < b.N; i++ {
-		workerResults, err := mputil.Scatter(len(input), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
+		workerResults, err := async.Scatter(len(input), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
 			return hash(input[offset : offset+entries]), nil
 		})
 		require.NoError(b, err)

async/debounce.go

@@ -1,4 +1,4 @@
-package asyncutil
+package async
 
 import (
 	"context"

async/debounce_test.go

@@ -1,4 +1,4 @@
-package asyncutil
+package async_test
 
 import (
 	"context"
@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prysmaticlabs/prysm/async"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
@@ -24,7 +25,7 @@ func TestDebounce_NoEvents(t *testing.T) {
 		})
 	}()
 	go func() {
-		Debounce(ctx, interval, eventsChan, func(event interface{}) {
+		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 			timesHandled++
 		})
 		wg.Done()
@@ -60,7 +61,7 @@ func TestDebounce_CtxClosing(t *testing.T) {
 		})
 	}()
 	go func() {
-		Debounce(ctx, interval, eventsChan, func(event interface{}) {
+		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 			timesHandled++
 		})
 		wg.Done()
@@ -76,7 +77,7 @@ func TestDebounce_SingleHandlerInvocation(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
 	timesHandled := 0
-	go Debounce(ctx, interval, eventsChan, func(event interface{}) {
+	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 		timesHandled++
 	})
 	for i := 0; i < 100; i++ {
@@ -94,7 +95,7 @@ func TestDebounce_MultipleHandlerInvocation(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
 	timesHandled := 0
-	go Debounce(ctx, interval, eventsChan, func(event interface{}) {
+	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 		timesHandled++
 	})
 	for i := 0; i < 100; i++ {

async/event/BUILD.bazel

@@ -6,9 +6,9 @@ go_library(
         "feed.go",
         "subscription.go",
     ],
-    importpath = "github.com/prysmaticlabs/prysm/shared/event",
+    importpath = "github.com/prysmaticlabs/prysm/async/event",
     visibility = ["//visibility:public"],
-    deps = ["//shared/mclockutil:go_default_library"],
+    deps = ["//time/mclock:go_default_library"],
 )
 
 go_test(

async/event/example_feed_test.go

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

async/event/example_scope_test.go

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

async/event/example_subscription_test.go

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

async/event/feed.go

@@ -98,6 +98,11 @@ func (f *Feed) typecheck(typ reflect.Type) bool {
 		f.etype = typ
 		return true
 	}
+	// In the event the feed's type is an actual interface, we
+	// perform an interface conformance check here.
+	if f.etype.Kind() == reflect.Interface && typ.Implements(f.etype) {
+		return true
+	}
 	return f.etype == typ
 }
 

async/event/feed_test.go

@@ -159,7 +159,7 @@ func TestFeedSubscribeSameChannel(t *testing.T) {
 	done.Wait()
 }
 
-func TestFeedSubscribeBlockedPost(t *testing.T) {
+func TestFeedSubscribeBlockedPost(_ *testing.T) {
 	var (
 		feed   Feed
 		nsends = 2000
@@ -192,7 +192,7 @@ func TestFeedSubscribeBlockedPost(t *testing.T) {
 	}
 }
 
-func TestFeedUnsubscribeBlockedPost(t *testing.T) {
+func TestFeedUnsubscribeBlockedPost(_ *testing.T) {
 	var (
 		feed   Feed
 		nsends = 200
@@ -229,7 +229,7 @@ func TestFeedUnsubscribeBlockedPost(t *testing.T) {
 
 // Checks that unsubscribing a channel during Send works even if that
 // channel has already been sent on.
-func TestFeedUnsubscribeSentChan(t *testing.T) {
+func TestFeedUnsubscribeSentChan(_ *testing.T) {
 	var (
 		feed Feed
 		ch1  = make(chan int)
@@ -315,3 +315,193 @@ func BenchmarkFeedSend1000(b *testing.B) {
 	b.StopTimer()
 	done.Wait()
 }
+
+func TestFeed_Send(t *testing.T) {
+	tests := []struct {
+		name        string
+		evFeed      *Feed
+		testSetup   func(fd *Feed, t *testing.T, o interface{})
+		obj         interface{}
+		expectPanic bool
+	}{
+		{
+			name:   "normal struct",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedWithPointer, 1)
+				fd.Subscribe(testChan)
+			},
+			obj: testFeedWithPointer{
+				a: new(uint64),
+				b: new(string),
+			},
+			expectPanic: false,
+		},
+		{
+			name:   "un-implemented interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface, 1)
+				fd.Subscribe(testChan)
+			},
+			obj: testFeedWithPointer{
+				a: new(uint64),
+				b: new(string),
+			},
+			expectPanic: true,
+		},
+		{
+			name:   "semi-implemented interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface, 1)
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed2{
+				a: 0,
+				b: "",
+				c: []byte{'A'},
+			},
+			expectPanic: true,
+		},
+		{
+			name:   "fully-implemented interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface)
+				// Make it unbuffered to allow message to
+				// pass through
+				go func() {
+					a := <-testChan
+					if !reflect.DeepEqual(a, o) {
+						t.Errorf("Got = %v, want = %v", a, o)
+					}
+				}()
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed{
+				a: 0,
+				b: "",
+			},
+			expectPanic: false,
+		},
+		{
+			name:   "fully-implemented interface with additional methods",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeedIface)
+				// Make it unbuffered to allow message to
+				// pass through
+				go func() {
+					a := <-testChan
+					if !reflect.DeepEqual(a, o) {
+						t.Errorf("Got = %v, want = %v", a, o)
+					}
+				}()
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed3{
+				a: 0,
+				b: "",
+				c: []byte{'A'},
+				d: []byte{'B'},
+			},
+			expectPanic: false,
+		},
+		{
+			name:   "concrete types implementing the same interface",
+			evFeed: new(Feed),
+			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
+				testChan := make(chan testFeed, 1)
+				// Make it unbuffered to allow message to
+				// pass through
+				go func() {
+					a := <-testChan
+					if !reflect.DeepEqual(a, o) {
+						t.Errorf("Got = %v, want = %v", a, o)
+					}
+				}()
+				fd.Subscribe(testChan)
+			},
+			obj: testFeed3{
+				a: 0,
+				b: "",
+				c: []byte{'A'},
+				d: []byte{'B'},
+			},
+			expectPanic: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					if !tt.expectPanic {
+						t.Errorf("panic triggered when unexpected: %v", r)
+					}
+				} else {
+					if tt.expectPanic {
+						t.Error("panic not triggered when expected")
+					}
+				}
+			}()
+			tt.testSetup(tt.evFeed, t, tt.obj)
+			if gotNsent := tt.evFeed.Send(tt.obj); gotNsent != 1 {
+				t.Errorf("Send() = %v, want %v", gotNsent, 1)
+			}
+		})
+	}
+}
+
+// The following objects below are a collection of different
+// struct types to test with.
+type testFeed struct {
+	a uint64
+	b string
+}
+
+func (testFeed) method1() {
+
+}
+
+func (testFeed) method2() {
+
+}
+
+type testFeedWithPointer struct {
+	a *uint64
+	b *string
+}
+
+type testFeed2 struct {
+	a uint64
+	b string
+	c []byte
+}
+
+func (testFeed2) method1() {
+
+}
+
+type testFeed3 struct {
+	a    uint64
+	b    string
+	c, d []byte
+}
+
+func (testFeed3) method1() {
+
+}
+
+func (testFeed3) method2() {
+
+}
+
+func (testFeed3) method3() {
+
+}
+
+type testFeedIface interface {
+	method1()
+	method2()
+}

async/event/subscription.go

@@ -21,7 +21,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/shared/mclockutil"
+	"github.com/prysmaticlabs/prysm/time/mclock"
 )
 
 // waitQuotient is divided against the max backoff time, in order to have N requests based on the full
@@ -120,7 +120,7 @@ type resubscribeSub struct {
 	err                  chan error
 	unsub                chan struct{}
 	unsubOnce            sync.Once
-	lastTry              mclockutil.AbsTime
+	lastTry              mclock.AbsTime
 	waitTime, backoffMax time.Duration
 }
 
@@ -151,11 +151,11 @@ func (s *resubscribeSub) loop() {
 }
 
 func (s *resubscribeSub) subscribe() Subscription {
-	subscribed := make(chan error)
+	subscribed := make(chan error, 1)
 	var sub Subscription
 retry:
 	for {
-		s.lastTry = mclockutil.Now()
+		s.lastTry = mclock.Now()
 		ctx, cancel := context.WithCancel(context.TODO())
 		go func() {
 			rsub, err := s.fn(ctx)
@@ -194,7 +194,7 @@ func (s *resubscribeSub) waitForError(sub Subscription) bool {
 }
 
 func (s *resubscribeSub) backoffWait() bool {
-	if time.Duration(mclockutil.Now()-s.lastTry) > s.backoffMax {
+	if time.Duration(mclock.Now()-s.lastTry) > s.backoffMax {
 		s.waitTime = s.backoffMax / waitQuotient
 	} else {
 		s.waitTime *= 2

async/event/subscription_test.go

@@ -19,6 +19,7 @@ package event
 import (
 	"context"
 	"errors"
+	"runtime"
 	"testing"
 	"time"
 
@@ -108,3 +109,18 @@ func TestResubscribeAbort(t *testing.T) {
 	sub.Unsubscribe()
 	require.NoError(t, <-done)
 }
+
+func TestResubscribeNonBlocking(t *testing.T) {
+	done := make(chan struct{})
+	sub := Resubscribe(0, func(ctx context.Context) (Subscription, error) {
+		<-done
+		return nil, nil
+	})
+
+	resub, ok := sub.(*resubscribeSub)
+	require.Equal(t, true, ok)
+	currNum := runtime.NumGoroutine()
+	resub.unsub <- struct{}{}
+	done <- struct{}{}
+	require.Equal(t, currNum-1, runtime.NumGoroutine())
+}

async/every.go

@@ -1,5 +1,5 @@
 // Package runutil includes helpers for scheduling runnable, periodic functions.
-package runutil
+package async
 
 import (
 	"context"

async/every_test.go

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

async/multilock.go

@@ -10,7 +10,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package mputil
+package async
 
 import (
 	"runtime"

async/multilock_test.go

@@ -10,7 +10,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package mputil
+package async
 
 import (
 	"sync"

async/scatter.go

@@ -1,6 +1,6 @@
 // Package mputil contains useful helpers for converting
 // multi-processor computation.
-package mputil
+package async
 
 import (
 	"errors"

async/scatter_test.go

@@ -1,11 +1,11 @@
-package mputil_test
+package async_test
 
 import (
 	"errors"
 	"sync"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/mputil"
+	"github.com/prysmaticlabs/prysm/async"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
@@ -46,7 +46,7 @@ func TestDouble(t *testing.T) {
 				inValues[i] = i
 			}
 			outValues := make([]int, test.inValues)
-			workerResults, err := mputil.Scatter(len(inValues), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
+			workerResults, err := async.Scatter(len(inValues), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
 				extent := make([]int, entries)
 				for i := 0; i < entries; i++ {
 					extent[i] = inValues[offset+i] * 2
@@ -72,7 +72,7 @@ func TestDouble(t *testing.T) {
 func TestMutex(t *testing.T) {
 	totalRuns := 1048576
 	val := 0
-	_, err := mputil.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
+	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
 		for i := 0; i < entries; i++ {
 			mu.Lock()
 			val++
@@ -90,7 +90,7 @@ func TestMutex(t *testing.T) {
 func TestError(t *testing.T) {
 	totalRuns := 1024
 	val := 0
-	_, err := mputil.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
+	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
 		for i := 0; i < entries; i++ {
 			mu.Lock()
 			val++

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/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.
+Also, read the official beacon chain [specification](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/beacon-chain.md), this design spec serves as a source of truth for the beacon chain implementation we follow at Prysmatic Labs.

beacon-chain/blockchain/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "chain_info.go",
         "head.go",
+        "head_sync_committee_info.go",
         "info.go",
         "init_sync_process_block.go",
         "log.go",
@@ -21,16 +22,19 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain",
     visibility = [
         "//beacon-chain:__subpackages__",
-        "//fuzz:__pkg__",
+        "//testing/fuzz:__pkg__",
     ],
     deps = [
+        "//async:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
+        "//beacon-chain/core:go_default_library",
+        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/state:go_default_library",
+        "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
@@ -43,19 +47,18 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
+        "//config/features:go_default_library",
+        "//crypto/bls:go_default_library",
+        "//monitoring/tracing:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
-        "//shared/attestationutil:go_default_library",
-        "//shared/bls:go_default_library",
+        "//runtime/version: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",
+        "//time:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_emicklei_dot//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
@@ -81,9 +84,11 @@ 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",
@@ -95,11 +100,12 @@ 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/state:go_default_library",
+        "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p:go_default_library",
@@ -109,7 +115,6 @@ go_test(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/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",
@@ -146,11 +151,12 @@ 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/state:go_default_library",
+        "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p:go_default_library",
@@ -158,7 +164,6 @@ go_test(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/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",

beacon-chain/blockchain/chain_info.go

@@ -11,7 +11,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/copyutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )
@@ -24,6 +23,8 @@ type ChainInfoFetcher interface {
 	GenesisFetcher
 	CanonicalFetcher
 	ForkFetcher
+	TimeFetcher
+	HeadDomainFetcher
 }
 
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
@@ -48,8 +49,12 @@ type HeadFetcher interface {
 	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.
@@ -77,7 +82,7 @@ func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	return copyutil.CopyCheckpoint(s.finalizedCheckpt)
+	return ethpb.CopyCheckpoint(s.finalizedCheckpt)
 }
 
 // CurrentJustifiedCheckpt returns the current justified checkpoint from head state.
@@ -86,7 +91,7 @@ func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	return copyutil.CopyCheckpoint(s.justifiedCheckpt)
+	return ethpb.CopyCheckpoint(s.justifiedCheckpt)
 }
 
 // PreviousJustifiedCheckpt returns the previous justified checkpoint from head state.
@@ -95,7 +100,7 @@ func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	return copyutil.CopyCheckpoint(s.prevJustifiedCheckpt)
+	return ethpb.CopyCheckpoint(s.prevJustifiedCheckpt)
 }
 
 // HeadSlot returns the slot of the head of the chain.
@@ -297,7 +302,7 @@ func (s *Service) HeadValidatorIndexToPublicKey(ctx context.Context, index types
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
-	v, err := s.headState(ctx).ValidatorAtIndexReadOnly(index)
+	v, err := s.headValidatorAtIndex(index)
 	if err != nil {
 		return [48]byte{}, err
 	}

beacon-chain/blockchain/head.go

@@ -7,16 +7,18 @@ import (
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/features"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/slotutil"
+	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -129,7 +131,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 := slotutil.AbsoluteValueSlotDifference(newHeadSlot, headSlot)
+		absoluteSlotDifference := slots.AbsoluteValueSlotDifference(newHeadSlot, headSlot)
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Reorg,
 			Data: &ethpbv1.EventChainReorg{
@@ -139,10 +141,14 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 				NewHeadBlock: headRoot[:],
 				OldHeadState: oldStateRoot,
 				NewHeadState: newStateRoot,
-				Epoch:        helpers.SlotToEpoch(newHeadSlot),
+				Epoch:        core.SlotToEpoch(newHeadSlot),
 			},
 		})
 
+		if err := s.saveOrphanedAtts(ctx, bytesutil.ToBytes32(r)); err != nil {
+			return err
+		}
+
 		reorgCount.Inc()
 	}
 
@@ -254,6 +260,13 @@ 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 {
@@ -285,7 +298,7 @@ func (s *Service) cacheJustifiedStateBalances(ctx context.Context, justifiedRoot
 		return errors.New("justified state can't be nil")
 	}
 
-	epoch := helpers.CurrentEpoch(justifiedState)
+	epoch := core.CurrentEpoch(justifiedState)
 
 	justifiedBalances := make([]uint64, justifiedState.NumValidators())
 	if err := justifiedState.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
@@ -323,15 +336,15 @@ func (s *Service) notifyNewHeadEvent(
 	currentDutyDependentRoot := s.genesisRoot[:]
 
 	var previousDutyEpoch types.Epoch
-	currentDutyEpoch := helpers.SlotToEpoch(newHeadSlot)
+	currentDutyEpoch := core.SlotToEpoch(newHeadSlot)
 	if currentDutyEpoch > 0 {
 		previousDutyEpoch = currentDutyEpoch.Sub(1)
 	}
-	currentDutySlot, err := helpers.StartSlot(currentDutyEpoch)
+	currentDutySlot, err := core.StartSlot(currentDutyEpoch)
 	if err != nil {
 		return errors.Wrap(err, "could not get duty slot")
 	}
-	previousDutySlot, err := helpers.StartSlot(previousDutyEpoch)
+	previousDutySlot, err := core.StartSlot(previousDutyEpoch)
 	if err != nil {
 		return errors.Wrap(err, "could not get duty slot")
 	}
@@ -353,10 +366,47 @@ func (s *Service) notifyNewHeadEvent(
 			Slot:                      newHeadSlot,
 			Block:                     newHeadRoot,
 			State:                     newHeadStateRoot,
-			EpochTransition:           helpers.IsEpochEnd(newHeadSlot),
+			EpochTransition:           core.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
+}

beacon-chain/blockchain/head_sync_committee_info.go

@@ -0,0 +1,173 @@
+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"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// 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 := core.SlotToEpoch(slot + 1)
+	currentEpoch := core.SlotToEpoch(slot)
+
+	switch {
+	case core.SyncCommitteePeriod(nextSlotEpoch) == core.SyncCommitteePeriod(currentEpoch):
+		return s.headCurrentSyncCommitteeIndices(ctx, index, slot)
+	// At sync committee period boundary, validator should sample the next epoch sync committee.
+	case core.SyncCommitteePeriod(nextSlotEpoch) == core.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 := core.SlotToEpoch(headState.Slot() + 1)
+	currEpoch := core.SlotToEpoch(headState.Slot())
+
+	var syncCommittee *ethpb.SyncCommittee
+	if currEpoch == nextSlotEpoch || core.SyncCommitteePeriod(currEpoch) == core.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 helpers.Domain(headState.Fork(), core.SlotToEpoch(headState.Slot()), domain, headState.GenesisValidatorRoot())
+}
+
+// returns the head state that is advanced up to `slot`. It utilizes the cache `syncCommitteeHeadState` by retrieving using `slot` as key.
+// For the cache miss, it processes head state up to slot and fill the cache with `slot` as key.
+func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot types.Slot) (state.BeaconState, error) {
+	var headState state.BeaconState
+	var err error
+	mLock := async.NewMultilock(fmt.Sprintf("%s-%d", "syncHeadState", slot))
+	mLock.Lock()
+	defer mLock.Unlock()
+
+	// If there's already a head state exists with the request slot, we don't need to process slots.
+	cachedState, err := syncCommitteeHeadStateCache.Get(slot)
+	switch {
+	case err == nil:
+		syncHeadStateHit.Inc()
+		headState = cachedState
+		return headState, nil
+	case errors.Is(err, cache.ErrNotFound):
+		headState, err = s.HeadState(ctx)
+		if err != nil {
+			return nil, err
+		}
+		if headState == nil || headState.IsNil() {
+			return nil, errors.New("nil state")
+		}
+		if slot > headState.Slot() {
+			headState, err = transition.ProcessSlots(ctx, headState, slot)
+			if err != nil {
+				return nil, err
+			}
+		}
+		syncHeadStateMiss.Inc()
+		err = syncCommitteeHeadStateCache.Put(slot, headState)
+		return headState, err
+	default:
+		// In the event, we encounter another error
+		// we return it.
+		return nil, err
+	}
+}

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -0,0 +1,176 @@
+package blockchain
+
+import (
+	"context"
+	"testing"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+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, _ := testutil.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, _ := testutil.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, _ := testutil.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, _ := testutil.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, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	c := &Service{}
+	c.head = &head{state: s}
+
+	wanted, err := helpers.Domain(s.Fork(), core.SlotToEpoch(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, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	c := &Service{}
+	c.head = &head{state: s}
+
+	wanted, err := helpers.Domain(s.Fork(), core.SlotToEpoch(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, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	c := &Service{}
+	c.head = &head{state: s}
+
+	wanted, err := helpers.Domain(s.Fork(), core.SlotToEpoch(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, _ := testutil.DeterministicGenesisStateAltair(t, 100)
+	require.NoError(t, beaconState.SetSlot(100))
+	cachedState, err := c.Get(101)
+	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
+	require.Equal(t, nil, cachedState)
+	require.NoError(t, c.Put(101, beaconState))
+	cachedState, err = c.Get(101)
+	require.NoError(t, err)
+	require.DeepEqual(t, beaconState, cachedState)
+}

beacon-chain/blockchain/head_test.go

@@ -4,14 +4,17 @@ 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"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/config/features"
 	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/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
@@ -35,18 +38,17 @@ func TestSaveHead_Different(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldRoot := [32]byte{'A'}
+	testutil.NewBeaconBlock()
+	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
+		testutil.NewBeaconBlock(),
+	)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
+	oldRoot, err := oldBlock.Block().HashTreeRoot()
+	require.NoError(t, err)
 	service.head = &head{
-		slot: 0,
-		root: oldRoot,
-		block: wrapper.WrappedPhase0SignedBeaconBlock(
-			&ethpb.SignedBeaconBlock{
-				Block: &ethpb.BeaconBlock{
-					Slot:      0,
-					StateRoot: make([]byte, 32),
-				},
-			},
-		),
+		slot:  0,
+		root:  oldRoot,
+		block: oldBlock,
 	}
 
 	newHeadSignedBlock := testutil.NewBeaconBlock()
@@ -78,18 +80,16 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldRoot := [32]byte{'A'}
+	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
+		testutil.NewBeaconBlock(),
+	)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
+	oldRoot, err := oldBlock.Block().HashTreeRoot()
+	require.NoError(t, err)
 	service.head = &head{
-		slot: 0,
-		root: oldRoot,
-		block: wrapper.WrappedPhase0SignedBeaconBlock(
-			&ethpb.SignedBeaconBlock{
-				Block: &ethpb.BeaconBlock{
-					Slot:      0,
-					StateRoot: make([]byte, 32),
-				},
-			},
-		),
+		slot:  0,
+		root:  oldRoot,
+		block: oldBlock,
 	}
 
 	reorgChainParent := [32]byte{'B'}
@@ -187,9 +187,9 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			},
 			genesisRoot: genesisRoot,
 		}
-		epoch1Start, err := helpers.StartSlot(1)
+		epoch1Start, err := core.StartSlot(1)
 		require.NoError(t, err)
-		epoch2Start, err := helpers.StartSlot(1)
+		epoch2Start, err := core.StartSlot(1)
 		require.NoError(t, err)
 		require.NoError(t, bState.SetSlot(epoch1Start))
 
@@ -213,3 +213,55 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 		require.DeepSSZEqual(t, wanted, eventHead)
 	})
 }
+
+func TestSaveOrphanedAtts(t *testing.T) {
+	resetCfg := features.InitWithReset(&features.Flags{
+		CorrectlyInsertOrphanedAtts: true,
+	})
+	defer resetCfg()
+
+	genesis, keys := testutil.DeterministicGenesisState(t, 64)
+	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.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 := testutil.DeterministicGenesisState(t, 64)
+	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
+	assert.NoError(t, err)
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
+
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	require.NoError(t, service.saveOrphanedAtts(ctx, r))
+
+	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
+	savedAtts := service.cfg.AttPool.AggregatedAttestations()
+	atts := b.Block.Body.Attestations
+	require.DeepNotSSZEqual(t, atts, savedAtts)
+}

beacon-chain/blockchain/log.go

@@ -5,11 +5,12 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/timeutils"
+	prysmTime "github.com/prysmaticlabs/prysm/time"
 	"github.com/sirupsen/logrus"
 )
 
@@ -17,7 +18,7 @@ var log = logrus.WithField("prefix", "blockchain")
 
 // logs state transition related data every slot.
 func logStateTransitionData(b block.BeaconBlock) {
-	log := log.WithField("slot", b.Slot)
+	log := log.WithField("slot", b.Slot())
 	if len(b.Body().Attestations()) > 0 {
 		log = log.WithField("attestations", len(b.Body().Attestations()))
 	}
@@ -33,11 +34,17 @@ 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 := helpers.SlotToTime(genesisTime, block.Slot())
+	startTime, err := core.SlotToTime(genesisTime, block.Slot())
 	if err != nil {
 		return err
 	}
@@ -45,14 +52,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":          helpers.SlotToEpoch(block.Slot()),
+		"epoch":          core.SlotToEpoch(block.Slot()),
 		"finalizedEpoch": finalized.Epoch,
 		"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
 	}).Info("Synced new block")
 	log.WithFields(logrus.Fields{
 		"slot":                      block.Slot,
-		"sinceSlotStartTime":        timeutils.Now().Sub(startTime),
-		"chainServiceProcessedTime": timeutils.Now().Sub(receivedTime),
+		"sinceSlotStartTime":        prysmTime.Now().Sub(startTime),
+		"chainServiceProcessedTime": prysmTime.Now().Sub(receivedTime),
 	}).Debug("Sync new block times")
 	return nil
 }

beacon-chain/blockchain/metrics.go

@@ -3,13 +3,16 @@ 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"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
@@ -60,6 +63,10 @@ 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",
@@ -76,6 +83,10 @@ 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.",
@@ -97,9 +108,13 @@ 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_reorg_total",
+		Name: "beacon_reorgs_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",
@@ -107,6 +122,14 @@ 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.
@@ -179,6 +202,7 @@ 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))
@@ -205,15 +229,33 @@ 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))
 
-	// 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
+	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.InitializeEpochValidators(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())
 	}
 	prevEpochActiveBalances.Set(float64(b.ActivePrevEpoch))
 	prevEpochSourceBalances.Set(float64(b.PrevEpochAttested))

beacon-chain/blockchain/process_attestation.go

@@ -4,13 +4,13 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/attestationutil"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/copyutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/timeutils"
+	"github.com/prysmaticlabs/prysm/time"
 	"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 := copyutil.CopyCheckpoint(a.Data.Target)
+	tgt := ethpb.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(timeutils.Now().Unix()), tgt); err != nil {
+	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {
 		return err
 	}
 
@@ -75,7 +75,7 @@ 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 := helpers.VerifySlotTime(genesisTime, a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+	if err := core.VerifySlotTime(genesisTime, a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return err
 	}
 
@@ -84,11 +84,11 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error
 	if err != nil {
 		return err
 	}
-	indexedAtt, err := attestationutil.ConvertToIndexed(ctx, a, committee)
+	indexedAtt, err := attestation.ConvertToIndexed(ctx, a, committee)
 	if err != nil {
 		return err
 	}
-	if err := attestationutil.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
+	if err := attestation.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
 		return err
 	}
 

beacon-chain/blockchain/process_attestation_helpers.go

@@ -7,13 +7,13 @@ import (
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/async"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	core "github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/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"
 )
 
@@ -22,7 +22,7 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 	// 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 := mputil.NewMultilock(string(c.Root) + epochKey)
+	lock := async.NewMultilock(string(c.Root) + epochKey)
 	lock.Lock()
 	defer lock.Unlock()
 	cachedState, err := s.checkpointStateCache.StateByCheckpoint(c)
@@ -38,23 +38,17 @@ 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 := helpers.StartSlot(c.Epoch)
+	epochStartSlot, err := core.StartSlot(c.Epoch)
 	if err != nil {
 		return nil, err
 	}
 	if epochStartSlot > baseState.Slot() {
-		if featureconfig.Get().EnableNextSlotStateCache {
-			baseState, err = core.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 = core.ProcessSlots(ctx, baseState, epochStartSlot)
-			if err != nil {
-				return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
-			}
+		baseState, err = transition.ProcessSlots(ctx, baseState, epochStartSlot)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
 		}
 	}
+
 	// Sharing the same state across caches is perfectly fine here, the fetching
 	// 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
@@ -69,7 +63,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 := helpers.SlotToEpoch(currentSlot)
+	currentEpoch := core.SlotToEpoch(currentSlot)
 	var prevEpoch types.Epoch
 	// Prevents previous epoch under flow
 	if currentEpoch > 1 {

beacon-chain/blockchain/process_attestation_test.go

@@ -5,8 +5,8 @@ import (
 	"testing"
 
 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
@@ -17,7 +17,7 @@ import (
 	"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"
+	"github.com/prysmaticlabs/prysm/time"
 )
 
 func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
@@ -138,13 +138,13 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
-	require.NoError(t, genesisState.SetGenesisTime(uint64(timeutils.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
+	require.NoError(t, genesisState.SetGenesisTime(uint64(time.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 	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 = state.ProcessSlots(ctx, copied, 1)
+	copied, err = transition.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))
@@ -251,9 +251,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 := helpers.StartSlot(newCheckpoint.Epoch)
+	s, err := core.StartSlot(newCheckpoint.Epoch)
 	require.NoError(t, err)
-	baseState, err = state.ProcessSlots(ctx, baseState, s)
+	baseState, err = transition.ProcessSlots(ctx, baseState, s)
 	require.NoError(t, err)
 	assert.Equal(t, returned.Slot(), baseState.Slot(), "Incorrectly returned base state")
 

beacon-chain/blockchain/process_block.go

@@ -6,18 +6,19 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"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"
-	core "github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"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/crypto/bls"
 	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/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"
 )
@@ -96,7 +97,7 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		return err
 	}
 
-	postState, err := core.ExecuteStateTransition(ctx, preState, signed)
+	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
 		return err
 	}
@@ -106,14 +107,14 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	}
 
 	// Updating next slot state cache can happen in the background. It shouldn't block rest of the process.
-	if featureconfig.Get().EnableNextSlotStateCache {
+	if features.Get().EnableNextSlotStateCache {
 		go func() {
 			// Use a custom deadline here, since this method runs asynchronously.
 			// We ignore the parent method's context and instead create a new one
 			// with a custom deadline, therefore using the background context instead.
 			slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
 			defer cancel()
-			if err := core.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
+			if err := transition.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
 				log.WithError(err).Debug("could not update next slot state cache")
 			}
 		}()
@@ -127,7 +128,7 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	}
 
 	newFinalized := postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch
-	if featureconfig.Get().UpdateHeadTimely {
+	if features.Get().UpdateHeadTimely {
 		if newFinalized {
 			if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
 				return errors.Wrap(err, "could not save new justified")
@@ -140,6 +141,10 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 			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,
@@ -161,7 +166,7 @@ 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 !features.Get().UpdateHeadTimely {
 			if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
 				return errors.Wrap(err, "could not save new justified")
 			}
@@ -229,12 +234,12 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 	var set *bls.SignatureSet
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
-		set, preState, err = core.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
+		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
 		if err != nil {
 			return nil, nil, err
 		}
 		// Save potential boundary states.
-		if helpers.IsEpochStart(preState.Slot()) {
+		if core.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 +309,7 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 		if err := s.updateFinalized(ctx, fCheckpoint); err != nil {
 			return err
 		}
-		if featureconfig.Get().UpdateHeadTimely {
+		if features.Get().UpdateHeadTimely {
 			s.prevFinalizedCheckpt = s.finalizedCheckpt
 			s.finalizedCheckpt = fCheckpoint
 		}
@@ -314,13 +319,16 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 
 // 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()
+
 	if postState.Slot()+1 == s.nextEpochBoundarySlot {
 		// Update caches for the next epoch at epoch boundary slot - 1.
-		if err := helpers.UpdateCommitteeCache(postState, helpers.NextEpoch(postState)); err != nil {
+		if err := helpers.UpdateCommitteeCache(postState, core.NextEpoch(postState)); err != nil {
 			return err
 		}
 		copied := postState.Copy()
-		copied, err := core.ProcessSlots(ctx, copied, copied.Slot()+1)
+		copied, err := transition.ProcessSlots(ctx, copied, copied.Slot()+1)
 		if err != nil {
 			return err
 		}
@@ -332,14 +340,14 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 			return err
 		}
 		var err error
-		s.nextEpochBoundarySlot, err = helpers.StartSlot(helpers.NextEpoch(postState))
+		s.nextEpochBoundarySlot, err = core.StartSlot(core.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, helpers.CurrentEpoch(postState)); err != nil {
+		if err := helpers.UpdateCommitteeCache(postState, core.CurrentEpoch(postState)); err != nil {
 			return err
 		}
 		if err := helpers.UpdateProposerIndicesInCache(postState); err != nil {
@@ -354,6 +362,9 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 // 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()
+
 	fCheckpoint := st.FinalizedCheckpoint()
 	jCheckpoint := st.CurrentJustifiedCheckpoint()
 	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint); err != nil {
@@ -365,7 +376,7 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 		if err != nil {
 			return err
 		}
-		indices, err := attestationutil.AttestingIndices(a.AggregationBits, committee)
+		indices, err := attestation.AttestingIndices(a.AggregationBits, committee)
 		if err != nil {
 			return err
 		}
@@ -407,3 +418,33 @@ 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
+}

beacon-chain/blockchain/process_block_helpers.go

@@ -7,21 +7,22 @@ import (
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/features"
+	"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/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 helpers.CurrentSlot(uint64(s.genesisTime.Unix()))
+	return core.CurrentSlot(uint64(s.genesisTime.Unix()))
 }
 
 // getBlockPreState returns the pre state of an incoming block. It uses the parent root of the block
@@ -45,7 +46,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b block.BeaconBlock) (st
 	}
 
 	// Verify block slot time is not from the future.
-	if err := helpers.VerifySlotTime(preState.GenesisTime(), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+	if err := core.VerifySlotTime(preState.GenesisTime(), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return nil, err
 	}
 
@@ -113,7 +114,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[:]))
-		traceutil.AnnotateError(span, err)
+		tracing.AnnotateError(span, err)
 		return err
 	}
 	return nil
@@ -122,7 +123,7 @@ 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 := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+	finalizedSlot, err := core.StartSlot(s.finalizedCheckpt.Epoch)
 	if err != nil {
 		return err
 	}
@@ -137,7 +138,10 @@ func (s *Service) verifyBlkFinalizedSlot(b block.BeaconBlock) error {
 // Otherwise, delay incorporation of new justified checkpoint until next epoch boundary.
 // See https://ethresear.ch/t/prevention-of-bouncing-attack-on-ffg/6114 for more detailed analysis and discussion.
 func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustifiedCheckpt *ethpb.Checkpoint) (bool, error) {
-	if helpers.SlotsSinceEpochStarts(s.CurrentSlot()) < params.BeaconConfig().SafeSlotsToUpdateJustified {
+	ctx, span := trace.StartSpan(ctx, "blockChain.shouldUpdateCurrentJustified")
+	defer span.End()
+
+	if core.SlotsSinceEpochStarts(s.CurrentSlot()) < params.BeaconConfig().SafeSlotsToUpdateJustified {
 		return true, nil
 	}
 	var newJustifiedBlockSigned block.SignedBeaconBlock
@@ -156,7 +160,7 @@ func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustified
 	}
 
 	newJustifiedBlock := newJustifiedBlockSigned.Block()
-	jSlot, err := helpers.StartSlot(s.justifiedCheckpt.Epoch)
+	jSlot, err := core.StartSlot(s.justifiedCheckpt.Epoch)
 	if err != nil {
 		return false, err
 	}
@@ -189,6 +193,9 @@ func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustified
 }
 
 func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaconState) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.updateJustified")
+	defer span.End()
+
 	cpt := state.CurrentJustifiedCheckpoint()
 	if cpt.Epoch > s.bestJustifiedCheckpt.Epoch {
 		s.bestJustifiedCheckpt = cpt
@@ -223,6 +230,9 @@ 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 {
@@ -233,7 +243,7 @@ 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 {
+	if !features.Get().UpdateHeadTimely {
 		s.prevFinalizedCheckpt = s.finalizedCheckpt
 		s.finalizedCheckpt = cp
 	}
@@ -336,14 +346,14 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot types.Slot)
 //                store.justified_checkpoint = state.current_justified_checkpoint
 func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state state.BeaconState) error {
 	// Update justified if it's different than the one cached in the store.
-	if !attestationutil.CheckPointIsEqual(s.justifiedCheckpt, state.CurrentJustifiedCheckpoint()) {
+	if !attestation.CheckPointIsEqual(s.justifiedCheckpt, state.CurrentJustifiedCheckpoint()) {
 		if state.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
 			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
 			return s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
 		}
 
 		// Update justified if store justified is not in chain with finalized check point.
-		finalizedSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+		finalizedSlot, err := core.StartSlot(s.finalizedCheckpt.Epoch)
 		if err != nil {
 			return err
 		}
@@ -372,7 +382,7 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk block.B
 	parentRoot := bytesutil.ToBytes32(blk.ParentRoot())
 	slot := blk.Slot()
 	// Fork choice only matters from last finalized slot.
-	fSlot, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+	fSlot, err := core.StartSlot(s.finalizedCheckpt.Epoch)
 	if err != nil {
 		return err
 	}

beacon-chain/blockchain/process_block_test.go

@@ -13,23 +13,24 @@ 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"
-	core "github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"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"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	"github.com/prysmaticlabs/prysm/config/features"
 	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/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"
+	prysmTime "github.com/prysmaticlabs/prysm/time"
 )
 
 func TestStore_OnBlock(t *testing.T) {
@@ -160,7 +161,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	for i := 1; i < 10; i++ {
 		b, err := testutil.GenerateFullBlock(bState, keys, testutil.DefaultBlockGenConfig(), types.Slot(i))
 		require.NoError(t, err)
-		bState, err = core.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		require.NoError(t, err)
 		if i == 1 {
 			firstState = bState.Copy()
@@ -566,7 +567,7 @@ func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byt
 }
 
 func TestCurrentSlot_HandlesOverflow(t *testing.T) {
-	svc := Service{genesisTime: timeutils.Now().Add(1 * time.Hour)}
+	svc := Service{genesisTime: prysmTime.Now().Add(1 * time.Hour)}
 
 	slot := svc.CurrentSlot()
 	require.Equal(t, types.Slot(0), slot, "Unexpected slot")
@@ -789,7 +790,7 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		}
 
 		require.NoError(t, service.finalizedImpliesNewJustified(ctx, beaconState))
-		assert.Equal(t, true, attestationutil.CheckPointIsEqual(test.want, service.justifiedCheckpt), "Did not get wanted check point")
+		assert.Equal(t, true, attestation.CheckPointIsEqual(test.want, service.justifiedCheckpt), "Did not get wanted check point")
 	}
 }
 
@@ -1000,3 +1001,49 @@ 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 := testutil.DeterministicGenesisState(t, 64)
+	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.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 := testutil.DeterministicGenesisState(t, 64)
+	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.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())
+}

beacon-chain/blockchain/receive_attestation.go

@@ -7,13 +7,14 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/slotutil"
+	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -44,11 +45,11 @@ func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Att
 
 // AttestationPreState returns the pre state of attestation.
 func (s *Service) AttestationPreState(ctx context.Context, att *ethpb.Attestation) (state.BeaconState, error) {
-	ss, err := helpers.StartSlot(att.Data.Target.Epoch)
+	ss, err := core.StartSlot(att.Data.Target.Epoch)
 	if err != nil {
 		return nil, err
 	}
-	if err := helpers.ValidateSlotClock(ss, uint64(s.genesisTime.Unix())); err != nil {
+	if err := core.ValidateSlotClock(ss, uint64(s.genesisTime.Unix())); err != nil {
 		return nil, err
 	}
 	return s.getAttPreState(ctx, att.Data.Target)
@@ -56,7 +57,7 @@ func (s *Service) AttestationPreState(ctx context.Context, att *ethpb.Attestatio
 
 // 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 := helpers.StartSlot(a.Data.Target.Epoch)
+	targetSlot, err := core.StartSlot(a.Data.Target.Epoch)
 	if err != nil {
 		return err
 	}
@@ -81,7 +82,7 @@ func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) e
 	}
 
 	f := s.FinalizedCheckpt()
-	ss, err := helpers.StartSlot(f.Epoch)
+	ss, err := core.StartSlot(f.Epoch)
 	if err != nil {
 		return err
 	}
@@ -113,7 +114,7 @@ func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan<- stru
 		log.Warn("Genesis time received, now available to process attestations")
 	}
 
-	st := slotutil.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+	st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
 	for {
 		select {
 		case <-s.ctx.Done():
@@ -138,9 +139,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/eth2.0-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
+		// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
 		nextSlot := a.Data.Slot + 1
-		if err := helpers.VerifySlotTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+		if err := core.VerifySlotTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 			continue
 		}
 

beacon-chain/blockchain/receive_attestation_test.go

@@ -6,8 +6,9 @@ import (
 	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
@@ -18,7 +19,7 @@ import (
 	"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"
+	prysmTime "github.com/prysmaticlabs/prysm/time"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
@@ -29,7 +30,7 @@ func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 	chainService := setupBeaconChain(t, beaconDB)
 	chainService.genesisTime = time.Now()
 
-	e := types.Epoch(helpers.MaxSlotBuffer/uint64(params.BeaconConfig().SlotsPerEpoch) + 1)
+	e := types.Epoch(core.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)
 }
@@ -102,16 +103,16 @@ func TestProcessAttestations_Ok(t *testing.T) {
 		AttPool:         attestations.NewPool(),
 	}
 	service, err := NewService(ctx, cfg)
-	service.genesisTime = timeutils.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
+	service.genesisTime = prysmTime.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
 	require.NoError(t, err)
 	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
-	require.NoError(t, genesisState.SetGenesisTime(uint64(timeutils.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
+	require.NoError(t, genesisState.SetGenesisTime(uint64(prysmTime.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 	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 = state.ProcessSlots(ctx, copied, 1)
+	copied, err = transition.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))

beacon-chain/blockchain/receive_block.go

@@ -5,13 +5,13 @@ import (
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"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/config/features"
+	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
-	"github.com/prysmaticlabs/prysm/shared/timeutils"
-	"github.com/prysmaticlabs/prysm/shared/traceutil"
+	"github.com/prysmaticlabs/prysm/time"
 	"go.opencensus.io/trace"
 )
 
@@ -33,21 +33,26 @@ type BlockReceiver interface {
 func (s *Service) ReceiveBlock(ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
-	receivedTime := timeutils.Now()
+	receivedTime := time.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")
-		traceutil.AnnotateError(span, err)
+		tracing.AnnotateError(span, err)
 		return err
 	}
 
 	// Update and save head block after fork choice.
-	if !featureconfig.Get().UpdateHeadTimely {
+	if !features.Get().UpdateHeadTimely {
 		if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
 			log.WithError(err).Warn("Could not update head")
 		}
+
+		if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, block); err != nil {
+			return err
+		}
+
 		// Send notification of the processed block to the state feed.
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.BlockProcessed,
@@ -94,14 +99,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")
-		traceutil.AnnotateError(span, err)
+		tracing.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 {
-			traceutil.AnnotateError(span, err)
+			tracing.AnnotateError(span, err)
 			return err
 		}
 		// Send notification of the processed block to the state feed.
@@ -160,7 +165,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 := helpers.SlotToEpoch(s.CurrentSlot())
+	currentEpoch := core.SlotToEpoch(s.CurrentSlot())
 	// Prevent `sinceFinality` going underflow.
 	var sinceFinality types.Epoch
 	if currentEpoch > s.finalizedCheckpt.Epoch {

beacon-chain/blockchain/receive_block_test.go

@@ -8,17 +8,17 @@ import (
 
 	types "github.com/prysmaticlabs/eth2-types"
 	blockchainTesting "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/config/features"
 	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/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -287,7 +287,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 
 func TestService_ReceiveBlockBatch_UpdateFinalizedCheckpoint(t *testing.T) {
 	// Must enable head timely feature flag to test this.
-	resetCfg := featureconfig.InitWithReset(&featureconfig.Flags{
+	resetCfg := features.InitWithReset(&features.Flags{
 		UpdateHeadTimely: true,
 	})
 	defer resetCfg()
@@ -302,7 +302,7 @@ func TestService_ReceiveBlockBatch_UpdateFinalizedCheckpoint(t *testing.T) {
 	for i := types.Slot(1); i < params.BeaconConfig().SlotsPerEpoch*5; i++ {
 		b, err := testutil.GenerateFullBlock(copied, keys, testutil.DefaultBlockGenConfig(), i)
 		assert.NoError(t, err)
-		copied, err = state.ExecuteStateTransition(context.Background(), copied, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		copied, err = transition.ExecuteStateTransition(context.Background(), copied, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		assert.NoError(t, err)
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)

beacon-chain/blockchain/service.go

@@ -13,10 +13,11 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"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"
-	core "github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
@@ -31,9 +32,8 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"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/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -152,7 +152,7 @@ func (s *Service) Start() {
 		if err != nil {
 			log.Fatalf("Could not hash tree root genesis state: %v", err)
 		}
-		go slotutil.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()), gRoot)
+		go slots.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()), gRoot)
 
 		justifiedCheckpoint, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
 		if err != nil {
@@ -164,17 +164,17 @@ func (s *Service) Start() {
 		}
 
 		// Resume fork choice.
-		s.justifiedCheckpt = copyutil.CopyCheckpoint(justifiedCheckpoint)
+		s.justifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
 		if err := s.cacheJustifiedStateBalances(s.ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))); err != nil {
 			log.Fatalf("Could not cache justified state balances: %v", err)
 		}
-		s.prevJustifiedCheckpt = copyutil.CopyCheckpoint(justifiedCheckpoint)
-		s.bestJustifiedCheckpt = copyutil.CopyCheckpoint(justifiedCheckpoint)
-		s.finalizedCheckpt = copyutil.CopyCheckpoint(finalizedCheckpoint)
-		s.prevFinalizedCheckpt = copyutil.CopyCheckpoint(finalizedCheckpoint)
+		s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.finalizedCheckpt = ethpb.CopyCheckpoint(finalizedCheckpoint)
+		s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(finalizedCheckpoint)
 		s.resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint)
 
-		ss, err := helpers.StartSlot(s.finalizedCheckpt.Epoch)
+		ss, err := core.StartSlot(s.finalizedCheckpt.Epoch)
 		if err != nil {
 			log.Fatalf("Could not get start slot of finalized epoch: %v", err)
 		}
@@ -252,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 slotutil.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
+	go slots.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.
@@ -278,7 +278,7 @@ func (s *Service) initializeBeaconChain(
 	s.genesisTime = genesisTime
 	unixTime := uint64(genesisTime.Unix())
 
-	genesisState, err := core.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
+	genesisState, err := transition.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not initialize genesis state")
 	}
@@ -351,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 = copyutil.CopyCheckpoint(genesisCheckpoint)
+	s.justifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
 	if err := s.cacheJustifiedStateBalances(ctx, genesisBlkRoot); err != nil {
 		return err
 	}
-	s.prevJustifiedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)
-	s.bestJustifiedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)
-	s.finalizedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)
-	s.prevFinalizedCheckpt = copyutil.CopyCheckpoint(genesisCheckpoint)
+	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.finalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
 
 	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
 		genesisBlk.Block().Slot(),
@@ -411,7 +411,7 @@ func (s *Service) initializeChainInfo(ctx context.Context) error {
 		if err != nil {
 			return errors.Wrap(err, "could not retrieve head block")
 		}
-		headEpoch := helpers.SlotToEpoch(headBlock.Block().Slot())
+		headEpoch := core.SlotToEpoch(headBlock.Block().Slot())
 		var epochsSinceFinality types.Epoch
 		if headEpoch > finalized.Epoch {
 			epochsSinceFinality = headEpoch - finalized.Epoch

beacon-chain/blockchain/service_test.go

@@ -8,12 +8,14 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
@@ -27,7 +29,6 @@ import (
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"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"
@@ -62,6 +63,11 @@ 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 {
@@ -196,7 +202,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 	trie, _, err := testutil.DepositTrieFromDeposits(deposits)
 	require.NoError(t, err)
 	hashTreeRoot := trie.HashTreeRoot()
-	genState, err := state.EmptyGenesisState()
+	genState, err := transition.EmptyGenesisState()
 	require.NoError(t, err)
 	err = genState.SetEth1Data(&ethpb.Eth1Data{
 		DepositRoot:  hashTreeRoot[:],
@@ -275,7 +281,7 @@ 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: helpers.SlotToEpoch(finalizedSlot), Root: headRoot[:]}))
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: core.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)
@@ -369,7 +375,7 @@ 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: helpers.SlotToEpoch(finalizedBlock.Block.Slot),
+		Epoch: core.SlotToEpoch(finalizedBlock.Block.Slot),
 		Root:  finalizedRoot[:],
 	}))
 

beacon-chain/blockchain/testing/BUILD.bazel

@@ -7,9 +7,10 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing",
     visibility = [
         "//beacon-chain:__subpackages__",
-        "//fuzz:__pkg__",
+        "//testing/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",
@@ -23,7 +24,6 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/block: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",

beacon-chain/blockchain/testing/mock.go

@@ -10,6 +10,7 @@ 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"
@@ -21,10 +22,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	statepb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/event"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/sirupsen/logrus"
 )
@@ -42,7 +41,7 @@ type ChainService struct {
 	Genesis                     time.Time
 	ValidatorsRoot              [32]byte
 	CanonicalRoots              map[[32]byte]bool
-	Fork                        *statepb.Fork
+	Fork                        *ethpb.Fork
 	ETH1Data                    *ethpb.Eth1Data
 	DB                          db.Database
 	stateNotifier               statefeed.Notifier
@@ -52,6 +51,12 @@ 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
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -259,7 +264,7 @@ func (s *ChainService) HeadState(context.Context) (state.BeaconState, error) {
 }
 
 // CurrentFork mocks HeadState method in chain service.
-func (s *ChainService) CurrentFork() *statepb.Fork {
+func (s *ChainService) CurrentFork() *ethpb.Fork {
 	return s.Fork
 }
 
@@ -393,3 +398,38 @@ 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(ctx context.Context, pubKey [48]byte) (types.ValidatorIndex, bool) {
+	return 0, true
+}
+
+// HeadValidatorIndexToPublicKey mocks HeadValidatorIndexToPublicKey and always return empty and nil.
+func (s *ChainService) HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([48]byte, error) {
+	return s.PublicKey, nil
+}
+
+// HeadSyncCommitteeIndices mocks HeadSyncCommitteeIndices and always return `HeadNextSyncCommitteeIndices`.
+func (s *ChainService) HeadSyncCommitteeIndices(ctx 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(ctx context.Context, slot types.Slot, committeeIndex types.CommitteeIndex) ([][]byte, error) {
+	return s.SyncCommitteePubkeys, nil
+}
+
+// HeadSyncCommitteeDomain mocks HeadSyncCommitteeDomain and always return empty nil.
+func (s *ChainService) HeadSyncCommitteeDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
+	return s.SyncCommitteeDomain, nil
+}
+
+// HeadSyncSelectionProofDomain mocks HeadSyncSelectionProofDomain and always return empty nil.
+func (s *ChainService) HeadSyncSelectionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
+	return s.SyncSelectionProofDomain, nil
+}
+
+// HeadSyncContributionProofDomain mocks HeadSyncContributionProofDomain and always return empty nil.
+func (s *ChainService) HeadSyncContributionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
+	return s.SyncContributionProofDomain, nil
+}

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -4,14 +4,14 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 // 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
+// Reference design: https://github.com/ethereum/consensus-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 {
@@ -38,7 +38,7 @@ func (s *Service) VerifyWeakSubjectivityRoot(ctx context.Context) error {
 		return fmt.Errorf("node does not have root in DB: %#x", r)
 	}
 
-	startSlot, err := helpers.StartSlot(s.cfg.WeakSubjectivityCheckpt.Epoch)
+	startSlot, err := core.StartSlot(s.cfg.WeakSubjectivityCheckpt.Epoch)
 	if err != nil {
 		return err
 	}

beacon-chain/cache/BUILD.bazel

@@ -10,34 +10,47 @@ 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({
-        "//fuzz:fuzzing_enabled": [
+        "//testing/fuzz:fuzzing_enabled": [
+            "active_balance_disabled.go",
             "committee_disabled.go",
             "proposer_indices_disabled.go",
+            "sync_committee_disabled.go",
         ],
         "//conditions:default": [
+            "active_balance.go",
             "committee.go",
             "proposer_indices.go",
+            "sync_committee.go",
         ],
     }),
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache",
     visibility = [
         "//beacon-chain:__subpackages__",
-        "//fuzz:__pkg__",
+        "//testing/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",
+        "//container/slice:go_default_library",
+        "//crypto/hash:go_default_library",
+        "//crypto/rand:go_default_library",
+        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//shared/copyutil:go_default_library",
-        "//shared/hashutil:go_default_library",
+        "//shared/bytesutil: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",
@@ -50,6 +63,7 @@ go_test(
     name = "go_default_test",
     size = "small",
     srcs = [
+        "active_balance_test.go",
         "attestation_data_test.go",
         "cache_test.go",
         "checkpoint_state_test.go",
@@ -58,14 +72,20 @@ 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/v1:go_default_library",
+        "//beacon-chain/state/v2:go_default_library",
+        "//config/features:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",

beacon-chain/cache/active_balance.go

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

beacon-chain/cache/active_balance_disabled.go

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

beacon-chain/cache/active_balance_test.go

@@ -0,0 +1,81 @@
+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"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/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)
+}

beacon-chain/cache/attestation_data.go

@@ -11,7 +11,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/copyutil"
 	"k8s.io/client-go/tools/cache"
 )
 
@@ -98,7 +97,7 @@ func (c *AttestationCache) Get(ctx context.Context, req *ethpb.AttestationDataRe
 
 	if exists && item != nil && item.(*attestationReqResWrapper).res != nil {
 		attestationCacheHit.Inc()
-		return copyutil.CopyAttestationData(item.(*attestationReqResWrapper).res), nil
+		return ethpb.CopyAttestationData(item.(*attestationReqResWrapper).res), nil
 	}
 	attestationCacheMiss.Inc()
 	return nil, nil

beacon-chain/cache/checkpoint_state.go

@@ -7,8 +7,9 @@ import (
 	"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"
-	"github.com/prysmaticlabs/prysm/shared/hashutil"
 )
 
 var (
@@ -36,12 +37,8 @@ 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: cache,
+		cache: lruwrpr.New(maxCheckpointStateSize),
 	}
 }
 
@@ -50,7 +47,7 @@ func NewCheckpointStateCache() *CheckpointStateCache {
 func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.BeaconState, error) {
 	c.lock.RLock()
 	defer c.lock.RUnlock()
-	h, err := hashutil.HashProto(cp)
+	h, err := hash.HashProto(cp)
 	if err != nil {
 		return nil, err
 	}
@@ -72,7 +69,7 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.Be
 func (c *CheckpointStateCache) AddCheckpointState(cp *ethpb.Checkpoint, s state.ReadOnlyBeaconState) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
-	h, err := hashutil.HashProto(cp)
+	h, err := hash.HashProto(cp)
 	if err != nil {
 		return err
 	}

beacon-chain/cache/committee.go

@@ -10,8 +10,10 @@ import (
 	"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/container/slice"
+	"github.com/prysmaticlabs/prysm/math"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 )
 
 var (
@@ -48,14 +50,8 @@ 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: cCache,
+		CommitteeCache: lruwrpr.New(int(maxCommitteesCacheSize)),
 	}
 }
 
@@ -83,7 +79,10 @@ func (c *CommitteeCache) Committee(slot types.Slot, seed [32]byte, index types.C
 		committeeCountPerSlot = item.CommitteeCount / uint64(params.BeaconConfig().SlotsPerEpoch)
 	}
 
-	indexOffSet := uint64(index) + uint64(slot.ModSlot(params.BeaconConfig().SlotsPerEpoch).Mul(committeeCountPerSlot))
+	indexOffSet, err := math.Add64(uint64(index), uint64(slot.ModSlot(params.BeaconConfig().SlotsPerEpoch).Mul(committeeCountPerSlot)))
+	if err != nil {
+		return nil, err
+	}
 	start, end := startEndIndices(item, indexOffSet)
 
 	if end > uint64(len(item.ShuffledIndices)) || end < start {
@@ -155,15 +154,15 @@ func (c *CommitteeCache) HasEntry(seed string) bool {
 
 func startEndIndices(c *Committees, index uint64) (uint64, uint64) {
 	validatorCount := uint64(len(c.ShuffledIndices))
-	start := sliceutil.SplitOffset(validatorCount, c.CommitteeCount, index)
-	end := sliceutil.SplitOffset(validatorCount, c.CommitteeCount, index+1)
+	start := slice.SplitOffset(validatorCount, c.CommitteeCount, index)
+	end := slice.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/eth2.0-specs/blob/v0.9.3/specs/core/0_beacon-chain.md#get_seed
+// https://github.com/ethereum/consensus-specs/blob/v0.9.3/specs/core/0_beacon-chain.md#get_seed
 func key(seed [32]byte) string {
 	return string(seed[:])
 }

beacon-chain/cache/committee_disabled.go

@@ -41,6 +41,11 @@ func (c *FakeCommitteeCache) ActiveIndicesCount(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) {
+	return 0, nil
+}
+
 // ProposerIndices returns the proposer indices of a given seed.
 func (c *FakeCommitteeCache) ProposerIndices(seed [32]byte) ([]types.ValidatorIndex, error) {
 	return nil, nil

beacon-chain/cache/committees.go

@@ -10,6 +10,9 @@ import (
 // a Committee struct.
 var ErrNotCommittee = errors.New("object is not a committee struct")
 
+// ErrNonCommitteeKey will be returned when the committee key does not exist in cache.
+var ErrNonCommitteeKey = errors.New("committee key does not exist")
+
 // Committees defines the shuffled committees seed.
 type Committees struct {
 	CommitteeCount  uint64

beacon-chain/cache/depositcache/BUILD.bazel

@@ -10,11 +10,11 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
+        "//container/trie:go_default_library",
+        "//crypto/hash:go_default_library",
         "//proto/prysm/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 +31,12 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//container/trie:go_default_library",
         "//proto/prysm/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",
     ],

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/container/trie"
 	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/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        *trieutil.SparseMerkleTrie
+	Deposits        *trie.SparseMerkleTrie
 	MerkleTrieIndex int64
 }
 
@@ -59,7 +59,7 @@ type DepositCache struct {
 
 // New instantiates a new deposit cache
 func New() (*DepositCache, error) {
-	finalizedDepositsTrie, err := trieutil.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
+	finalizedDepositsTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -7,13 +7,13 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/container/trie"
 	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/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 := trieutil.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
+	trie, err := trie.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 := trieutil.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
+	trie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate deposit trie")
 	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
 }

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"
-	"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 := hashutil.HashProto(d)
+	depRoot, err := hash.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 := hashutil.HashProto(ctnr.Deposit)
+		hash, err := hash.HashProto(ctnr.Deposit)
 		if err != nil {
 			log.Errorf("Could not hash deposit %v", err)
 			continue

beacon-chain/cache/error.go

@@ -0,0 +1,15 @@
+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")
+)

beacon-chain/cache/skip_slot_cache.go

@@ -10,6 +10,7 @@ import (
 	"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"
 	"go.opencensus.io/trace"
 )
 
@@ -25,7 +26,7 @@ var (
 	})
 )
 
-// SkipSlotCache is used to store the cached results of processing skip slots in state.ProcessSlots.
+// SkipSlotCache is used to store the cached results of processing skip slots in transition.ProcessSlots.
 type SkipSlotCache struct {
 	cache      *lru.Cache
 	lock       sync.RWMutex
@@ -35,12 +36,8 @@ 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:      cache,
+		cache:      lruwrpr.New(8),
 		inProgress: make(map[[32]byte]bool),
 	}
 }

beacon-chain/cache/subnet_ids.go

@@ -7,8 +7,9 @@ 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/container/slice"
 	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/sliceutil"
 )
 
 type subnetIDs struct {
@@ -27,14 +28,8 @@ 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, err := lru.New(cacheSize)
-	if err != nil {
-		panic(err)
-	}
-	aggregatorCache, err := lru.New(cacheSize)
-	if err != nil {
-		panic(err)
-	}
+	attesterCache := lruwrpr.New(cacheSize)
+	aggregatorCache := lruwrpr.New(cacheSize)
 	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)
@@ -49,7 +44,7 @@ func (s *subnetIDs) AddAttesterSubnetID(slot types.Slot, subnetID uint64) {
 	ids := []uint64{subnetID}
 	val, exists := s.attester.Get(slot)
 	if exists {
-		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
+		ids = slice.UnionUint64(append(val.([]uint64), ids...))
 	}
 	s.attester.Add(slot, ids)
 }
@@ -77,7 +72,7 @@ func (s *subnetIDs) AddAggregatorSubnetID(slot types.Slot, subnetID uint64) {
 	ids := []uint64{subnetID}
 	val, exists := s.aggregator.Get(slot)
 	if exists {
-		ids = sliceutil.UnionUint64(append(val.([]uint64), ids...))
+		ids = slice.UnionUint64(append(val.([]uint64), ids...))
 	}
 	s.aggregator.Add(slot, ids)
 }
@@ -122,7 +117,7 @@ func (s *subnetIDs) GetAllSubnets() []uint64 {
 		}
 		committees = append(committees, v.Object.([]uint64)...)
 	}
-	return sliceutil.SetUint64(committees)
+	return slice.SetUint64(committees)
 }
 
 // AddPersistentCommittee adds the relevant committee for that particular validator along with its

beacon-chain/cache/sync_committee.go

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

beacon-chain/cache/sync_committee_disabled.go

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

beacon-chain/cache/sync_committee_head_state.go

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

beacon-chain/cache/sync_committee_head_state_test.go

@@ -0,0 +1,102 @@
+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"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/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)
+		})
+	}
+}

beacon-chain/cache/sync_committee_test.go

@@ -0,0 +1,222 @@
+package cache_test
+
+import (
+	"testing"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"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"
+)
+
+func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
+	numValidators := 101
+	deterministicState, _ := testutil.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, _ := testutil.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, _ := testutil.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),
+	}
+}

beacon-chain/cache/sync_subnet_ids.go

@@ -0,0 +1,131 @@
+package cache
+
+import (
+	"sync"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/container/slice"
+	"github.com/prysmaticlabs/prysm/crypto/rand"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+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...))
+}

beacon-chain/cache/sync_subnet_ids_test.go

@@ -0,0 +1,57 @@
+package cache
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/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))
+}

beacon-chain/core/BUILD.bazel

@@ -0,0 +1,50 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["slot_epoch.go"],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core",
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//fuzz:__pkg__",
+        "//network/forks:__pkg__",
+        "//proto/prysm/v1alpha1/attestation:__pkg__",
+        "//shared/attestationutil:__pkg__",
+        "//shared/depositutil:__pkg__",
+        "//shared/interop:__pkg__",
+        "//shared/keystore:__pkg__",
+        "//shared/testutil:__pkg__",
+        "//shared/testutil/altair:__pkg__",
+        "//slasher:__subpackages__",
+        "//testing/benchmark/benchmark_files:__subpackages__",
+        "//testing/endtoend/evaluators:__pkg__",
+        "//testing/fuzz:__pkg__",
+        "//testing/spectest:__subpackages__",
+        "//tools:__subpackages__",
+        "//validator:__subpackages__",
+    ],
+    deps = [
+        "//beacon-chain/state:go_default_library",
+        "//runtime/version:go_default_library",
+        "//shared/params:go_default_library",
+        "//time:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["slot_epoch_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//beacon-chain/state/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//shared/params:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
+        "//time:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
+    ],
+)

beacon-chain/core/altair/BUILD.bazel

@@ -3,48 +3,84 @@ 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__",
         "//shared/testutil:__pkg__",
+        "//testing/spectest:__subpackages__",
+        "//validator/client:__pkg__",
     ],
     deps = [
+        "//beacon-chain/core:go_default_library",
         "//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/p2p/types:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/v2:go_default_library",
+        "//crypto/bls:go_default_library",
+        "//crypto/hash:go_default_library",
+        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//shared/bls:go_default_library",
+        "//proto/prysm/v1alpha1/attestation:go_default_library",
+        "//proto/prysm/v1alpha1/block:go_default_library",
         "//shared/bytesutil:go_default_library",
-        "//shared/hashutil:go_default_library",
-        "//shared/mathutil:go_default_library",
         "//shared/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//: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 = [
-        ":go_default_library",
+        "//beacon-chain/core: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/p2p/types:go_default_library",
+        "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
+        "//container/trie:go_default_library",
+        "//crypto/bls:go_default_library",
+        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//shared/bls:go_default_library",
+        "//proto/prysm/v1alpha1/attestation:go_default_library",
+        "//proto/prysm/v1alpha1/wrapper:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/params:go_default_library",
         "//shared/testutil:go_default_library",
+        "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
-        "//shared/trieutil:go_default_library",
+        "//time: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",
     ],
 )

beacon-chain/core/altair/attestation.go

@@ -0,0 +1,300 @@
+package altair
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	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/shared/params"
+	"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.VerifyNilBeaconBlock(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(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(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(
+	beaconState state.BeaconState,
+	targetEpoch types.Epoch,
+	indices []uint64,
+	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
+	var epochParticipation []byte
+	currentEpoch := core.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(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 {
+	return ((flag >> flagPosition) & 1) == 1
+}
+
+// AddValidatorFlag adds new validator flag to existing one.
+func AddValidatorFlag(flag, flagPosition uint8) uint8 {
+	return flag | (1 << flagPosition)
+}
+
+// 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
+		}
+		if participatedFlags[sourceFlagIndex] && !HasValidatorFlag(epochParticipation[index], sourceFlagIndex) {
+			epochParticipation[index] = AddValidatorFlag(epochParticipation[index], sourceFlagIndex)
+			proposerRewardNumerator += br * cfg.TimelySourceWeight
+		}
+		if participatedFlags[targetFlagIndex] && !HasValidatorFlag(epochParticipation[index], targetFlagIndex) {
+			epochParticipation[index] = AddValidatorFlag(epochParticipation[index], targetFlagIndex)
+			proposerRewardNumerator += br * cfg.TimelyTargetWeight
+		}
+		if participatedFlags[headFlagIndex] && !HasValidatorFlag(epochParticipation[index], headFlagIndex) {
+			epochParticipation[index] = AddValidatorFlag(epochParticipation[index], headFlagIndex)
+			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(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(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 := core.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
+}

beacon-chain/core/altair/attestation_test.go

@@ -0,0 +1,754 @@
+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"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	"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/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
+	attestations := []*ethpb.Attestation{
+		testutil.HydrateAttestation(&ethpb.Attestation{
+			Data: &ethpb.AttestationData{
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+				Slot:   5,
+			},
+		}),
+	}
+	b := testutil.NewBeaconBlockAltair()
+	b.Block = &ethpb.BeaconBlockAltair{
+		Body: &ethpb.BeaconBlockBodyAltair{
+			Attestations: attestations,
+		},
+	}
+	beaconState, _ := testutil.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 := testutil.HydrateAttestation(&ethpb.Attestation{
+		Data: &ethpb.AttestationData{
+			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
+			Target: &ethpb.Checkpoint{Epoch: 0}}})
+
+	b := testutil.NewBeaconBlockAltair()
+	b.Block = &ethpb.BeaconBlockAltair{
+		Body: &ethpb.BeaconBlockBodyAltair{
+			Attestations: []*ethpb.Attestation{att},
+		},
+	}
+	beaconState, _ := testutil.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,
+		core.PrevEpoch(beaconState),
+		core.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 := testutil.NewBeaconBlockAltair()
+	b.Block = &ethpb.BeaconBlockAltair{
+		Body: &ethpb.BeaconBlockBodyAltair{
+			Attestations: attestations,
+		},
+	}
+	beaconState, _ := testutil.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 = core.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, _ := testutil.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 := testutil.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 = core.PrevEpoch(beaconState)
+	b.Block.Body.Attestations[0].Data.Target.Epoch = core.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, _ := testutil.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 := testutil.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 := testutil.DeterministicGenesisStateAltair(t, 100)
+
+	aggBits := bitfield.NewBitlist(3)
+	aggBits.SetBitAt(0, true)
+	var mockRoot [32]byte
+	copy(mockRoot[:], "hello-world")
+	att := testutil.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(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 := helpers.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 := testutil.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, _ := testutil.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(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 {
+		require.Equal(t, true, altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelyHeadFlagIndex))
+		require.Equal(t, true, altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelyTargetFlagIndex))
+		require.Equal(t, true, altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelySourceFlagIndex))
+	}
+}
+
+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 {
+				require.Equal(t, true, altair.HasValidatorFlag(tt.set, f))
+			}
+		})
+	}
+}
+
+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{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := uint8(0)
+			for _, f := range tt.set {
+				b = altair.AddValidatorFlag(b, f)
+			}
+			for _, f := range tt.expectedFalse {
+				require.Equal(t, false, altair.HasValidatorFlag(b, f))
+			}
+			for _, f := range tt.expectedTrue {
+				require.Equal(t, true, altair.HasValidatorFlag(b, f))
+			}
+		})
+	}
+}
+
+func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconStateAltair{}
+	b := &ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}
+	ctx := context.Background()
+	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(ctx, 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, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+			require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
+
+			currentEpoch := core.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(beaconState, test.epoch, test.indices, test.participatedFlags, b)
+			require.NoError(t, err)
+
+			i, err := helpers.BeaconProposerIndex(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, _ := testutil.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, _ := testutil.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(beaconState, test.rewardNumerator))
+		i, err := helpers.BeaconProposerIndex(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, _ := testutil.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, _ := testutil.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)
+	}
+}

beacon-chain/core/altair/block.go

@@ -0,0 +1,176 @@
+package altair
+
+import (
+	"errors"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	p2pType "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/crypto/bls"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// 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(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(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 := core.PrevSlot(s.Slot())
+	d, err := helpers.Domain(s.Fork(), core.SlotToEpoch(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 := helpers.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(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(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
+}

beacon-chain/core/altair/block_test.go

@@ -0,0 +1,318 @@
+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"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	p2pType "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
+	"github.com/prysmaticlabs/prysm/crypto/bls"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"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"
+)
+
+func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
+	beaconState, privKeys := testutil.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 := core.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 := helpers.ComputeDomainAndSign(beaconState, core.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(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(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 := testutil.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 := core.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 := helpers.ComputeDomainAndSign(beaconState, core.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(beaconState, syncAggregate)
+	require.ErrorContains(t, "invalid sync committee signature", err)
+}
+
+func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
+	beaconState, privKeys := testutil.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 := core.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 := helpers.ComputeDomainAndSign(beaconState, core.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(beaconState, syncAggregate)
+	require.NoError(t, err)
+}
+
+func TestProcessSyncCommittee_FilterSyncCommitteeVotes(t *testing.T) {
+	beaconState, _ := testutil.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 := testutil.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 := core.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 := helpers.ComputeDomainAndSign(beaconState, core.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, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, err := altair.ApplySyncRewardsPenalties(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(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)
+		})
+	}
+}

beacon-chain/core/altair/deposit.go

@@ -4,12 +4,10 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 // ProcessDeposits processes validator deposits for beacon state Altair.
@@ -37,22 +35,11 @@ func ProcessDeposits(
 
 // 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, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature)
+	beaconState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature)
 	if err != nil {
 		return nil, err
 	}
-
-	// The last validator in the beacon state validator registry.
-	v, err := beaconState.ValidatorAtIndexReadOnly(types.ValidatorIndex(beaconState.NumValidators() - 1))
-	if err != nil {
-		return nil, err
-	}
-	// We know a validator is brand new when its status epochs are all far future epoch.
-	// In this case, we append 0 to inactivity score and participation bits.
-	if v.ActivationEligibilityEpoch() == v.ActivationEpoch() &&
-		v.ActivationEpoch() == v.ExitEpoch() &&
-		v.ExitEpoch() == v.WithdrawableEpoch() &&
-		v.WithdrawableEpoch() == params.BeaconConfig().FarFutureEpoch {
+	if isNewValidator {
 		if err := beaconState.AppendInactivityScore(0); err != nil {
 			return nil, err
 		}

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -8,13 +8,12 @@ import (
 	"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"
-	statepb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
 
 func TestFuzzProcessDeposits_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &statepb.BeaconStateAltair{}
+	state := &ethpb.BeaconStateAltair{}
 	deposits := make([]*ethpb.Deposit, 100)
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
@@ -33,7 +32,7 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 
 func TestFuzzProcessDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	state := &statepb.BeaconStateAltair{}
+	state := &ethpb.BeaconStateAltair{}
 	deposit := &ethpb.Deposit{}
 
 	for i := 0; i < 10000; i++ {