Use multi lock

* bring over helpers

* slasher helpers pass tests

* fix dead link

* rem eth2

* gaz

* params

* gaz

* builds

Co-authored-by: Preston Van Loon <preston@prysmaticlabs.com>

api/gateway/BUILD.bazel

@@ -3,12 +3,8 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "api_middleware.go",
-        "api_middleware_processing.go",
-        "api_middleware_structs.go",
         "gateway.go",
         "log.go",
-        "param_handling.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/api/gateway",
     visibility = [
@@ -16,16 +12,13 @@ go_library(
         "//validator:__subpackages__",
     ],
     deps = [
-        "//api/grpc:go_default_library",
+        "//api/gateway/apimiddleware:go_default_library",
         "//runtime:go_default_library",
-        "//shared/bytesutil: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",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_rs_cors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_wealdtech_go_bytesutil//:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//connectivity:go_default_library",
         "@org_golang_google_grpc//credentials:go_default_library",
@@ -34,17 +27,13 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "api_middleware_processing_test.go",
-        "gateway_test.go",
-        "param_handling_test.go",
-    ],
+    srcs = ["gateway_test.go"],
     embed = [":go_default_library"],
     deps = [
-        "//api/grpc:go_default_library",
+        "//api/gateway/apimiddleware:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
-        "//shared/testutil/assert:go_default_library",
-        "//shared/testutil/require:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
         "@com_github_gorilla_mux//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",

api/gateway/apimiddleware/BUILD.bazel

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

api/gateway/apimiddleware/api_middleware.go

@@ -1,4 +1,4 @@
-package gateway
+package apimiddleware
 
 import (
 	"net/http"
@@ -13,9 +13,7 @@ import (
 //   - gRPC responses can be returned as spec-compliant Ethereum consensus API responses
 type ApiProxyMiddleware struct {
 	GatewayAddress  string
-	ProxyAddress    string
 	EndpointCreator EndpointFactory
-	router          *mux.Router
 }
 
 // EndpointFactory is responsible for creating new instances of Endpoint values.
@@ -28,16 +26,19 @@ 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.
+	GetResponse        interface{}     // The struct corresponding to the JSON structure used in a GET response.
 	PostRequest        interface{}     // The struct corresponding to the JSON structure used in a POST request.
 	PostResponse       interface{}     // The struct corresponding to the JSON structure used in a POST response.
 	RequestURLLiterals []string        // Names of URL parameters that should not be base64-encoded.
 	RequestQueryParams []QueryParam    // Query parameters of the request.
-	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.
 }
 
+// RunDefault expresses whether the default processing logic should be carried out after running a pre hook.
+type RunDefault bool
+
 // DefaultEndpoint returns an Endpoint with default configuration, e.g. DefaultErrorJson for error handling.
 func DefaultEndpoint() Endpoint {
 	return Endpoint{
@@ -52,19 +53,16 @@ type QueryParam struct {
 	Enum bool
 }
 
-// Hook is a function that can be invoked at various stages of the request/response cycle, leading to custom behaviour for a specific endpoint.
-type Hook = func(endpoint Endpoint, w http.ResponseWriter, req *http.Request) ErrorJson
-
 // CustomHandler is a function that can be invoked at the very beginning of the request,
 // essentially replacing the whole default request/response logic with custom logic for a specific endpoint.
 type CustomHandler = func(m *ApiProxyMiddleware, endpoint Endpoint, w http.ResponseWriter, req *http.Request) (handled bool)
 
 // HookCollection contains hooks that can be used to amend the default request/response cycle with custom logic for a specific endpoint.
 type HookCollection struct {
-	OnPreDeserializeRequestBodyIntoContainer      []Hook
-	OnPostDeserializeRequestBodyIntoContainer     []Hook
-	OnPreDeserializeGrpcResponseBodyIntoContainer []func([]byte, interface{}) (bool, ErrorJson)
-	OnPreSerializeMiddlewareResponseIntoJson      []func(interface{}) (bool, []byte, ErrorJson)
+	OnPreDeserializeRequestBodyIntoContainer      func(endpoint Endpoint, w http.ResponseWriter, req *http.Request) (RunDefault, ErrorJson)
+	OnPostDeserializeRequestBodyIntoContainer     func(endpoint Endpoint, w http.ResponseWriter, req *http.Request) ErrorJson
+	OnPreDeserializeGrpcResponseBodyIntoContainer func([]byte, interface{}) (RunDefault, ErrorJson)
+	OnPreSerializeMiddlewareResponseIntoJson      func(interface{}) (RunDefault, []byte, ErrorJson)
 }
 
 // fieldProcessor applies the processing function f to a value when the tag is present on the field.
@@ -73,19 +71,15 @@ type fieldProcessor struct {
 	f   func(value reflect.Value) error
 }
 
-// Run starts the proxy, registering all proxy endpoints on ApiProxyMiddleware.ProxyAddress.
-func (m *ApiProxyMiddleware) Run() error {
-	m.router = mux.NewRouter()
-
+// Run starts the proxy, registering all proxy endpoints.
+func (m *ApiProxyMiddleware) Run(gatewayRouter *mux.Router) {
 	for _, path := range m.EndpointCreator.Paths() {
-		m.handleApiPath(path, m.EndpointCreator)
+		m.handleApiPath(gatewayRouter, path, m.EndpointCreator)
 	}
-
-	return http.ListenAndServe(m.ProxyAddress, m.router)
 }
 
-func (m *ApiProxyMiddleware) handleApiPath(path string, endpointFactory EndpointFactory) {
-	m.router.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) {
+func (m *ApiProxyMiddleware) handleApiPath(gatewayRouter *mux.Router, path string, endpointFactory EndpointFactory) {
+	gatewayRouter.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) {
 		endpoint, err := endpointFactory.Create(path)
 		if err != nil {
 			errJson := InternalServerErrorWithMessage(err, "could not create endpoint")
@@ -99,23 +93,10 @@ func (m *ApiProxyMiddleware) handleApiPath(path string, endpointFactory Endpoint
 		}
 
 		if req.Method == "POST" {
-			for _, hook := range endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer {
-				if errJson := hook(*endpoint, w, req); errJson != nil {
-					WriteError(w, errJson, nil)
-					return
-				}
-			}
-
-			if errJson := DeserializeRequestBodyIntoContainer(req.Body, endpoint.PostRequest); errJson != nil {
+			if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
 				WriteError(w, errJson, nil)
 				return
 			}
-			for _, hook := range endpoint.Hooks.OnPostDeserializeRequestBodyIntoContainer {
-				if errJson := hook(*endpoint, w, req); errJson != nil {
-					WriteError(w, errJson, nil)
-					return
-				}
-			}
 
 			if errJson := ProcessRequestContainerFields(endpoint.PostRequest); errJson != nil {
 				WriteError(w, errJson, nil)
@@ -131,87 +112,122 @@ func (m *ApiProxyMiddleware) handleApiPath(path string, endpointFactory Endpoint
 			WriteError(w, errJson, nil)
 			return
 		}
-		grpcResponse, errJson := ProxyRequest(req)
+		grpcResp, errJson := ProxyRequest(req)
 		if errJson != nil {
 			WriteError(w, errJson, nil)
 			return
 		}
-		grpcResponseBody, errJson := ReadGrpcResponseBody(grpcResponse.Body)
+		grpcRespBody, errJson := ReadGrpcResponseBody(grpcResp.Body)
 		if errJson != nil {
 			WriteError(w, errJson, nil)
 			return
 		}
 
-		var responseJson []byte
-		if !GrpcResponseIsEmpty(grpcResponseBody) {
-			if errJson := DeserializeGrpcResponseBodyIntoErrorJson(endpoint.Err, grpcResponseBody); errJson != nil {
+		var respJson []byte
+		if !GrpcResponseIsEmpty(grpcRespBody) {
+			if errJson := DeserializeGrpcResponseBodyIntoErrorJson(endpoint.Err, grpcRespBody); errJson != nil {
 				WriteError(w, errJson, nil)
 				return
 			}
 			if endpoint.Err.Msg() != "" {
-				HandleGrpcResponseError(endpoint.Err, grpcResponse, w)
+				HandleGrpcResponseError(endpoint.Err, grpcResp, w)
 				return
 			}
-			var response interface{}
+
+			var resp interface{}
 			if req.Method == "GET" {
-				response = endpoint.GetResponse
+				resp = endpoint.GetResponse
 			} else {
-				response = endpoint.PostResponse
+				resp = endpoint.PostResponse
 			}
-
-			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 errJson := deserializeGrpcResponseBodyIntoContainerWrapped(endpoint, grpcRespBody, resp); errJson != nil {
+				WriteError(w, errJson, nil)
+				return
 			}
-			if runDefault {
-				if errJson := DeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, response); errJson != nil {
-					WriteError(w, errJson, nil)
-					return
-				}
-			}
-
-			if errJson := ProcessMiddlewareResponseFields(response); errJson != nil {
+			if errJson := ProcessMiddlewareResponseFields(resp); 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
-				}
+			respJson, errJson = serializeMiddlewareResponseIntoJsonWrapped(endpoint, respJson, resp)
+			if errJson != nil {
+				WriteError(w, errJson, nil)
+				return
 			}
 		}
 
-		if errJson := WriteMiddlewareResponseHeadersAndBody(grpcResponse, responseJson, w); errJson != nil {
+		if errJson := WriteMiddlewareResponseHeadersAndBody(grpcResp, respJson, w); errJson != nil {
 			WriteError(w, errJson, nil)
 			return
 		}
-		if errJson := Cleanup(grpcResponse.Body); errJson != nil {
+		if errJson := Cleanup(grpcResp.Body); errJson != nil {
 			WriteError(w, errJson, nil)
 			return
 		}
 	})
 }
+
+func deserializeRequestBodyIntoContainerWrapped(endpoint *Endpoint, req *http.Request, w http.ResponseWriter) ErrorJson {
+	runDefault := true
+	if endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer != nil {
+		run, errJson := endpoint.Hooks.OnPreDeserializeRequestBodyIntoContainer(*endpoint, w, req)
+		if errJson != nil {
+			return errJson
+		}
+		if !run {
+			runDefault = false
+		}
+	}
+	if runDefault {
+		if errJson := DeserializeRequestBodyIntoContainer(req.Body, endpoint.PostRequest); errJson != nil {
+			return errJson
+		}
+	}
+	if endpoint.Hooks.OnPostDeserializeRequestBodyIntoContainer != nil {
+		if errJson := endpoint.Hooks.OnPostDeserializeRequestBodyIntoContainer(*endpoint, w, req); errJson != nil {
+			return errJson
+		}
+	}
+	return nil
+}
+
+func deserializeGrpcResponseBodyIntoContainerWrapped(endpoint *Endpoint, grpcResponseBody []byte, resp interface{}) ErrorJson {
+	runDefault := true
+	if endpoint.Hooks.OnPreDeserializeGrpcResponseBodyIntoContainer != nil {
+		run, errJson := endpoint.Hooks.OnPreDeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, resp)
+		if errJson != nil {
+			return errJson
+		}
+		if !run {
+			runDefault = false
+		}
+	}
+	if runDefault {
+		if errJson := DeserializeGrpcResponseBodyIntoContainer(grpcResponseBody, resp); errJson != nil {
+			return errJson
+		}
+	}
+	return nil
+}
+
+func serializeMiddlewareResponseIntoJsonWrapped(endpoint *Endpoint, respJson []byte, resp interface{}) ([]byte, ErrorJson) {
+	runDefault := true
+	var errJson ErrorJson
+	if endpoint.Hooks.OnPreSerializeMiddlewareResponseIntoJson != nil {
+		var run RunDefault
+		run, respJson, errJson = endpoint.Hooks.OnPreSerializeMiddlewareResponseIntoJson(resp)
+		if errJson != nil {
+			return nil, errJson
+		}
+		if !run {
+			runDefault = false
+		}
+	}
+	if runDefault {
+		respJson, errJson = SerializeMiddlewareResponseIntoJson(resp)
+		if errJson != nil {
+			return nil, errJson
+		}
+	}
+	return respJson, nil
+}

api/gateway/apimiddleware/log.go

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

api/gateway/apimiddleware/param_handling.go

@@ -1,4 +1,4 @@
-package gateway
+package apimiddleware
 
 import (
 	"encoding/base64"
@@ -7,7 +7,7 @@ import (
 	"strings"
 
 	"github.com/gorilla/mux"
-	butil "github.com/prysmaticlabs/prysm/shared/bytesutil"
+	butil "github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/wealdtech/go-bytesutil"
 )
 

api/gateway/apimiddleware/param_handling_test.go

@@ -1,4 +1,4 @@
-package gateway
+package apimiddleware
 
 import (
 	"bytes"
@@ -6,8 +6,8 @@ import (
 	"testing"
 
 	"github.com/gorilla/mux"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestHandleURLParameters(t *testing.T) {

api/gateway/apimiddleware/process_field.go

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

api/gateway/apimiddleware/process_request.go

@@ -1,22 +1,16 @@
-package gateway
+package apimiddleware
 
 import (
 	"bytes"
-	"encoding/base64"
 	"encoding/json"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
-	"reflect"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/api/grpc"
-	"github.com/wealdtech/go-bytesutil"
 )
 
 // DeserializeRequestBodyIntoContainer deserializes the request's body into an endpoint-specific struct.
@@ -62,7 +56,12 @@ func (m *ApiProxyMiddleware) PrepareRequestForProxying(endpoint Endpoint, req *h
 	if errJson := HandleURLParameters(endpoint.Path, req, endpoint.RequestURLLiterals); errJson != nil {
 		return errJson
 	}
-	return HandleQueryParameters(req, endpoint.RequestQueryParams)
+	if errJson := HandleQueryParameters(req, endpoint.RequestQueryParams); errJson != nil {
+		return errJson
+	}
+	// We have to add the prefix after handling parameters because adding the prefix changes URL segment indexing.
+	req.URL.Path = "/internal" + req.URL.Path
+	return nil
 }
 
 // ProxyRequest proxies the request to grpc-gateway.
@@ -224,97 +223,3 @@ func Cleanup(grpcResponseBody io.ReadCloser) ErrorJson {
 	}
 	return nil
 }
-
-// processField calls each processor function on any field that has the matching tag set.
-// It is a recursive function.
-func processField(s interface{}, processors []fieldProcessor) error {
-	kind := reflect.TypeOf(s).Kind()
-	if kind != reflect.Ptr && kind != reflect.Slice && kind != reflect.Array {
-		return fmt.Errorf("processing fields of kind '%v' is unsupported", kind)
-	}
-
-	t := reflect.TypeOf(s).Elem()
-	v := reflect.Indirect(reflect.ValueOf(s))
-
-	for i := 0; i < t.NumField(); i++ {
-		switch v.Field(i).Kind() {
-		case reflect.Slice:
-			sliceElem := t.Field(i).Type.Elem()
-			kind := sliceElem.Kind()
-			// Recursively process slices to struct pointers.
-			if kind == reflect.Ptr && sliceElem.Elem().Kind() == reflect.Struct {
-				for j := 0; j < v.Field(i).Len(); j++ {
-					if err := processField(v.Field(i).Index(j).Interface(), processors); err != nil {
-						return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-					}
-				}
-			}
-			// Process each string in string slices.
-			if kind == reflect.String {
-				for _, proc := range processors {
-					_, hasTag := t.Field(i).Tag.Lookup(proc.tag)
-					if hasTag {
-						for j := 0; j < v.Field(i).Len(); j++ {
-							if err := proc.f(v.Field(i).Index(j)); err != nil {
-								return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-							}
-						}
-					}
-				}
-
-			}
-		// Recursively process struct pointers.
-		case reflect.Ptr:
-			if v.Field(i).Elem().Kind() == reflect.Struct {
-				if err := processField(v.Field(i).Interface(), processors); err != nil {
-					return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-				}
-			}
-		default:
-			field := t.Field(i)
-			for _, proc := range processors {
-				if _, hasTag := field.Tag.Lookup(proc.tag); hasTag {
-					if err := proc.f(v.Field(i)); err != nil {
-						return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func hexToBase64Processor(v reflect.Value) error {
-	b, err := bytesutil.FromHexString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(base64.StdEncoding.EncodeToString(b))
-	return nil
-}
-
-func base64ToHexProcessor(v reflect.Value) error {
-	if v.String() == "" {
-		return nil
-	}
-	b, err := base64.StdEncoding.DecodeString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(hexutil.Encode(b))
-	return nil
-}
-
-func enumToLowercaseProcessor(v reflect.Value) error {
-	v.SetString(strings.ToLower(v.String()))
-	return nil
-}
-
-func timeToUnixProcessor(v reflect.Value) error {
-	t, err := time.Parse(time.RFC3339, v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(strconv.FormatUint(uint64(t.Unix()), 10))
-	return nil
-}

api/gateway/apimiddleware/process_request_test.go

@@ -1,4 +1,4 @@
-package gateway
+package apimiddleware
 
 import (
 	"bytes"
@@ -9,8 +9,8 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/api/grpc"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/sirupsen/logrus/hooks/test"
 )
 

api/gateway/apimiddleware/structs.go

@@ -1,4 +1,4 @@
-package gateway
+package apimiddleware
 
 import (
 	"net/http"

api/gateway/gateway.go

@@ -10,8 +10,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/gorilla/mux"
 	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/api/gateway/apimiddleware"
 	"github.com/prysmaticlabs/prysm/runtime"
 	"github.com/rs/cors"
 	"google.golang.org/grpc"
@@ -25,7 +27,7 @@ var _ runtime.Service = (*Gateway)(nil)
 type PbMux struct {
 	Registrations []PbHandlerRegistration // Protobuf registrations to be registered in Mux.
 	Patterns      []string                // URL patterns that will be handled by Mux.
-	Mux           *gwruntime.ServeMux     // The mux that will be used for grpc-gateway requests.
+	Mux           *gwruntime.ServeMux     // The router that will be used for grpc-gateway requests.
 }
 
 // PbHandlerRegistration is a function that registers a protobuf handler.
@@ -37,16 +39,15 @@ type MuxHandler func(http.Handler, http.ResponseWriter, *http.Request)
 // Gateway is the gRPC gateway to serve HTTP JSON traffic as a proxy and forward it to the gRPC server.
 type Gateway struct {
 	conn                         *grpc.ClientConn
-	pbHandlers                   []PbMux
+	pbHandlers                   []*PbMux
 	muxHandler                   MuxHandler
 	maxCallRecvMsgSize           uint64
-	mux                          *http.ServeMux
+	router                       *mux.Router
 	server                       *http.Server
 	cancel                       context.CancelFunc
 	remoteCert                   string
 	gatewayAddr                  string
-	apiMiddlewareAddr            string
-	apiMiddlewareEndpointFactory EndpointFactory
+	apiMiddlewareEndpointFactory apimiddleware.EndpointFactory
 	ctx                          context.Context
 	startFailure                 error
 	remoteAddr                   string
@@ -56,7 +57,7 @@ type Gateway struct {
 // New returns a new instance of the Gateway.
 func New(
 	ctx context.Context,
-	pbHandlers []PbMux,
+	pbHandlers []*PbMux,
 	muxHandler MuxHandler,
 	remoteAddr,
 	gatewayAddress string,
@@ -64,7 +65,7 @@ func New(
 	g := &Gateway{
 		pbHandlers:     pbHandlers,
 		muxHandler:     muxHandler,
-		mux:            http.NewServeMux(),
+		router:         mux.NewRouter(),
 		gatewayAddr:    gatewayAddress,
 		ctx:            ctx,
 		remoteAddr:     remoteAddr,
@@ -73,9 +74,9 @@ func New(
 	return g
 }
 
-// WithMux allows adding a custom http.ServeMux to the gateway.
-func (g *Gateway) WithMux(m *http.ServeMux) *Gateway {
-	g.mux = m
+// WithRouter allows adding a custom mux router to the gateway.
+func (g *Gateway) WithRouter(r *mux.Router) *Gateway {
+	g.router = r
 	return g
 }
 
@@ -98,8 +99,7 @@ func (g *Gateway) WithMaxCallRecvMsgSize(size uint64) *Gateway {
 }
 
 // WithApiMiddleware allows adding API Middleware proxy to the gateway.
-func (g *Gateway) WithApiMiddleware(address string, endpointFactory EndpointFactory) *Gateway {
-	g.apiMiddlewareAddr = address
+func (g *Gateway) WithApiMiddleware(endpointFactory apimiddleware.EndpointFactory) *Gateway {
 	g.apiMiddlewareEndpointFactory = endpointFactory
 	return g
 }
@@ -126,21 +126,25 @@ func (g *Gateway) Start() {
 			}
 		}
 		for _, p := range h.Patterns {
-			g.mux.Handle(p, h.Mux)
+			g.router.PathPrefix(p).Handler(h.Mux)
 		}
 	}
 
-	corsMux := g.corsMiddleware(g.mux)
+	corsMux := g.corsMiddleware(g.router)
 
 	if g.muxHandler != nil {
-		g.mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		g.router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 			g.muxHandler(corsMux, w, r)
 		})
 	}
 
+	if g.apiMiddlewareEndpointFactory != nil && !g.apiMiddlewareEndpointFactory.IsNil() {
+		go g.registerApiMiddleware()
+	}
+
 	g.server = &http.Server{
 		Addr:    g.gatewayAddr,
-		Handler: corsMux,
+		Handler: g.router,
 	}
 
 	go func() {
@@ -151,10 +155,6 @@ func (g *Gateway) Start() {
 			return
 		}
 	}()
-
-	if g.apiMiddlewareAddr != "" && g.apiMiddlewareEndpointFactory != nil && !g.apiMiddlewareEndpointFactory.IsNil() {
-		go g.registerApiMiddleware()
-	}
 }
 
 // Status of grpc gateway. Returns an error if this service is unhealthy.
@@ -272,15 +272,10 @@ func (g *Gateway) dialUnix(ctx context.Context, addr string) (*grpc.ClientConn,
 }
 
 func (g *Gateway) registerApiMiddleware() {
-	proxy := &ApiProxyMiddleware{
+	proxy := &apimiddleware.ApiProxyMiddleware{
 		GatewayAddress:  g.gatewayAddr,
-		ProxyAddress:    g.apiMiddlewareAddr,
 		EndpointCreator: g.apiMiddlewareEndpointFactory,
 	}
-	log.WithField("API middleware address", g.apiMiddlewareAddr).Info("Starting API middleware")
-	if err := proxy.Run(); err != http.ErrServerClosed {
-		log.WithError(err).Error("Failed to start API middleware")
-		g.startFailure = err
-		return
-	}
+	log.Info("Starting API middleware")
+	proxy.Run(g.router)
 }

api/gateway/gateway_test.go

@@ -9,9 +9,11 @@ import (
 	"net/url"
 	"testing"
 
+	"github.com/gorilla/mux"
+	"github.com/prysmaticlabs/prysm/api/gateway/apimiddleware"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 	"github.com/urfave/cli/v2"
 )
@@ -23,7 +25,7 @@ func (*mockEndpointFactory) Paths() []string {
 	return []string{}
 }
 
-func (*mockEndpointFactory) Create(_ string) (*Endpoint, error) {
+func (*mockEndpointFactory) Create(_ string) (*apimiddleware.Endpoint, error) {
 	return nil, nil
 }
 
@@ -32,33 +34,31 @@ func (*mockEndpointFactory) IsNil() bool {
 }
 
 func TestGateway_Customized(t *testing.T) {
-	mux := http.NewServeMux()
+	r := mux.NewRouter()
 	cert := "cert"
 	origins := []string{"origin"}
 	size := uint64(100)
-	middlewareAddr := "middleware"
 	endpointFactory := &mockEndpointFactory{}
 
 	g := New(
 		context.Background(),
-		[]PbMux{},
+		[]*PbMux{},
 		func(handler http.Handler, writer http.ResponseWriter, request *http.Request) {
 
 		},
 		"",
 		"",
-	).WithMux(mux).
+	).WithRouter(r).
 		WithRemoteCert(cert).
 		WithAllowedOrigins(origins).
 		WithMaxCallRecvMsgSize(size).
-		WithApiMiddleware(middlewareAddr, endpointFactory)
+		WithApiMiddleware(endpointFactory)
 
-	assert.Equal(t, mux, g.mux)
+	assert.Equal(t, r, g.router)
 	assert.Equal(t, cert, g.remoteCert)
 	require.Equal(t, 1, len(g.allowedOrigins))
 	assert.Equal(t, origins[0], g.allowedOrigins[0])
 	assert.Equal(t, size, g.maxCallRecvMsgSize)
-	assert.Equal(t, middlewareAddr, g.apiMiddlewareAddr)
 	assert.Equal(t, endpointFactory, g.apiMiddlewareEndpointFactory)
 }
 
@@ -77,7 +77,7 @@ func TestGateway_StartStop(t *testing.T) {
 
 	g := New(
 		ctx.Context,
-		[]PbMux{},
+		[]*PbMux{},
 		func(handler http.Handler, writer http.ResponseWriter, request *http.Request) {
 
 		},
@@ -108,13 +108,13 @@ func TestGateway_NilHandler_NotFoundHandlerRegistered(t *testing.T) {
 
 	g := New(
 		ctx.Context,
-		[]PbMux{},
+		[]*PbMux{},
 		/* muxHandler */ nil,
 		selfAddress,
 		gatewayAddress,
 	)
 
 	writer := httptest.NewRecorder()
-	g.mux.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
+	g.router.ServeHTTP(writer, &http.Request{Method: "GET", Host: "localhost", URL: &url.URL{Path: "/foo"}})
 	assert.Equal(t, http.StatusNotFound, writer.Code)
 }

api/grpc/BUILD.bazel

@@ -20,8 +20,8 @@ go_test(
     srcs = ["grpcutils_test.go"],
     embed = [":go_default_library"],
     deps = [
-        "//shared/testutil/assert:go_default_library",
-        "//shared/testutil/require:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@org_golang_google_grpc//:go_default_library",

api/grpc/grpcutils_test.go

@@ -7,8 +7,8 @@ import (
 	"testing"
 
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"

api/pagination/BUILD.bazel

@@ -6,7 +6,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/api/pagination",
     visibility = ["//visibility:public"],
     deps = [
-        "//shared/params:go_default_library",
+        "//config/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )
@@ -16,7 +16,7 @@ go_test(
     srcs = ["pagination_test.go"],
     deps = [
         ":go_default_library",
-        "//shared/testutil/assert:go_default_library",
-        "//shared/testutil/require:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
     ],
 )

api/pagination/pagination.go

@@ -6,7 +6,7 @@ import (
 	"strconv"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/config/params"
 )
 
 // StartAndEndPage takes in the requested page token, wanted page size, total page size.

api/pagination/pagination_test.go

@@ -4,8 +4,8 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/api/pagination"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestStartAndEndPage(t *testing.T) {

async/BUILD.bazel

@@ -24,9 +24,9 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//shared/testutil:go_default_library",
-        "//shared/testutil/assert:go_default_library",
-        "//shared/testutil/require:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_stretchr_testify//assert:go_default_library",
     ],

async/benchmark_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/async"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	log "github.com/sirupsen/logrus"
 )
 

async/debounce_test.go

@@ -7,9 +7,9 @@ import (
 	"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"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestDebounce_NoEvents(t *testing.T) {
@@ -30,7 +30,7 @@ func TestDebounce_NoEvents(t *testing.T) {
 		})
 		wg.Done()
 	}()
-	if testutil.WaitTimeout(wg, interval*2) {
+	if util.WaitTimeout(wg, interval*2) {
 		t.Fatalf("Test should have exited by now, timed out")
 	}
 	assert.Equal(t, 0, timesHandled, "Wrong number of handled calls")
@@ -66,7 +66,7 @@ func TestDebounce_CtxClosing(t *testing.T) {
 		})
 		wg.Done()
 	}()
-	if testutil.WaitTimeout(wg, interval*2) {
+	if util.WaitTimeout(wg, interval*2) {
 		t.Fatalf("Test should have exited by now, timed out")
 	}
 	assert.Equal(t, 0, timesHandled, "Wrong number of handled calls")

async/event/BUILD.bazel

@@ -23,7 +23,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//shared/testutil/assert:go_default_library",
-        "//shared/testutil/require:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
     ],
 )

async/event/feed_test.go

@@ -23,7 +23,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/testing/assert"
 )
 
 func TestFeedPanics(t *testing.T) {

async/event/subscription_test.go

@@ -23,7 +23,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 var errInts = errors.New("error in subscribeInts")

async/every.go

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

async/multilock_test.go

@@ -50,7 +50,7 @@ func TestGetChan(t *testing.T) {
 	assert.Equal(ch1, ch3)
 }
 
-func TestLockUnlock(t *testing.T) {
+func TestLockUnlock(_ *testing.T) {
 	var wg sync.WaitGroup
 
 	wg.Add(5)

async/scatter.go

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

async/scatter_test.go

@@ -6,8 +6,8 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/async"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestDouble(t *testing.T) {

beacon-chain/blockchain/BUILD.bazel

@@ -48,15 +48,15 @@ go_library(
         "//beacon-chain/state/stategen:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
+        "//config/params:go_default_library",
         "//crypto/bls:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
         "//runtime/version:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/params:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_emicklei_dot//:go_default_library",
@@ -112,13 +112,13 @@ go_test(
         "//beacon-chain/powchain:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
+        "//config/params:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//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",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
@@ -161,13 +161,13 @@ go_test(
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//config/params:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//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",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -8,10 +8,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )
 
@@ -298,7 +298,7 @@ func (s *Service) HeadPublicKeyToValidatorIndex(ctx context.Context, pubKey [48]
 }
 
 // HeadValidatorIndexToPublicKey returns the pubkey of the validator `index`  in current head state.
-func (s *Service) HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([48]byte, error) {
+func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.ValidatorIndex) ([48]byte, error) {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 

beacon-chain/blockchain/chain_info_norace_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestHeadSlot_DataRace(t *testing.T) {

beacon-chain/blockchain/chain_info_test.go

@@ -10,13 +10,13 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -122,7 +122,7 @@ func TestHeadRoot_UseDB(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	c := &Service{cfg: &Config{BeaconDB: beaconDB}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
@@ -134,7 +134,7 @@ func TestHeadRoot_UseDB(t *testing.T) {
 }
 
 func TestHeadBlock_CanRetrieve(t *testing.T) {
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
 	require.NoError(t, err)
@@ -217,7 +217,7 @@ func TestIsCanonical_Ok(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	c := setupBeaconChain(t, beaconDB)
 
-	blk := testutil.NewBeaconBlock()
+	blk := util.NewBeaconBlock()
 	blk.Block.Slot = 0
 	root, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -233,7 +233,7 @@ func TestIsCanonical_Ok(t *testing.T) {
 }
 
 func TestService_HeadValidatorsIndices(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisState(t, 10)
+	s, _ := util.DeterministicGenesisState(t, 10)
 	c := &Service{}
 
 	c.head = &head{}
@@ -248,7 +248,7 @@ func TestService_HeadValidatorsIndices(t *testing.T) {
 }
 
 func TestService_HeadSeed(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisState(t, 1)
+	s, _ := util.DeterministicGenesisState(t, 1)
 	c := &Service{}
 	seed, err := helpers.Seed(s, 0, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
@@ -265,7 +265,7 @@ func TestService_HeadSeed(t *testing.T) {
 }
 
 func TestService_HeadGenesisValidatorRoot(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisState(t, 1)
+	s, _ := util.DeterministicGenesisState(t, 1)
 	c := &Service{}
 
 	c.head = &head{}
@@ -298,7 +298,7 @@ func TestService_ChainHeads(t *testing.T) {
 }
 
 func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisState(t, 10)
+	s, _ := util.DeterministicGenesisState(t, 10)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -314,7 +314,7 @@ func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
 }
 
 func TestService_HeadValidatorIndexToPublicKey(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisState(t, 10)
+	s, _ := util.DeterministicGenesisState(t, 10)
 	c := &Service{}
 	c.head = &head{state: s}
 

beacon-chain/blockchain/head.go

@@ -14,10 +14,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	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/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"

beacon-chain/blockchain/head_sync_committee_info.go

@@ -13,8 +13,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 // Initialize the state cache for sync committees.

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -10,9 +10,9 @@ import (
 	"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"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestService_headSyncCommitteeFetcher_Errors(t *testing.T) {
@@ -52,7 +52,7 @@ func TestService_HeadDomainFetcher_Errors(t *testing.T) {
 }
 
 func TestService_HeadSyncCommitteeIndices(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -75,7 +75,7 @@ func TestService_HeadSyncCommitteeIndices(t *testing.T) {
 }
 
 func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -89,7 +89,7 @@ func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
 }
 
 func TestService_headNextSyncCommitteeIndices(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -103,7 +103,7 @@ func TestService_headNextSyncCommitteeIndices(t *testing.T) {
 }
 
 func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -118,7 +118,7 @@ func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
 }
 
 func TestService_HeadSyncCommitteeDomain(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -132,7 +132,7 @@ func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 }
 
 func TestService_HeadSyncContributionProofDomain(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -146,7 +146,7 @@ func TestService_HeadSyncContributionProofDomain(t *testing.T) {
 }
 
 func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
 	c := &Service{}
 	c.head = &head{state: s}
 
@@ -164,7 +164,7 @@ func TestSyncCommitteeHeadStateCache_RoundTrip(t *testing.T) {
 	t.Cleanup(func() {
 		syncCommitteeHeadStateCache = cache.NewSyncCommitteeHeadState()
 	})
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, 100)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
 	require.NoError(t, beaconState.SetSlot(100))
 	cachedState, err := c.Get(101)
 	require.ErrorContains(t, cache.ErrNotFound.Error(), err)

beacon-chain/blockchain/head_test.go

@@ -11,13 +11,13 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
@@ -38,9 +38,9 @@ func TestSaveHead_Different(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	testutil.NewBeaconBlock()
+	util.NewBeaconBlock()
 	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
-		testutil.NewBeaconBlock(),
+		util.NewBeaconBlock(),
 	)
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
@@ -51,14 +51,14 @@ func TestSaveHead_Different(t *testing.T) {
 		block: oldBlock,
 	}
 
-	newHeadSignedBlock := testutil.NewBeaconBlock()
+	newHeadSignedBlock := util.NewBeaconBlock()
 	newHeadSignedBlock.Block.Slot = 1
 	newHeadBlock := newHeadSignedBlock.Block
 
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	headState, err := testutil.NewBeaconState()
+	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(1))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
@@ -81,7 +81,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	service := setupBeaconChain(t, beaconDB)
 
 	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
-		testutil.NewBeaconBlock(),
+		util.NewBeaconBlock(),
 	)
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
@@ -93,7 +93,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	}
 
 	reorgChainParent := [32]byte{'B'}
-	newHeadSignedBlock := testutil.NewBeaconBlock()
+	newHeadSignedBlock := util.NewBeaconBlock()
 	newHeadSignedBlock.Block.Slot = 1
 	newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
 	newHeadBlock := newHeadSignedBlock.Block
@@ -101,7 +101,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	headState, err := testutil.NewBeaconState()
+	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(1))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
@@ -124,7 +124,7 @@ func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	state, _ := testutil.DeterministicGenesisState(t, 100)
+	state, _ := util.DeterministicGenesisState(t, 100)
 	r := [32]byte{'a'}
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: r[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), state, r))
@@ -136,7 +136,7 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -150,7 +150,7 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
 
 func Test_notifyNewHeadEvent(t *testing.T) {
 	t.Run("genesis_state_root", func(t *testing.T) {
-		bState, _ := testutil.DeterministicGenesisState(t, 10)
+		bState, _ := util.DeterministicGenesisState(t, 10)
 		notifier := &mock.MockStateNotifier{RecordEvents: true}
 		srv := &Service{
 			cfg: &Config{
@@ -178,7 +178,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 		require.DeepSSZEqual(t, wanted, eventHead)
 	})
 	t.Run("non_genesis_values", func(t *testing.T) {
-		bState, _ := testutil.DeterministicGenesisState(t, 10)
+		bState, _ := util.DeterministicGenesisState(t, 10)
 		notifier := &mock.MockStateNotifier{RecordEvents: true}
 		genesisRoot := [32]byte{1}
 		srv := &Service{
@@ -220,8 +220,8 @@ func TestSaveOrphanedAtts(t *testing.T) {
 	})
 	defer resetCfg()
 
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -246,8 +246,8 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
 	})
 	defer resetCfg()
 
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)

beacon-chain/blockchain/info.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 
 	"github.com/emicklei/dot"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/config/params"
 )
 
 const template = `<html>

beacon-chain/blockchain/info_test.go

@@ -9,11 +9,11 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestService_TreeHandler(t *testing.T) {
@@ -22,7 +22,7 @@ func TestService_TreeHandler(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	headState, err := testutil.NewBeaconState()
+	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetBalances([]uint64{params.BeaconConfig().GweiPerEth}))
 	cfg := &Config{
@@ -38,7 +38,7 @@ func TestService_TreeHandler(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, [32]byte{'a'}, [32]byte{'g'}, [32]byte{'c'}, 0, 0))
 	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'c'}, 0, 0))
-	s.setHead([32]byte{'a'}, wrapper.WrappedPhase0SignedBeaconBlock(testutil.NewBeaconBlock()), headState)
+	s.setHead([32]byte{'a'}, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), headState)
 
 	rr := httptest.NewRecorder()
 	handler := http.HandlerFunc(s.TreeHandler)

beacon-chain/blockchain/init_test.go

@@ -1,7 +1,7 @@
 package blockchain
 
 import (
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/config/params"
 )
 
 func init() {

beacon-chain/blockchain/log.go

@@ -6,10 +6,10 @@ import (
 	"time"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/core"
+	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 	"github.com/sirupsen/logrus"
 )

beacon-chain/blockchain/log_test.go

@@ -6,7 +6,7 @@ import (
 	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/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 

beacon-chain/blockchain/metrics.go

@@ -10,11 +10,11 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 var (
@@ -246,7 +246,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 			return err
 		}
 	case version.Altair:
-		v, b, err = altair.InitializeEpochValidators(ctx, headState)
+		v, b, err = altair.InitializePrecomputeValidators(ctx, headState)
 		if err != nil {
 			return err
 		}

beacon-chain/blockchain/metrics_test.go

@@ -5,14 +5,14 @@ import (
 	"testing"
 
 	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestReportEpochMetrics_BadHeadState(t *testing.T) {
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
-	h, err := testutil.NewBeaconState()
+	h, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, h.SetValidators(nil))
 	err = reportEpochMetrics(context.Background(), s, h)
@@ -20,9 +20,9 @@ func TestReportEpochMetrics_BadHeadState(t *testing.T) {
 }
 
 func TestReportEpochMetrics_BadAttestation(t *testing.T) {
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
-	h, err := testutil.NewBeaconState()
+	h, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 0}))
 	err = reportEpochMetrics(context.Background(), s, h)
@@ -30,12 +30,12 @@ func TestReportEpochMetrics_BadAttestation(t *testing.T) {
 }
 
 func TestReportEpochMetrics_SlashedValidatorOutOfBound(t *testing.T) {
-	h, _ := testutil.DeterministicGenesisState(t, 1)
+	h, _ := util.DeterministicGenesisState(t, 1)
 	v, err := h.ValidatorAtIndex(0)
 	require.NoError(t, err)
 	v.Slashed = true
 	require.NoError(t, h.UpdateValidatorAtIndex(0, v))
-	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 1, Data: testutil.HydrateAttestationData(&eth.AttestationData{})}))
+	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 1, Data: util.HydrateAttestationData(&eth.AttestationData{})}))
 	err = reportEpochMetrics(context.Background(), h, h)
 	require.ErrorContains(t, "slot 0 out of bounds", err)
 }

beacon-chain/blockchain/process_attestation.go

@@ -6,10 +6,10 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/time"
 	"go.opencensus.io/trace"
 )

beacon-chain/blockchain/process_attestation_helpers.go

@@ -12,9 +12,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 // getAttPreState retrieves the att pre state by either from the cache or the DB.

beacon-chain/blockchain/process_attestation_test.go

@@ -10,13 +10,13 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/prysmaticlabs/prysm/time"
 )
 
@@ -35,30 +35,30 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	_, err = blockTree1(t, beaconDB, []byte{'g'})
 	require.NoError(t, err)
 
-	BlkWithOutState := testutil.NewBeaconBlock()
+	BlkWithOutState := util.NewBeaconBlock()
 	BlkWithOutState.Block.Slot = 0
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState)))
 	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	BlkWithStateBadAtt := testutil.NewBeaconBlock()
+	BlkWithStateBadAtt := util.NewBeaconBlock()
 	BlkWithStateBadAtt.Block.Slot = 1
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt)))
 	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
 
-	BlkWithValidState := testutil.NewBeaconBlock()
+	BlkWithValidState := util.NewBeaconBlock()
 	BlkWithValidState.Block.Slot = 2
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))
 
 	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
-	s, err = testutil.NewBeaconState()
+	s, err = util.NewBeaconState()
 	require.NoError(t, err)
 	err = s.SetFork(&ethpb.Fork{
 		Epoch:           0,
@@ -75,17 +75,17 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	}{
 		{
 			name:      "attestation's data slot not aligned with target vote",
-			a:         testutil.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
+			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
 			wantedErr: "slot 32 does not match target epoch 0",
 		},
 		{
 			name:      "no pre state for attestations's target block",
-			a:         testutil.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
+			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
 			wantedErr: "could not get pre state for epoch 0",
 		},
 		{
 			name: "process attestation doesn't match current epoch",
-			a: testutil.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
+			a: util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
 				Root: BlkWithStateBadAttRoot[:]}}}),
 			wantedErr: "target epoch 100 does not match current epoch",
 		},
@@ -137,10 +137,10 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 	}
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
+	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	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)
+	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
 	tRoot := bytesutil.ToBytes32(att[0].Data.Target.Root)
 	copied := genesisState.Copy()
@@ -162,7 +162,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	err = s.SetFinalizedCheckpoint(&ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)})
 	require.NoError(t, err)
@@ -235,7 +235,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 
 	epoch := types.Epoch(1)
-	baseState, _ := testutil.DeterministicGenesisState(t, 1)
+	baseState, _ := util.DeterministicGenesisState(t, 1)
 	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("hi"), 32)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
 	returned, err := service.getAttPreState(ctx, checkpoint)
@@ -307,7 +307,7 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	d := testutil.HydrateAttestationData(&ethpb.AttestationData{})
+	d := util.HydrateAttestationData(&ethpb.AttestationData{})
 	assert.ErrorContains(t, "signed beacon block can't be nil", service.verifyBeaconBlock(ctx, d))
 }
 
@@ -319,7 +319,7 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
@@ -337,7 +337,7 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
@@ -355,7 +355,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b32 := testutil.NewBeaconBlock()
+	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
@@ -363,7 +363,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 
 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
 
-	b33 := testutil.NewBeaconBlock()
+	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
@@ -382,7 +382,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b32 := testutil.NewBeaconBlock()
+	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
@@ -390,7 +390,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 
 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
 
-	b33 := testutil.NewBeaconBlock()
+	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
@@ -409,14 +409,14 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b32 := testutil.NewBeaconBlock()
+	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
 
-	b33 := testutil.NewBeaconBlock()
+	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	r33, err := b33.Block.HashTreeRoot()

beacon-chain/blockchain/process_block.go

@@ -13,13 +13,13 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	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/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )
 
@@ -128,35 +128,33 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	}
 
 	newFinalized := postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch
-	if features.Get().UpdateHeadTimely {
-		if newFinalized {
-			if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
-				return errors.Wrap(err, "could not save new justified")
-			}
-			s.prevFinalizedCheckpt = s.finalizedCheckpt
-			s.finalizedCheckpt = postState.FinalizedCheckpoint()
+	if newFinalized {
+		if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
+			return errors.Wrap(err, "could not save new justified")
 		}
-
-		if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
-			log.WithError(err).Warn("Could not update head")
-		}
-
-		if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
-			return err
-		}
-
-		// Send notification of the processed block to the state feed.
-		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-			Type: statefeed.BlockProcessed,
-			Data: &statefeed.BlockProcessedData{
-				Slot:        signed.Block().Slot(),
-				BlockRoot:   blockRoot,
-				SignedBlock: signed,
-				Verified:    true,
-			},
-		})
+		s.prevFinalizedCheckpt = s.finalizedCheckpt
+		s.finalizedCheckpt = postState.FinalizedCheckpoint()
 	}
 
+	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
+		log.WithError(err).Warn("Could not update head")
+	}
+
+	if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
+		return err
+	}
+
+	// Send notification of the processed block to the state feed.
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.BlockProcessed,
+		Data: &statefeed.BlockProcessedData{
+			Slot:        signed.Block().Slot(),
+			BlockRoot:   blockRoot,
+			SignedBlock: signed,
+			Verified:    true,
+		},
+	})
+
 	// Update finalized check point.
 	if newFinalized {
 		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
@@ -166,11 +164,6 @@ 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 !features.Get().UpdateHeadTimely {
-			if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
-				return errors.Wrap(err, "could not save new justified")
-			}
-		}
 		go func() {
 			// Send an event regarding the new finalized checkpoint over a common event feed.
 			s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
@@ -309,10 +302,8 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 		if err := s.updateFinalized(ctx, fCheckpoint); err != nil {
 			return err
 		}
-		if features.Get().UpdateHeadTimely {
-			s.prevFinalizedCheckpt = s.finalizedCheckpt
-			s.finalizedCheckpt = fCheckpoint
-		}
+		s.prevFinalizedCheckpt = s.finalizedCheckpt
+		s.finalizedCheckpt = fCheckpoint
 	}
 	return nil
 }

beacon-chain/blockchain/process_block_helpers.go

@@ -10,13 +10,12 @@ import (
 	"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/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )
 
@@ -243,10 +242,6 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 	if err := s.cfg.BeaconDB.SaveFinalizedCheckpoint(ctx, cp); err != nil {
 		return err
 	}
-	if !features.Get().UpdateHeadTimely {
-		s.prevFinalizedCheckpt = s.finalizedCheckpt
-		s.finalizedCheckpt = cp
-	}
 
 	fRoot := bytesutil.ToBytes32(cp.Root)
 	if err := s.cfg.StateGen.MigrateToCold(ctx, fRoot); err != nil {

beacon-chain/blockchain/process_block_test.go

@@ -21,15 +21,15 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 )
 
@@ -49,12 +49,12 @@ func TestStore_OnBlock(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	st, err := testutil.NewBeaconState()
+	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)
-	random := testutil.NewBeaconBlock()
+	random := util.NewBeaconBlock()
 	random.Block.Slot = 1
 	random.Block.ParentRoot = validGenesisRoot[:]
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random)))
@@ -75,14 +75,14 @@ func TestStore_OnBlock(t *testing.T) {
 	}{
 		{
 			name:          "parent block root does not have a state",
-			blk:           testutil.NewBeaconBlock(),
+			blk:           util.NewBeaconBlock(),
 			s:             st.Copy(),
 			wantErrString: "could not reconstruct parent state",
 		},
 		{
 			name: "block is from the future",
 			blk: func() *ethpb.SignedBeaconBlock {
-				b := testutil.NewBeaconBlock()
+				b := util.NewBeaconBlock()
 				b.Block.ParentRoot = randomParentRoot2
 				b.Block.Slot = params.BeaconConfig().FarFutureSlot
 				return b
@@ -93,7 +93,7 @@ func TestStore_OnBlock(t *testing.T) {
 		{
 			name: "could not get finalized block",
 			blk: func() *ethpb.SignedBeaconBlock {
-				b := testutil.NewBeaconBlock()
+				b := util.NewBeaconBlock()
 				b.Block.ParentRoot = randomParentRoot[:]
 				return b
 			}(),
@@ -103,7 +103,7 @@ func TestStore_OnBlock(t *testing.T) {
 		{
 			name: "same slot as finalized block",
 			blk: func() *ethpb.SignedBeaconBlock {
-				b := testutil.NewBeaconBlock()
+				b := util.NewBeaconBlock()
 				b.Block.Slot = 0
 				b.Block.ParentRoot = randomParentRoot2
 				return b
@@ -151,7 +151,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
-	st, keys := testutil.DeterministicGenesisState(t, 64)
+	st, keys := util.DeterministicGenesisState(t, 64)
 
 	bState := st.Copy()
 
@@ -159,7 +159,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	var blkRoots [][32]byte
 	var firstState state.BeaconState
 	for i := 1; i < 10; i++ {
-		b, err := testutil.GenerateFullBlock(bState, keys, testutil.DefaultBlockGenConfig(), types.Slot(i))
+		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
 		require.NoError(t, err)
 		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		require.NoError(t, err)
@@ -196,11 +196,11 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: make([]byte, 32)})
 	require.NoError(t, err)
 	assert.Equal(t, true, update, "Should be able to update justified")
-	lastJustifiedBlk := testutil.NewBeaconBlock()
+	lastJustifiedBlk := util.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	newJustifiedBlk := testutil.NewBeaconBlock()
+	newJustifiedBlk := util.NewBeaconBlock()
 	newJustifiedBlk.Block.Slot = 1
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
@@ -225,11 +225,11 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	cfg := &Config{BeaconDB: beaconDB}
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
-	lastJustifiedBlk := testutil.NewBeaconBlock()
+	lastJustifiedBlk := util.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	newJustifiedBlk := testutil.NewBeaconBlock()
+	newJustifiedBlk := util.NewBeaconBlock()
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -270,7 +270,7 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
 	b.Block.ParentRoot = gRoot[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
@@ -300,7 +300,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
 	err = service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block))
@@ -323,18 +323,18 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	signedBlock := testutil.NewBeaconBlock()
+	signedBlock := util.NewBeaconBlock()
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock)))
 	r, err := signedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
 	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
-	st, err := testutil.NewBeaconState()
+	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, st.Copy(), r))
 
 	// Could update
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: r[:]}))
 	require.NoError(t, service.updateJustified(context.Background(), s))
@@ -363,15 +363,15 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	st, err := testutil.NewBeaconState()
+	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)
 
-	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
-	block := testutil.NewBeaconBlock()
+	beaconState, _ := util.DeterministicGenesisState(t, 32)
+	block := util.NewBeaconBlock()
 	block.Block.Slot = 9
 	block.Block.ParentRoot = roots[8]
 
@@ -401,15 +401,15 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	st, err := testutil.NewBeaconState()
+	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
 	require.NoError(t, err)
 
-	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
-	block := testutil.NewBeaconBlock()
+	beaconState, _ := util.DeterministicGenesisState(t, 32)
+	block := util.NewBeaconBlock()
 	block.Block.Slot = 9
 	block.Block.ParentRoot = roots[8]
 
@@ -443,29 +443,29 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	assert.NoError(t, err)
-	st, err := testutil.NewBeaconState()
+	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
 
 	// Define a tree branch, slot 63 <- 64 <- 65
-	b63 := testutil.NewBeaconBlock()
+	b63 := util.NewBeaconBlock()
 	b63.Block.Slot = 63
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63)))
 	r63, err := b63.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b64 := testutil.NewBeaconBlock()
+	b64 := util.NewBeaconBlock()
 	b64.Block.Slot = 64
 	b64.Block.ParentRoot = r63[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64)))
 	r64, err := b64.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b65 := testutil.NewBeaconBlock()
+	b65 := util.NewBeaconBlock()
 	b65.Block.Slot = 65
 	b65.Block.ParentRoot = r64[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65)))
 
-	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
+	beaconState, _ := util.DeterministicGenesisState(t, 32)
 	err = service.fillInForkChoiceMissingBlocks(
 		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
@@ -484,67 +484,67 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 // (B1, and B3 are all from the same slots)
 func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byte, error) {
 	genesisRoot = bytesutil.PadTo(genesisRoot, 32)
-	b0 := testutil.NewBeaconBlock()
+	b0 := util.NewBeaconBlock()
 	b0.Block.Slot = 0
 	b0.Block.ParentRoot = genesisRoot
 	r0, err := b0.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b1 := testutil.NewBeaconBlock()
+	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = r0[:]
 	r1, err := b1.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b3 := testutil.NewBeaconBlock()
+	b3 := util.NewBeaconBlock()
 	b3.Block.Slot = 3
 	b3.Block.ParentRoot = r0[:]
 	r3, err := b3.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b4 := testutil.NewBeaconBlock()
+	b4 := util.NewBeaconBlock()
 	b4.Block.Slot = 4
 	b4.Block.ParentRoot = r3[:]
 	r4, err := b4.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b5 := testutil.NewBeaconBlock()
+	b5 := util.NewBeaconBlock()
 	b5.Block.Slot = 5
 	b5.Block.ParentRoot = r4[:]
 	r5, err := b5.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b6 := testutil.NewBeaconBlock()
+	b6 := util.NewBeaconBlock()
 	b6.Block.Slot = 6
 	b6.Block.ParentRoot = r4[:]
 	r6, err := b6.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b7 := testutil.NewBeaconBlock()
+	b7 := util.NewBeaconBlock()
 	b7.Block.Slot = 7
 	b7.Block.ParentRoot = r5[:]
 	r7, err := b7.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	b8 := testutil.NewBeaconBlock()
+	b8 := util.NewBeaconBlock()
 	b8.Block.Slot = 8
 	b8.Block.ParentRoot = r6[:]
 	r8, err := b8.Block.HashTreeRoot()
 	if err != nil {
 		return nil, err
 	}
-	st, err := testutil.NewBeaconState()
+	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 
 	for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
-		beaconBlock := testutil.NewBeaconBlock()
+		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil {
@@ -590,23 +590,23 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b1 := testutil.NewBeaconBlock()
+	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b100 := testutil.NewBeaconBlock()
+	b100 := util.NewBeaconBlock()
 	b100.Block.Slot = 100
 	b100.Block.ParentRoot = r1[:]
 	r100, err := b100.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b200 := testutil.NewBeaconBlock()
+	b200 := util.NewBeaconBlock()
 	b200.Block.Slot = 200
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
-		beaconBlock := testutil.NewBeaconBlock()
+		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)))
@@ -633,23 +633,23 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b1 := testutil.NewBeaconBlock()
+	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b100 := testutil.NewBeaconBlock()
+	b100 := util.NewBeaconBlock()
 	b100.Block.Slot = 100
 	b100.Block.ParentRoot = r1[:]
 	r100, err := b100.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b200 := testutil.NewBeaconBlock()
+	b200 := util.NewBeaconBlock()
 	b200.Block.Slot = 200
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
-		beaconBlock := testutil.NewBeaconBlock()
+		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
@@ -672,23 +672,23 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b1 := testutil.NewBeaconBlock()
+	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b100 := testutil.NewBeaconBlock()
+	b100 := util.NewBeaconBlock()
 	b100.Block.Slot = 100
 	b100.Block.ParentRoot = r1[:]
 	r100, err := b100.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b200 := testutil.NewBeaconBlock()
+	b200 := util.NewBeaconBlock()
 	b200.Block.Slot = 200
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
-		beaconBlock := testutil.NewBeaconBlock()
+		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock))) // Saves blocks to DB.
@@ -757,30 +757,30 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		beaconState, err := testutil.NewBeaconState()
+		beaconState, err := util.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(test.args.stateCheckPoint))
 		service, err := NewService(ctx, &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})})
 		require.NoError(t, err)
 		service.justifiedCheckpt = test.args.cachedCheckPoint
 		require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
-		genesisState, err := testutil.NewBeaconState()
+		genesisState, err := util.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, bytesutil.ToBytes32(test.want.Root)))
 
 		if test.args.diffFinalizedCheckPoint {
-			b1 := testutil.NewBeaconBlock()
+			b1 := util.NewBeaconBlock()
 			b1.Block.Slot = 1
 			b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
 			r1, err := b1.Block.HashTreeRoot()
 			require.NoError(t, err)
-			b100 := testutil.NewBeaconBlock()
+			b100 := util.NewBeaconBlock()
 			b100.Block.Slot = 100
 			b100.Block.ParentRoot = r1[:]
 			r100, err := b100.Block.HashTreeRoot()
 			require.NoError(t, err)
 			for _, b := range []*ethpb.SignedBeaconBlock{b1, b100} {
-				beaconBlock := testutil.NewBeaconBlock()
+				beaconBlock := util.NewBeaconBlock()
 				beaconBlock.Block.Slot = b.Block.Slot
 				beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 				require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)))
@@ -798,13 +798,13 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 
-	b1 := testutil.NewBeaconBlock()
+	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
@@ -873,13 +873,13 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	gBlk := testutil.NewBeaconBlock()
+	gBlk := util.NewBeaconBlock()
 	gRoot, err := gBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(gBlk)))
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, gRoot))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: gRoot[:]}))
-	beaconState, _ := testutil.DeterministicGenesisState(t, 32)
+	beaconState, _ := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, beaconState, gRoot))
 	service.genesisRoot = gRoot
 	currentCp := &ethpb.Checkpoint{Epoch: 1}
@@ -901,7 +901,7 @@ func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
 	service.head = &head{state: (*v1.BeaconState)(nil)}
@@ -915,7 +915,7 @@ func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	s, _ := testutil.DeterministicGenesisState(t, 1024)
+	s, _ := util.DeterministicGenesisState(t, 1024)
 	service.head = &head{state: s}
 	require.NoError(t, s.SetSlot(2*params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, service.handleEpochBoundary(ctx, s))
@@ -937,7 +937,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	gs, keys := testutil.DeterministicGenesisState(t, 32)
+	gs, keys := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
 	gBlk, err := service.cfg.BeaconDB.GenesisBlock(ctx)
 	require.NoError(t, err)
@@ -947,7 +947,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 
 	testState := gs.Copy()
 	for i := types.Slot(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
-		blk, err := testutil.GenerateFullBlock(testState, keys, testutil.DefaultBlockGenConfig(), i)
+		blk, err := util.GenerateFullBlock(testState, keys, util.DefaultBlockGenConfig(), i)
 		require.NoError(t, err)
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
@@ -973,7 +973,7 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	gs, _ := testutil.DeterministicGenesisState(t, 32)
+	gs, _ := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
 	gBlk, err := service.cfg.BeaconDB.GenesisBlock(ctx)
 	require.NoError(t, err)
@@ -1008,8 +1008,8 @@ func TestRemoveBlockAttestationsInPool_Canonical(t *testing.T) {
 	})
 	defer resetCfg()
 
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -1032,8 +1032,8 @@ func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
 	})
 	defer resetCfg()
 
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)

beacon-chain/blockchain/receive_attestation.go

@@ -11,9 +11,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"

beacon-chain/blockchain/receive_attestation_test.go

@@ -13,12 +13,12 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
@@ -43,12 +43,12 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b32 := testutil.NewBeaconBlock()
+	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b33 := testutil.NewBeaconBlock()
+	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
@@ -56,7 +56,7 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	require.NoError(t, err)
 
 	wanted := "FFG and LMD votes are not consistent"
-	a := testutil.NewAttestation()
+	a := util.NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = []byte{'a'}
 	a.Data.BeaconBlockRoot = r33[:]
@@ -71,19 +71,19 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	require.NoError(t, err)
 
-	b32 := testutil.NewBeaconBlock()
+	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
-	b33 := testutil.NewBeaconBlock()
+	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	a := testutil.NewAttestation()
+	a := util.NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = r32[:]
 	a.Data.BeaconBlockRoot = r33[:]
@@ -105,10 +105,10 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	service, err := NewService(ctx, cfg)
 	service.genesisTime = prysmTime.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
 	require.NoError(t, err)
-	genesisState, pks := testutil.DeterministicGenesisState(t, 64)
+	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	require.NoError(t, genesisState.SetGenesisTime(uint64(prysmTime.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	atts, err := testutil.GenerateAttestations(genesisState, pks, 1, 0, false)
+	atts, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
 	tRoot := bytesutil.ToBytes32(atts[0].Data.Target.Root)
 	copied := genesisState.Copy()

beacon-chain/blockchain/receive_block.go

@@ -8,7 +8,6 @@ import (
 	"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/config/features"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/time"
@@ -43,28 +42,6 @@ func (s *Service) ReceiveBlock(ctx context.Context, block block.SignedBeaconBloc
 		return err
 	}
 
-	// Update and save head block after fork choice.
-	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,
-			Data: &statefeed.BlockProcessedData{
-				Slot:        blockCopy.Block().Slot(),
-				BlockRoot:   blockRoot,
-				SignedBlock: blockCopy,
-				Verified:    true,
-			},
-		})
-	}
-
 	// Handle post block operations such as attestations and exits.
 	if err := s.handlePostBlockOperations(blockCopy.Block()); err != nil {
 		return err

beacon-chain/blockchain/receive_block_test.go

@@ -8,30 +8,28 @@ import (
 
 	types "github.com/prysmaticlabs/eth2-types"
 	blockchainTesting "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
-	"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"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 func TestService_ReceiveBlock(t *testing.T) {
 	ctx := context.Background()
 
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
-		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	genFullBlock := func(t *testing.T, conf *util.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
+		blk, err := util.GenerateFullBlock(genesis, keys, conf, slot)
 		assert.NoError(t, err)
 		return blk
 	}
@@ -51,7 +49,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		{
 			name: "applies block with state transition",
 			args: args{
-				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
+				block: genFullBlock(t, util.DefaultBlockGenConfig(), 2 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				if hs := s.head.state.Slot(); hs != 2 {
@@ -66,7 +64,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 			name: "saves attestations to pool",
 			args: args{
 				block: genFullBlock(t,
-					&testutil.BlockGenConfig{
+					&util.BlockGenConfig{
 						NumProposerSlashings: 0,
 						NumAttesterSlashings: 0,
 						NumAttestations:      2,
@@ -86,7 +84,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		{
 			name: "updates exit pool",
 			args: args{
-				block: genFullBlock(t, &testutil.BlockGenConfig{
+				block: genFullBlock(t, &util.BlockGenConfig{
 					NumProposerSlashings: 0,
 					NumAttesterSlashings: 0,
 					NumAttestations:      0,
@@ -110,7 +108,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		{
 			name: "notifies block processed on state feed",
 			args: args{
-				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
+				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
@@ -161,8 +159,8 @@ func TestService_ReceiveBlock(t *testing.T) {
 
 func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	ctx := context.Background()
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	b, err := testutil.GenerateFullBlock(genesis, keys, testutil.DefaultBlockGenConfig(), 1)
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
 	beaconDB := testDB.SetupDB(t)
 	genesisBlockRoot := bytesutil.ToBytes32(nil)
@@ -206,9 +204,9 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 func TestService_ReceiveBlockBatch(t *testing.T) {
 	ctx := context.Background()
 
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-	genFullBlock := func(t *testing.T, conf *testutil.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
-		blk, err := testutil.GenerateFullBlock(genesis, keys, conf, slot)
+	genesis, keys := util.DeterministicGenesisState(t, 64)
+	genFullBlock := func(t *testing.T, conf *util.BlockGenConfig, slot types.Slot) *ethpb.SignedBeaconBlock {
+		blk, err := util.GenerateFullBlock(genesis, keys, conf, slot)
 		assert.NoError(t, err)
 		return blk
 	}
@@ -225,7 +223,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 		{
 			name: "applies block with state transition",
 			args: args{
-				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 2 /*slot*/),
+				block: genFullBlock(t, util.DefaultBlockGenConfig(), 2 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				assert.Equal(t, types.Slot(2), s.head.state.Slot(), "Incorrect head state slot")
@@ -235,7 +233,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 		{
 			name: "notifies block processed on state feed",
 			args: args{
-				block: genFullBlock(t, testutil.DefaultBlockGenConfig(), 1 /*slot*/),
+				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
 				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
@@ -285,62 +283,6 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 	}
 }
 
-func TestService_ReceiveBlockBatch_UpdateFinalizedCheckpoint(t *testing.T) {
-	// Must enable head timely feature flag to test this.
-	resetCfg := features.InitWithReset(&features.Flags{
-		UpdateHeadTimely: true,
-	})
-	defer resetCfg()
-
-	ctx := context.Background()
-	genesis, keys := testutil.DeterministicGenesisState(t, 64)
-
-	// Generate 5 epochs worth of blocks.
-	var blks []block.SignedBeaconBlock
-	var roots [][32]byte
-	copied := genesis.Copy()
-	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 = transition.ExecuteStateTransition(context.Background(), copied, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		assert.NoError(t, err)
-		r, err := b.Block.HashTreeRoot()
-		require.NoError(t, err)
-		blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		roots = append(roots, r)
-	}
-
-	beaconDB := testDB.SetupDB(t)
-	genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	cfg := &Config{
-		BeaconDB: beaconDB,
-		ForkChoiceStore: protoarray.New(
-			0, // justifiedEpoch
-			0, // finalizedEpoch
-			genesisBlockRoot,
-		),
-		StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: false},
-		StateGen:      stategen.New(beaconDB),
-	}
-	s, err := NewService(ctx, cfg)
-	require.NoError(t, err)
-	err = s.saveGenesisData(ctx, genesis)
-	require.NoError(t, err)
-	gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
-	require.NoError(t, err)
-
-	gRoot, err := gBlk.Block().HashTreeRoot()
-	require.NoError(t, err)
-	s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
-
-	// Process 5 epochs worth of blocks.
-	require.NoError(t, s.ReceiveBlockBatch(ctx, blks, roots))
-
-	// Finalized epoch must be updated.
-	require.Equal(t, types.Epoch(2), s.finalizedCheckpt.Epoch)
-}
-
 func TestService_HasInitSyncBlock(t *testing.T) {
 	s, err := NewService(context.Background(), &Config{StateNotifier: &blockchainTesting.MockStateNotifier{}})
 	require.NoError(t, err)
@@ -348,7 +290,7 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 	if s.HasInitSyncBlock(r) {
 		t.Error("Should not have block")
 	}
-	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(testutil.NewBeaconBlock()))
+	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()))
 	if !s.HasInitSyncBlock(r) {
 		t.Error("Should have block")
 	}

beacon-chain/blockchain/service.go

@@ -29,10 +29,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"

beacon-chain/blockchain/service_norace_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/sirupsen/logrus"
 )
 

beacon-chain/blockchain/service_test.go

@@ -25,14 +25,14 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 	"google.golang.org/protobuf/proto"
 )
@@ -75,7 +75,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	ctx := context.Background()
 	var web3Service *powchain.Service
 	var err error
-	bState, _ := testutil.DeterministicGenesisState(t, 10)
+	bState, _ := util.DeterministicGenesisState(t, 10)
 	pbState, err := v1.ProtobufBeaconState(bState.InnerStateUnsafe())
 	require.NoError(t, err)
 	err = beaconDB.SavePowchainData(ctx, &ethpb.ETH1ChainData{
@@ -137,11 +137,11 @@ func TestChainStartStop_Initialized(t *testing.T) {
 
 	chainService := setupBeaconChain(t, beaconDB)
 
-	genesisBlk := testutil.NewBeaconBlock()
+	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
@@ -167,11 +167,11 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 
 	chainService := setupBeaconChain(t, beaconDB)
 
-	genesisBlk := testutil.NewBeaconBlock()
+	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
@@ -197,9 +197,9 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 
 	// Set up 10 deposits pre chain start for validators to register
 	count := uint64(10)
-	deposits, _, err := testutil.DeterministicDepositsAndKeys(count)
+	deposits, _, err := util.DeterministicDepositsAndKeys(count)
 	require.NoError(t, err)
-	trie, _, err := testutil.DepositTrieFromDeposits(deposits)
+	trie, _, err := util.DepositTrieFromDeposits(deposits)
 	require.NoError(t, err)
 	hashTreeRoot := trie.HashTreeRoot()
 	genState, err := transition.EmptyGenesisState()
@@ -236,11 +236,11 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 
 	chainService := setupBeaconChain(t, beaconDB)
 
-	genesisBlk := testutil.NewBeaconBlock()
+	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
-	s, err := testutil.NewBeaconState()
+	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(0))
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
@@ -262,17 +262,17 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	genesis := testutil.NewBeaconBlock()
+	genesis := util.NewBeaconBlock()
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
-	headBlock := testutil.NewBeaconBlock()
+	headBlock := util.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot
 	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
-	headState, err := testutil.NewBeaconState()
+	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
 	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
@@ -303,17 +303,17 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	genesis := testutil.NewBeaconBlock()
+	genesis := util.NewBeaconBlock()
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
-	headBlock := testutil.NewBeaconBlock()
+	headBlock := util.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot
 	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
-	headState, err := testutil.NewBeaconState()
+	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
 	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
@@ -345,13 +345,13 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	genesisBlock := testutil.NewBeaconBlock()
+	genesisBlock := util.NewBeaconBlock()
 	genesisRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))
 
-	finalizedBlock := testutil.NewBeaconBlock()
+	finalizedBlock := util.NewBeaconBlock()
 	finalizedBlock.Block.Slot = finalizedSlot
 	finalizedBlock.Block.ParentRoot = genesisRoot[:]
 	finalizedRoot, err := finalizedBlock.Block.HashTreeRoot()
@@ -359,14 +359,14 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(finalizedBlock)))
 
 	// Set head slot close to the finalization point, no head sync is triggered.
-	headBlock := testutil.NewBeaconBlock()
+	headBlock := util.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot + params.BeaconConfig().SlotsPerEpoch*5
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 
-	headState, err := testutil.NewBeaconState()
+	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(headBlock.Block.Slot))
 	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
@@ -392,7 +392,7 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	assert.LogsDoNotContain(t, hook, "Regenerating state from the last checkpoint at slot")
 
 	// Set head slot far beyond the finalization point, head sync should be triggered.
-	headBlock = testutil.NewBeaconBlock()
+	headBlock = util.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot + params.BeaconConfig().SlotsPerEpoch*headSyncMinEpochsAfterCheckpoint
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err = headBlock.Block.HashTreeRoot()
@@ -419,11 +419,11 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	s := &Service{
 		cfg: &Config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 	}
-	blk := testutil.NewBeaconBlock()
+	blk := util.NewBeaconBlock()
 	blk.Block.Slot = 1
 	r, err := blk.HashTreeRoot()
 	require.NoError(t, err)
-	newState, err := testutil.NewBeaconState()
+	newState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
 	require.NoError(t, s.saveHeadNoDB(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r, newState))
@@ -442,10 +442,10 @@ func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
 		cfg:              &Config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
 		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
 	}
-	block := testutil.NewBeaconBlock()
+	block := util.NewBeaconBlock()
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
-	beaconState, err := testutil.NewBeaconState()
+	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
@@ -462,7 +462,7 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 		cancel:         cancel,
 		initSyncBlocks: make(map[[32]byte]block.SignedBeaconBlock),
 	}
-	block := testutil.NewBeaconBlock()
+	block := util.NewBeaconBlock()
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
 	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(block))
@@ -490,7 +490,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
 	s := &Service{
 		cfg: &Config{BeaconDB: beaconDB},
 	}
-	block := testutil.NewBeaconBlock()
+	block := util.NewBeaconBlock()
 	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block)))
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)

beacon-chain/blockchain/testing/BUILD.bazel

@@ -21,10 +21,10 @@ go_library(
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
+        "//config/params:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -21,10 +21,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/sirupsen/logrus"
 )
 
@@ -57,6 +57,7 @@ type ChainService struct {
 	SyncContributionProofDomain []byte
 	PublicKey                   [48]byte
 	SyncCommitteePubkeys        [][]byte
+	InitSyncBlockRoots          map[[32]byte]bool
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -360,8 +361,11 @@ func (s *ChainService) IsCanonical(_ context.Context, r [32]byte) (bool, error)
 }
 
 // HasInitSyncBlock mocks the same method in the chain service.
-func (s *ChainService) HasInitSyncBlock(_ [32]byte) bool {
-	return false
+func (s *ChainService) HasInitSyncBlock(rt [32]byte) bool {
+	if s.InitSyncBlockRoots == nil {
+		return false
+	}
+	return s.InitSyncBlockRoots[rt]
 }
 
 // HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
@@ -400,36 +404,36 @@ func (s *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
 }
 
 // HeadPublicKeyToValidatorIndex mocks HeadPublicKeyToValidatorIndex and always return 0 and true.
-func (s *ChainService) HeadPublicKeyToValidatorIndex(ctx context.Context, pubKey [48]byte) (types.ValidatorIndex, bool) {
+func (s *ChainService) HeadPublicKeyToValidatorIndex(_ context.Context, _ [48]byte) (types.ValidatorIndex, bool) {
 	return 0, true
 }
 
 // HeadValidatorIndexToPublicKey mocks HeadValidatorIndexToPublicKey and always return empty and nil.
-func (s *ChainService) HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([48]byte, error) {
+func (s *ChainService) HeadValidatorIndexToPublicKey(_ context.Context, _ types.ValidatorIndex) ([48]byte, error) {
 	return s.PublicKey, nil
 }
 
 // HeadSyncCommitteeIndices mocks HeadSyncCommitteeIndices and always return `HeadNextSyncCommitteeIndices`.
-func (s *ChainService) HeadSyncCommitteeIndices(ctx context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
+func (s *ChainService) HeadSyncCommitteeIndices(_ context.Context, index types.ValidatorIndex, slot types.Slot) ([]types.CommitteeIndex, error) {
 	return s.SyncCommitteeIndices, nil
 }
 
 // HeadSyncCommitteePubKeys mocks HeadSyncCommitteePubKeys and always return empty nil.
-func (s *ChainService) HeadSyncCommitteePubKeys(ctx context.Context, slot types.Slot, committeeIndex types.CommitteeIndex) ([][]byte, error) {
+func (s *ChainService) HeadSyncCommitteePubKeys(_ context.Context, _ types.Slot, _ types.CommitteeIndex) ([][]byte, error) {
 	return s.SyncCommitteePubkeys, nil
 }
 
 // HeadSyncCommitteeDomain mocks HeadSyncCommitteeDomain and always return empty nil.
-func (s *ChainService) HeadSyncCommitteeDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
+func (s *ChainService) HeadSyncCommitteeDomain(_ context.Context, _ types.Slot) ([]byte, error) {
 	return s.SyncCommitteeDomain, nil
 }
 
 // HeadSyncSelectionProofDomain mocks HeadSyncSelectionProofDomain and always return empty nil.
-func (s *ChainService) HeadSyncSelectionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
+func (s *ChainService) HeadSyncSelectionProofDomain(_ context.Context, _ types.Slot) ([]byte, error) {
 	return s.SyncSelectionProofDomain, nil
 }
 
 // HeadSyncContributionProofDomain mocks HeadSyncContributionProofDomain and always return empty nil.
-func (s *ChainService) HeadSyncContributionProofDomain(ctx context.Context, slot types.Slot) ([]byte, error) {
+func (s *ChainService) HeadSyncContributionProofDomain(_ context.Context, _ types.Slot) ([]byte, error) {
 	return s.SyncContributionProofDomain, nil
 }

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -6,8 +6,8 @@ import (
 
 	"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"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 )
 
 // VerifyWeakSubjectivityRoot verifies the weak subjectivity root in the service struct.

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -6,17 +6,17 @@ import (
 
 	types "github.com/prysmaticlabs/eth2-types"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
-	b := testutil.NewBeaconBlock()
+	b := util.NewBeaconBlock()
 	b.Block.Slot = 32
 	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()

beacon-chain/cache/BUILD.bazel

@@ -41,13 +41,13 @@ go_library(
         "//beacon-chain/state/v2:go_default_library",
         "//cache/lru:go_default_library",
         "//config/features:go_default_library",
+        "//config/params:go_default_library",
         "//container/slice:go_default_library",
         "//crypto/hash:go_default_library",
         "//crypto/rand:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/params: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",
@@ -82,12 +82,12 @@ go_test(
         "//beacon-chain/state/v1:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
         "//config/features:go_default_library",
+        "//config/params:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//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",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

beacon-chain/cache/active_balance.go

@@ -14,7 +14,7 @@ import (
 	"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"
+	"github.com/prysmaticlabs/prysm/config/params"
 )
 
 var (

beacon-chain/cache/active_balance_test.go

@@ -8,9 +8,9 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	state "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestBalanceCache_AddGetBalance(t *testing.T) {

beacon-chain/cache/attestation_data_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/testing/assert"
 	"google.golang.org/protobuf/proto"
 )
 

beacon-chain/cache/checkpoint_state_test.go

@@ -6,11 +6,11 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	"google.golang.org/protobuf/proto"
 )
 

beacon-chain/cache/committee.go

@@ -11,9 +11,9 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	types "github.com/prysmaticlabs/eth2-types"
 	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/container/slice"
 	"github.com/prysmaticlabs/prysm/math"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 var (

beacon-chain/cache/committee_fuzz_test.go

@@ -4,8 +4,8 @@ import (
 	"testing"
 
 	fuzz "github.com/google/gofuzz"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestCommitteeKeyFuzz_OK(t *testing.T) {

beacon-chain/cache/committee_test.go

@@ -7,10 +7,10 @@ import (
 	"testing"
 
 	types "github.com/prysmaticlabs/eth2-types"
-	"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/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestCommitteeKeyFn_OK(t *testing.T) {

beacon-chain/cache/common.go

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

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 = [
+        "//config/params:go_default_library",
         "//container/trie:go_default_library",
         "//crypto/hash:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/params: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 = [
+        "//config/params:go_default_library",
         "//container/trie:go_default_library",
+        "//encoding/bytesutil: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",
+        "//testing/assert:go_default_library",
+        "//testing/require: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/config/params"
 	"github.com/prysmaticlabs/prysm/container/trie"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -7,13 +7,13 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/container/trie"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/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/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 

beacon-chain/cache/depositcache/pending_deposits_test.go

@@ -5,10 +5,10 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/testing/assert"
 	"google.golang.org/protobuf/proto"
 )
 

beacon-chain/cache/proposer_indices_test.go

@@ -5,9 +5,9 @@ import (
 	"testing"
 
 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestProposerKeyFn_OK(t *testing.T) {

beacon-chain/cache/skip_slot_cache_test.go

@@ -8,8 +8,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"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestSkipSlotCache_RoundTrip(t *testing.T) {

beacon-chain/cache/subnet_ids.go

@@ -8,8 +8,8 @@ import (
 	"github.com/patrickmn/go-cache"
 	types "github.com/prysmaticlabs/eth2-types"
 	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/container/slice"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 type subnetIDs struct {

beacon-chain/cache/subnet_ids_test.go

@@ -4,8 +4,8 @@ import (
 	"testing"
 
 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestSubnetIDsCache_RoundTrip(t *testing.T) {

beacon-chain/cache/sync_committee.go

@@ -9,7 +9,7 @@ import (
 	"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"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"k8s.io/client-go/tools/cache"
 )
 

beacon-chain/cache/sync_committee_head_state_test.go

@@ -7,9 +7,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestSyncCommitteeHeadState(t *testing.T) {

beacon-chain/cache/sync_committee_test.go

@@ -5,16 +5,16 @@ import (
 
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 	numValidators := 101
-	deterministicState, _ := testutil.DeterministicGenesisStateAltair(t, uint64(numValidators))
+	deterministicState, _ := util.DeterministicGenesisStateAltair(t, uint64(numValidators))
 	pubKeys := make([][]byte, deterministicState.NumValidators())
 	for i, val := range deterministicState.Validators() {
 		pubKeys[i] = val.PublicKey
@@ -160,7 +160,7 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			s, _ := testutil.DeterministicGenesisStateAltair(t, uint64(numValidators))
+			s, _ := util.DeterministicGenesisStateAltair(t, uint64(numValidators))
 			require.NoError(t, s.SetCurrentSyncCommittee(tt.currentSyncCommittee))
 			require.NoError(t, s.SetNextSyncCommittee(tt.nextSyncCommittee))
 			cache := cache.NewSyncCommittee()
@@ -188,7 +188,7 @@ func TestSyncCommitteeCache_RootDoesNotExist(t *testing.T) {
 
 func TestSyncCommitteeCache_CanRotate(t *testing.T) {
 	c := cache.NewSyncCommittee()
-	s, _ := testutil.DeterministicGenesisStateAltair(t, 64)
+	s, _ := util.DeterministicGenesisStateAltair(t, 64)
 	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{1}})))
 	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'a'}, s))
 	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{2}})))

beacon-chain/cache/sync_subnet_ids.go

@@ -6,10 +6,10 @@ import (
 
 	"github.com/patrickmn/go-cache"
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/container/slice"
 	"github.com/prysmaticlabs/prysm/crypto/rand"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 )
 
 type syncSubnetIDs struct {

beacon-chain/cache/sync_subnet_ids_test.go

@@ -3,9 +3,9 @@ package cache
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestSyncSubnetIDsCache_Roundtrip(t *testing.T) {

beacon-chain/core/BUILD.bazel

@@ -6,27 +6,27 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core",
     visibility = [
         "//beacon-chain:__subpackages__",
+        "//contracts/deposit:__pkg__",
         "//fuzz:__pkg__",
         "//network/forks:__pkg__",
         "//proto/prysm/v1alpha1/attestation:__pkg__",
+        "//runtime/interop:__pkg__",
         "//shared/attestationutil:__pkg__",
-        "//shared/depositutil:__pkg__",
-        "//shared/interop:__pkg__",
         "//shared/keystore:__pkg__",
-        "//shared/testutil:__pkg__",
-        "//shared/testutil/altair:__pkg__",
         "//slasher:__subpackages__",
+        "//testing/altair:__pkg__",
         "//testing/benchmark/benchmark_files:__subpackages__",
         "//testing/endtoend/evaluators:__pkg__",
         "//testing/fuzz:__pkg__",
         "//testing/spectest:__subpackages__",
+        "//testing/util:__pkg__",
         "//tools:__subpackages__",
         "//validator:__subpackages__",
     ],
     deps = [
         "//beacon-chain/state:go_default_library",
+        "//config/params: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",
@@ -40,10 +40,10 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/state/v1:go_default_library",
+        "//config/params: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",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
         "//time:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
     ],

beacon-chain/core/altair/BUILD.bazel

@@ -16,8 +16,8 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/altair",
     visibility = [
         "//beacon-chain:__subpackages__",
-        "//shared/testutil:__pkg__",
         "//testing/spectest:__subpackages__",
+        "//testing/util:__pkg__",
         "//validator/client:__pkg__",
     ],
     deps = [
@@ -29,16 +29,17 @@ go_library(
         "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
+        "//config/params:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
-        "//shared/bytesutil:go_default_library",
-        "//shared/params:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
 )
@@ -66,17 +67,17 @@ go_test(
         "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
+        "//config/params:go_default_library",
         "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//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",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "//time:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -11,10 +11,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )
 

beacon-chain/core/altair/attestation_test.go

@@ -13,32 +13,32 @@ import (
 	"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/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/math"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 	attestations := []*ethpb.Attestation{
-		testutil.HydrateAttestation(&ethpb.Attestation{
+		util.HydrateAttestation(&ethpb.Attestation{
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
 				Slot:   5,
 			},
 		}),
 	}
-	b := testutil.NewBeaconBlockAltair()
+	b := util.NewBeaconBlockAltair()
 	b.Block = &ethpb.BeaconBlockAltair{
 		Body: &ethpb.BeaconBlockBodyAltair{
 			Attestations: attestations,
 		},
 	}
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, 100)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
 
 	want := fmt.Sprintf(
 		"attestation slot %d + inclusion delay %d > state slot %d",
@@ -53,18 +53,18 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 }
 
 func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
-	att := testutil.HydrateAttestation(&ethpb.Attestation{
+	att := util.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
 			Target: &ethpb.Checkpoint{Epoch: 0}}})
 
-	b := testutil.NewBeaconBlockAltair()
+	b := util.NewBeaconBlockAltair()
 	b.Block = &ethpb.BeaconBlockAltair{
 		Body: &ethpb.BeaconBlockBodyAltair{
 			Attestations: []*ethpb.Attestation{att},
 		},
 	}
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, 100)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
 	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().SlotsPerEpoch*4 + params.BeaconConfig().MinAttestationInclusionDelay)
 	require.NoError(t, err)
 	pfc := beaconState.PreviousJustifiedCheckpoint()
@@ -93,13 +93,13 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 			AggregationBits: bitfield.Bitlist{0x09},
 		},
 	}
-	b := testutil.NewBeaconBlockAltair()
+	b := util.NewBeaconBlockAltair()
 	b.Block = &ethpb.BeaconBlockAltair{
 		Body: &ethpb.BeaconBlockBodyAltair{
 			Attestations: attestations,
 		},
 	}
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, 100)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
 	require.NoError(t, beaconState.SetSlot(beaconState.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
 	cfc := beaconState.CurrentJustifiedCheckpoint()
 	cfc.Root = []byte("hello-world")
@@ -119,7 +119,7 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 }
 
 func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, 100)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
 
 	aggBits := bitfield.NewBitlist(3)
 	aggBits.SetBitAt(0, true)
@@ -133,7 +133,7 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 			AggregationBits: aggBits,
 		},
 	}
-	b := testutil.NewBeaconBlockAltair()
+	b := util.NewBeaconBlockAltair()
 	b.Block = &ethpb.BeaconBlockAltair{
 		Body: &ethpb.BeaconBlockBodyAltair{
 			Attestations: attestations,
@@ -161,7 +161,7 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 }
 
 func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, 100)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
 
 	aggBits := bitfield.NewBitlist(4)
 	att := &ethpb.Attestation{
@@ -171,7 +171,7 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 		AggregationBits: aggBits,
 	}
 
-	b := testutil.NewBeaconBlockAltair()
+	b := util.NewBeaconBlockAltair()
 	b.Block = &ethpb.BeaconBlockAltair{
 		Body: &ethpb.BeaconBlockBodyAltair{
 			Attestations: []*ethpb.Attestation{att},
@@ -193,13 +193,13 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 }
 
 func TestProcessAttestations_OK(t *testing.T) {
-	beaconState, privKeys := testutil.DeterministicGenesisStateAltair(t, 100)
+	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, 100)
 
 	aggBits := bitfield.NewBitlist(3)
 	aggBits.SetBitAt(0, true)
 	var mockRoot [32]byte
 	copy(mockRoot[:], "hello-world")
-	att := testutil.HydrateAttestation(&ethpb.Attestation{
+	att := util.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Root: mockRoot[:]},
 			Target: &ethpb.Checkpoint{Root: mockRoot[:]},
@@ -225,7 +225,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 	}
 	att.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	block := testutil.NewBeaconBlockAltair()
+	block := util.NewBeaconBlockAltair()
 	block.Block.Body.Attestations = []*ethpb.Attestation{att}
 
 	err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
@@ -237,7 +237,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 }
 
 func TestProcessAttestationNoVerify_SourceTargetHead(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, 64)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, 64)
 	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
 	require.NoError(t, err)
 
@@ -468,7 +468,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			beaconState, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+			beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 			require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
 
 			currentEpoch := core.CurrentEpoch(beaconState)
@@ -503,7 +503,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 }
 
 func TestEpochParticipation(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	cfg := params.BeaconConfig()
 	sourceFlagIndex := cfg.TimelySourceFlagIndex
 	targetFlagIndex := cfg.TimelyTargetFlagIndex
@@ -573,7 +573,7 @@ func TestEpochParticipation(t *testing.T) {
 }
 
 func TestRewardProposer(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	tests := []struct {
 		rewardNumerator uint64
@@ -596,7 +596,7 @@ func TestRewardProposer(t *testing.T) {
 }
 
 func TestAttestationParticipationFlagIndices(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	cfg := params.BeaconConfig()
 	sourceFlagIndex := cfg.TimelySourceFlagIndex
@@ -678,7 +678,7 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 }
 
 func TestMatchingStatus(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	tests := []struct {
 		name          string

beacon-chain/core/altair/block.go

@@ -8,10 +8,10 @@ import (
 	"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/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 // ProcessSyncAggregate verifies sync committee aggregate signature signing over the previous slot block root.

beacon-chain/core/altair/block_test.go

@@ -11,16 +11,16 @@ import (
 	"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/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
-	beaconState, privKeys := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
@@ -94,7 +94,7 @@ func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
 }
 
 func TestProcessSyncCommittee_MixParticipation_BadSignature(t *testing.T) {
-	beaconState, privKeys := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
@@ -129,7 +129,7 @@ func TestProcessSyncCommittee_MixParticipation_BadSignature(t *testing.T) {
 }
 
 func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
-	beaconState, privKeys := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
@@ -166,7 +166,7 @@ func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
 }
 
 func TestProcessSyncCommittee_FilterSyncCommitteeVotes(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
@@ -202,7 +202,7 @@ func TestProcessSyncCommittee_FilterSyncCommitteeVotes(t *testing.T) {
 }
 
 func Test_VerifySyncCommitteeSig(t *testing.T) {
-	beaconState, privKeys := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
 	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
@@ -238,7 +238,7 @@ func Test_VerifySyncCommitteeSig(t *testing.T) {
 }
 
 func Test_ApplySyncRewardsPenalties(t *testing.T) {
-	beaconState, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	beaconState, err := altair.ApplySyncRewardsPenalties(beaconState,
 		[]types.ValidatorIndex{0, 1}, // voted
 		[]types.ValidatorIndex{2, 3}) // didn't vote

beacon-chain/core/altair/deposit.go

@@ -6,8 +6,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 )
 
 // ProcessDeposits processes validator deposits for beacon state Altair.

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -8,7 +8,7 @@ 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"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestFuzzProcessDeposits_10000(t *testing.T) {

beacon-chain/core/altair/deposit_test.go

@@ -7,20 +7,20 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/container/trie"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
 	// Same validator created 3 valid deposits within the same block
-	dep, _, err := testutil.DeterministicDepositsAndKeysSameValidator(3)
+	dep, _, err := util.DeterministicDepositsAndKeysSameValidator(3)
 	require.NoError(t, err)
-	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
+	eth1Data, err := util.DeterministicEth1Data(len(dep))
 	require.NoError(t, err)
 	registry := []*ethpb.Validator{
 		{
@@ -75,9 +75,9 @@ func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 }
 
 func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
-	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	dep, _, err := util.DeterministicDepositsAndKeys(1)
 	require.NoError(t, err)
-	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
+	eth1Data, err := util.DeterministicEth1Data(len(dep))
 	require.NoError(t, err)
 
 	registry := []*ethpb.Validator{
@@ -160,9 +160,9 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 
 func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
 	// Similar to TestProcessDeposits_AddsNewValidatorDeposit except that this test directly calls ProcessDeposit
-	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	dep, _, err := util.DeterministicDepositsAndKeys(1)
 	require.NoError(t, err)
-	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
+	eth1Data, err := util.DeterministicEth1Data(len(dep))
 	require.NoError(t, err)
 
 	registry := []*ethpb.Validator{
@@ -197,10 +197,10 @@ func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
 
 func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 	// Same test settings as in TestProcessDeposit_AddsNewValidatorDeposit, except that we use an invalid signature
-	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	dep, _, err := util.DeterministicDepositsAndKeys(1)
 	require.NoError(t, err)
 	dep[0].Data.Signature = make([]byte, 96)
-	trie, _, err := testutil.DepositTrieFromDeposits(dep)
+	trie, _, err := util.DepositTrieFromDeposits(dep)
 	require.NoError(t, err)
 	root := trie.HashTreeRoot()
 	eth1Data := &ethpb.Eth1Data{

beacon-chain/core/altair/epoch_precompute.go

@@ -8,57 +8,53 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/math"
-	"github.com/prysmaticlabs/prysm/shared/params"
 	"go.opencensus.io/trace"
 )
 
-// InitializeEpochValidators gets called at the beginning of process epoch cycle to return
-// pre computed instances of validators attesting records and total
-// balances attested in an epoch.
-func InitializeEpochValidators(ctx context.Context, st state.BeaconStateAltair) ([]*precompute.Validator, *precompute.Balance, error) {
-	_, span := trace.StartSpan(ctx, "altair.InitializeEpochValidators")
+// InitializePrecomputeValidators precomputes individual validator for its attested balances and the total sum of validators attested balances of the epoch.
+func InitializePrecomputeValidators(ctx context.Context, beaconState state.BeaconStateAltair) ([]*precompute.Validator, *precompute.Balance, error) {
+	_, span := trace.StartSpan(ctx, "altair.InitializePrecomputeValidators")
 	defer span.End()
-	pValidators := make([]*precompute.Validator, st.NumValidators())
+	vals := make([]*precompute.Validator, beaconState.NumValidators())
 	bal := &precompute.Balance{}
-	prevEpoch := core.PrevEpoch(st)
-	currentEpoch := core.CurrentEpoch(st)
-	inactivityScores, err := st.InactivityScores()
+	prevEpoch := core.PrevEpoch(beaconState)
+	currentEpoch := core.CurrentEpoch(beaconState)
+	inactivityScores, err := beaconState.InactivityScores()
 	if err != nil {
 		return nil, nil, err
 	}
 
 	// This shouldn't happen with a correct beacon state,
 	// but rather be safe to defend against index out of bound panics.
-	if st.NumValidators() > len(inactivityScores) {
-		return nil, nil, errors.New("num of validators can't be greater than length of inactivity scores")
+	if beaconState.NumValidators() != len(inactivityScores) {
+		return nil, nil, errors.New("num of validators is different than num of inactivity scores")
 	}
-	if err := st.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
-		// Was validator withdrawable or slashed
-		withdrawable := currentEpoch >= val.WithdrawableEpoch()
-		pVal := &precompute.Validator{
-			IsSlashed:                    val.Slashed(),
-			IsWithdrawableCurrentEpoch:   withdrawable,
+	if err := beaconState.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
+		// Set validator's balance, inactivity score and slashed/withdrawable status.
+		v := &precompute.Validator{
 			CurrentEpochEffectiveBalance: val.EffectiveBalance(),
 			InactivityScore:              inactivityScores[idx],
+			IsSlashed:                    val.Slashed(),
+			IsWithdrawableCurrentEpoch:   currentEpoch >= val.WithdrawableEpoch(),
 		}
-		// Validator active current epoch
+		// Set validator's active status for current epoch.
 		if helpers.IsActiveValidatorUsingTrie(val, currentEpoch) {
-			pVal.IsActiveCurrentEpoch = true
+			v.IsActiveCurrentEpoch = true
 			bal.ActiveCurrentEpoch += val.EffectiveBalance()
 		}
-		// Validator active previous epoch
+		// Set validator's active status for preivous epoch.
 		if helpers.IsActiveValidatorUsingTrie(val, prevEpoch) {
-			pVal.IsActivePrevEpoch = true
+			v.IsActivePrevEpoch = true
 			bal.ActivePrevEpoch += val.EffectiveBalance()
 		}
-
-		pValidators[idx] = pVal
+		vals[idx] = v
 		return nil
 	}); err != nil {
-		return nil, nil, errors.Wrap(err, "could not initialize epoch validator")
+		return nil, nil, errors.Wrap(err, "could not read every validator")
 	}
-	return pValidators, bal, nil
+	return vals, bal, nil
 }
 
 // ProcessInactivityScores of beacon chain. This updates inactivity scores of beacon chain and
@@ -71,26 +67,26 @@ func InitializeEpochValidators(ctx context.Context, st state.BeaconStateAltair)
 //    If the chain has recently finalized, each validator's score drops by 16.
 func ProcessInactivityScores(
 	ctx context.Context,
-	state state.BeaconState,
+	beaconState state.BeaconState,
 	vals []*precompute.Validator,
 ) (state.BeaconState, []*precompute.Validator, error) {
 	_, span := trace.StartSpan(ctx, "altair.ProcessInactivityScores")
 	defer span.End()
 
 	cfg := params.BeaconConfig()
-	if core.CurrentEpoch(state) == cfg.GenesisEpoch {
-		return state, vals, nil
+	if core.CurrentEpoch(beaconState) == cfg.GenesisEpoch {
+		return beaconState, vals, nil
 	}
 
-	inactivityScores, err := state.InactivityScores()
+	inactivityScores, err := beaconState.InactivityScores()
 	if err != nil {
 		return nil, nil, err
 	}
 
 	bias := cfg.InactivityScoreBias
 	recoveryRate := cfg.InactivityScoreRecoveryRate
-	prevEpoch := core.PrevEpoch(state)
-	finalizedEpoch := state.FinalizedCheckpointEpoch()
+	prevEpoch := core.PrevEpoch(beaconState)
+	finalizedEpoch := beaconState.FinalizedCheckpointEpoch()
 	for i, v := range vals {
 		if !precompute.EligibleForRewards(v) {
 			continue
@@ -116,11 +112,11 @@ func ProcessInactivityScores(
 		inactivityScores[i] = v.InactivityScore
 	}
 
-	if err := state.SetInactivityScores(inactivityScores); err != nil {
+	if err := beaconState.SetInactivityScores(inactivityScores); err != nil {
 		return nil, nil, err
 	}
 
-	return state, vals, nil
+	return beaconState, vals, nil
 }
 
 // ProcessEpochParticipation processes the epoch participation in state and updates individual validator's pre computes,
@@ -135,14 +131,14 @@ func ProcessInactivityScores(
 //    return set(filter(lambda index: not state.validators[index].slashed, participating_indices))
 func ProcessEpochParticipation(
 	ctx context.Context,
-	state state.BeaconState,
+	beaconState state.BeaconState,
 	bal *precompute.Balance,
 	vals []*precompute.Validator,
 ) ([]*precompute.Validator, *precompute.Balance, error) {
 	_, span := trace.StartSpan(ctx, "altair.ProcessEpochParticipation")
 	defer span.End()
 
-	cp, err := state.CurrentEpochParticipation()
+	cp, err := beaconState.CurrentEpochParticipation()
 	if err != nil {
 		return nil, nil, err
 	}
@@ -155,7 +151,7 @@ func ProcessEpochParticipation(
 			vals[i].IsCurrentEpochTargetAttester = true
 		}
 	}
-	pp, err := state.PreviousEpochParticipation()
+	pp, err := beaconState.PreviousEpochParticipation()
 	if err != nil {
 		return nil, nil, err
 	}
@@ -177,27 +173,28 @@ func ProcessEpochParticipation(
 // ProcessRewardsAndPenaltiesPrecompute processes the rewards and penalties of individual validator.
 // This is an optimized version by passing in precomputed validator attesting records and and total epoch balances.
 func ProcessRewardsAndPenaltiesPrecompute(
-	state state.BeaconStateAltair,
+	beaconState state.BeaconStateAltair,
 	bal *precompute.Balance,
 	vals []*precompute.Validator,
 ) (state.BeaconStateAltair, error) {
 	// Don't process rewards and penalties in genesis epoch.
-	if core.CurrentEpoch(state) == 0 {
-		return state, nil
+	cfg := params.BeaconConfig()
+	if core.CurrentEpoch(beaconState) == cfg.GenesisEpoch {
+		return beaconState, nil
 	}
 
-	numOfVals := state.NumValidators()
+	numOfVals := beaconState.NumValidators()
 	// Guard against an out-of-bounds using validator balance precompute.
-	if len(vals) != numOfVals || len(vals) != state.BalancesLength() {
-		return state, errors.New("validator registries not the same length as state's validator registries")
+	if len(vals) != numOfVals || len(vals) != beaconState.BalancesLength() {
+		return beaconState, errors.New("validator registries not the same length as state's validator registries")
 	}
 
-	attsRewards, attsPenalties, err := AttestationsDelta(state, bal, vals)
+	attsRewards, attsPenalties, err := AttestationsDelta(beaconState, bal, vals)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get attestation delta")
 	}
 
-	balances := state.Balances()
+	balances := beaconState.Balances()
 	for i := 0; i < numOfVals; i++ {
 		vals[i].BeforeEpochTransitionBalance = balances[i]
 
@@ -209,23 +206,23 @@ func ProcessRewardsAndPenaltiesPrecompute(
 		vals[i].AfterEpochTransitionBalance = balances[i]
 	}
 
-	if err := state.SetBalances(balances); err != nil {
+	if err := beaconState.SetBalances(balances); err != nil {
 		return nil, errors.Wrap(err, "could not set validator balances")
 	}
 
-	return state, nil
+	return beaconState, nil
 }
 
 // AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the
 // voting records.
-func AttestationsDelta(state state.BeaconStateAltair, bal *precompute.Balance, vals []*precompute.Validator) (rewards, penalties []uint64, err error) {
-	numOfVals := state.NumValidators()
+func AttestationsDelta(beaconState state.BeaconStateAltair, bal *precompute.Balance, vals []*precompute.Validator) (rewards, penalties []uint64, err error) {
+	numOfVals := beaconState.NumValidators()
 	rewards = make([]uint64, numOfVals)
 	penalties = make([]uint64, numOfVals)
-	prevEpoch := core.PrevEpoch(state)
-	finalizedEpoch := state.FinalizedCheckpointEpoch()
 
 	cfg := params.BeaconConfig()
+	prevEpoch := core.PrevEpoch(beaconState)
+	finalizedEpoch := beaconState.FinalizedCheckpointEpoch()
 	increment := cfg.EffectiveBalanceIncrement
 	factor := cfg.BaseRewardFactor
 	baseRewardMultiplier := increment * factor / math.IntegerSquareRoot(bal.ActiveCurrentEpoch)
@@ -241,10 +238,10 @@ func AttestationsDelta(state state.BeaconStateAltair, bal *precompute.Balance, v
 
 func attestationDelta(
 	bal *precompute.Balance,
-	v *precompute.Validator,
+	val *precompute.Validator,
 	baseRewardMultiplier, inactivityDenominator uint64,
 	inactivityLeak bool) (reward, penalty uint64) {
-	eligible := v.IsActivePrevEpoch || (v.IsSlashed && !v.IsWithdrawableCurrentEpoch)
+	eligible := val.IsActivePrevEpoch || (val.IsSlashed && !val.IsWithdrawableCurrentEpoch)
 	// Per spec `ActiveCurrentEpoch` can't be 0 to process attestation delta.
 	if !eligible || bal.ActiveCurrentEpoch == 0 {
 		return 0, 0
@@ -252,7 +249,7 @@ func attestationDelta(
 
 	cfg := params.BeaconConfig()
 	increment := cfg.EffectiveBalanceIncrement
-	effectiveBalance := v.CurrentEpochEffectiveBalance
+	effectiveBalance := val.CurrentEpochEffectiveBalance
 	baseReward := (effectiveBalance / increment) * baseRewardMultiplier
 	activeIncrement := bal.ActiveCurrentEpoch / increment
 
@@ -262,7 +259,7 @@ func attestationDelta(
 	headWeight := cfg.TimelyHeadWeight
 	reward, penalty = uint64(0), uint64(0)
 	// Process source reward / penalty
-	if v.IsPrevEpochAttester && !v.IsSlashed {
+	if val.IsPrevEpochAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * srcWeight * (bal.PrevEpochAttested / increment)
 			reward += n / (activeIncrement * weightDenominator)
@@ -272,7 +269,7 @@ func attestationDelta(
 	}
 
 	// Process target reward / penalty
-	if v.IsPrevEpochTargetAttester && !v.IsSlashed {
+	if val.IsPrevEpochTargetAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * tgtWeight * (bal.PrevEpochTargetAttested / increment)
 			reward += n / (activeIncrement * weightDenominator)
@@ -282,7 +279,7 @@ func attestationDelta(
 	}
 
 	// Process head reward / penalty
-	if v.IsPrevEpochHeadAttester && !v.IsSlashed {
+	if val.IsPrevEpochHeadAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * headWeight * (bal.PrevEpochHeadAttested / increment)
 			reward += n / (activeIncrement * weightDenominator)
@@ -291,8 +288,8 @@ func attestationDelta(
 
 	// Process finality delay penalty
 	// Apply an additional penalty to validators that did not vote on the correct target or slashed
-	if !v.IsPrevEpochTargetAttester || v.IsSlashed {
-		n := effectiveBalance * v.InactivityScore
+	if !val.IsPrevEpochTargetAttester || val.IsSlashed {
+		n := effectiveBalance * val.InactivityScore
 		penalty += n / inactivityDenominator
 	}
 

beacon-chain/core/altair/epoch_precompute_test.go

@@ -8,10 +8,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestInitializeEpochValidators_Ok(t *testing.T) {
@@ -31,7 +31,7 @@ func TestInitializeEpochValidators_Ok(t *testing.T) {
 		InactivityScores: []uint64{0, 1, 2, 3},
 	})
 	require.NoError(t, err)
-	v, b, err := InitializeEpochValidators(context.Background(), s)
+	v, b, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	assert.DeepEqual(t, &precompute.Validator{
 		IsSlashed:                    true,
@@ -68,14 +68,14 @@ func TestInitializeEpochValidators_BadState(t *testing.T) {
 		InactivityScores: []uint64{},
 	})
 	require.NoError(t, err)
-	_, _, err = InitializeEpochValidators(context.Background(), s)
-	require.ErrorContains(t, "num of validators can't be greater than length of inactivity scores", err)
+	_, _, err = InitializePrecomputeValidators(context.Background(), s)
+	require.ErrorContains(t, "num of validators is different than num of inactivity scores", err)
 }
 
 func TestProcessEpochParticipation(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -145,7 +145,7 @@ func TestProcessEpochParticipation_InactiveValidator(t *testing.T) {
 		InactivityScores: []uint64{0, 0, 0},
 	})
 	require.NoError(t, err)
-	validators, balance, err := InitializeEpochValidators(context.Background(), st)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), st)
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), st, balance, validators)
 	require.NoError(t, err)
@@ -182,7 +182,7 @@ func TestProcessEpochParticipation_InactiveValidator(t *testing.T) {
 func TestAttestationsDelta(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -208,7 +208,7 @@ func TestAttestationsDelta(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -240,7 +240,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_InactivityLeak(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -268,7 +268,7 @@ func TestProcessInactivityScores_CanProcessInactivityLeak(t *testing.T) {
 	defaultScore := uint64(5)
 	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
 	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch*types.Slot(params.BeaconConfig().MinEpochsToInactivityPenalty+2)))
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -283,12 +283,32 @@ func TestProcessInactivityScores_CanProcessInactivityLeak(t *testing.T) {
 	require.Equal(t, defaultScore-1, inactivityScores[3])
 }
 
+func TestProcessInactivityScores_GenesisEpoch(t *testing.T) {
+	s, err := testState()
+	require.NoError(t, err)
+	defaultScore := uint64(10)
+	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
+	require.NoError(t, s.SetSlot(params.BeaconConfig().GenesisSlot))
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
+	require.NoError(t, err)
+	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
+	require.NoError(t, err)
+	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
+	require.NoError(t, err)
+	inactivityScores, err := s.InactivityScores()
+	require.NoError(t, err)
+	require.Equal(t, defaultScore, inactivityScores[0])
+	require.Equal(t, defaultScore, inactivityScores[1])
+	require.Equal(t, defaultScore, inactivityScores[2])
+	require.Equal(t, defaultScore, inactivityScores[3])
+}
+
 func TestProcessInactivityScores_CanProcessNonInactivityLeak(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
 	defaultScore := uint64(5)
 	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -306,7 +326,7 @@ func TestProcessInactivityScores_CanProcessNonInactivityLeak(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_GenesisEpoch(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -325,7 +345,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_GenesisEpoch(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_BadState(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	_, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
@@ -338,7 +358,7 @@ func TestProcessInactivityScores_NonEligibleValidator(t *testing.T) {
 	require.NoError(t, err)
 	defaultScore := uint64(5)
 	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	validators, balance, err := InitializeEpochValidators(context.Background(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 
 	// v0 is eligible (not active previous epoch, slashed and not withdrawable)

beacon-chain/core/altair/epoch_spec.go

@@ -6,7 +6,8 @@ import (
 	"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/shared/params"
+	"github.com/prysmaticlabs/prysm/config/params"
+	log "github.com/sirupsen/logrus"
 )
 
 // ProcessSyncCommitteeUpdates  processes sync client committee updates for the beacon state.
@@ -35,7 +36,7 @@ func ProcessSyncCommitteeUpdates(ctx context.Context, beaconState state.BeaconSt
 			return nil, err
 		}
 		if err := helpers.UpdateSyncCommitteeCache(beaconState); err != nil {
-			return nil, err
+			log.WithError(err).Error("Could not update sync committee cache")
 		}
 	}
 	return beaconState, nil

beacon-chain/core/altair/epoch_spec_test.go

@@ -11,17 +11,17 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	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/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	"google.golang.org/protobuf/proto"
 )
 
 func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	h := &ethpb.BeaconBlockHeader{
 		StateRoot:  bytesutil.PadTo([]byte{'a'}, 32),
 		ParentRoot: bytesutil.PadTo([]byte{'b'}, 32),
@@ -66,7 +66,7 @@ func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
 }
 
 func TestProcessParticipationFlagUpdates_CanRotate(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	c, err := s.CurrentEpochParticipation()
 	require.NoError(t, err)
 	require.DeepEqual(t, make([]byte, params.BeaconConfig().MaxValidatorsPerCommittee), c)

beacon-chain/core/altair/reward.go

@@ -5,8 +5,8 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/math"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 // BaseReward takes state and validator index and calculate

beacon-chain/core/altair/reward_test.go

@@ -7,14 +7,14 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func Test_BaseReward(t *testing.T) {
 	genState := func(valCount uint64) state.ReadOnlyBeaconState {
-		s, _ := testutil.DeterministicGenesisStateAltair(t, valCount)
+		s, _ := util.DeterministicGenesisStateAltair(t, valCount)
 		return s
 	}
 	tests := []struct {
@@ -66,7 +66,7 @@ func Test_BaseReward(t *testing.T) {
 }
 
 func Test_BaseRewardWithTotalBalance(t *testing.T) {
-	s, _ := testutil.DeterministicGenesisStateAltair(t, 1)
+	s, _ := util.DeterministicGenesisStateAltair(t, 1)
 	tests := []struct {
 		name          string
 		valIdx        types.ValidatorIndex

beacon-chain/core/altair/sync_committee.go

@@ -10,12 +10,12 @@ import (
 	"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/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/math"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
-	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
 const maxRandomByte = uint64(1<<8 - 1)

beacon-chain/core/altair/sync_committee_test.go

@@ -9,11 +9,11 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 )
 

beacon-chain/core/altair/transition.go

@@ -7,7 +7,7 @@ import (
 	e "github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"go.opencensus.io/trace"
 )
 
@@ -35,7 +35,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconStateAltair) (state.Bea
 	if state == nil || state.IsNil() {
 		return nil, errors.New("nil state")
 	}
-	vp, bp, err := InitializeEpochValidators(ctx, state)
+	vp, bp, err := InitializePrecomputeValidators(ctx, state)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/altair/transition_test.go

@@ -5,13 +5,13 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/shared/params"
-	"github.com/prysmaticlabs/prysm/shared/testutil"
-	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
 func TestProcessEpoch_CanProcess(t *testing.T) {
-	st, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	st, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
 	newState, err := altair.ProcessEpoch(context.Background(), st)
 	require.NoError(t, err)