tree test

WORKSPACE

@@ -225,7 +225,7 @@ filegroup(
     url = "https://github.com/eth2-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
-consensus_spec_version = "v1.1.6"
+consensus_spec_version = "v1.1.5"
 
 bls_test_version = "v0.1.1"
 
@@ -241,7 +241,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "58dbf798e86017b5561af38f2217b99e9fa5b6be0e928b4c73dad6040bb94d65",
+    sha256 = "a7d7173d953494c0dfde432c9fc064c25d46d666b024749b3474ae0cdfc50050",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -257,7 +257,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "5be19f7fca9733686ca25dad5ae306327e98830ef6354549d1ddfc56c10e0e9a",
+    sha256 = "f86872061588c0197516b23025d39e9365b4716c112218a618739dc0d6f4666a",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -273,7 +273,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "cc110528fcf7ede049e6a05788c77f4a865c3110b49508149d61bb2a992bb896",
+    sha256 = "7a06975360fd37fbb4694d0e06abb78d2a0835146c1d9b26d33569edff8b98f0",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -288,7 +288,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "c318d7b909ab39db9cc861f645ddd364e7475a4a3425bb702ab407fad3807acd",
+    sha256 = "87d8089200163340484d61212fbdffbb5d9d03e1244622761dcb91e641a65761",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -362,9 +362,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "f196fe4367c2d2d01d36565c0dc6eecfa4f03adba1fc03a61d62953fce606e1f",
+    sha256 = "0a3d94428ea28916276694c517b82b364122063fdbf924f54ee9ae0bc500289f",
     urls = [
-        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.2/prysm-web-ui.tar.gz",
+        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.1/prysm-web-ui.tar.gz",
     ],
 )
 

api/client/openapi/BUILD.bazel

@@ -1,24 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "checkpoint.go",
-        "client.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/client/openapi",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/rpc/apimiddleware:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/sniff:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)

api/client/openapi/checkpoint.go

@@ -1,228 +0,0 @@
-package openapi
-
-import (
-	"context"
-	"fmt"
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/proto/sniff"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	log "github.com/sirupsen/logrus"
-	"io"
-)
-
-var ErrMismatchedLatestBlockRoot = errors.New("block root in state does not match value from api")
-
-type WeakSubjectivityData struct {
-	BlockRoot [32]byte
-	StateRoot [32]byte
-	Epoch     types.Epoch
-}
-type OriginData struct {
-	WeakSubjectivity *WeakSubjectivityData
-	StateBytes       []byte
-	blockBytes       []byte
-}
-
-// this method downloads the head state, which can be used to find the correct chain config
-// and use prysm's helper methods to compute the latest weak subjectivity epoch.
-func getWeakSubjectivityEpochFromHead(ctx context.Context, client *Client) (types.Epoch, error) {
-	headReader, err := client.GetStateById(StateIdHead)
-	headBytes, err := io.ReadAll(headReader)
-	if err != nil {
-		return 0, errors.Wrap(err, "failed to read response body for get head state api call")
-	}
-	headState, err := sniff.BeaconState(headBytes)
-	if err != nil {
-		return 0, errors.Wrap(err, "error unmarshaling state to correct version")
-	}
-	cf, err := sniff.ConfigForkForState(headBytes)
-	if err != nil {
-		return 0, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in remote head state, name=%s, fork=%s", cf.ConfigName.String(), cf.Fork)
-
-	// LatestWeakSubjectivityEpoch uses package-level vars from the params package, so we need to override it
-	params.OverrideBeaconConfig(cf.Config)
-	epoch, err := helpers.LatestWeakSubjectivityEpoch(ctx, headState)
-	if err != nil {
-		return 0, errors.Wrap(err, "error computing the weak subjectivity epoch from head state")
-	}
-
-	log.Printf("(computed client-side) weak subjectivity epoch = %d", epoch)
-	return epoch, nil
-}
-
-// for older endpoints or clients that do not support the weak_subjectivity api method (only prysm at release time)
-// we gather the necessary data for a checkpoint sync by:
-// - inspecting the remote server's head state and computing the weak subjectivity epoch locally
-// - requesting the state at the first slot of the epoch
-// - using hash_tree_root(state.latest_block_header) to compute the block the state integrates
-// - requesting that block by its root
-func downloadBackwardsCompatible(ctx context.Context, client *Client) (*OriginData, error) {
-	log.Print("falling back to generic checkpoint derivation, weak_subjectivity API not supported by server")
-	epoch, err := getWeakSubjectivityEpochFromHead(ctx, client)
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing weak subjectivity epoch via head state inspection")
-	}
-
-	// use first slot of the epoch for the state slot
-	slot, err := slots.EpochStart(epoch)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("Error computing first slot of epoch=%d", epoch))
-	}
-
-	log.Printf("requesting checkpoint state at slot %d", slot)
-	// get the state at the first slot of the epoch
-	sReader, err := client.GetStateBySlot(uint64(slot))
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("failed to request state by slot from api, slot=%d", slot))
-	}
-	stateBytes, err := io.ReadAll(sReader)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to read response body for get checkpoint state api call")
-	}
-
-	// ConfigFork is used to unmarshal the BeaconState so we can read the block root in latest_block_header
-	cf, err := sniff.ConfigForkForState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.ConfigName.String(), cf.Fork)
-
-	state, err := sniff.BeaconStateForConfigFork(stateBytes, cf)
-	if err != nil {
-		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
-	}
-
-	// compute state and block roots
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of state")
-	}
-	blockRoot, err := state.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of latest_block_header")
-	}
-	log.Printf("found hash_tree_root(state.latest_block_header)=%#x", blockRoot)
-
-	bReader, err := client.GetBlockByRoot(fmt.Sprintf("%#x", blockRoot))
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("error requesting block by root = %#x", blockRoot))
-	}
-	blockBytes, err := io.ReadAll(bReader)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to read response body for get checkpoint block api call")
-	}
-	block, err := sniff.BlockForConfigFork(blockBytes, cf)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
-	}
-	realBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block")
-	}
-
-	log.Printf("BeaconState slot=%d, Block slot=%d", state.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconState latest_block_header htr=%#xd, block htr=%#x", blockRoot, realBlockRoot)
-
-	return &OriginData{
-		WeakSubjectivity: &WeakSubjectivityData{
-			BlockRoot: blockRoot,
-			StateRoot: stateRoot,
-			Epoch:     epoch,
-		},
-		StateBytes: stateBytes,
-		blockBytes: blockBytes,
-	}, nil
-}
-
-// DownloadOriginData attempts to use the proposed weak_subjectivity beacon node api
-// to obtain the weak_subjectivity metadata (epoch, block_root, state_root) needed to sync
-// a beacon node from the canonical weak subjectivity checkpoint. As this is a proposed API
-// that will only be supported by prysm at first, in the event of a 404 we fallback to using a
-// different technique where we first download the head state which can be used to compute the
-// weak subjectivity epoch on the client side.
-func DownloadOriginData(ctx context.Context, client *Client) (*OriginData, error) {
-	ws, err := client.GetWeakSubjectivity()
-	if err != nil {
-		// a 404 is expected if querying an endpoint that doesn't support the weak subjectivity checkpoint api
-		if !errors.Is(err, ErrNotFound) {
-			return nil, errors.Wrap(err, "unexpected API response for prysm-only weak subjectivity checkpoint API")
-		}
-		// ok so it's a 404, use the head state method
-		return downloadBackwardsCompatible(ctx, client)
-	}
-	log.Printf("server weak subjectivity checkpoint response - epoch=%d, block_root=%#x, state_root=%#x", ws.Epoch, ws.BlockRoot, ws.StateRoot)
-
-	// use first slot of the epoch for the block slot
-	slot, err := slots.EpochStart(ws.Epoch)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("Error computing first slot of epoch=%d", ws.Epoch))
-	}
-	log.Printf("requesting checkpoint state at slot %d", slot)
-
-	sReader, err := client.GetStateBySlot(uint64(slot))
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("failed to request state by slot from api, slot=%d", slot))
-	}
-
-	stateBytes, err := io.ReadAll(sReader)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to read response body for get checkpoint state api call")
-	}
-	cf, err := sniff.ConfigForkForState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.ConfigName.String(), cf.Fork)
-
-	state, err := sniff.BeaconStateForConfigFork(stateBytes, cf)
-	if err != nil {
-		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
-	}
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("failed to compute htr for state at slot=%d", slot))
-	}
-
-	blockRoot, err := state.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of latest_block_header")
-	}
-	log.Printf("found hash_tree_root(state.latest_block_header)=%#x", blockRoot)
-	if blockRoot != ws.BlockRoot {
-		log.Warn("checkpoint block root doesn't match hash_tree_root(state.latest_block_header)")
-		msg := fmt.Sprintf("api block_root=%#x, hash_tree_root(state.latest_block_header)=%#x", ws.BlockRoot, blockRoot)
-		return nil, errors.Wrap(ErrMismatchedLatestBlockRoot, msg)
-	}
-
-	log.Printf("hash_tree_root(state.latest_block_header) matches API response, fetching %#x", blockRoot)
-	bReader, err := client.GetBlockByRoot(fmt.Sprintf("%#x", blockRoot))
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("error requesting block by root = %#x", blockRoot))
-	}
-	blockBytes, err := io.ReadAll(bReader)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to read response body for get checkpoint block api call")
-	}
-	block, err := sniff.BlockForConfigFork(blockBytes, cf)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
-	}
-	realBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block")
-	}
-	log.Printf("BeaconState slot=%d, Block slot=%d", state.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconState latest_block_header htr=%#xd, block htr=%#x", blockRoot, realBlockRoot)
-	return &OriginData{
-		WeakSubjectivity: ws,
-		StateBytes:       stateBytes,
-		blockBytes:       blockBytes,
-	}, nil
-}

api/client/openapi/client.go

@@ -1,403 +0,0 @@
-package openapi
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/apimiddleware"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/url"
-	"path"
-	"sort"
-	"strconv"
-	"text/template"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	GET_WEAK_SUBJECTIVITY_PATH = "/eth/v1/beacon/weak_subjectivity"
-	GET_SIGNED_BLOCK_PATH      = "/eth/v2/beacon/blocks"
-	GET_STATE_PATH             = "/eth/v2/debug/beacon/states"
-	GET_FORK_SCHEDULE_PATH     = "/eth/v1/config/fork_schedule"
-	GET_FORK_FOR_STATE         = "/eth/v1/beacon/states/{{.StateId}}/fork"
-	GET_BLOCK_ROOT             = "/eth/v1/beacon/blocks/{{.BlockId}}/root"
-)
-
-const (
-	StateIdHead = "head"
-)
-
-var ErrNotOK = errors.New("did not receive 2xx response from API")
-var ErrNotFound = errors.Wrap(ErrNotOK, "recv 404 NotFound response from API")
-
-// ClientOpt is a functional option for the Client type (http.Client wrapper)
-type ClientOpt func(*Client)
-
-// WithTimeout sets the .Timeout attribute of the wrapped http.Client
-func WithTimeout(timeout time.Duration) ClientOpt {
-	return func(c *Client) {
-		c.c.Timeout = timeout
-	}
-}
-
-// Client provides a collection of helper methods for calling the beacon node OpenAPI endpoints
-type Client struct {
-	c      *http.Client
-	host   string
-	scheme string
-}
-
-func (c *Client) urlForPath(methodPath string) *url.URL {
-	u := &url.URL{
-		Scheme: c.scheme,
-		Host:   c.host,
-	}
-	u.Path = path.Join(u.Path, methodPath)
-	return u
-}
-
-// NewClient constructs a new client with the provided options (ex WithTimeout).
-// host is the base host + port used to construct request urls. This value can be
-// a URL string, or NewClient will assume an http endpoint if just `host:port` is used.
-func NewClient(host string, opts ...ClientOpt) (*Client, error) {
-	host, err := validHostname(host)
-	if err != nil {
-		return nil, err
-	}
-	c := &Client{
-		c:      &http.Client{},
-		scheme: "http",
-		host:   host,
-	}
-	for _, o := range opts {
-		o(c)
-	}
-	return c, nil
-}
-
-func validHostname(h string) (string, error) {
-	// try to parse as url (being permissive)
-	u, err := url.Parse(h)
-	if err == nil && u.Host != "" {
-		return u.Host, nil
-	}
-	// try to parse as host:port
-	host, port, err := net.SplitHostPort(h)
-	if err != nil {
-		return "", err
-	}
-	return fmt.Sprintf("%s:%s", host, port), nil
-}
-
-// GetBlockBySlot queries the beacon node API for the SignedBeaconBlockAltair for the given slot
-func (c *Client) GetBlockBySlot(slot uint64) (io.Reader, error) {
-	blockPath := path.Join(GET_SIGNED_BLOCK_PATH, strconv.FormatUint(slot, 10))
-	u := c.urlForPath(blockPath)
-	log.Printf("requesting %s", u.String())
-	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Accept", "application/octet-stream")
-	r, err := c.c.Do(req)
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if err != nil {
-		return nil, err
-	}
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	b := bytes.NewBuffer(nil)
-	_, err = io.Copy(b, r.Body)
-	if err != nil {
-		return nil, errors.Wrap(err, "error reading http response body from GetBlockBySlot")
-	}
-	return b, nil
-}
-
-// blockId can be one of:
-// - "head" (canonical head in node's view)
-// - "genesis"
-// - "finalized"
-// - <slot>
-// - <hex encoded blockRoot with 0x prefix>. -- you could, but should you?
-func (c *Client) GetBlockRoot(blockId string) ([32]byte, error) {
-	var root [32]byte
-	t := template.Must(template.New("get-block-root").Parse(GET_BLOCK_ROOT))
-	b := bytes.NewBuffer(nil)
-	err := t.Execute(b, struct{ BlockId string }{BlockId: blockId})
-	if err != nil {
-		return root, errors.Wrap(err, fmt.Sprintf("unable to generate path w/ blockId=%s", blockId))
-	}
-	rootPath := b.String()
-	u := c.urlForPath(rootPath)
-	log.Printf("requesting %s", u.String())
-	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
-	if err != nil {
-		return root, err
-	}
-	r, err := c.c.Do(req)
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if err != nil {
-		return root, err
-	}
-	if r.StatusCode != http.StatusOK {
-		return root, non200Err(r)
-	}
-	jsonr := &struct{ Data struct{ Root string } }{}
-	err = json.NewDecoder(r.Body).Decode(jsonr)
-	if err != nil {
-		return root, errors.Wrap(err, "error decoding json data from get block root response")
-	}
-	rs, err := hexutil.Decode(jsonr.Data.Root)
-	if err != nil {
-		return root, errors.Wrap(err, fmt.Sprintf("error decoding hex-encoded value %s", jsonr.Data.Root))
-	}
-	return bytesutil.ToBytes32(rs), nil
-}
-
-// GetBlockByRoot retrieves a SignedBeaconBlockAltair with the given root via the beacon node API
-func (c *Client) GetBlockByRoot(blockHex string) (io.Reader, error) {
-	blockPath := path.Join(GET_SIGNED_BLOCK_PATH, blockHex)
-	u := c.urlForPath(blockPath)
-	log.Printf("requesting %s", u.String())
-	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Accept", "application/octet-stream")
-	r, err := c.c.Do(req)
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if err != nil {
-		return nil, err
-	}
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	b := bytes.NewBuffer(nil)
-	_, err = io.Copy(b, r.Body)
-	return b, nil
-}
-
-// GetStateByRoot retrieves a BeaconStateAltair with the given root via the beacon node API
-func (c *Client) GetStateByRoot(stateHex string) (io.Reader, error) {
-	return c.GetStateById(stateHex)
-}
-
-// GetStateBySlot retrieves a BeaconStateAltair at the given slot via the beacon node API
-func (c *Client) GetStateBySlot(slot uint64) (io.Reader, error) {
-	slotStr := strconv.FormatUint(slot, 10)
-	return c.GetStateById(slotStr)
-}
-
-func (c *Client) GetStateById(stateId string) (io.Reader, error) {
-	statePath := path.Join(GET_STATE_PATH, stateId)
-	u := c.urlForPath(statePath)
-	log.Printf("requesting %s", u.String())
-	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Accept", "application/octet-stream")
-	r, err := c.c.Do(req)
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if err != nil {
-		return nil, err
-	}
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	b := bytes.NewBuffer(nil)
-	_, err = io.Copy(b, r.Body)
-	if err != nil {
-		return nil, errors.Wrap(err, "error reading http response body from GetStateById")
-	}
-	return b, nil
-}
-
-func (c *Client) GetForkForState(stateId string) (*ethpb.Fork, error) {
-	t := template.Must(template.New("get-for-for-state").Parse(GET_FORK_FOR_STATE))
-	b := bytes.NewBuffer(nil)
-	err := t.Execute(b, struct{ StateId string }{StateId: stateId})
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("unable to generate path w/ stateId=%s", stateId))
-	}
-	u := c.urlForPath(b.String())
-	r, err := c.c.Get(u.String())
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if err != nil {
-		return nil, err
-	}
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	fr := &forkResponse{}
-	dataWrapper := &struct{ Data *forkResponse }{Data: fr}
-	err = json.NewDecoder(r.Body).Decode(dataWrapper)
-	if err != nil {
-		return nil, errors.Wrap(err, "error decoding json response in GetForkForState")
-	}
-
-	return fr.Fork()
-}
-
-type forkResponse struct {
-	PreviousVersion string `json:"previous_version"`
-	CurrentVersion  string `json:"current_version"`
-	Epoch           string `json:"epoch"`
-}
-
-func (f *forkResponse) Fork() (*ethpb.Fork, error) {
-	epoch, err := strconv.Atoi(f.Epoch)
-	if err != nil {
-		return nil, err
-	}
-	cSlice, err := hexutil.Decode(f.CurrentVersion)
-	if err != nil {
-		return nil, err
-	}
-	if len(cSlice) != 4 {
-		return nil, fmt.Errorf("got %d byte version for CurrentVersion, expected 4 bytes. hex=%s", len(cSlice), f.CurrentVersion)
-	}
-	pSlice, err := hexutil.Decode(f.PreviousVersion)
-	if err != nil {
-		return nil, err
-	}
-	if len(pSlice) != 4 {
-		return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(pSlice), f.PreviousVersion)
-	}
-	return &ethpb.Fork{
-		CurrentVersion:  cSlice,
-		PreviousVersion: pSlice,
-		Epoch:           types.Epoch(epoch),
-	}, nil
-}
-
-type forkScheduleResponse struct {
-	Data []forkResponse
-}
-
-func (fsr *forkScheduleResponse) OrderedForkSchedule() (params.OrderedForkSchedule, error) {
-	ofs := make(params.OrderedForkSchedule, 0)
-	for _, d := range fsr.Data {
-		epoch, err := strconv.Atoi(d.Epoch)
-		if err != nil {
-			return nil, err
-		}
-		vSlice, err := hexutil.Decode(d.CurrentVersion)
-		if err != nil {
-			return nil, err
-		}
-		if len(vSlice) != 4 {
-			return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(vSlice), d.CurrentVersion)
-		}
-		version := bytesutil.ToBytes4(vSlice)
-		ofs = append(ofs, params.ForkScheduleEntry{
-			Version: version,
-			Epoch:   types.Epoch(uint64(epoch)),
-		})
-	}
-	sort.Sort(ofs)
-	return ofs, nil
-}
-
-func (c *Client) GetForkSchedule() (params.OrderedForkSchedule, error) {
-	u := c.urlForPath(GET_FORK_SCHEDULE_PATH)
-	log.Printf("requesting %s", u.String())
-	r, err := c.c.Get(u.String())
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if err != nil {
-		return nil, err
-	}
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	fsr := &forkScheduleResponse{}
-	err = json.NewDecoder(r.Body).Decode(fsr)
-	if err != nil {
-		return nil, err
-	}
-	ofs, err := fsr.OrderedForkSchedule()
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("problem unmarshaling %s response", GET_FORK_SCHEDULE_PATH))
-	}
-	return ofs, nil
-}
-
-// GetWeakSubjectivity calls a proposed API endpoint that is unique to prysm
-// This api method does the following:
-// - computes weak subjectivity epoch
-// - finds the highest non-skipped block preceding the epoch
-// - returns the htr of the found block and returns this + the value of state_root from the block
-func (c *Client) GetWeakSubjectivity() (*WeakSubjectivityData, error) {
-	u := c.urlForPath(GET_WEAK_SUBJECTIVITY_PATH)
-	r, err := c.c.Get(u.String())
-	if err != nil {
-		return nil, err
-	}
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	v := &apimiddleware.WeakSubjectivityResponse{}
-	err = json.NewDecoder(r.Body).Decode(v)
-	if err != nil {
-		return nil, err
-	}
-	epoch, err := strconv.ParseUint(v.Data.Checkpoint.Epoch, 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	blockRoot, err := hexutil.Decode(v.Data.Checkpoint.Root)
-	if err != nil {
-		return nil, err
-	}
-	stateRoot, err := hexutil.Decode(v.Data.StateRoot)
-	if err != nil {
-		return nil, err
-	}
-	return &WeakSubjectivityData{
-		Epoch:     types.Epoch(epoch),
-		BlockRoot: bytesutil.ToBytes32(blockRoot),
-		StateRoot: bytesutil.ToBytes32(stateRoot),
-	}, nil
-}
-
-func non200Err(response *http.Response) error {
-	bodyBytes, err := ioutil.ReadAll(response.Body)
-	var body string
-	if err != nil {
-		body = "(Unable to read response body.)"
-	} else {
-		body = "response body:\n" + string(bodyBytes)
-	}
-	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
-	switch response.StatusCode {
-	case 404:
-		return errors.Wrap(ErrNotFound, msg)
-	default:
-		return errors.Wrap(ErrNotOK, msg)
-	}
-}

api/gateway/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "gateway.go",
         "log.go",
-        "options.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/api/gateway",
     visibility = [

api/gateway/apimiddleware/api_middleware.go

@@ -14,7 +14,6 @@ import (
 type ApiProxyMiddleware struct {
 	GatewayAddress  string
 	EndpointCreator EndpointFactory
-	router          *mux.Router
 }
 
 // EndpointFactory is responsible for creating new instances of Endpoint values.
@@ -30,8 +29,6 @@ type Endpoint struct {
 	GetResponse        interface{}     // The struct corresponding to the JSON structure used in a GET response.
 	PostRequest        interface{}     // The struct corresponding to the JSON structure used in a POST request.
 	PostResponse       interface{}     // The struct corresponding to the JSON structure used in a POST response.
-	DeleteRequest      interface{}     // The struct corresponding to the JSON structure used in a DELETE request.
-	DeleteResponse     interface{}     // The struct corresponding to the JSON structure used in a DELETE response.
 	RequestURLLiterals []string        // Names of URL parameters that should not be base64-encoded.
 	RequestQueryParams []QueryParam    // Query parameters of the request.
 	Err                ErrorJson       // The struct corresponding to the error that should be returned in case of a request failure.
@@ -77,24 +74,18 @@ type fieldProcessor struct {
 // Run starts the proxy, registering all proxy endpoints.
 func (m *ApiProxyMiddleware) Run(gatewayRouter *mux.Router) {
 	for _, path := range m.EndpointCreator.Paths() {
-		gatewayRouter.HandleFunc(path, m.WithMiddleware(path))
+		m.handleApiPath(gatewayRouter, path, m.EndpointCreator)
 	}
-	m.router = gatewayRouter
 }
 
-// ServeHTTP for the proxy middleware.
-func (m *ApiProxyMiddleware) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	m.router.ServeHTTP(w, req)
-}
+func (m *ApiProxyMiddleware) handleApiPath(gatewayRouter *mux.Router, path string, endpointFactory EndpointFactory) {
+	gatewayRouter.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) {
+		endpoint, err := endpointFactory.Create(path)
+		if err != nil {
+			errJson := InternalServerErrorWithMessage(err, "could not create endpoint")
+			WriteError(w, errJson, nil)
+		}
 
-// WithMiddleware wraps the given endpoint handler with the middleware logic.
-func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
-	endpoint, err := m.EndpointCreator.Create(path)
-	if err != nil {
-		log.WithError(err).Errorf("Could not create endpoint for path: %s", path)
-		return nil
-	}
-	return func(w http.ResponseWriter, req *http.Request) {
 		for _, handler := range endpoint.CustomHandlers {
 			if handler(m, *endpoint, w, req) {
 				return
@@ -102,14 +93,16 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 		}
 
 		if req.Method == "POST" {
-			if errJson := handlePostRequestForEndpoint(endpoint, w, req); errJson != nil {
+			if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
 				WriteError(w, errJson, nil)
 				return
 			}
-		}
 
-		if req.Method == "DELETE" {
-			if errJson := handleDeleteRequestForEndpoint(endpoint, req); errJson != nil {
+			if errJson := ProcessRequestContainerFields(endpoint.PostRequest); errJson != nil {
+				WriteError(w, errJson, nil)
+				return
+			}
+			if errJson := SetRequestBodyToRequestContainer(endpoint.PostRequest, req); errJson != nil {
 				WriteError(w, errJson, nil)
 				return
 			}
@@ -144,8 +137,6 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 			var resp interface{}
 			if req.Method == "GET" {
 				resp = endpoint.GetResponse
-			} else if req.Method == "DELETE" {
-				resp = endpoint.DeleteResponse
 			} else {
 				resp = endpoint.PostResponse
 			}
@@ -173,27 +164,7 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 			WriteError(w, errJson, nil)
 			return
 		}
-	}
-}
-
-func handlePostRequestForEndpoint(endpoint *Endpoint, w http.ResponseWriter, req *http.Request) ErrorJson {
-	if errJson := deserializeRequestBodyIntoContainerWrapped(endpoint, req, w); errJson != nil {
-		return errJson
-	}
-	if errJson := ProcessRequestContainerFields(endpoint.PostRequest); errJson != nil {
-		return errJson
-	}
-	return SetRequestBodyToRequestContainer(endpoint.PostRequest, req)
-}
-
-func handleDeleteRequestForEndpoint(endpoint *Endpoint, req *http.Request) ErrorJson {
-	if errJson := DeserializeRequestBodyIntoContainer(req.Body, endpoint.DeleteRequest); errJson != nil {
-		return errJson
-	}
-	if errJson := ProcessRequestContainerFields(endpoint.DeleteRequest); errJson != nil {
-		return errJson
-	}
-	return SetRequestBodyToRequestContainer(endpoint.DeleteRequest, req)
+	})
 }
 
 func deserializeRequestBodyIntoContainerWrapped(endpoint *Endpoint, req *http.Request, w http.ResponseWriter) ErrorJson {

api/gateway/apimiddleware/process_request.go

@@ -74,21 +74,10 @@ func (m *ApiProxyMiddleware) PrepareRequestForProxying(endpoint Endpoint, req *h
 	return nil
 }
 
-type ClientOption func(*http.Client)
-
-func WithTimeout(t time.Duration) ClientOption {
-	return func(c *http.Client) {
-		c.Timeout = t
-	}
-}
-
 // ProxyRequest proxies the request to grpc-gateway.
-func ProxyRequest(req *http.Request, opts ...ClientOption) (*http.Response, ErrorJson) {
+func ProxyRequest(req *http.Request) (*http.Response, ErrorJson) {
 	// We do not use http.DefaultClient because it does not have any timeout.
 	netClient := &http.Client{Timeout: time.Minute * 2}
-	for _, o := range opts {
-		o(netClient)
-	}
 	grpcResp, err := netClient.Do(req)
 	if err != nil {
 		return nil, InternalServerErrorWithMessage(err, "could not proxy request")

api/gateway/gateway.go

@@ -34,51 +34,74 @@ type PbMux struct {
 type PbHandlerRegistration func(context.Context, *gwruntime.ServeMux, *grpc.ClientConn) error
 
 // MuxHandler is a function that implements the mux handler functionality.
-type MuxHandler func(
-	apiMiddlewareHandler *apimiddleware.ApiProxyMiddleware,
-	h http.HandlerFunc,
-	w http.ResponseWriter,
-	req *http.Request,
-)
-
-// Config parameters for setting up the gateway service.
-type config struct {
-	maxCallRecvMsgSize           uint64
-	remoteCert                   string
-	gatewayAddr                  string
-	remoteAddr                   string
-	allowedOrigins               []string
-	apiMiddlewareEndpointFactory apimiddleware.EndpointFactory
-	muxHandler                   MuxHandler
-	pbHandlers                   []*PbMux
-	router                       *mux.Router
-}
+type MuxHandler func(http.Handler, http.ResponseWriter, *http.Request)
 
 // Gateway is the gRPC gateway to serve HTTP JSON traffic as a proxy and forward it to the gRPC server.
 type Gateway struct {
-	cfg          *config
-	conn         *grpc.ClientConn
-	server       *http.Server
-	cancel       context.CancelFunc
-	proxy        *apimiddleware.ApiProxyMiddleware
-	ctx          context.Context
-	startFailure error
+	conn                         *grpc.ClientConn
+	pbHandlers                   []*PbMux
+	muxHandler                   MuxHandler
+	maxCallRecvMsgSize           uint64
+	router                       *mux.Router
+	server                       *http.Server
+	cancel                       context.CancelFunc
+	remoteCert                   string
+	gatewayAddr                  string
+	apiMiddlewareEndpointFactory apimiddleware.EndpointFactory
+	ctx                          context.Context
+	startFailure                 error
+	remoteAddr                   string
+	allowedOrigins               []string
 }
 
 // New returns a new instance of the Gateway.
-func New(ctx context.Context, opts ...Option) (*Gateway, error) {
+func New(
+	ctx context.Context,
+	pbHandlers []*PbMux,
+	muxHandler MuxHandler,
+	remoteAddr,
+	gatewayAddress string,
+) *Gateway {
 	g := &Gateway{
-		ctx: ctx,
-		cfg: &config{
-			router: mux.NewRouter(),
-		},
+		pbHandlers:     pbHandlers,
+		muxHandler:     muxHandler,
+		router:         mux.NewRouter(),
+		gatewayAddr:    gatewayAddress,
+		ctx:            ctx,
+		remoteAddr:     remoteAddr,
+		allowedOrigins: []string{},
 	}
-	for _, opt := range opts {
-		if err := opt(g); err != nil {
-			return nil, err
-		}
-	}
-	return g, nil
+	return g
+}
+
+// WithRouter allows adding a custom mux router to the gateway.
+func (g *Gateway) WithRouter(r *mux.Router) *Gateway {
+	g.router = r
+	return g
+}
+
+// WithAllowedOrigins allows adding a set of allowed origins to the gateway.
+func (g *Gateway) WithAllowedOrigins(origins []string) *Gateway {
+	g.allowedOrigins = origins
+	return g
+}
+
+// WithRemoteCert allows adding a custom certificate to the gateway,
+func (g *Gateway) WithRemoteCert(cert string) *Gateway {
+	g.remoteCert = cert
+	return g
+}
+
+// WithMaxCallRecvMsgSize allows specifying the maximum allowed gRPC message size.
+func (g *Gateway) WithMaxCallRecvMsgSize(size uint64) *Gateway {
+	g.maxCallRecvMsgSize = size
+	return g
+}
+
+// WithApiMiddleware allows adding API Middleware proxy to the gateway.
+func (g *Gateway) WithApiMiddleware(endpointFactory apimiddleware.EndpointFactory) *Gateway {
+	g.apiMiddlewareEndpointFactory = endpointFactory
+	return g
 }
 
 // Start the gateway service.
@@ -86,7 +109,7 @@ func (g *Gateway) Start() {
 	ctx, cancel := context.WithCancel(g.ctx)
 	g.cancel = cancel
 
-	conn, err := g.dial(ctx, "tcp", g.cfg.remoteAddr)
+	conn, err := g.dial(ctx, "tcp", g.remoteAddr)
 	if err != nil {
 		log.WithError(err).Error("Failed to connect to gRPC server")
 		g.startFailure = err
@@ -94,7 +117,7 @@ func (g *Gateway) Start() {
 	}
 	g.conn = conn
 
-	for _, h := range g.cfg.pbHandlers {
+	for _, h := range g.pbHandlers {
 		for _, r := range h.Registrations {
 			if err := r(ctx, h.Mux, g.conn); err != nil {
 				log.WithError(err).Error("Failed to register handler")
@@ -103,29 +126,29 @@ func (g *Gateway) Start() {
 			}
 		}
 		for _, p := range h.Patterns {
-			g.cfg.router.PathPrefix(p).Handler(h.Mux)
+			g.router.PathPrefix(p).Handler(h.Mux)
 		}
 	}
 
-	corsMux := g.corsMiddleware(g.cfg.router)
+	corsMux := g.corsMiddleware(g.router)
 
-	if g.cfg.apiMiddlewareEndpointFactory != nil && !g.cfg.apiMiddlewareEndpointFactory.IsNil() {
-		g.registerApiMiddleware()
-	}
-
-	if g.cfg.muxHandler != nil {
-		g.cfg.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			g.cfg.muxHandler(g.proxy, corsMux.ServeHTTP, w, r)
+	if g.muxHandler != nil {
+		g.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			g.muxHandler(corsMux, w, r)
 		})
 	}
 
+	if g.apiMiddlewareEndpointFactory != nil && !g.apiMiddlewareEndpointFactory.IsNil() {
+		go g.registerApiMiddleware()
+	}
+
 	g.server = &http.Server{
-		Addr:    g.cfg.gatewayAddr,
-		Handler: corsMux,
+		Addr:    g.gatewayAddr,
+		Handler: g.router,
 	}
 
 	go func() {
-		log.WithField("address", g.cfg.gatewayAddr).Info("Starting gRPC gateway")
+		log.WithField("address", g.gatewayAddr).Info("Starting gRPC gateway")
 		if err := g.server.ListenAndServe(); err != http.ErrServerClosed {
 			log.WithError(err).Error("Failed to start gRPC gateway")
 			g.startFailure = err
@@ -139,9 +162,11 @@ func (g *Gateway) Status() error {
 	if g.startFailure != nil {
 		return g.startFailure
 	}
+
 	if s := g.conn.GetState(); s != connectivity.Ready {
 		return fmt.Errorf("grpc server is %s", s)
 	}
+
 	return nil
 }
 
@@ -158,16 +183,18 @@ func (g *Gateway) Stop() error {
 			}
 		}
 	}
+
 	if g.cancel != nil {
 		g.cancel()
 	}
+
 	return nil
 }
 
 func (g *Gateway) corsMiddleware(h http.Handler) http.Handler {
 	c := cors.New(cors.Options{
-		AllowedOrigins:   g.cfg.allowedOrigins,
-		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
+		AllowedOrigins:   g.allowedOrigins,
+		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodOptions},
 		AllowCredentials: true,
 		MaxAge:           600,
 		AllowedHeaders:   []string{"*"},
@@ -209,8 +236,8 @@ func (g *Gateway) dial(ctx context.Context, network, addr string) (*grpc.ClientC
 // "addr" must be a valid TCP address with a port number.
 func (g *Gateway) dialTCP(ctx context.Context, addr string) (*grpc.ClientConn, error) {
 	security := grpc.WithInsecure()
-	if len(g.cfg.remoteCert) > 0 {
-		creds, err := credentials.NewClientTLSFromFile(g.cfg.remoteCert, "")
+	if len(g.remoteCert) > 0 {
+		creds, err := credentials.NewClientTLSFromFile(g.remoteCert, "")
 		if err != nil {
 			return nil, err
 		}
@@ -218,7 +245,7 @@ func (g *Gateway) dialTCP(ctx context.Context, addr string) (*grpc.ClientConn, e
 	}
 	opts := []grpc.DialOption{
 		security,
-		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
+		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.maxCallRecvMsgSize))),
 	}
 
 	return grpc.DialContext(ctx, addr, opts...)
@@ -239,16 +266,16 @@ func (g *Gateway) dialUnix(ctx context.Context, addr string) (*grpc.ClientConn,
 	opts := []grpc.DialOption{
 		grpc.WithInsecure(),
 		grpc.WithContextDialer(f),
-		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.cfg.maxCallRecvMsgSize))),
+		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(int(g.maxCallRecvMsgSize))),
 	}
 	return grpc.DialContext(ctx, addr, opts...)
 }
 
 func (g *Gateway) registerApiMiddleware() {
-	g.proxy = &apimiddleware.ApiProxyMiddleware{
-		GatewayAddress:  g.cfg.gatewayAddr,
-		EndpointCreator: g.cfg.apiMiddlewareEndpointFactory,
+	proxy := &apimiddleware.ApiProxyMiddleware{
+		GatewayAddress:  g.gatewayAddr,
+		EndpointCreator: g.apiMiddlewareEndpointFactory,
 	}
 	log.Info("Starting API middleware")
-	g.proxy.Run(g.cfg.router)
+	proxy.Run(g.router)
 }

api/gateway/gateway_test.go

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

api/gateway/options.go

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

beacon-chain/blockchain/chain_info_test.go

@@ -56,8 +56,8 @@ func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
 	c := setupBeaconChain(t, beaconDB)
 	c.finalizedCheckpt = cp
-	c.originBlockRoot = genesisRoot
-	assert.DeepEqual(t, c.originBlockRoot[:], c.FinalizedCheckpt().Root)
+	c.genesisRoot = genesisRoot
+	assert.DeepEqual(t, c.genesisRoot[:], c.FinalizedCheckpt().Root)
 }
 
 func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
@@ -77,8 +77,8 @@ func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 	genesisRoot := [32]byte{'B'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
 	c.justifiedCheckpt = cp
-	c.originBlockRoot = genesisRoot
-	assert.DeepEqual(t, c.originBlockRoot[:], c.CurrentJustifiedCheckpt().Root)
+	c.genesisRoot = genesisRoot
+	assert.DeepEqual(t, c.genesisRoot[:], c.CurrentJustifiedCheckpt().Root)
 }
 
 func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
@@ -98,8 +98,8 @@ func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
 	c := setupBeaconChain(t, beaconDB)
 	c.prevJustifiedCheckpt = cp
-	c.originBlockRoot = genesisRoot
-	assert.DeepEqual(t, c.originBlockRoot[:], c.PreviousJustifiedCheckpt().Root)
+	c.genesisRoot = genesisRoot
+	assert.DeepEqual(t, c.genesisRoot[:], c.PreviousJustifiedCheckpt().Root)
 }
 
 func TestHeadSlot_CanRetrieve(t *testing.T) {

beacon-chain/blockchain/head.go

@@ -46,11 +46,11 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 	// Get head from the fork choice service.
 	f := s.finalizedCheckpt
 	j := s.justifiedCheckpt
-	// To get head before the first justified epoch, the fork choice will start with origin root
+	// To get head before the first justified epoch, the fork choice will start with genesis root
 	// instead of zero hashes.
 	headStartRoot := bytesutil.ToBytes32(j.Root)
 	if headStartRoot == params.BeaconConfig().ZeroHash {
-		headStartRoot = s.originBlockRoot
+		headStartRoot = s.genesisRoot
 	}
 
 	// In order to process head, fork choice store requires justified info.
@@ -244,7 +244,7 @@ func (s *Service) headBlock() block.SignedBeaconBlock {
 // It does a full copy on head state for immutability.
 // This is a lock free version.
 func (s *Service) headState(ctx context.Context) state.BeaconState {
-	_, span := trace.StartSpan(ctx, "blockChain.headState")
+	ctx, span := trace.StartSpan(ctx, "blockChain.headState")
 	defer span.End()
 
 	return s.head.state.Copy()
@@ -277,8 +277,8 @@ func (s *Service) notifyNewHeadEvent(
 	newHeadStateRoot,
 	newHeadRoot []byte,
 ) error {
-	previousDutyDependentRoot := s.originBlockRoot[:]
-	currentDutyDependentRoot := s.originBlockRoot[:]
+	previousDutyDependentRoot := s.genesisRoot[:]
+	currentDutyDependentRoot := s.genesisRoot[:]
 
 	var previousDutyEpoch types.Epoch
 	currentDutyEpoch := slots.ToEpoch(newHeadSlot)

beacon-chain/blockchain/head_test.go

@@ -158,7 +158,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			cfg: &config{
 				StateNotifier: notifier,
 			},
-			originBlockRoot: [32]byte{1},
+			genesisRoot: [32]byte{1},
 		}
 		newHeadStateRoot := [32]byte{2}
 		newHeadRoot := [32]byte{3}
@@ -174,8 +174,8 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			Block:                     newHeadRoot[:],
 			State:                     newHeadStateRoot[:],
 			EpochTransition:           false,
-			PreviousDutyDependentRoot: srv.originBlockRoot[:],
-			CurrentDutyDependentRoot:  srv.originBlockRoot[:],
+			PreviousDutyDependentRoot: srv.genesisRoot[:],
+			CurrentDutyDependentRoot:  srv.genesisRoot[:],
 		}
 		require.DeepSSZEqual(t, wanted, eventHead)
 	})
@@ -187,7 +187,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			cfg: &config{
 				StateNotifier: notifier,
 			},
-			originBlockRoot: genesisRoot,
+			genesisRoot: genesisRoot,
 		}
 		epoch1Start, err := slots.EpochStart(1)
 		require.NoError(t, err)

beacon-chain/blockchain/metrics.go

@@ -253,7 +253,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 		if err != nil {
 			return err
 		}
-	case version.Altair, version.Merge:
+	case version.Altair:
 		v, b, err = altair.InitializePrecomputeValidators(ctx, headState)
 		if err != nil {
 			return err

beacon-chain/blockchain/process_attestation.go

@@ -62,7 +62,7 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error
 	genesisTime := baseState.GenesisTime()
 
 	// Verify attestation target is from current epoch or previous epoch.
-	if err := verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {
+	if err := s.verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {
 		return err
 	}
 

beacon-chain/blockchain/process_attestation_helpers.go

@@ -61,7 +61,7 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 }
 
 // verifyAttTargetEpoch validates attestation is from the current or previous epoch.
-func verifyAttTargetEpoch(_ context.Context, genesisTime, nowTime uint64, c *ethpb.Checkpoint) error {
+func (s *Service) verifyAttTargetEpoch(_ context.Context, genesisTime, nowTime uint64, c *ethpb.Checkpoint) error {
 	currentSlot := types.Slot((nowTime - genesisTime) / params.BeaconConfig().SecondsPerSlot)
 	currentEpoch := slots.ToEpoch(currentSlot)
 	var prevEpoch types.Epoch

beacon-chain/blockchain/process_attestation_test.go

@@ -266,22 +266,34 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	ctx := context.Background()
 
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
-	require.NoError(t, verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)}))
+	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)}))
 }
 
 func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 	ctx := context.Background()
 
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
-	require.NoError(t, verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
+	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
 }
 
 func TestAttEpoch_NotMatch(t *testing.T) {
 	ctx := context.Background()
 
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
 	nowTime := 2 * uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
-	err := verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)})
+	err = service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)})
 	assert.ErrorContains(t, "target epoch 0 does not match current epoch 2 or prev epoch 1", err)
 }
 

beacon-chain/blockchain/process_block.go

@@ -260,12 +260,12 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 
 	jCheckpoints := make([]*ethpb.Checkpoint, len(blks))
 	fCheckpoints := make([]*ethpb.Checkpoint, len(blks))
-	sigSet := &bls.SignatureBatch{
+	sigSet := &bls.SignatureSet{
 		Signatures: [][]byte{},
 		PublicKeys: []bls.PublicKey{},
 		Messages:   [][32]byte{},
 	}
-	var set *bls.SignatureBatch
+	var set *bls.SignatureSet
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
 		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)

beacon-chain/blockchain/process_block_helpers.go

@@ -439,7 +439,7 @@ func (s *Service) deletePoolAtts(atts []*ethpb.Attestation) error {
 // fork choice justification routine.
 func (s *Service) ensureRootNotZeros(root [32]byte) [32]byte {
 	if root == params.BeaconConfig().ZeroHash {
-		return s.originBlockRoot
+		return s.genesisRoot
 	}
 	return root
 }

beacon-chain/blockchain/process_block_test.go

@@ -186,8 +186,8 @@ func TestStore_OnBlockBatch(t *testing.T) {
 
 func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	ctx := context.Background()
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MinimalSpecConfig())
+	params.UseMinimalConfig()
+	defer params.UseMainnetConfig()
 
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
@@ -219,8 +219,8 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 
 func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	ctx := context.Background()
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MinimalSpecConfig())
+	params.UseMinimalConfig()
+	defer params.UseMainnetConfig()
 
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
@@ -733,10 +733,10 @@ func TestEnsureRootNotZeroHashes(t *testing.T) {
 	opts := testServiceOptsNoDB()
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.originBlockRoot = [32]byte{'a'}
+	service.genesisRoot = [32]byte{'a'}
 
 	r := service.ensureRootNotZeros(params.BeaconConfig().ZeroHash)
-	assert.Equal(t, service.originBlockRoot, r, "Did not get wanted justified root")
+	assert.Equal(t, service.genesisRoot, r, "Did not get wanted justified root")
 	root := [32]byte{'b'}
 	r = service.ensureRootNotZeros(root)
 	assert.Equal(t, root, r, "Did not get wanted justified root")
@@ -917,7 +917,7 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: gRoot[:]}))
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, beaconState, gRoot))
-	service.originBlockRoot = gRoot
+	service.genesisRoot = gRoot
 	currentCp := &ethpb.Checkpoint{Epoch: 1}
 	service.justifiedCheckpt = currentCp
 	newCp := &ethpb.Checkpoint{Epoch: 2, Root: gRoot[:]}

beacon-chain/blockchain/receive_attestation.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -104,56 +103,45 @@ func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) e
 }
 
 // This routine processes fork choice attestations from the pool to account for validator votes and fork choice.
-func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
+func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan<- struct{}) {
 	// Wait for state to be initialized.
 	stateChannel := make(chan *feed.Event, 1)
-	stateSub := stateFeed.Subscribe(stateChannel)
-	go func() {
+	stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
+	subscribedToStateEvents <- struct{}{}
+	<-stateChannel
+	stateSub.Unsubscribe()
+
+	if s.genesisTime.IsZero() {
+		log.Warn("ProcessAttestations routine waiting for genesis time")
+		for s.genesisTime.IsZero() {
+			time.Sleep(1 * time.Second)
+		}
+		log.Warn("Genesis time received, now available to process attestations")
+	}
+
+	st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+	for {
 		select {
 		case <-s.ctx.Done():
-			stateSub.Unsubscribe()
 			return
-		case <-stateChannel:
-			stateSub.Unsubscribe()
-			break
-		}
-
-		if s.genesisTime.IsZero() {
-			log.Warn("ProcessAttestations routine waiting for genesis time")
-			for s.genesisTime.IsZero() {
-				if err := s.ctx.Err(); err != nil {
-					log.WithError(err).Error("Giving up waiting for genesis time")
-					return
-				}
-				time.Sleep(1 * time.Second)
+		case <-st.C():
+			// Continue when there's no fork choice attestation, there's nothing to process and update head.
+			// This covers the condition when the node is still initial syncing to the head of the chain.
+			if s.cfg.AttPool.ForkchoiceAttestationCount() == 0 {
+				continue
 			}
-			log.Warn("Genesis time received, now available to process attestations")
-		}
+			s.processAttestations(s.ctx)
 
-		st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
-		for {
-			select {
-			case <-s.ctx.Done():
-				return
-			case <-st.C():
-				// Continue when there's no fork choice attestation, there's nothing to process and update head.
-				// This covers the condition when the node is still initial syncing to the head of the chain.
-				if s.cfg.AttPool.ForkchoiceAttestationCount() == 0 {
-					continue
-				}
-				s.processAttestations(s.ctx)
-
-				balances, err := s.justifiedBalances.get(s.ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
-				if err != nil {
-					log.WithError(err).Errorf("Unable to get justified balances for root %v", s.justifiedCheckpt.Root)
-					continue
-				}
-				if err := s.updateHead(s.ctx, balances); err != nil {
-					log.WithError(err).Warn("Resolving fork due to new attestation")
-				}
+			balances, err := s.justifiedBalances.get(s.ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+			if err != nil {
+				log.Errorf("Unable to get justified balances for root %v w/ error %s", s.justifiedCheckpt.Root, err)
+				continue
+			}
+			if err := s.updateHead(s.ctx, balances); err != nil {
+				log.Warnf("Resolving fork due to new attestation: %v", err)
 			}
 		}
-	}()
+	}
 }
 
 // This processes fork choice attestations from the pool to account for validator votes and fork choice.

beacon-chain/blockchain/receive_block_test.go

@@ -33,7 +33,6 @@ func TestService_ReceiveBlock(t *testing.T) {
 		assert.NoError(t, err)
 		return blk
 	}
-	params.SetupTestConfigCleanup(t)
 	bc := params.BeaconConfig()
 	bc.ShardCommitteePeriod = 0 // Required for voluntary exits test in reasonable time.
 	params.OverrideBeaconConfig(bc)

beacon-chain/blockchain/service.go

@@ -33,7 +33,6 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	prysmTime "github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -46,14 +45,13 @@ const headSyncMinEpochsAfterCheckpoint = 128
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg         *config
-	ctx         context.Context
-	cancel      context.CancelFunc
-	genesisTime time.Time
-	head        *head
-	headLock    sync.RWMutex
-	// originBlockRoot is the genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	originBlockRoot       [32]byte
+	cfg                   *config
+	ctx                   context.Context
+	cancel                context.CancelFunc
+	genesisTime           time.Time
+	head                  *head
+	headLock              sync.RWMutex
+	genesisRoot           [32]byte
 	justifiedCheckpt      *ethpb.Checkpoint
 	prevJustifiedCheckpt  *ethpb.Checkpoint
 	bestJustifiedCheckpt  *ethpb.Checkpoint
@@ -122,17 +120,179 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 
 // Start a blockchain service's main event loop.
 func (s *Service) Start() {
-	saved := s.cfg.FinalizedStateAtStartUp
+	beaconState := s.cfg.FinalizedStateAtStartUp
 
-	if saved != nil && !saved.IsNil() {
-		if err := s.startFromSavedState(saved); err != nil {
-			log.Fatal(err)
+	// Make sure that attestation processor is subscribed and ready for state initializing event.
+	attestationProcessorSubscribed := make(chan struct{}, 1)
+
+	// If the chain has already been initialized, simply start the block processing routine.
+	if beaconState != nil && !beaconState.IsNil() {
+		log.Info("Blockchain data already exists in DB, initializing...")
+		s.genesisTime = time.Unix(int64(beaconState.GenesisTime()), 0)
+		s.cfg.AttService.SetGenesisTime(beaconState.GenesisTime())
+		if err := s.initializeChainInfo(s.ctx); err != nil {
+			log.Fatalf("Could not set up chain info: %v", err)
 		}
+
+		// We start a counter to genesis, if needed.
+		gState, err := s.cfg.BeaconDB.GenesisState(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not retrieve genesis state: %v", err)
+		}
+		gRoot, err := gState.HashTreeRoot(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not hash tree root genesis state: %v", err)
+		}
+		go slots.CountdownToGenesis(s.ctx, s.genesisTime, uint64(gState.NumValidators()), gRoot)
+
+		justifiedCheckpoint, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not get justified checkpoint: %v", err)
+		}
+		finalizedCheckpoint, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
+		if err != nil {
+			log.Fatalf("Could not get finalized checkpoint: %v", err)
+		}
+
+		// Resume fork choice.
+		s.justifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		s.finalizedCheckpt = ethpb.CopyCheckpoint(finalizedCheckpoint)
+		s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(finalizedCheckpoint)
+		s.resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint)
+
+		ss, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+		if err != nil {
+			log.Fatalf("Could not get start slot of finalized epoch: %v", err)
+		}
+		h := s.headBlock().Block()
+		if h.Slot() > ss {
+			log.WithFields(logrus.Fields{
+				"startSlot": ss,
+				"endSlot":   h.Slot(),
+			}).Info("Loading blocks to fork choice store, this may take a while.")
+			if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, s.finalizedCheckpt, s.justifiedCheckpt); err != nil {
+				log.Fatalf("Could not fill in fork choice store missing blocks: %v", err)
+			}
+		}
+
+		// not attempting to save initial sync blocks here, because there shouldn't be until
+		// after the statefeed.Initialized event is fired (below)
+		if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, s.finalizedCheckpt.Epoch); err != nil {
+			// Exit run time if the node failed to verify weak subjectivity checkpoint.
+			log.Fatalf("could not verify initial checkpoint provided for chain sync, with err=: %v", err)
+		}
+
+		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+			Type: statefeed.Initialized,
+			Data: &statefeed.InitializedData{
+				StartTime:             s.genesisTime,
+				GenesisValidatorsRoot: beaconState.GenesisValidatorRoot(),
+			},
+		})
 	} else {
-		if err := s.startFromPOWChain(); err != nil {
-			log.Fatal(err)
+		log.Info("Waiting to reach the validator deposit threshold to start the beacon chain...")
+		if s.cfg.ChainStartFetcher == nil {
+			log.Fatal("Not configured web3Service for POW chain")
+			return // return need for TestStartUninitializedChainWithoutConfigPOWChain.
 		}
+		go func() {
+			stateChannel := make(chan *feed.Event, 1)
+			stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
+			defer stateSub.Unsubscribe()
+			<-attestationProcessorSubscribed
+			for {
+				select {
+				case event := <-stateChannel:
+					if event.Type == statefeed.ChainStarted {
+						data, ok := event.Data.(*statefeed.ChainStartedData)
+						if !ok {
+							log.Error("event data is not type *statefeed.ChainStartedData")
+							return
+						}
+						log.WithField("starttime", data.StartTime).Debug("Received chain start event")
+						s.processChainStartTime(s.ctx, data.StartTime)
+						return
+					}
+				case <-s.ctx.Done():
+					log.Debug("Context closed, exiting goroutine")
+					return
+				case err := <-stateSub.Err():
+					log.WithError(err).Error("Subscription to state notifier failed")
+					return
+				}
+			}
+		}()
 	}
+
+	go s.processAttestationsRoutine(attestationProcessorSubscribed)
+}
+
+// processChainStartTime initializes a series of deposits from the ChainStart deposits in the eth1
+// deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
+func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Time) {
+	preGenesisState := s.cfg.ChainStartFetcher.PreGenesisState()
+	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.cfg.ChainStartFetcher.ChainStartEth1Data())
+	if err != nil {
+		log.Fatalf("Could not initialize beacon chain: %v", err)
+	}
+	// We start a counter to genesis, if needed.
+	gRoot, err := initializedState.HashTreeRoot(s.ctx)
+	if err != nil {
+		log.Fatalf("Could not hash tree root genesis state: %v", err)
+	}
+	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
+
+	// We send out a state initialized event to the rest of the services
+	// running in the beacon node.
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.Initialized,
+		Data: &statefeed.InitializedData{
+			StartTime:             genesisTime,
+			GenesisValidatorsRoot: initializedState.GenesisValidatorRoot(),
+		},
+	})
+}
+
+// initializes the state and genesis block of the beacon chain to persistent storage
+// based on a genesis timestamp value obtained from the ChainStart event emitted
+// by the ETH1.0 Deposit Contract and the POWChain service of the node.
+func (s *Service) initializeBeaconChain(
+	ctx context.Context,
+	genesisTime time.Time,
+	preGenesisState state.BeaconState,
+	eth1data *ethpb.Eth1Data) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.Service.initializeBeaconChain")
+	defer span.End()
+	s.genesisTime = genesisTime
+	unixTime := uint64(genesisTime.Unix())
+
+	genesisState, err := transition.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not initialize genesis state")
+	}
+
+	if err := s.saveGenesisData(ctx, genesisState); err != nil {
+		return nil, errors.Wrap(err, "could not save genesis data")
+	}
+
+	log.Info("Initialized beacon chain genesis state")
+
+	// Clear out all pre-genesis data now that the state is initialized.
+	s.cfg.ChainStartFetcher.ClearPreGenesisData()
+
+	// Update committee shuffled indices for genesis epoch.
+	if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
+		return nil, err
+	}
+	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState); err != nil {
+		return nil, err
+	}
+
+	s.cfg.AttService.SetGenesisTime(genesisState.GenesisTime())
+
+	return genesisState, nil
 }
 
 // Stop the blockchain service's main event loop and associated goroutines.
@@ -152,7 +312,7 @@ func (s *Service) Stop() error {
 // Status always returns nil unless there is an error condition that causes
 // this service to be unhealthy.
 func (s *Service) Status() error {
-	if s.originBlockRoot == params.BeaconConfig().ZeroHash {
+	if s.genesisRoot == params.BeaconConfig().ZeroHash {
 		return errors.New("genesis state has not been created")
 	}
 	if runtime.NumGoroutine() > s.cfg.MaxRoutines {
@@ -161,105 +321,61 @@ func (s *Service) Status() error {
 	return nil
 }
 
-func (s *Service) startFromSavedState(saved state.BeaconState) error {
-	log.Info("Blockchain data already exists in DB, initializing...")
-	s.genesisTime = time.Unix(int64(saved.GenesisTime()), 0)
-	s.cfg.AttService.SetGenesisTime(saved.GenesisTime())
-
-	originRoot, err := s.originRootFromSavedState(s.ctx)
+// This gets called when beacon chain is first initialized to save genesis data (state, block, and more) in db.
+func (s *Service) saveGenesisData(ctx context.Context, genesisState state.BeaconState) error {
+	if err := s.cfg.BeaconDB.SaveGenesisData(ctx, genesisState); err != nil {
+		return errors.Wrap(err, "could not save genesis data")
+	}
+	genesisBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
+	if err != nil || genesisBlk == nil || genesisBlk.IsNil() {
+		return fmt.Errorf("could not load genesis block: %v", err)
+	}
+	genesisBlkRoot, err := genesisBlk.Block().HashTreeRoot()
 	if err != nil {
-		return err
-	}
-	s.originBlockRoot = originRoot
-
-	if err := s.initializeHeadFromDB(s.ctx); err != nil {
-		return errors.Wrap(err, "could not set up chain info")
-	}
-	spawnCountdownIfPreGenesis(s.ctx, s.genesisTime, s.cfg.BeaconDB)
-
-	justified, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get justified checkpoint")
-	}
-	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(justified)
-	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(justified)
-	s.justifiedCheckpt = ethpb.CopyCheckpoint(justified)
-
-	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint")
-	}
-	s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(finalized)
-	s.finalizedCheckpt = ethpb.CopyCheckpoint(finalized)
-
-	store := protoarray.New(justified.Epoch, finalized.Epoch, bytesutil.ToBytes32(finalized.Root))
-	s.cfg.ForkChoiceStore = store
-
-	ss, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
-	if err != nil {
-		return errors.Wrap(err, "could not get start slot of finalized epoch")
-	}
-	h := s.headBlock().Block()
-	if h.Slot() > ss {
-		log.WithFields(logrus.Fields{
-			"startSlot": ss,
-			"endSlot":   h.Slot(),
-		}).Info("Loading blocks to fork choice store, this may take a while.")
-		if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, s.finalizedCheckpt, s.justifiedCheckpt); err != nil {
-			return errors.Wrap(err, "could not fill in fork choice store missing blocks")
-		}
+		return errors.Wrap(err, "could not get genesis block root")
 	}
 
-	// not attempting to save initial sync blocks here, because there shouldn't be any until
-	// after the statefeed.Initialized event is fired (below)
-	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, s.finalizedCheckpt.Epoch); err != nil {
-		// Exit run time if the node failed to verify weak subjectivity checkpoint.
-		return errors.Wrap(err, "could not verify initial checkpoint provided for chain sync")
+	s.genesisRoot = genesisBlkRoot
+	s.cfg.StateGen.SaveFinalizedState(0 /*slot*/, genesisBlkRoot, genesisState)
+
+	// Finalized checkpoint at genesis is a zero hash.
+	genesisCheckpoint := genesisState.FinalizedCheckpoint()
+
+	s.justifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.finalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+
+	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
+		genesisBlk.Block().Slot(),
+		genesisBlkRoot,
+		params.BeaconConfig().ZeroHash,
+		[32]byte{},
+		genesisCheckpoint.Epoch,
+		genesisCheckpoint.Epoch); err != nil {
+		log.Fatalf("Could not process genesis block for fork choice: %v", err)
 	}
 
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.Initialized,
-		Data: &statefeed.InitializedData{
-			StartTime:             s.genesisTime,
-			GenesisValidatorsRoot: saved.GenesisValidatorRoot(),
-		},
-	})
-
-	s.spawnProcessAttestationsRoutine(s.cfg.StateNotifier.StateFeed())
-
+	s.setHead(genesisBlkRoot, genesisBlk, genesisState)
 	return nil
 }
 
-func (s *Service) originRootFromSavedState(ctx context.Context) ([32]byte, error) {
-	// first check if we have started from checkpoint sync and have a root
-	originRoot, err := s.cfg.BeaconDB.OriginCheckpointBlockRoot(ctx)
-	if err == nil {
-		return originRoot, nil
-	}
-	if !errors.Is(err, db.ErrNotFound) {
-		return originRoot, errors.Wrap(err, "could not retrieve checkpoint sync chain origin data from db")
-	}
-
-	// we got here because OriginCheckpointBlockRoot gave us an ErrNotFound. this means the node was started from a genesis state,
-	// so we should have a value for GenesisBlock
+// This gets called to initialize chain info variables using the finalized checkpoint stored in DB
+func (s *Service) initializeChainInfo(ctx context.Context) error {
 	genesisBlock, err := s.cfg.BeaconDB.GenesisBlock(ctx)
 	if err != nil {
-		return originRoot, errors.Wrap(err, "could not get genesis block from db")
+		return errors.Wrap(err, "could not get genesis block from db")
 	}
 	if err := helpers.BeaconBlockIsNil(genesisBlock); err != nil {
-		return originRoot, err
+		return err
 	}
 	genesisBlkRoot, err := genesisBlock.Block().HashTreeRoot()
 	if err != nil {
-		return genesisBlkRoot, errors.Wrap(err, "could not get signing root of genesis block")
+		return errors.Wrap(err, "could not get signing root of genesis block")
 	}
-	return genesisBlkRoot, nil
-}
+	s.genesisRoot = genesisBlkRoot
 
-// initializeHeadFromDB uses the finalized checkpoint and head block found in the database to set the current head
-// note that this may block until stategen replays blocks between the finalized and head blocks
-// if the head sync flag was specified and the gap between the finalized and head blocks is at least 128 epochs long
-func (s *Service) initializeHeadFromDB(ctx context.Context) error {
 	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint from db")
@@ -326,146 +442,11 @@ func (s *Service) initializeHeadFromDB(ctx context.Context) error {
 	return nil
 }
 
-func (s *Service) startFromPOWChain() error {
-	log.Info("Waiting to reach the validator deposit threshold to start the beacon chain...")
-	if s.cfg.ChainStartFetcher == nil {
-		return errors.New("not configured web3Service for POW chain")
-	}
-	go func() {
-		stateChannel := make(chan *feed.Event, 1)
-		stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
-		defer stateSub.Unsubscribe()
-		s.spawnProcessAttestationsRoutine(s.cfg.StateNotifier.StateFeed())
-		for {
-			select {
-			case event := <-stateChannel:
-				if event.Type == statefeed.ChainStarted {
-					data, ok := event.Data.(*statefeed.ChainStartedData)
-					if !ok {
-						log.Error("event data is not type *statefeed.ChainStartedData")
-						return
-					}
-					log.WithField("starttime", data.StartTime).Debug("Received chain start event")
-					s.onPowchainStart(s.ctx, data.StartTime)
-					return
-				}
-			case <-s.ctx.Done():
-				log.Debug("Context closed, exiting goroutine")
-				return
-			case err := <-stateSub.Err():
-				log.WithError(err).Error("Subscription to state notifier failed")
-				return
-			}
-		}
-	}()
-
-	return nil
-}
-
-// onPowchainStart initializes a series of deposits from the ChainStart deposits in the eth1
-// deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
-func (s *Service) onPowchainStart(ctx context.Context, genesisTime time.Time) {
-	preGenesisState := s.cfg.ChainStartFetcher.PreGenesisState()
-	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.cfg.ChainStartFetcher.ChainStartEth1Data())
-	if err != nil {
-		log.Fatalf("Could not initialize beacon chain: %v", err)
-	}
-	// We start a counter to genesis, if needed.
-	gRoot, err := initializedState.HashTreeRoot(s.ctx)
-	if err != nil {
-		log.Fatalf("Could not hash tree root genesis state: %v", err)
-	}
-	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
-
-	// We send out a state initialized event to the rest of the services
-	// running in the beacon node.
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.Initialized,
-		Data: &statefeed.InitializedData{
-			StartTime:             genesisTime,
-			GenesisValidatorsRoot: initializedState.GenesisValidatorRoot(),
-		},
-	})
-}
-
-// initializes the state and genesis block of the beacon chain to persistent storage
-// based on a genesis timestamp value obtained from the ChainStart event emitted
-// by the ETH1.0 Deposit Contract and the POWChain service of the node.
-func (s *Service) initializeBeaconChain(
-	ctx context.Context,
-	genesisTime time.Time,
-	preGenesisState state.BeaconState,
-	eth1data *ethpb.Eth1Data) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "beacon-chain.Service.initializeBeaconChain")
-	defer span.End()
-	s.genesisTime = genesisTime
-	unixTime := uint64(genesisTime.Unix())
-
-	genesisState, err := transition.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not initialize genesis state")
-	}
-
-	if err := s.saveGenesisData(ctx, genesisState); err != nil {
-		return nil, errors.Wrap(err, "could not save genesis data")
-	}
-
-	log.Info("Initialized beacon chain genesis state")
-
-	// Clear out all pre-genesis data now that the state is initialized.
-	s.cfg.ChainStartFetcher.ClearPreGenesisData()
-
-	// Update committee shuffled indices for genesis epoch.
-	if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
-		return nil, err
-	}
-	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState); err != nil {
-		return nil, err
-	}
-
-	s.cfg.AttService.SetGenesisTime(genesisState.GenesisTime())
-
-	return genesisState, nil
-}
-
-// This gets called when beacon chain is first initialized to save genesis data (state, block, and more) in db.
-func (s *Service) saveGenesisData(ctx context.Context, genesisState state.BeaconState) error {
-	if err := s.cfg.BeaconDB.SaveGenesisData(ctx, genesisState); err != nil {
-		return errors.Wrap(err, "could not save genesis data")
-	}
-	genesisBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
-	if err != nil || genesisBlk == nil || genesisBlk.IsNil() {
-		return fmt.Errorf("could not load genesis block: %v", err)
-	}
-	genesisBlkRoot, err := genesisBlk.Block().HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not get genesis block root")
-	}
-
-	s.originBlockRoot = genesisBlkRoot
-	s.cfg.StateGen.SaveFinalizedState(0 /*slot*/, genesisBlkRoot, genesisState)
-
-	// Finalized checkpoint at genesis is a zero hash.
-	genesisCheckpoint := genesisState.FinalizedCheckpoint()
-
-	s.justifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.finalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-
-	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
-		genesisBlk.Block().Slot(),
-		genesisBlkRoot,
-		params.BeaconConfig().ZeroHash,
-		[32]byte{},
-		genesisCheckpoint.Epoch,
-		genesisCheckpoint.Epoch); err != nil {
-		log.Fatalf("Could not process genesis block for fork choice: %v", err)
-	}
-
-	s.setHead(genesisBlkRoot, genesisBlk, genesisState)
-	return nil
+// This is called when a client starts from non-genesis slot. This passes last justified and finalized
+// information to fork choice service to initializes fork choice store.
+func (s *Service) resumeForkChoice(justifiedCheckpoint, finalizedCheckpoint *ethpb.Checkpoint) {
+	store := protoarray.New(justifiedCheckpoint.Epoch, finalizedCheckpoint.Epoch, bytesutil.ToBytes32(finalizedCheckpoint.Root))
+	s.cfg.ForkChoiceStore = store
 }
 
 // This returns true if block has been processed before. Two ways to verify the block has been processed:
@@ -479,20 +460,3 @@ func (s *Service) hasBlock(ctx context.Context, root [32]byte) bool {
 
 	return s.cfg.BeaconDB.HasBlock(ctx, root)
 }
-
-func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db db.HeadAccessDatabase) {
-	currentTime := prysmTime.Now()
-	if currentTime.After(genesisTime) {
-		return
-	}
-
-	gState, err := db.GenesisState(ctx)
-	if err != nil {
-		log.Fatalf("Could not retrieve genesis state: %v", err)
-	}
-	gRoot, err := gState.HashTreeRoot(ctx)
-	if err != nil {
-		log.Fatalf("Could not hash tree root genesis state: %v", err)
-	}
-	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
-}

beacon-chain/blockchain/service_test.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/async/event"
-	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
@@ -284,11 +283,9 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
-	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
-	require.NoError(t, err)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stategen.New(beaconDB)), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
-	require.NoError(t, err)
-	require.NoError(t, c.startFromSavedState(headState))
+	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
+	c.cfg.FinalizedStateAtStartUp = headState
+	require.NoError(t, c.initializeChainInfo(ctx))
 	headBlk, err := c.HeadBlock(ctx)
 	require.NoError(t, err)
 	assert.DeepEqual(t, headBlock, headBlk.Proto(), "Head block incorrect")
@@ -301,7 +298,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	if !bytes.Equal(headRoot[:], r) {
 		t.Error("head slot incorrect")
 	}
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 }
 
 func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
@@ -327,15 +324,12 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
-	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
-	require.NoError(t, err)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stategen.New(beaconDB)), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}))
-	require.NoError(t, err)
-	require.NoError(t, c.startFromSavedState(headState))
+	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
+	require.NoError(t, c.initializeChainInfo(ctx))
 	s, err := c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 	assert.DeepEqual(t, genesis, c.head.block.Proto())
 }
 
@@ -387,15 +381,13 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 		Root:  finalizedRoot[:],
 	}))
 
-	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
-	require.NoError(t, err)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stategen.New(beaconDB)), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
-	require.NoError(t, err)
-	require.NoError(t, c.startFromSavedState(headState))
+	c := &Service{cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}}
+	c.cfg.FinalizedStateAtStartUp = headState
+	require.NoError(t, c.initializeChainInfo(ctx))
 	s, err := c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 	// Since head sync is not triggered, chain is initialized to the last finalization checkpoint.
 	assert.DeepEqual(t, finalizedBlock, c.head.block.Proto())
 	assert.LogsContain(t, hook, "resetting head from the checkpoint ('--head-sync' flag is ignored)")
@@ -412,11 +404,11 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
 
 	hook.Reset()
-	require.NoError(t, c.initializeHeadFromDB(ctx))
+	require.NoError(t, c.initializeChainInfo(ctx))
 	s, err = c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
-	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
+	assert.Equal(t, genesisRoot, c.genesisRoot, "Genesis block root incorrect")
 	// Head slot is far beyond the latest finalized checkpoint, head sync is triggered.
 	assert.DeepEqual(t, headBlock, c.head.block.Proto())
 	assert.LogsContain(t, hook, "Regenerating state from the last checkpoint at slot 225")
@@ -486,7 +478,7 @@ func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
 	stateChannel := make(chan *feed.Event, 1)
 	stateSub := service.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
 	defer stateSub.Unsubscribe()
-	service.onPowchainStart(context.Background(), time.Now())
+	service.processChainStartTime(context.Background(), time.Now())
 
 	stateEvent := <-stateChannel
 	require.Equal(t, int(stateEvent.Type), statefeed.Initialized)

beacon-chain/blockchain/state_balance_cache.go

@@ -28,7 +28,7 @@ type stateByRooter interface {
 // to avoid nil pointer bugs when updating the cache in the read path (get())
 func newStateBalanceCache(sg *stategen.State) (*stateBalanceCache, error) {
 	if sg == nil {
-		return nil, errors.New("can't initialize state balance cache without stategen")
+		return nil, errors.New("Can't initialize state balance cache without stategen")
 	}
 	return &stateBalanceCache{stateGen: sg}, nil
 }

beacon-chain/blockchain/testing/mock.go

@@ -285,12 +285,12 @@ func (s *ChainService) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
 }
 
 // ReceiveAttestation mocks ReceiveAttestation method in chain service.
-func (_ *ChainService) ReceiveAttestation(_ context.Context, _ *ethpb.Attestation) error {
+func (s *ChainService) ReceiveAttestation(_ context.Context, _ *ethpb.Attestation) error {
 	return nil
 }
 
 // ReceiveAttestationNoPubsub mocks ReceiveAttestationNoPubsub method in chain service.
-func (_ *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attestation) error {
+func (s *ChainService) ReceiveAttestationNoPubsub(context.Context, *ethpb.Attestation) error {
 	return nil
 }
 
@@ -369,7 +369,7 @@ func (s *ChainService) HasInitSyncBlock(rt [32]byte) bool {
 }
 
 // HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
-func (_ *ChainService) HeadGenesisValidatorRoot() [32]byte {
+func (s *ChainService) HeadGenesisValidatorRoot() [32]byte {
 	return [32]byte{}
 }
 
@@ -379,7 +379,7 @@ func (s *ChainService) VerifyBlkDescendant(_ context.Context, _ [32]byte) error
 }
 
 // VerifyLmdFfgConsistency mocks VerifyLmdFfgConsistency and always returns nil.
-func (_ *ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
+func (s *ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
 	if !bytes.Equal(a.Data.BeaconBlockRoot, a.Data.Target.Root) {
 		return errors.New("LMD and FFG miss matched")
 	}
@@ -395,7 +395,7 @@ func (s *ChainService) VerifyFinalizedConsistency(_ context.Context, r []byte) e
 }
 
 // ChainHeads mocks ChainHeads and always return nil.
-func (_ *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
+func (s *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
 	return [][32]byte{
 			bytesutil.ToBytes32(bytesutil.PadTo([]byte("foo"), 32)),
 			bytesutil.ToBytes32(bytesutil.PadTo([]byte("bar"), 32)),
@@ -404,7 +404,7 @@ func (_ *ChainService) ChainHeads() ([][32]byte, []types.Slot) {
 }
 
 // HeadPublicKeyToValidatorIndex mocks HeadPublicKeyToValidatorIndex and always return 0 and true.
-func (_ *ChainService) HeadPublicKeyToValidatorIndex(_ context.Context, _ [48]byte) (types.ValidatorIndex, bool) {
+func (s *ChainService) HeadPublicKeyToValidatorIndex(_ context.Context, _ [48]byte) (types.ValidatorIndex, bool) {
 	return 0, true
 }
 

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -36,7 +36,6 @@ func NewWeakSubjectivityVerifier(wsc *ethpb.Checkpoint, db weakSubjectivityDB) (
 	// per 7342, a nil checkpoint, zero-root or zero-epoch should all fail validation
 	// and return an error instead of creating a WeakSubjectivityVerifier that permits any chain history.
 	if wsc == nil || len(wsc.Root) == 0 || wsc.Epoch == 0 {
-		log.Warn("no valid weak subjectivity checkpoint specified, running without weak subjectivity verification")
 		return &WeakSubjectivityVerifier{
 			enabled: false,
 		}, nil
@@ -82,7 +81,6 @@ func (v *WeakSubjectivityVerifier) VerifyWeakSubjectivity(ctx context.Context, f
 	}
 	filter := filters.NewFilter().SetStartSlot(v.slot).SetEndSlot(v.slot + params.BeaconConfig().SlotsPerEpoch)
 	// A node should have the weak subjectivity block corresponds to the correct epoch in the DB.
-	log.Infof("searching block roots index for weak subjectivity root=%#x", v.root)
 	roots, err := v.db.BlockRoots(ctx, filter)
 	if err != nil {
 		return errors.Wrap(err, "error while retrieving block roots to verify weak subjectivity")

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -2,13 +2,12 @@ package blockchain
 
 import (
 	"context"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/time/slots"
 	"testing"
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -19,55 +18,52 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	b := util.NewBeaconBlock()
-	b.Block.Slot = 1792480
-	blockEpoch := slots.ToEpoch(b.Block.Slot)
+	b.Block.Slot = 32
 	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	tests := []struct {
 		wsVerified     bool
-		disabled       bool
 		wantErr        error
 		checkpt        *ethpb.Checkpoint
 		finalizedEpoch types.Epoch
 		name           string
 	}{
 		{
-			name:     "nil root and epoch",
-			disabled: true,
+			name: "nil root and epoch",
+		},
+		{
+			name:           "already verified",
+			checkpt:        &ethpb.Checkpoint{Epoch: 2},
+			finalizedEpoch: 2,
+			wsVerified:     true,
 		},
 		{
 			name:           "not yet to verify, ws epoch higher than finalized epoch",
-			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, 32), Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch - 1,
+			checkpt:        &ethpb.Checkpoint{Epoch: 2},
+			finalizedEpoch: 1,
 		},
 		{
 			name:           "can't find the block in DB",
 			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, 32), Epoch: 1},
-			finalizedEpoch: blockEpoch + 1,
+			finalizedEpoch: 3,
 			wantErr:        errWSBlockNotFound,
 		},
 		{
 			name:           "can't find the block corresponds to ws epoch in DB",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch - 2}, // Root belongs in epoch 1.
-			finalizedEpoch: blockEpoch - 1,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 2}, // Root belongs in epoch 1.
+			finalizedEpoch: 3,
 			wantErr:        errWSBlockNotFoundInEpoch,
 		},
 		{
 			name:           "can verify and pass",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch + 1,
-		},
-		{
-			name:           "equal epoch",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 1},
+			finalizedEpoch: 3,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			wv, err := NewWeakSubjectivityVerifier(tt.checkpt, beaconDB)
-			require.Equal(t, !tt.disabled, wv.enabled)
 			require.NoError(t, err)
 			s := &Service{
 				cfg:              &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt},

beacon-chain/cache/depositcache/deposits_cache.go

@@ -17,6 +17,7 @@ import (
 	"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/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -49,10 +50,10 @@ type FinalizedDeposits struct {
 // stores all the deposit related data that is required by the beacon-node.
 type DepositCache struct {
 	// Beacon chain deposits in memory.
-	pendingDeposits   []*ethpb.DepositContainer
-	deposits          []*ethpb.DepositContainer
+	pendingDeposits   []*dbpb.DepositContainer
+	deposits          []*dbpb.DepositContainer
 	finalizedDeposits *FinalizedDeposits
-	depositsByKey     map[[48]byte][]*ethpb.DepositContainer
+	depositsByKey     map[[48]byte][]*dbpb.DepositContainer
 	depositsLock      sync.RWMutex
 }
 
@@ -66,8 +67,8 @@ func New() (*DepositCache, error) {
 	// finalizedDeposits.MerkleTrieIndex is initialized to -1 because it represents the index of the last trie item.
 	// Inserting the first item into the trie will set the value of the index to 0.
 	return &DepositCache{
-		pendingDeposits:   []*ethpb.DepositContainer{},
-		deposits:          []*ethpb.DepositContainer{},
+		pendingDeposits:   []*dbpb.DepositContainer{},
+		deposits:          []*dbpb.DepositContainer{},
 		depositsByKey:     map[[48]byte][]*ethpb.DepositContainer{},
 		finalizedDeposits: &FinalizedDeposits{Deposits: finalizedDepositsTrie, MerkleTrieIndex: -1},
 	}, nil
@@ -76,7 +77,7 @@ func New() (*DepositCache, error) {
 // InsertDeposit into the database. If deposit or block number are nil
 // then this method does nothing.
 func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertDeposit")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertDeposit")
 	defer span.End()
 	if d == nil {
 		log.WithFields(logrus.Fields{
@@ -95,9 +96,9 @@ func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blo
 	}
 	// Keep the slice sorted on insertion in order to avoid costly sorting on retrieval.
 	heightIdx := sort.Search(len(dc.deposits), func(i int) bool { return dc.deposits[i].Index >= index })
-	depCtr := &ethpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}
+	depCtr := &dbpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}
 	newDeposits := append(
-		[]*ethpb.DepositContainer{depCtr},
+		[]*dbpb.DepositContainer{depCtr},
 		dc.deposits[heightIdx:]...)
 	dc.deposits = append(dc.deposits[:heightIdx], newDeposits...)
 	// Append the deposit to our map, in the event no deposits
@@ -109,8 +110,8 @@ func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blo
 }
 
 // InsertDepositContainers inserts a set of deposit containers into our deposit cache.
-func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*ethpb.DepositContainer) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertDepositContainers")
+func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*dbpb.DepositContainer) {
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertDepositContainers")
 	defer span.End()
 	dc.depositsLock.Lock()
 	defer dc.depositsLock.Unlock()
@@ -129,7 +130,7 @@ func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*eth
 
 // InsertFinalizedDeposits inserts deposits up to eth1DepositIndex (inclusive) into the finalized deposits cache.
 func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1DepositIndex int64) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertFinalizedDeposits")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertFinalizedDeposits")
 	defer span.End()
 	dc.depositsLock.Lock()
 	defer dc.depositsLock.Unlock()
@@ -162,8 +163,8 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
 }
 
 // AllDepositContainers returns all historical deposit containers.
-func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*ethpb.DepositContainer {
-	_, span := trace.StartSpan(ctx, "DepositsCache.AllDepositContainers")
+func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*dbpb.DepositContainer {
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.AllDepositContainers")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -174,7 +175,7 @@ func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*ethpb.Depos
 // AllDeposits returns a list of historical deposits until the given block number
 // (inclusive). If no block is specified then this method returns all historical deposits.
 func (dc *DepositCache) AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
-	_, span := trace.StartSpan(ctx, "DepositsCache.AllDeposits")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.AllDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -191,7 +192,7 @@ func (dc *DepositCache) AllDeposits(ctx context.Context, untilBlk *big.Int) []*e
 // DepositsNumberAndRootAtHeight returns number of deposits made up to blockheight and the
 // root that corresponds to the latest deposit at that blockheight.
 func (dc *DepositCache) DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.DepositsNumberAndRootAtHeight")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.DepositsNumberAndRootAtHeight")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -207,7 +208,7 @@ func (dc *DepositCache) DepositsNumberAndRootAtHeight(ctx context.Context, block
 // DepositByPubkey looks through historical deposits and finds one which contains
 // a certain public key within its deposit data.
 func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.DepositByPubkey")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.DepositByPubkey")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -228,7 +229,7 @@ func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*et
 
 // FinalizedDeposits returns the finalized deposits trie.
 func (dc *DepositCache) FinalizedDeposits(ctx context.Context) *FinalizedDeposits {
-	_, span := trace.StartSpan(ctx, "DepositsCache.FinalizedDeposits")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.FinalizedDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/container/trie"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -43,31 +44,31 @@ func TestInsertDeposit_MaintainsSortedOrderByIndex(t *testing.T) {
 	}{
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &ethpb.Deposit_Data{PublicKey: []byte{'A'}}},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'A'}}},
 			index:       0,
 			expectedErr: "",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &ethpb.Deposit_Data{PublicKey: []byte{'B'}}},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'B'}}},
 			index:       3,
 			expectedErr: "wanted deposit with index 1 to be inserted but received 3",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &ethpb.Deposit_Data{PublicKey: []byte{'C'}}},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'C'}}},
 			index:       1,
 			expectedErr: "",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &ethpb.Deposit_Data{PublicKey: []byte{'D'}}},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'D'}}},
 			index:       4,
 			expectedErr: "wanted deposit with index 2 to be inserted but received 4",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &ethpb.Deposit_Data{PublicKey: []byte{'E'}}},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'E'}}},
 			index:       2,
 			expectedErr: "",
 		},
@@ -92,7 +93,7 @@ func TestAllDeposits_ReturnsAllDeposits(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	deposits := []*ethpb.DepositContainer{
+	deposits := []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 10,
 			Deposit:         &ethpb.Deposit{},
@@ -132,7 +133,7 @@ func TestAllDeposits_FiltersDepositUpToAndIncludingBlockNumber(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	deposits := []*ethpb.DepositContainer{
+	deposits := []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 10,
 			Deposit:         &ethpb.Deposit{},
@@ -173,7 +174,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 	t.Run("requesting_last_item_works", func(t *testing.T) {
 		dc, err := New()
 		require.NoError(t, err)
-		dc.deposits = []*ethpb.DepositContainer{
+		dc.deposits = []*dbpb.DepositContainer{
 			{
 				Eth1BlockHeight: 10,
 				Index:           0,
@@ -204,7 +205,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 		dc, err := New()
 		require.NoError(t, err)
 
-		dc.deposits = []*ethpb.DepositContainer{
+		dc.deposits = []*dbpb.DepositContainer{
 			{
 				Eth1BlockHeight: 10,
 				Index:           0,
@@ -220,7 +221,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 		dc, err := New()
 		require.NoError(t, err)
 
-		dc.deposits = []*ethpb.DepositContainer{
+		dc.deposits = []*dbpb.DepositContainer{
 			{
 				Eth1BlockHeight: 8,
 				Index:           0,
@@ -246,7 +247,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 		dc, err := New()
 		require.NoError(t, err)
 
-		dc.deposits = []*ethpb.DepositContainer{
+		dc.deposits = []*dbpb.DepositContainer{
 			{
 				Eth1BlockHeight: 8,
 				Index:           0,
@@ -262,7 +263,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 		dc, err := New()
 		require.NoError(t, err)
 
-		dc.deposits = []*ethpb.DepositContainer{
+		dc.deposits = []*dbpb.DepositContainer{
 			{
 				Eth1BlockHeight: 8,
 				Index:           0,
@@ -278,7 +279,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 		dc, err := New()
 		require.NoError(t, err)
 
-		dc.deposits = []*ethpb.DepositContainer{
+		dc.deposits = []*dbpb.DepositContainer{
 			{
 				Eth1BlockHeight: 8,
 				Index:           0,
@@ -315,7 +316,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
-	ctrs := []*ethpb.DepositContainer{
+	ctrs := []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 9,
 			Deposit: &ethpb.Deposit{
@@ -373,7 +374,7 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	finalizedDeposits := []*ethpb.DepositContainer{
+	finalizedDeposits := []*dbpb.DepositContainer{
 		{
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
@@ -405,7 +406,7 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 			Index: 2,
 		},
 	}
-	dc.deposits = append(finalizedDeposits, &ethpb.DepositContainer{
+	dc.deposits = append(finalizedDeposits, &dbpb.DepositContainer{
 		Deposit: &ethpb.Deposit{
 			Data: &ethpb.Deposit_Data{
 				PublicKey:             bytesutil.PadTo([]byte{3}, 48),
@@ -437,7 +438,7 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	oldFinalizedDeposits := []*ethpb.DepositContainer{
+	oldFinalizedDeposits := []*dbpb.DepositContainer{
 		{
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
@@ -459,7 +460,7 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 			Index: 1,
 		},
 	}
-	newFinalizedDeposit := ethpb.DepositContainer{
+	newFinalizedDeposit := dbpb.DepositContainer{
 		Deposit: &ethpb.Deposit{
 			Data: &ethpb.Deposit_Data{
 				PublicKey:             bytesutil.PadTo([]byte{2}, 48),
@@ -472,7 +473,7 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 	dc.deposits = oldFinalizedDeposits
 	dc.InsertFinalizedDeposits(context.Background(), 1)
 	// Artificially exclude old deposits so that they can only be retrieved from previously finalized deposits.
-	dc.deposits = []*ethpb.DepositContainer{&newFinalizedDeposit}
+	dc.deposits = []*dbpb.DepositContainer{&newFinalizedDeposit}
 
 	dc.InsertFinalizedDeposits(context.Background(), 2)
 
@@ -505,7 +506,7 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	finalizedDeposits := []*ethpb.DepositContainer{
+	finalizedDeposits := []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
@@ -530,7 +531,7 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 		},
 	}
 	dc.deposits = append(finalizedDeposits,
-		&ethpb.DepositContainer{
+		&dbpb.DepositContainer{
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
@@ -541,7 +542,7 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 			},
 			Index: 2,
 		},
-		&ethpb.DepositContainer{
+		&dbpb.DepositContainer{
 			Eth1BlockHeight: 11,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
@@ -562,7 +563,7 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 	dc, err := New()
 	require.NoError(t, err)
 
-	finalizedDeposits := []*ethpb.DepositContainer{
+	finalizedDeposits := []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
@@ -587,7 +588,7 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 		},
 	}
 	dc.deposits = append(finalizedDeposits,
-		&ethpb.DepositContainer{
+		&dbpb.DepositContainer{
 			Eth1BlockHeight: 10,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{
@@ -598,7 +599,7 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 			},
 			Index: 2,
 		},
-		&ethpb.DepositContainer{
+		&dbpb.DepositContainer{
 			Eth1BlockHeight: 11,
 			Deposit: &ethpb.Deposit{
 				Data: &ethpb.Deposit_Data{

beacon-chain/cache/depositcache/pending_deposits.go

@@ -8,6 +8,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
+	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -23,13 +24,13 @@ var (
 // PendingDepositsFetcher specifically outlines a struct that can retrieve deposits
 // which have not yet been included in the chain.
 type PendingDepositsFetcher interface {
-	PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer
+	PendingContainers(ctx context.Context, untilBlk *big.Int) []*dbpb.DepositContainer
 }
 
 // InsertPendingDeposit into the database. If deposit or block number are nil
 // then this method does nothing.
 func (dc *DepositCache) InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.InsertPendingDeposit")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertPendingDeposit")
 	defer span.End()
 	if d == nil {
 		log.WithFields(logrus.Fields{
@@ -41,7 +42,7 @@ func (dc *DepositCache) InsertPendingDeposit(ctx context.Context, d *ethpb.Depos
 	dc.depositsLock.Lock()
 	defer dc.depositsLock.Unlock()
 	dc.pendingDeposits = append(dc.pendingDeposits,
-		&ethpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, Index: index, DepositRoot: depositRoot[:]})
+		&dbpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, Index: index, DepositRoot: depositRoot[:]})
 	pendingDepositsCount.Inc()
 	span.AddAttributes(trace.Int64Attribute("count", int64(len(dc.pendingDeposits))))
 }
@@ -65,13 +66,13 @@ func (dc *DepositCache) PendingDeposits(ctx context.Context, untilBlk *big.Int)
 
 // PendingContainers returns a list of deposit containers until the given block number
 // (inclusive).
-func (dc *DepositCache) PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer {
-	_, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
+func (dc *DepositCache) PendingContainers(ctx context.Context, untilBlk *big.Int) []*dbpb.DepositContainer {
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
 
-	var depositCntrs []*ethpb.DepositContainer
+	var depositCntrs []*dbpb.DepositContainer
 	for _, ctnr := range dc.pendingDeposits {
 		if untilBlk == nil || untilBlk.Uint64() >= ctnr.Eth1BlockHeight {
 			depositCntrs = append(depositCntrs, ctnr)
@@ -90,7 +91,7 @@ func (dc *DepositCache) PendingContainers(ctx context.Context, untilBlk *big.Int
 // RemovePendingDeposit from the database. The deposit is indexed by the
 // Index. This method does nothing if deposit ptr is nil.
 func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Deposit) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.RemovePendingDeposit")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.RemovePendingDeposit")
 	defer span.End()
 
 	if d == nil {
@@ -128,7 +129,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 
 // PrunePendingDeposits removes any deposit which is older than the given deposit merkle tree index.
 func (dc *DepositCache) PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64) {
-	_, span := trace.StartSpan(ctx, "DepositsCache.PrunePendingDeposits")
+	ctx, span := trace.StartSpan(ctx, "DepositsCache.PrunePendingDeposits")
 	defer span.End()
 
 	if merkleTreeIndex == 0 {
@@ -139,7 +140,7 @@ func (dc *DepositCache) PrunePendingDeposits(ctx context.Context, merkleTreeInde
 	dc.depositsLock.Lock()
 	defer dc.depositsLock.Unlock()
 
-	var cleanDeposits []*ethpb.DepositContainer
+	var cleanDeposits []*dbpb.DepositContainer
 	for _, dp := range dc.pendingDeposits {
 		if dp.Index >= merkleTreeIndex {
 			cleanDeposits = append(cleanDeposits, dp)

beacon-chain/cache/depositcache/pending_deposits_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"google.golang.org/protobuf/proto"
@@ -41,7 +42,7 @@ func TestRemovePendingDeposit_OK(t *testing.T) {
 	}
 	depToRemove := &ethpb.Deposit{Proof: proof1, Data: data}
 	otherDep := &ethpb.Deposit{Proof: proof2, Data: data}
-	db.pendingDeposits = []*ethpb.DepositContainer{
+	db.pendingDeposits = []*dbpb.DepositContainer{
 		{Deposit: depToRemove, Index: 1},
 		{Deposit: otherDep, Index: 5},
 	}
@@ -54,7 +55,7 @@ func TestRemovePendingDeposit_OK(t *testing.T) {
 
 func TestRemovePendingDeposit_IgnoresNilDeposit(t *testing.T) {
 	dc := DepositCache{}
-	dc.pendingDeposits = []*ethpb.DepositContainer{{Deposit: &ethpb.Deposit{}}}
+	dc.pendingDeposits = []*dbpb.DepositContainer{{Deposit: &ethpb.Deposit{}}}
 	dc.RemovePendingDeposit(context.Background(), nil /*deposit*/)
 	assert.Equal(t, 1, len(dc.pendingDeposits), "Deposit unexpectedly removed")
 }
@@ -78,7 +79,7 @@ func TestPendingDeposit_RoundTrip(t *testing.T) {
 func TestPendingDeposits_OK(t *testing.T) {
 	dc := DepositCache{}
 
-	dc.pendingDeposits = []*ethpb.DepositContainer{
+	dc.pendingDeposits = []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 2, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("A")}}},
 		{Eth1BlockHeight: 4, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("B")}}},
 		{Eth1BlockHeight: 6, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("c")}}},
@@ -98,7 +99,7 @@ func TestPendingDeposits_OK(t *testing.T) {
 func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
 	dc := DepositCache{}
 
-	dc.pendingDeposits = []*ethpb.DepositContainer{
+	dc.pendingDeposits = []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},
 		{Eth1BlockHeight: 4, Index: 4},
 		{Eth1BlockHeight: 6, Index: 6},
@@ -108,7 +109,7 @@ func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
 	}
 
 	dc.PrunePendingDeposits(context.Background(), 0)
-	expected := []*ethpb.DepositContainer{
+	expected := []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},
 		{Eth1BlockHeight: 4, Index: 4},
 		{Eth1BlockHeight: 6, Index: 6},
@@ -122,7 +123,7 @@ func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
 func TestPrunePendingDeposits_OK(t *testing.T) {
 	dc := DepositCache{}
 
-	dc.pendingDeposits = []*ethpb.DepositContainer{
+	dc.pendingDeposits = []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},
 		{Eth1BlockHeight: 4, Index: 4},
 		{Eth1BlockHeight: 6, Index: 6},
@@ -132,7 +133,7 @@ func TestPrunePendingDeposits_OK(t *testing.T) {
 	}
 
 	dc.PrunePendingDeposits(context.Background(), 6)
-	expected := []*ethpb.DepositContainer{
+	expected := []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 6, Index: 6},
 		{Eth1BlockHeight: 8, Index: 8},
 		{Eth1BlockHeight: 10, Index: 10},
@@ -141,7 +142,7 @@ func TestPrunePendingDeposits_OK(t *testing.T) {
 
 	assert.DeepEqual(t, expected, dc.pendingDeposits)
 
-	dc.pendingDeposits = []*ethpb.DepositContainer{
+	dc.pendingDeposits = []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},
 		{Eth1BlockHeight: 4, Index: 4},
 		{Eth1BlockHeight: 6, Index: 6},
@@ -151,7 +152,7 @@ func TestPrunePendingDeposits_OK(t *testing.T) {
 	}
 
 	dc.PrunePendingDeposits(context.Background(), 10)
-	expected = []*ethpb.DepositContainer{
+	expected = []*dbpb.DepositContainer{
 		{Eth1BlockHeight: 10, Index: 10},
 		{Eth1BlockHeight: 12, Index: 12},
 	}

beacon-chain/cache/sync_committee_test.go

@@ -5,6 +5,8 @@ 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/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
@@ -26,10 +28,10 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 	}{
 		{
 			name: "only current epoch",
-			currentSyncCommittee: util.ConvertToCommittee([][]byte{
+			currentSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[1], pubKeys[2], pubKeys[3], pubKeys[2], pubKeys[2],
 			}),
-			nextSyncCommittee: util.ConvertToCommittee([][]byte{}),
+			nextSyncCommittee: convertToCommittee([][]byte{}),
 			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
 				1: {0},
 				2: {1, 3, 4},
@@ -43,8 +45,8 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 		},
 		{
 			name:                 "only next epoch",
-			currentSyncCommittee: util.ConvertToCommittee([][]byte{}),
-			nextSyncCommittee: util.ConvertToCommittee([][]byte{
+			currentSyncCommittee: convertToCommittee([][]byte{}),
+			nextSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[1], pubKeys[2], pubKeys[3], pubKeys[2], pubKeys[2],
 			}),
 			currentSyncMap: map[types.ValidatorIndex][]types.CommitteeIndex{
@@ -60,14 +62,14 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 		},
 		{
 			name: "some current epoch and some next epoch",
-			currentSyncCommittee: util.ConvertToCommittee([][]byte{
+			currentSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[1],
 				pubKeys[2],
 				pubKeys[3],
 				pubKeys[2],
 				pubKeys[2],
 			}),
-			nextSyncCommittee: util.ConvertToCommittee([][]byte{
+			nextSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[7],
 				pubKeys[6],
 				pubKeys[5],
@@ -88,14 +90,14 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 		},
 		{
 			name: "some current epoch and some next epoch duplicated across",
-			currentSyncCommittee: util.ConvertToCommittee([][]byte{
+			currentSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[1],
 				pubKeys[2],
 				pubKeys[3],
 				pubKeys[2],
 				pubKeys[2],
 			}),
-			nextSyncCommittee: util.ConvertToCommittee([][]byte{
+			nextSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[2],
 				pubKeys[1],
 				pubKeys[3],
@@ -115,13 +117,13 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 		},
 		{
 			name: "all duplicated",
-			currentSyncCommittee: util.ConvertToCommittee([][]byte{
+			currentSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[100],
 				pubKeys[100],
 				pubKeys[100],
 				pubKeys[100],
 			}),
-			nextSyncCommittee: util.ConvertToCommittee([][]byte{
+			nextSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[100],
 				pubKeys[100],
 				pubKeys[100],
@@ -136,13 +138,13 @@ func TestSyncCommitteeCache_CanUpdateAndRetrieve(t *testing.T) {
 		},
 		{
 			name: "unknown keys",
-			currentSyncCommittee: util.ConvertToCommittee([][]byte{
+			currentSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[100],
 				pubKeys[100],
 				pubKeys[100],
 				pubKeys[100],
 			}),
-			nextSyncCommittee: util.ConvertToCommittee([][]byte{
+			nextSyncCommittee: convertToCommittee([][]byte{
 				pubKeys[100],
 				pubKeys[100],
 				pubKeys[100],
@@ -187,13 +189,13 @@ func TestSyncCommitteeCache_RootDoesNotExist(t *testing.T) {
 func TestSyncCommitteeCache_CanRotate(t *testing.T) {
 	c := cache.NewSyncCommittee()
 	s, _ := util.DeterministicGenesisStateAltair(t, 64)
-	require.NoError(t, s.SetCurrentSyncCommittee(util.ConvertToCommittee([][]byte{{1}})))
+	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{1}})))
 	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'a'}, s))
-	require.NoError(t, s.SetCurrentSyncCommittee(util.ConvertToCommittee([][]byte{{2}})))
+	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{2}})))
 	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'b'}, s))
-	require.NoError(t, s.SetCurrentSyncCommittee(util.ConvertToCommittee([][]byte{{3}})))
+	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{3}})))
 	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'c'}, s))
-	require.NoError(t, s.SetCurrentSyncCommittee(util.ConvertToCommittee([][]byte{{4}})))
+	require.NoError(t, s.SetCurrentSyncCommittee(convertToCommittee([][]byte{{4}})))
 	require.NoError(t, c.UpdatePositionsInCommittee([32]byte{'d'}, s))
 
 	_, err := c.CurrentPeriodIndexPosition([32]byte{'a'}, 0)
@@ -202,3 +204,19 @@ func TestSyncCommitteeCache_CanRotate(t *testing.T) {
 	_, err = c.CurrentPeriodIndexPosition([32]byte{'c'}, 0)
 	require.NoError(t, err)
 }
+
+func convertToCommittee(inputKeys [][]byte) *ethpb.SyncCommittee {
+	var pubKeys [][]byte
+	for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSize; i++ {
+		if i < uint64(len(inputKeys)) {
+			pubKeys = append(pubKeys, bytesutil.PadTo(inputKeys[i], params.BeaconConfig().BLSPubkeyLength))
+		} else {
+			pubKeys = append(pubKeys, bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength))
+		}
+	}
+
+	return &ethpb.SyncCommittee{
+		Pubkeys:         pubKeys,
+		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
+	}
+}

beacon-chain/core/altair/BUILD.bazel

@@ -38,7 +38,6 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
-        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
@@ -71,7 +70,6 @@ go_test(
         "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
-        "//beacon-chain/state/v3:go_default_library",
         "//config/params:go_default_library",
         "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",

beacon-chain/core/altair/epoch_precompute.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/math"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"go.opencensus.io/trace"
 )
 
@@ -254,7 +253,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 
 // AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the
 // voting records.
-func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, vals []*precompute.Validator) (rewards, penalties []uint64, err error) {
+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)
@@ -266,18 +265,7 @@ func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, v
 	factor := cfg.BaseRewardFactor
 	baseRewardMultiplier := increment * factor / math.IntegerSquareRoot(bal.ActiveCurrentEpoch)
 	leak := helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch)
-
-	// Modified in Altair and Merge.
-	var inactivityDenominator uint64
-	bias := cfg.InactivityScoreBias
-	switch beaconState.Version() {
-	case version.Altair:
-		inactivityDenominator = bias * cfg.InactivityPenaltyQuotientAltair
-	case version.Merge:
-		inactivityDenominator = bias * cfg.InactivityPenaltyQuotientMerge
-	default:
-		return nil, nil, errors.Errorf("invalid state type version: %T", beaconState.Version())
-	}
+	inactivityDenominator := cfg.InactivityScoreBias * cfg.InactivityPenaltyQuotientAltair
 
 	for i, v := range vals {
 		rewards[i], penalties[i], err = attestationDelta(bal, v, baseRewardMultiplier, inactivityDenominator, leak)

beacon-chain/core/altair/epoch_precompute_test.go

@@ -9,7 +9,6 @@ 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"
-	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
 	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -231,42 +230,6 @@ func TestAttestationsDelta(t *testing.T) {
 	require.Equal(t, uint64(0), rewards[0])
 	// Last index should have 0 penalty.
 	require.Equal(t, uint64(0), penalties[len(penalties)-1])
-
-	want := []uint64{0, 939146, 2101898, 2414946}
-	require.DeepEqual(t, want, rewards)
-	want = []uint64{3577700, 2325505, 0, 0}
-	require.DeepEqual(t, want, penalties)
-}
-
-func TestAttestationsDeltaMerge(t *testing.T) {
-	s, err := testStateMerge()
-	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
-	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
-	require.NoError(t, err)
-	rewards, penalties, err := AttestationsDelta(s, balance, validators)
-	require.NoError(t, err)
-
-	// Reward amount should increase as validator index increases due to setup.
-	for i := 1; i < len(rewards); i++ {
-		require.Equal(t, true, rewards[i] > rewards[i-1])
-	}
-
-	// Penalty amount should decrease as validator index increases due to setup.
-	for i := 1; i < len(penalties); i++ {
-		require.Equal(t, true, penalties[i] <= penalties[i-1])
-	}
-
-	// First index should have 0 reward.
-	require.Equal(t, uint64(0), rewards[0])
-	// Last index should have 0 penalty.
-	require.Equal(t, uint64(0), penalties[len(penalties)-1])
-
-	want := []uint64{0, 9782, 1172534, 1485582}
-	require.DeepEqual(t, want, rewards)
-	want = []uint64{3577700, 2325505, 0, 0}
-	require.DeepEqual(t, want, penalties)
 }
 
 func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
@@ -492,40 +455,3 @@ func testState() (state.BeaconState, error) {
 		Balances:         []uint64{0, 0, 0, 0},
 	})
 }
-
-func testStateMerge() (state.BeaconState, error) {
-	generateParticipation := func(flags ...uint8) byte {
-		b := byte(0)
-		var err error
-		for _, flag := range flags {
-			b, err = AddValidatorFlag(b, flag)
-			if err != nil {
-				return 0
-			}
-		}
-		return b
-	}
-	return v3.InitializeFromProto(&ethpb.BeaconStateMerge{
-		Slot: 2 * params.BeaconConfig().SlotsPerEpoch,
-		Validators: []*ethpb.Validator{
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-			{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance, ExitEpoch: params.BeaconConfig().FarFutureEpoch},
-		},
-		CurrentEpochParticipation: []byte{
-			0,
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex),
-		},
-		PreviousEpochParticipation: []byte{
-			0,
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex),
-			generateParticipation(params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex),
-		},
-		InactivityScores: []uint64{0, 0, 0, 0},
-		Balances:         []uint64{0, 0, 0, 0},
-	})
-}

beacon-chain/core/altair/transition.go

@@ -8,7 +8,6 @@ import (
 	"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/runtime/version"
 	"go.opencensus.io/trace"
 )
 
@@ -29,7 +28,7 @@ import (
 //    process_historical_roots_update(state)
 //    process_participation_flag_updates(state)  # [New in Altair]
 //    process_sync_committee_updates(state)  # [New in Altair]
-func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconStateAltair, error) {
+func ProcessEpoch(ctx context.Context, state state.BeaconStateAltair) (state.BeaconStateAltair, error) {
 	ctx, span := trace.StartSpan(ctx, "altair.ProcessEpoch")
 	defer span.End()
 
@@ -69,21 +68,10 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		return nil, errors.Wrap(err, "could not process registry updates")
 	}
 
-	// Modified in Altair and Merge.
-	cfg := params.BeaconConfig()
-	switch state.Version() {
-	case version.Altair:
-		state, err = e.ProcessSlashings(state, cfg.ProportionalSlashingMultiplierAltair)
-		if err != nil {
-			return nil, err
-		}
-	case version.Merge:
-		state, err = e.ProcessSlashings(state, cfg.ProportionalSlashingMultiplierMerge)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, errors.Errorf("invalid state type version: %T", state.Version())
+	// Modified in Altair.
+	state, err = e.ProcessSlashings(state, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
+	if err != nil {
+		return nil, err
 	}
 
 	state, err = e.ProcessEth1DataReset(state)

beacon-chain/core/altair/transition_test.go

@@ -41,35 +41,3 @@ func TestProcessEpoch_CanProcess(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
 }
-
-func TestProcessEpoch_CanProcessMerge(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateMerge(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
-	newState, err := altair.ProcessEpoch(context.Background(), st)
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), newState.Slashings()[2], "Unexpected slashed balance")
-
-	b := st.Balances()
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(b)))
-	require.Equal(t, uint64(31999841265), b[0])
-
-	s, err := st.InactivityScores()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(s)))
-
-	p, err := st.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
-
-	p, err = st.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
-
-	sc, err := st.CurrentSyncCommittee()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
-
-	sc, err = st.NextSyncCommittee()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
-}

beacon-chain/core/blocks/attestation_test.go

@@ -358,7 +358,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	}
 
 	want := "nil or missing indexed attestation data"
-	_, err := blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
+	_, err := blocks.AttestationSignatureSet(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 
 	atts = []*ethpb.Attestation{}
@@ -378,7 +378,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	}
 
 	want = "expected non-empty attesting indices"
-	_, err = blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
+	_, err = blocks.AttestationSignatureSet(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -502,7 +502,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	set, err := blocks.AttestationSignatureBatch(ctx, st, []*ethpb.Attestation{att1, att2})
+	set, err := blocks.AttestationSignatureSet(ctx, st, []*ethpb.Attestation{att1, att2})
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)
@@ -566,6 +566,6 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	_, err = blocks.AttestationSignatureBatch(ctx, st, []*ethpb.Attestation{att1, att2})
+	_, err = blocks.AttestationSignatureSet(ctx, st, []*ethpb.Attestation{att1, att2})
 	require.NoError(t, err)
 }

beacon-chain/core/blocks/attester_slashing.go

@@ -83,8 +83,6 @@ func ProcessAttesterSlashing(
 				slashingQuotient = cfg.MinSlashingPenaltyQuotient
 			case beaconState.Version() == version.Altair:
 				slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
-			case beaconState.Version() == version.Merge:
-				slashingQuotient = cfg.MinSlashingPenaltyQuotientMerge
 			default:
 				return nil, errors.New("unknown state version")
 			}

beacon-chain/core/blocks/attester_slashing_test.go

@@ -233,72 +233,3 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 	require.Equal(t, uint64(31500000000), newState.Balances()[1])
 	require.Equal(t, uint64(32000000000), newState.Balances()[2])
 }
-
-func TestProcessAttesterSlashings_AppliesCorrectStatusMerge(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateMerge(t, 100)
-	for _, vv := range beaconState.Validators() {
-		vv.WithdrawableEpoch = types.Epoch(params.BeaconConfig().SlotsPerEpoch)
-	}
-
-	att1 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 1},
-		},
-		AttestingIndices: []uint64{0, 1},
-	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
-	require.NoError(t, err)
-	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	sig0 := privKeys[0].Sign(signingRoot[:])
-	sig1 := privKeys[1].Sign(signingRoot[:])
-	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	att1.Signature = aggregateSig.Marshal()
-
-	att2 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
-		AttestingIndices: []uint64{0, 1},
-	})
-	signingRoot, err = signing.ComputeSigningRoot(att2.Data, domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	sig0 = privKeys[0].Sign(signingRoot[:])
-	sig1 = privKeys[1].Sign(signingRoot[:])
-	aggregateSig = bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	att2.Signature = aggregateSig.Marshal()
-
-	slashings := []*ethpb.AttesterSlashing{
-		{
-			Attestation_1: att1,
-			Attestation_2: att2,
-		},
-	}
-
-	currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch
-	require.NoError(t, beaconState.SetSlot(currentSlot))
-
-	b := util.NewBeaconBlock()
-	b.Block = &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			AttesterSlashings: slashings,
-		},
-	}
-
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
-	require.NoError(t, err)
-	newRegistry := newState.Validators()
-
-	// Given the intersection of slashable indices is [1], only validator
-	// at index 1 should be slashed and exited. We confirm this below.
-	if newRegistry[1].ExitEpoch != beaconState.Validators()[1].ExitEpoch {
-		t.Errorf(
-			`
-			Expected validator at index 1's exit epoch to match
-			%d, received %d instead
-			`,
-			beaconState.Validators()[1].ExitEpoch,
-			newRegistry[1].ExitEpoch,
-		)
-	}
-
-	require.Equal(t, uint64(31500000000), newState.Balances()[1])
-	require.Equal(t, uint64(32000000000), newState.Balances()[2])
-}

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -9,6 +9,7 @@ import (
 	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -18,7 +19,7 @@ func TestFuzzProcessAttestationNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	ctx := context.Background()
 	state := &ethpb.BeaconState{}
-	att := &ethpb.Attestation{}
+	att := &eth.Attestation{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -33,7 +34,7 @@ func TestFuzzProcessAttestationNoVerify_10000(t *testing.T) {
 func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	block := &ethpb.SignedBeaconBlock{}
+	block := &eth.SignedBeaconBlock{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -46,7 +47,7 @@ func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 	}
 }
 
-func TestFuzzverifyDepositDataSigningRoot_10000(_ *testing.T) {
+func TestFuzzverifyDepositDataSigningRoot_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	var ba []byte
 	pubkey := [48]byte{}
@@ -72,7 +73,7 @@ func TestFuzzverifyDepositDataSigningRoot_10000(_ *testing.T) {
 
 func TestFuzzProcessEth1DataInBlock_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	e := &ethpb.Eth1Data{}
+	e := &eth.Eth1Data{}
 	state := &v1.BeaconState{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -84,10 +85,10 @@ func TestFuzzProcessEth1DataInBlock_10000(t *testing.T) {
 	}
 }
 
-func TestFuzzareEth1DataEqual_10000(_ *testing.T) {
+func TestFuzzareEth1DataEqual_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	eth1data := &ethpb.Eth1Data{}
-	eth1data2 := &ethpb.Eth1Data{}
+	eth1data := &eth.Eth1Data{}
+	eth1data2 := &eth.Eth1Data{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(eth1data)
@@ -99,8 +100,8 @@ func TestFuzzareEth1DataEqual_10000(_ *testing.T) {
 
 func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	eth1data := &ethpb.Eth1Data{}
-	var stateVotes []*ethpb.Eth1Data
+	eth1data := &eth.Eth1Data{}
+	var stateVotes []*eth.Eth1Data
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(eth1data)
 		fuzzer.Fuzz(&stateVotes)
@@ -117,7 +118,7 @@ func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
 func TestFuzzProcessBlockHeaderNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	block := &ethpb.BeaconBlock{}
+	block := &eth.BeaconBlock{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -132,7 +133,7 @@ func TestFuzzProcessBlockHeaderNoVerify_10000(t *testing.T) {
 func TestFuzzProcessRandao_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	b := &ethpb.SignedBeaconBlock{}
+	b := &eth.SignedBeaconBlock{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -149,7 +150,7 @@ func TestFuzzProcessRandao_10000(t *testing.T) {
 func TestFuzzProcessRandaoNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	blockBody := &ethpb.BeaconBlockBody{}
+	blockBody := &eth.BeaconBlockBody{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -166,14 +167,14 @@ func TestFuzzProcessRandaoNoVerify_10000(t *testing.T) {
 func TestFuzzProcessProposerSlashings_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	p := &ethpb.ProposerSlashing{}
+	p := &eth.ProposerSlashing{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(p)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		r, err := ProcessProposerSlashings(ctx, s, []*ethpb.ProposerSlashing{p}, v.SlashValidator)
+		r, err := ProcessProposerSlashings(ctx, s, []*eth.ProposerSlashing{p}, v.SlashValidator)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and slashing: %v", r, err, state, p)
 		}
@@ -183,7 +184,7 @@ func TestFuzzProcessProposerSlashings_10000(t *testing.T) {
 func TestFuzzVerifyProposerSlashing_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	proposerSlashing := &ethpb.ProposerSlashing{}
+	proposerSlashing := &eth.ProposerSlashing{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(proposerSlashing)
@@ -197,14 +198,14 @@ func TestFuzzVerifyProposerSlashing_10000(t *testing.T) {
 func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	a := &ethpb.AttesterSlashing{}
+	a := &eth.AttesterSlashing{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(a)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		r, err := ProcessAttesterSlashings(ctx, s, []*ethpb.AttesterSlashing{a}, v.SlashValidator)
+		r, err := ProcessAttesterSlashings(ctx, s, []*eth.AttesterSlashing{a}, v.SlashValidator)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and slashing: %v", r, err, state, a)
 		}
@@ -214,7 +215,7 @@ func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
 func TestFuzzVerifyAttesterSlashing_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	attesterSlashing := &ethpb.AttesterSlashing{}
+	attesterSlashing := &eth.AttesterSlashing{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -226,10 +227,10 @@ func TestFuzzVerifyAttesterSlashing_10000(t *testing.T) {
 	}
 }
 
-func TestFuzzIsSlashableAttestationData_10000(_ *testing.T) {
+func TestFuzzIsSlashableAttestationData_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	attestationData := &ethpb.AttestationData{}
-	attestationData2 := &ethpb.AttestationData{}
+	attestationData := &eth.AttestationData{}
+	attestationData2 := &eth.AttestationData{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(attestationData)
@@ -238,9 +239,9 @@ func TestFuzzIsSlashableAttestationData_10000(_ *testing.T) {
 	}
 }
 
-func TestFuzzslashableAttesterIndices_10000(_ *testing.T) {
+func TestFuzzslashableAttesterIndices_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	attesterSlashing := &ethpb.AttesterSlashing{}
+	attesterSlashing := &eth.AttesterSlashing{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(attesterSlashing)
@@ -251,7 +252,7 @@ func TestFuzzslashableAttesterIndices_10000(_ *testing.T) {
 func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	b := &ethpb.SignedBeaconBlock{}
+	b := &eth.SignedBeaconBlock{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -268,7 +269,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	idxAttestation := &ethpb.IndexedAttestation{}
+	idxAttestation := &eth.IndexedAttestation{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -283,7 +284,7 @@ func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
 func TestFuzzVerifyAttestation_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	attestation := &ethpb.Attestation{}
+	attestation := &eth.Attestation{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -298,7 +299,7 @@ func TestFuzzVerifyAttestation_10000(t *testing.T) {
 func TestFuzzProcessDeposits_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	deposits := make([]*ethpb.Deposit, 100)
+	deposits := make([]*eth.Deposit, 100)
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -317,7 +318,7 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	deposit := &ethpb.Deposit{}
+	deposit := &eth.Deposit{}
 	ctx := context.Background()
 
 	for i := 0; i < 10000; i++ {
@@ -325,7 +326,7 @@ func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
 		fuzzer.Fuzz(deposit)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		r, err := ProcessPreGenesisDeposits(ctx, s, []*ethpb.Deposit{deposit})
+		r, err := ProcessPreGenesisDeposits(ctx, s, []*eth.Deposit{deposit})
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
 		}
@@ -335,7 +336,7 @@ func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
 func TestFuzzProcessDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	deposit := &ethpb.Deposit{}
+	deposit := &eth.Deposit{}
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -352,7 +353,7 @@ func TestFuzzProcessDeposit_10000(t *testing.T) {
 func TestFuzzverifyDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	deposit := &ethpb.Deposit{}
+	deposit := &eth.Deposit{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
@@ -366,14 +367,14 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 func TestFuzzProcessVoluntaryExits_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	e := &ethpb.SignedVoluntaryExit{}
+	e := &eth.SignedVoluntaryExit{}
 	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		r, err := ProcessVoluntaryExits(ctx, s, []*ethpb.SignedVoluntaryExit{e})
+		r, err := ProcessVoluntaryExits(ctx, s, []*eth.SignedVoluntaryExit{e})
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and exit: %v", r, err, state, e)
 		}
@@ -383,22 +384,22 @@ func TestFuzzProcessVoluntaryExits_10000(t *testing.T) {
 func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
-	e := &ethpb.SignedVoluntaryExit{}
+	e := &eth.SignedVoluntaryExit{}
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		r, err := ProcessVoluntaryExits(context.Background(), s, []*ethpb.SignedVoluntaryExit{e})
+		r, err := ProcessVoluntaryExits(context.Background(), s, []*eth.SignedVoluntaryExit{e})
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, e)
 		}
 	}
 }
 
-func TestFuzzVerifyExit_10000(_ *testing.T) {
+func TestFuzzVerifyExit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
-	ve := &ethpb.SignedVoluntaryExit{}
+	ve := &eth.SignedVoluntaryExit{}
 	rawVal := &ethpb.Validator{}
 	fork := &ethpb.Fork{}
 	var slot types.Slot

beacon-chain/core/blocks/header_test.go

@@ -321,7 +321,7 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
-	set, err := blocks.BlockSignatureBatch(state, block.Block.ProposerIndex, block.Signature, block.Block.HashTreeRoot)
+	set, err := blocks.BlockSignatureSet(state, block.Block.ProposerIndex, block.Signature, block.Block.HashTreeRoot)
 	require.NoError(t, err)
 
 	verified, err := set.Verify()

beacon-chain/core/blocks/proposer_slashing.go

@@ -81,8 +81,6 @@ func ProcessProposerSlashing(
 		slashingQuotient = cfg.MinSlashingPenaltyQuotient
 	case beaconState.Version() == version.Altair:
 		slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
-	case beaconState.Version() == version.Merge:
-		slashingQuotient = cfg.MinSlashingPenaltyQuotientMerge
 	default:
 		return nil, errors.New("unknown state version")
 	}

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -233,54 +233,6 @@ func TestProcessProposerSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 	require.Equal(t, uint64(32000000000), newState.Balances()[2])
 }
 
-func TestProcessProposerSlashings_AppliesCorrectStatusMerge(t *testing.T) {
-	// We test the case when data is correct and verify the validator
-	// registry has been updated.
-	beaconState, privKeys := util.DeterministicGenesisStateMerge(t, 100)
-	proposerIdx := types.ValidatorIndex(1)
-
-	header1 := &ethpb.SignedBeaconBlockHeader{
-		Header: util.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
-			ProposerIndex: proposerIdx,
-			StateRoot:     bytesutil.PadTo([]byte("A"), 32),
-		}),
-	}
-	var err error
-	header1.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
-	require.NoError(t, err)
-
-	header2 := util.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
-		Header: &ethpb.BeaconBlockHeader{
-			ProposerIndex: proposerIdx,
-			StateRoot:     bytesutil.PadTo([]byte("B"), 32),
-		},
-	})
-	header2.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
-	require.NoError(t, err)
-
-	slashings := []*ethpb.ProposerSlashing{
-		{
-			Header_1: header1,
-			Header_2: header2,
-		},
-	}
-
-	block := util.NewBeaconBlock()
-	block.Block.Body.ProposerSlashings = slashings
-
-	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
-	require.NoError(t, err)
-
-	newStateVals := newState.Validators()
-	if newStateVals[1].ExitEpoch != beaconState.Validators()[1].ExitEpoch {
-		t.Errorf("Proposer with index 1 did not correctly exit,"+"wanted slot:%d, got:%d",
-			newStateVals[1].ExitEpoch, beaconState.Validators()[1].ExitEpoch)
-	}
-
-	require.Equal(t, uint64(31500000000), newState.Balances()[1])
-	require.Equal(t, uint64(32000000000), newState.Balances()[2])
-}
-
 func TestVerifyProposerSlashing(t *testing.T) {
 	type args struct {
 		beaconState state.BeaconState

beacon-chain/core/blocks/randao_test.go

@@ -82,7 +82,7 @@ func TestRandaoSignatureSet_OK(t *testing.T) {
 		},
 	}
 
-	set, err := blocks.RandaoSignatureBatch(context.Background(), beaconState, block.Body.RandaoReveal)
+	set, err := blocks.RandaoSignatureSet(context.Background(), beaconState, block.Body.RandaoReveal)
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)

beacon-chain/core/blocks/signature.go

@@ -18,8 +18,8 @@ import (
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-// retrieves the signature batch from the raw data, public key,signature and domain provided.
-func signatureBatch(signedData, pub, signature, domain []byte) (*bls.SignatureBatch, error) {
+// retrieves the signature set from the raw data, public key,signature and domain provided.
+func signatureSet(signedData, pub, signature, domain []byte) (*bls.SignatureSet, error) {
 	publicKey, err := bls.PublicKeyFromBytes(pub)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert bytes to public key")
@@ -32,7 +32,7 @@ func signatureBatch(signedData, pub, signature, domain []byte) (*bls.SignatureBa
 	if err != nil {
 		return nil, errors.Wrap(err, "could not hash container")
 	}
-	return &bls.SignatureBatch{
+	return &bls.SignatureSet{
 		Signatures: [][]byte{signature},
 		PublicKeys: []bls.PublicKey{publicKey},
 		Messages:   [][32]byte{root},
@@ -41,7 +41,7 @@ func signatureBatch(signedData, pub, signature, domain []byte) (*bls.SignatureBa
 
 // verifies the signature from the raw data, public key and domain provided.
 func verifySignature(signedData, pub, signature, domain []byte) error {
-	set, err := signatureBatch(signedData, pub, signature, domain)
+	set, err := signatureSet(signedData, pub, signature, domain)
 	if err != nil {
 		return err
 	}
@@ -116,11 +116,11 @@ func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState,
 	return signing.VerifyBlockSigningRoot(proposerPubKey, blk.Signature(), domain, blk.Block().HashTreeRoot)
 }
 
-// BlockSignatureBatch retrieves the block signature batch from the provided block and its corresponding state.
-func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
+// BlockSignatureSet retrieves the block signature set from the provided block and its corresponding state.
+func BlockSignatureSet(beaconState state.ReadOnlyBeaconState,
 	proposerIndex types.ValidatorIndex,
 	sig []byte,
-	rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
+	rootFunc func() ([32]byte, error)) (*bls.SignatureSet, error) {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
 	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
 	if err != nil {
@@ -131,21 +131,21 @@ func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
 		return nil, err
 	}
 	proposerPubKey := proposer.PublicKey
-	return signing.BlockSignatureBatch(proposerPubKey, sig, domain, rootFunc)
+	return signing.BlockSignatureSet(proposerPubKey, sig, domain, rootFunc)
 }
 
-// RandaoSignatureBatch retrieves the relevant randao specific signature batch object
+// RandaoSignatureSet retrieves the relevant randao specific signature set object
 // from a block and its corresponding state.
-func RandaoSignatureBatch(
+func RandaoSignatureSet(
 	ctx context.Context,
 	beaconState state.ReadOnlyBeaconState,
 	reveal []byte,
-) (*bls.SignatureBatch, error) {
+) (*bls.SignatureSet, error) {
 	buf, proposerPub, domain, err := randaoSigningData(ctx, beaconState)
 	if err != nil {
 		return nil, err
 	}
-	set, err := signatureBatch(buf, proposerPub, reveal, domain)
+	set, err := signatureSet(buf, proposerPub, reveal, domain)
 	if err != nil {
 		return nil, err
 	}
@@ -171,13 +171,13 @@ func randaoSigningData(ctx context.Context, beaconState state.ReadOnlyBeaconStat
 	return buf, proposerPub[:], domain, nil
 }
 
-// Method to break down attestations of the same domain and collect them into a single signature batch.
-func createAttestationSignatureBatch(
+// Method to break down attestations of the same domain and collect them into a single signature set.
+func createAttestationSignatureSet(
 	ctx context.Context,
 	beaconState state.ReadOnlyBeaconState,
 	atts []*ethpb.Attestation,
 	domain []byte,
-) (*bls.SignatureBatch, error) {
+) (*bls.SignatureSet, error) {
 	if len(atts) == 0 {
 		return nil, nil
 	}
@@ -216,16 +216,16 @@ func createAttestationSignatureBatch(
 		}
 		msgs[i] = root
 	}
-	return &bls.SignatureBatch{
+	return &bls.SignatureSet{
 		Signatures: sigs,
 		PublicKeys: pks,
 		Messages:   msgs,
 	}, nil
 }
 
-// AttestationSignatureBatch retrieves all the related attestation signature data such as the relevant public keys,
-// signatures and attestation signing data and collate it into a signature batch object.
-func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBeaconState, atts []*ethpb.Attestation) (*bls.SignatureBatch, error) {
+// AttestationSignatureSet retrieves all the related attestation signature data such as the relevant public keys,
+// signatures and attestation signing data and collate it into a signature set object.
+func AttestationSignatureSet(ctx context.Context, beaconState state.ReadOnlyBeaconState, atts []*ethpb.Attestation) (*bls.SignatureSet, error) {
 	if len(atts) == 0 {
 		return bls.NewSet(), nil
 	}
@@ -247,12 +247,12 @@ func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBe
 	set := bls.NewSet()
 
 	// Check attestations from before the fork.
-	if fork.Epoch > 0 && len(preForkAtts) > 0 { // Check to prevent underflow and there is valid attestations to create sig batch.
+	if fork.Epoch > 0 && len(preForkAtts) > 0 { // Check to prevent underflow and there is valid attestations to create sig set.
 		prevDomain, err := signing.Domain(fork, fork.Epoch-1, dt, gvr)
 		if err != nil {
 			return nil, err
 		}
-		aSet, err := createAttestationSignatureBatch(ctx, beaconState, preForkAtts, prevDomain)
+		aSet, err := createAttestationSignatureSet(ctx, beaconState, preForkAtts, prevDomain)
 		if err != nil {
 			return nil, err
 		}
@@ -272,7 +272,7 @@ func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBe
 			return nil, err
 		}
 
-		aSet, err := createAttestationSignatureBatch(ctx, beaconState, postForkAtts, currDomain)
+		aSet, err := createAttestationSignatureSet(ctx, beaconState, postForkAtts, currDomain)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/core/epoch/precompute/attestation_test.go

@@ -147,8 +147,8 @@ func TestAttestedCurrentEpoch(t *testing.T) {
 }
 
 func TestProcessAttestations(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MinimalSpecConfig())
+	params.UseMinimalConfig()
+	defer params.UseMainnetConfig()
 
 	validators := uint64(128)
 	beaconState, _ := util.DeterministicGenesisState(t, validators)

beacon-chain/core/epoch/precompute/new.go

@@ -18,7 +18,7 @@ import (
 // pre computed instances of validators attesting records and total
 // balances attested in an epoch.
 func New(ctx context.Context, s state.BeaconState) ([]*Validator, *Balance, error) {
-	_, span := trace.StartSpan(ctx, "precomputeEpoch.New")
+	ctx, span := trace.StartSpan(ctx, "precomputeEpoch.New")
 	defer span.End()
 
 	pValidators := make([]*Validator, s.NumValidators())

beacon-chain/core/helpers/BUILD.bazel

@@ -15,7 +15,27 @@ go_library(
         "weak_subjectivity.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers",
-    visibility = ["//visibility:public"],
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//cmd/beacon-chain:__subpackages__",
+        "//contracts/deposit:__pkg__",
+        "//crypto/keystore:__pkg__",
+        "//fuzz:__pkg__",
+        "//network/forks:__pkg__",
+        "//proto/prysm/v1alpha1:__subpackages__",
+        "//proto/prysm/v1alpha1/attestation:__pkg__",
+        "//runtime/interop:__pkg__",
+        "//slasher:__subpackages__",
+        "//testing/altair:__pkg__",
+        "//testing/benchmark/benchmark_files:__subpackages__",
+        "//testing/endtoend/evaluators:__pkg__",
+        "//testing/fuzz:__pkg__",
+        "//testing/slasher/simulator:__pkg__",
+        "//testing/spectest:__subpackages__",
+        "//testing/util:__pkg__",
+        "//tools:__subpackages__",
+        "//validator:__subpackages__",
+    ],
     deps = [
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/helpers/attestation_test.go

@@ -32,8 +32,8 @@ func TestAttestation_IsAggregator(t *testing.T) {
 	})
 
 	t.Run("not aggregator", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		params.OverrideBeaconConfig(params.MinimalSpecConfig())
+		params.UseMinimalConfig()
+		defer params.UseMainnetConfig()
 		beaconState, privKeys := util.DeterministicGenesisState(t, 2048)
 
 		committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, 0, 0)

beacon-chain/core/helpers/rewards_penalties.go

@@ -59,7 +59,7 @@ func TotalActiveBalance(s state.ReadOnlyBeaconState) (uint64, error) {
 	case err == nil:
 		return bal, nil
 	case errors.Is(err, cache.ErrNotFound):
-		// Do nothing if we receive a not found error.
+		break
 	default:
 		// In the event, we encounter another error we return it.
 		return 0, err

beacon-chain/core/helpers/weak_subjectivity.go

@@ -1,11 +1,11 @@
 package helpers
 
 import (
+	"bytes"
 	"context"
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"strconv"
 	"strings"
 
@@ -14,7 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/math"
-	v1alpha1 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -122,20 +122,20 @@ func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconS
 //    current_epoch = compute_epoch_at_slot(get_current_slot(store))
 //    return current_epoch <= ws_state_epoch + ws_period
 func IsWithinWeakSubjectivityPeriod(
-	ctx context.Context, currentEpoch types.Epoch, wsState state.ReadOnlyBeaconState, wsStateRoot [32]byte, wsEpoch types.Epoch) (bool, error) {
+	ctx context.Context, currentEpoch types.Epoch, wsState state.ReadOnlyBeaconState, wsCheckpoint *eth.WeakSubjectivityCheckpoint) (bool, error) {
 	// Make sure that incoming objects are not nil.
-	if wsState == nil || wsState.IsNil() || wsState.LatestBlockHeader() == nil {
+	if wsState == nil || wsState.IsNil() || wsState.LatestBlockHeader() == nil || wsCheckpoint == nil {
 		return false, errors.New("invalid weak subjectivity state or checkpoint")
 	}
 
 	// Assert that state and checkpoint have the same root and epoch.
-	if bytesutil.ToBytes32(wsState.LatestBlockHeader().StateRoot) != wsStateRoot {
+	if !bytes.Equal(wsState.LatestBlockHeader().StateRoot, wsCheckpoint.StateRoot) {
 		return false, fmt.Errorf("state (%#x) and checkpoint (%#x) roots do not match",
-			wsState.LatestBlockHeader().StateRoot, wsStateRoot)
+			wsState.LatestBlockHeader().StateRoot, wsCheckpoint.StateRoot)
 	}
-	if slots.ToEpoch(wsState.Slot()) != wsEpoch {
+	if slots.ToEpoch(wsState.Slot()) != wsCheckpoint.Epoch {
 		return false, fmt.Errorf("state (%v) and checkpoint (%v) epochs do not match",
-			slots.ToEpoch(wsState.Slot()), wsEpoch)
+			slots.ToEpoch(wsState.Slot()), wsCheckpoint.Epoch)
 	}
 
 	// Compare given epoch to state epoch + weak subjectivity period.
@@ -164,7 +164,7 @@ func LatestWeakSubjectivityEpoch(ctx context.Context, st state.ReadOnlyBeaconSta
 }
 
 // ParseWeakSubjectivityInputString parses "blocks_root:epoch_number" string into a checkpoint.
-func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Checkpoint, error) {
+func ParseWeakSubjectivityInputString(wsCheckpointString string) (*eth.Checkpoint, error) {
 	if wsCheckpointString == "" {
 		return nil, nil
 	}
@@ -197,7 +197,7 @@ func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Chec
 		return nil, err
 	}
 
-	return &v1alpha1.Checkpoint{
+	return &eth.Checkpoint{
 		Epoch: types.Epoch(epoch),
 		Root:  bRoot,
 	}, nil

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -54,15 +54,12 @@ func TestWeakSubjectivity_ComputeWeakSubjectivityPeriod(t *testing.T) {
 		})
 	}
 }
-
-type mockWsCheckpoint func() (stateRoot [32]byte, blockRoot [32]byte, e types.Epoch)
-
 func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 	tests := []struct {
 		name            string
 		epoch           types.Epoch
 		genWsState      func() state.ReadOnlyBeaconState
-		genWsCheckpoint mockWsCheckpoint
+		genWsCheckpoint func() *ethpb.WeakSubjectivityCheckpoint
 		want            bool
 		wantedErr       string
 	}{
@@ -71,8 +68,22 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 			genWsState: func() state.ReadOnlyBeaconState {
 				return nil
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				return [32]byte{}, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					BlockRoot: make([]byte, 32),
+					StateRoot: make([]byte, 32),
+					Epoch:     42,
+				}
+			},
+			wantedErr: "invalid weak subjectivity state or checkpoint",
+		},
+		{
+			name: "nil weak subjectivity checkpoint",
+			genWsState: func() state.ReadOnlyBeaconState {
+				return genState(t, 128, 32)
+			},
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return nil
 			},
 			wantedErr: "invalid weak subjectivity state or checkpoint",
 		},
@@ -88,10 +99,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot2"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot2"), 32),
+					Epoch:     42,
+				}
 			},
 			wantedErr: fmt.Sprintf("state (%#x) and checkpoint (%#x) roots do not match",
 				bytesutil.PadTo([]byte("stateroot1"), 32), bytesutil.PadTo([]byte("stateroot2"), 32)),
@@ -108,10 +120,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 43
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     43,
+				}
 			},
 			wantedErr: "state (42) and checkpoint (43) epochs do not match",
 		},
@@ -127,10 +140,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     42,
+				}
 			},
 			wantedErr: "cannot compute weak subjectivity period: no active validators found",
 		},
@@ -147,10 +161,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     42,
+				}
 			},
 			want: false,
 		},
@@ -167,18 +182,18 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     42,
+				}
 			},
 			want: true,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			sr, _, e := tt.genWsCheckpoint()
-			got, err := helpers.IsWithinWeakSubjectivityPeriod(context.Background(), tt.epoch, tt.genWsState(), sr, e)
+			got, err := helpers.IsWithinWeakSubjectivityPeriod(context.Background(), tt.epoch, tt.genWsState(), tt.genWsCheckpoint())
 			if tt.wantedErr != "" {
 				assert.Equal(t, false, got)
 				assert.ErrorContains(t, tt.wantedErr, err)

beacon-chain/core/signing/signing_root.go

@@ -118,11 +118,11 @@ func VerifyBlockHeaderSigningRoot(blkHdr *ethpb.BeaconBlockHeader, pub, signatur
 
 // VerifyBlockSigningRoot verifies the signing root of a block given its public key, signature and domain.
 func VerifyBlockSigningRoot(pub, signature, domain []byte, rootFunc func() ([32]byte, error)) error {
-	set, err := BlockSignatureBatch(pub, signature, domain, rootFunc)
+	set, err := BlockSignatureSet(pub, signature, domain, rootFunc)
 	if err != nil {
 		return err
 	}
-	// We assume only one signature batch is returned here.
+	// We assume only one signature set is returned here.
 	sig := set.Signatures[0]
 	publicKey := set.PublicKeys[0]
 	root := set.Messages[0]
@@ -137,9 +137,9 @@ func VerifyBlockSigningRoot(pub, signature, domain []byte, rootFunc func() ([32]
 	return nil
 }
 
-// BlockSignatureBatch retrieves the relevant signature, message and pubkey data from a block and collating it
-// into a signature batch object.
-func BlockSignatureBatch(pub, signature, domain []byte, rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
+// BlockSignatureSet retrieves the relevant signature, message and pubkey data from a block and collating it
+// into a signature set object.
+func BlockSignatureSet(pub, signature, domain []byte, rootFunc func() ([32]byte, error)) (*bls.SignatureSet, error) {
 	publicKey, err := bls.PublicKeyFromBytes(pub)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert bytes to public key")
@@ -149,7 +149,7 @@ func BlockSignatureBatch(pub, signature, domain []byte, rootFunc func() ([32]byt
 	if err != nil {
 		return nil, errors.Wrap(err, "could not compute signing root")
 	}
-	return &bls.SignatureBatch{
+	return &bls.SignatureSet{
 		Signatures: [][]byte{signature},
 		PublicKeys: []bls.PublicKey{publicKey},
 		Messages:   [][32]byte{root},

beacon-chain/core/signing/signing_root_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -50,7 +51,7 @@ func TestSigningRoot_ComputeDomainAndSign(t *testing.T) {
 	tests := []struct {
 		name       string
 		genState   func(t *testing.T) (state.BeaconState, []bls.SecretKey)
-		genBlock   func(t *testing.T, st state.BeaconState, keys []bls.SecretKey) *ethpb.SignedBeaconBlock
+		genBlock   func(t *testing.T, st state.BeaconState, keys []bls.SecretKey) *eth.SignedBeaconBlock
 		domainType [4]byte
 		want       []byte
 	}{
@@ -61,7 +62,7 @@ func TestSigningRoot_ComputeDomainAndSign(t *testing.T) {
 				require.NoError(t, beaconState.SetSlot(beaconState.Slot()+1))
 				return beaconState, privKeys
 			},
-			genBlock: func(t *testing.T, st state.BeaconState, keys []bls.SecretKey) *ethpb.SignedBeaconBlock {
+			genBlock: func(t *testing.T, st state.BeaconState, keys []bls.SecretKey) *eth.SignedBeaconBlock {
 				block, err := util.GenerateFullBlock(st, keys, nil, 1)
 				require.NoError(t, err)
 				return block

beacon-chain/core/time/slot_epoch_test.go

@@ -81,7 +81,6 @@ func TestNextEpoch_OK(t *testing.T) {
 }
 
 func TestCanUpgradeToAltair(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
 	bc := params.BeaconConfig()
 	bc.AltairForkEpoch = 5
 	params.OverrideBeaconConfig(bc)
@@ -116,7 +115,6 @@ func TestCanUpgradeToAltair(t *testing.T) {
 }
 
 func TestCanUpgradeToMerge(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
 	bc := params.BeaconConfig()
 	bc.MergeForkEpoch = 5
 	params.OverrideBeaconConfig(bc)

beacon-chain/core/transition/BUILD.bazel

@@ -35,7 +35,6 @@ go_library(
         "//beacon-chain/core/transition/interop:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",

beacon-chain/core/transition/state.go

@@ -7,7 +7,6 @@ import (
 	b "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/beacon-chain/state/stateutil"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -106,7 +105,7 @@ func OptimizedGenesisBeaconState(genesisTime uint64, preState state.BeaconState,
 
 	slashings := make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector)
 
-	genesisValidatorsRoot, err := stateutil.ValidatorRegistryRoot(preState.Validators())
+	genesisValidatorsRoot, err := v1.ValidatorRegistryRoot(preState.Validators())
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not hash tree root genesis validators %v", err)
 	}

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -45,7 +45,7 @@ func ExecuteStateTransitionNoVerifyAnySig(
 	ctx context.Context,
 	state state.BeaconState,
 	signed block.SignedBeaconBlock,
-) (*bls.SignatureBatch, state.BeaconState, error) {
+) (*bls.SignatureSet, state.BeaconState, error) {
 	if ctx.Err() != nil {
 		return nil, nil, ctx.Err()
 	}
@@ -182,7 +182,7 @@ func ProcessBlockNoVerifyAnySig(
 	ctx context.Context,
 	state state.BeaconState,
 	signed block.SignedBeaconBlock,
-) (*bls.SignatureBatch, state.BeaconState, error) {
+) (*bls.SignatureSet, state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockNoVerifyAnySig")
 	defer span.End()
 	if err := helpers.BeaconBlockIsNil(signed); err != nil {
@@ -209,17 +209,17 @@ func ProcessBlockNoVerifyAnySig(
 		}
 	}
 
-	bSet, err := b.BlockSignatureBatch(state, blk.ProposerIndex(), signed.Signature(), blk.HashTreeRoot)
+	bSet, err := b.BlockSignatureSet(state, blk.ProposerIndex(), signed.Signature(), blk.HashTreeRoot)
 	if err != nil {
 		tracing.AnnotateError(span, err)
 		return nil, nil, errors.Wrap(err, "could not retrieve block signature set")
 	}
-	rSet, err := b.RandaoSignatureBatch(ctx, state, signed.Block().Body().RandaoReveal())
+	rSet, err := b.RandaoSignatureSet(ctx, state, signed.Block().Body().RandaoReveal())
 	if err != nil {
 		tracing.AnnotateError(span, err)
 		return nil, nil, errors.Wrap(err, "could not retrieve randao signature set")
 	}
-	aSet, err := b.AttestationSignatureBatch(ctx, state, signed.Block().Body().Attestations())
+	aSet, err := b.AttestationSignatureSet(ctx, state, signed.Block().Body().Attestations())
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "could not retrieve attestation signature set")
 	}

beacon-chain/core/transition/transition_test.go

@@ -481,10 +481,10 @@ func TestProcessSlots_LowerSlotAsParentState(t *testing.T) {
 
 func TestProcessSlots_ThroughAltairEpoch(t *testing.T) {
 	transition.SkipSlotCache.Disable()
-	params.SetupTestConfigCleanup(t)
 	conf := params.BeaconConfig()
 	conf.AltairForkEpoch = 5
 	params.OverrideBeaconConfig(conf)
+	defer params.UseMainnetConfig()
 
 	st, _ := util.DeterministicGenesisState(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	st, err := transition.ProcessSlots(context.Background(), st, params.BeaconConfig().SlotsPerEpoch*10)
@@ -516,10 +516,10 @@ func TestProcessSlots_ThroughAltairEpoch(t *testing.T) {
 
 func TestProcessSlots_OnlyAltairEpoch(t *testing.T) {
 	transition.SkipSlotCache.Disable()
-	params.SetupTestConfigCleanup(t)
 	conf := params.BeaconConfig()
 	conf.AltairForkEpoch = 5
 	params.OverrideBeaconConfig(conf)
+	defer params.UseMainnetConfig()
 
 	st, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*6))

beacon-chain/db/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "alias.go",
         "db.go",
-        "errors.go",
         "log.go",
         "restore.go",
     ],

beacon-chain/db/errors.go

@@ -1,9 +0,0 @@
-package db
-
-import "github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
-
-// ErrNotFound can be used to determine if an error from a method in the database package
-// represents a "not found" error. These often require different handling than a low-level
-// i/o error. This variable copies the value in the kv package to the same scope as the Database interfaces,
-// so that it is available to code paths that do not interact directly with the kv package.
-var ErrNotFound = kv.ErrNotFound

beacon-chain/db/iface/interface.go

@@ -13,7 +13,9 @@ import (
 	slashertypes "github.com/prysmaticlabs/prysm/beacon-chain/slasher/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/monitoring/backup"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	v2 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 )
 
@@ -38,8 +40,8 @@ type ReadOnlyDatabase interface {
 	HasStateSummary(ctx context.Context, blockRoot [32]byte) bool
 	HighestSlotStatesBelow(ctx context.Context, slot types.Slot) ([]state.ReadOnlyBeaconState, error)
 	// Checkpoint operations.
-	JustifiedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error)
-	FinalizedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error)
+	JustifiedCheckpoint(ctx context.Context) (*eth.Checkpoint, error)
+	FinalizedCheckpoint(ctx context.Context) (*eth.Checkpoint, error)
 	ArchivedPointRoot(ctx context.Context, slot types.Slot) [32]byte
 	HasArchivedPoint(ctx context.Context, slot types.Slot) bool
 	LastArchivedRoot(ctx context.Context) [32]byte
@@ -47,11 +49,7 @@ type ReadOnlyDatabase interface {
 	// Deposit contract related handlers.
 	DepositContractAddress(ctx context.Context) ([]byte, error)
 	// Powchain operations.
-	PowchainData(ctx context.Context) (*ethpb.ETH1ChainData, error)
-
-	// origin checkpoint sync support
-	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
-	LowestSyncedBlockSlot(ctx context.Context) (types.Slot, error)
+	PowchainData(ctx context.Context) (*v2.ETH1ChainData, error)
 }
 
 // NoHeadAccessDatabase defines a struct without access to chain head data.
@@ -70,12 +68,12 @@ type NoHeadAccessDatabase interface {
 	SaveStateSummary(ctx context.Context, summary *ethpb.StateSummary) error
 	SaveStateSummaries(ctx context.Context, summaries []*ethpb.StateSummary) error
 	// Checkpoint operations.
-	SaveJustifiedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
-	SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
+	SaveJustifiedCheckpoint(ctx context.Context, checkpoint *eth.Checkpoint) error
+	SaveFinalizedCheckpoint(ctx context.Context, checkpoint *eth.Checkpoint) error
 	// Deposit contract related handlers.
 	SaveDepositContractAddress(ctx context.Context, addr common.Address) error
 	// Powchain operations.
-	SavePowchainData(ctx context.Context, data *ethpb.ETH1ChainData) error
+	SavePowchainData(ctx context.Context, data *v2.ETH1ChainData) error
 	// Run any required database migrations.
 	RunMigrations(ctx context.Context) error
 
@@ -94,16 +92,13 @@ type HeadAccessDatabase interface {
 	LoadGenesis(ctx context.Context, r io.Reader) error
 	SaveGenesisData(ctx context.Context, state state.BeaconState) error
 	EnsureEmbeddedGenesis(ctx context.Context) error
-
-	// initialization method needed for origin checkpoint sync
-	SaveOrigin(ctx context.Context, state []byte, block []byte) error
 }
 
 // SlasherDatabase interface for persisting data related to detecting slashable offenses on Ethereum.
 type SlasherDatabase interface {
 	io.Closer
-	SaveLastEpochsWrittenForValidators(
-		ctx context.Context, epochByValidator map[types.ValidatorIndex]types.Epoch,
+	SaveLastEpochWrittenForValidators(
+		ctx context.Context, validatorIndices []types.ValidatorIndex, epoch types.Epoch,
 	) error
 	SaveAttestationRecordsForValidators(
 		ctx context.Context,
@@ -132,7 +127,7 @@ type SlasherDatabase interface {
 	) ([][]uint16, []bool, error)
 	CheckDoubleBlockProposals(
 		ctx context.Context, proposals []*slashertypes.SignedBlockHeaderWrapper,
-	) ([]*ethpb.ProposerSlashing, error)
+	) ([]*eth.ProposerSlashing, error)
 	PruneAttestationsAtEpoch(
 		ctx context.Context, maxEpoch types.Epoch,
 	) (numPruned uint, err error)
@@ -152,7 +147,6 @@ type Database interface {
 	io.Closer
 	backup.BackupExporter
 	HeadAccessDatabase
-
 	DatabasePath() string
 	ClearDB() error
 }

beacon-chain/db/kv/BUILD.bazel

@@ -3,17 +3,17 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "altair.go",
         "archived_point.go",
         "backup.go",
         "blocks.go",
         "checkpoint.go",
         "deposit_contract.go",
         "encoding.go",
-        "error.go",
         "finalized_block_roots.go",
         "genesis.go",
-        "key.go",
         "kv.go",
+        "light.go",
         "log.go",
         "migration.go",
         "migration_archived_index.go",
@@ -25,7 +25,6 @@ go_library(
         "state_summary.go",
         "state_summary_cache.go",
         "utils.go",
-        "wss.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/db/kv",
     visibility = [
@@ -42,7 +41,6 @@ go_library(
         "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
-        "//beacon-chain/state/v3:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//container/slice:go_default_library",
@@ -53,7 +51,6 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
         "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//proto/sniff:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_dgraph_io_ristretto//:go_default_library",
@@ -79,12 +76,10 @@ go_test(
         "archived_point_test.go",
         "backup_test.go",
         "block_altair_test.go",
-        "block_merge_test.go",
         "blocks_test.go",
         "checkpoint_test.go",
         "deposit_contract_test.go",
         "encoding_test.go",
-        "error_test.go",
         "finalized_block_roots_test.go",
         "genesis_test.go",
         "init_test.go",

beacon-chain/db/kv/altair.go

@@ -9,10 +9,3 @@ func hasAltairKey(enc []byte) bool {
 	}
 	return bytes.Equal(enc[:len(altairKey)], altairKey)
 }
-
-func hasMergeKey(enc []byte) bool {
-	if len(mergeKey) >= len(enc) {
-		return false
-	}
-	return bytes.Equal(enc[:len(mergeKey)], mergeKey)
-}

beacon-chain/db/kv/archived_point.go

@@ -11,7 +11,7 @@ import (
 
 // LastArchivedSlot from the db.
 func (s *Store) LastArchivedSlot(ctx context.Context) (types.Slot, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedSlot")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedSlot")
 	defer span.End()
 	var index types.Slot
 	err := s.db.View(func(tx *bolt.Tx) error {
@@ -26,7 +26,7 @@ func (s *Store) LastArchivedSlot(ctx context.Context) (types.Slot, error) {
 
 // LastArchivedRoot from the db.
 func (s *Store) LastArchivedRoot(ctx context.Context) [32]byte {
-	_, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedRoot")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedRoot")
 	defer span.End()
 
 	var blockRoot []byte
@@ -44,7 +44,7 @@ func (s *Store) LastArchivedRoot(ctx context.Context) [32]byte {
 // ArchivedPointRoot returns the block root of an archived point from the DB.
 // This is essential for cold state management and to restore a cold state.
 func (s *Store) ArchivedPointRoot(ctx context.Context, slot types.Slot) [32]byte {
-	_, span := trace.StartSpan(ctx, "BeaconDB.ArchivedPointRoot")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.ArchivedPointRoot")
 	defer span.End()
 
 	var blockRoot []byte
@@ -61,7 +61,7 @@ func (s *Store) ArchivedPointRoot(ctx context.Context, slot types.Slot) [32]byte
 
 // HasArchivedPoint returns true if an archived point exists in DB.
 func (s *Store) HasArchivedPoint(ctx context.Context, slot types.Slot) bool {
-	_, span := trace.StartSpan(ctx, "BeaconDB.HasArchivedPoint")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasArchivedPoint")
 	defer span.End()
 	var exists bool
 	if err := s.db.View(func(tx *bolt.Tx) error {

beacon-chain/db/kv/block_merge_test.go

@@ -1,534 +0,0 @@
-package kv
-
-import (
-	"context"
-	"sort"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	v2 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestStore_SaveMergeBlock_NoDuplicates(t *testing.T) {
-	BlockCacheSize = 1
-	db := setupDB(t)
-	slot := types.Slot(20)
-	ctx := context.Background()
-	// First we save a previous block to ensure the cache max size is reached.
-	prevBlock := util.NewBeaconBlockMerge()
-	prevBlock.Block.Slot = slot - 1
-	prevBlock.Block.ParentRoot = bytesutil.PadTo([]byte{1, 2, 3}, 32)
-	wsb, err := wrapper.WrappedMergeSignedBeaconBlock(prevBlock)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
-
-	block := util.NewBeaconBlockMerge()
-	block.Block.Slot = slot
-	block.Block.ParentRoot = bytesutil.PadTo([]byte{1, 2, 3}, 32)
-	// Even with a full cache, saving new blocks should not cause
-	// duplicated blocks in the DB.
-	for i := 0; i < 100; i++ {
-		wsb, err = wrapper.WrappedMergeSignedBeaconBlock(block)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(ctx, wsb))
-	}
-	f := filters.NewFilter().SetStartSlot(slot).SetEndSlot(slot)
-	retrieved, _, err := db.Blocks(ctx, f)
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(retrieved))
-	// We reset the block cache size.
-	BlockCacheSize = 256
-}
-
-func TestStore_MergeBlocksCRUD(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	block := util.NewBeaconBlockMerge()
-	block.Block.Slot = 20
-	block.Block.ParentRoot = bytesutil.PadTo([]byte{1, 2, 3}, 32)
-
-	blockRoot, err := block.Block.HashTreeRoot()
-	require.NoError(t, err)
-	retrievedBlock, err := db.Block(ctx, blockRoot)
-	require.NoError(t, err)
-	assert.DeepEqual(t, nil, retrievedBlock, "Expected nil block")
-	wsb, err := wrapper.WrappedMergeSignedBeaconBlock(block)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
-	assert.Equal(t, true, db.HasBlock(ctx, blockRoot), "Expected block to exist in the db")
-	retrievedBlock, err = db.Block(ctx, blockRoot)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(block, retrievedBlock.Proto()), "Wanted: %v, received: %v", block, retrievedBlock)
-	require.NoError(t, db.deleteBlock(ctx, blockRoot))
-	assert.Equal(t, false, db.HasBlock(ctx, blockRoot), "Expected block to have been deleted from the db")
-}
-
-func TestStore_MergeBlocksBatchDelete(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	numBlocks := 10
-	totalBlocks := make([]block.SignedBeaconBlock, numBlocks)
-	blockRoots := make([][32]byte, 0)
-	oddBlocks := make([]block.SignedBeaconBlock, 0)
-	for i := 0; i < len(totalBlocks); i++ {
-		b := util.NewBeaconBlockMerge()
-		b.Block.Slot = types.Slot(i)
-		b.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		wb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		totalBlocks[i] = wb
-		if i%2 == 0 {
-			r, err := totalBlocks[i].Block().HashTreeRoot()
-			require.NoError(t, err)
-			blockRoots = append(blockRoots, r)
-		} else {
-			oddBlocks = append(oddBlocks, totalBlocks[i])
-		}
-	}
-	require.NoError(t, db.SaveBlocks(ctx, totalBlocks))
-	retrieved, _, err := db.Blocks(ctx, filters.NewFilter().SetParentRoot(bytesutil.PadTo([]byte("parent"), 32)))
-	require.NoError(t, err)
-	assert.Equal(t, numBlocks, len(retrieved), "Unexpected number of blocks received")
-	// We delete all even indexed blocks.
-	require.NoError(t, db.deleteBlocks(ctx, blockRoots))
-	// When we retrieve the data, only the odd indexed blocks should remain.
-	retrieved, _, err = db.Blocks(ctx, filters.NewFilter().SetParentRoot(bytesutil.PadTo([]byte("parent"), 32)))
-	require.NoError(t, err)
-	sort.Slice(retrieved, func(i, j int) bool {
-		return retrieved[i].Block().Slot() < retrieved[j].Block().Slot()
-	})
-	for i, block := range retrieved {
-		assert.Equal(t, true, proto.Equal(block.Proto(), oddBlocks[i].Proto()), "Wanted: %v, received: %v", block, oddBlocks[i])
-	}
-}
-
-func TestStore_MergeBlocksHandleZeroCase(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	numBlocks := 10
-	totalBlocks := make([]block.SignedBeaconBlock, numBlocks)
-	for i := 0; i < len(totalBlocks); i++ {
-		b := util.NewBeaconBlockMerge()
-		b.Block.Slot = types.Slot(i)
-		b.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		wb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		totalBlocks[i] = wb
-		_, err = totalBlocks[i].Block().HashTreeRoot()
-		require.NoError(t, err)
-	}
-	require.NoError(t, db.SaveBlocks(ctx, totalBlocks))
-	zeroFilter := filters.NewFilter().SetStartSlot(0).SetEndSlot(0)
-	retrieved, _, err := db.Blocks(ctx, zeroFilter)
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(retrieved), "Unexpected number of blocks received, expected one")
-}
-
-func TestStore_MergeBlocksHandleInvalidEndSlot(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	numBlocks := 10
-	totalBlocks := make([]block.SignedBeaconBlock, numBlocks)
-	// Save blocks from slot 1 onwards.
-	for i := 0; i < len(totalBlocks); i++ {
-		b := util.NewBeaconBlockMerge()
-		b.Block.Slot = types.Slot(i) + 1
-		b.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		wb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		totalBlocks[i] = wb
-		_, err = totalBlocks[i].Block().HashTreeRoot()
-		require.NoError(t, err)
-	}
-	require.NoError(t, db.SaveBlocks(ctx, totalBlocks))
-	badFilter := filters.NewFilter().SetStartSlot(5).SetEndSlot(1)
-	_, _, err := db.Blocks(ctx, badFilter)
-	require.ErrorContains(t, errInvalidSlotRange.Error(), err)
-
-	goodFilter := filters.NewFilter().SetStartSlot(0).SetEndSlot(1)
-	requested, _, err := db.Blocks(ctx, goodFilter)
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(requested), "Unexpected number of blocks received, only expected two")
-}
-
-func TestStore_MergeBlocksCRUD_NoCache(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	block := util.NewBeaconBlockMerge()
-	block.Block.Slot = 20
-	block.Block.ParentRoot = bytesutil.PadTo([]byte{1, 2, 3}, 32)
-	blockRoot, err := block.Block.HashTreeRoot()
-	require.NoError(t, err)
-	retrievedBlock, err := db.Block(ctx, blockRoot)
-	require.NoError(t, err)
-	require.DeepEqual(t, nil, retrievedBlock, "Expected nil block")
-	wsb, err := wrapper.WrappedMergeSignedBeaconBlock(block)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
-	db.blockCache.Del(string(blockRoot[:]))
-	assert.Equal(t, true, db.HasBlock(ctx, blockRoot), "Expected block to exist in the db")
-	retrievedBlock, err = db.Block(ctx, blockRoot)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(block, retrievedBlock.Proto()), "Wanted: %v, received: %v", block, retrievedBlock)
-	require.NoError(t, db.deleteBlock(ctx, blockRoot))
-	assert.Equal(t, false, db.HasBlock(ctx, blockRoot), "Expected block to have been deleted from the db")
-}
-
-func TestStore_MergeBlocks_FiltersCorrectly(t *testing.T) {
-	db := setupDB(t)
-	b4 := util.NewBeaconBlockMerge()
-	b4.Block.Slot = 4
-	b4.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-	b5 := util.NewBeaconBlockMerge()
-	b5.Block.Slot = 5
-	b5.Block.ParentRoot = bytesutil.PadTo([]byte("parent2"), 32)
-	b6 := util.NewBeaconBlockMerge()
-	b6.Block.Slot = 6
-	b6.Block.ParentRoot = bytesutil.PadTo([]byte("parent2"), 32)
-	b7 := util.NewBeaconBlockMerge()
-	b7.Block.Slot = 7
-	b7.Block.ParentRoot = bytesutil.PadTo([]byte("parent3"), 32)
-	b8 := util.NewBeaconBlockMerge()
-	b8.Block.Slot = 8
-	b8.Block.ParentRoot = bytesutil.PadTo([]byte("parent4"), 32)
-	blocks := make([]block.SignedBeaconBlock, 0)
-	for _, b := range []*v2.SignedBeaconBlockMerge{b4, b5, b6, b7, b8} {
-		blk, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		blocks = append(blocks, blk)
-	}
-	ctx := context.Background()
-	require.NoError(t, db.SaveBlocks(ctx, blocks))
-
-	tests := []struct {
-		filter            *filters.QueryFilter
-		expectedNumBlocks int
-	}{
-		{
-			filter:            filters.NewFilter().SetParentRoot(bytesutil.PadTo([]byte("parent2"), 32)),
-			expectedNumBlocks: 2,
-		},
-		{
-			// No block meets the criteria below.
-			filter:            filters.NewFilter().SetParentRoot(bytesutil.PadTo([]byte{3, 4, 5}, 32)),
-			expectedNumBlocks: 0,
-		},
-		{
-			// Block slot range filter criteria.
-			filter:            filters.NewFilter().SetStartSlot(5).SetEndSlot(7),
-			expectedNumBlocks: 3,
-		},
-		{
-			filter:            filters.NewFilter().SetStartSlot(7).SetEndSlot(7),
-			expectedNumBlocks: 1,
-		},
-		{
-			filter:            filters.NewFilter().SetStartSlot(4).SetEndSlot(8),
-			expectedNumBlocks: 5,
-		},
-		{
-			filter:            filters.NewFilter().SetStartSlot(4).SetEndSlot(5),
-			expectedNumBlocks: 2,
-		},
-		{
-			filter:            filters.NewFilter().SetStartSlot(5).SetEndSlot(9),
-			expectedNumBlocks: 4,
-		},
-		{
-			filter:            filters.NewFilter().SetEndSlot(7),
-			expectedNumBlocks: 4,
-		},
-		{
-			filter:            filters.NewFilter().SetEndSlot(8),
-			expectedNumBlocks: 5,
-		},
-		{
-			filter:            filters.NewFilter().SetStartSlot(5).SetEndSlot(10),
-			expectedNumBlocks: 4,
-		},
-		{
-			// Composite filter criteria.
-			filter: filters.NewFilter().
-				SetParentRoot(bytesutil.PadTo([]byte("parent2"), 32)).
-				SetStartSlot(6).
-				SetEndSlot(8),
-			expectedNumBlocks: 1,
-		},
-	}
-	for _, tt := range tests {
-		retrievedBlocks, _, err := db.Blocks(ctx, tt.filter)
-		require.NoError(t, err)
-		assert.Equal(t, tt.expectedNumBlocks, len(retrievedBlocks), "Unexpected number of blocks")
-	}
-}
-
-func TestStore_MergeBlocks_VerifyBlockRoots(t *testing.T) {
-	ctx := context.Background()
-	db := setupDB(t)
-	b1 := util.NewBeaconBlockMerge()
-	b1.Block.Slot = 1
-	r1, err := b1.Block.HashTreeRoot()
-	require.NoError(t, err)
-	b2 := util.NewBeaconBlockMerge()
-	b2.Block.Slot = 2
-	r2, err := b2.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	for _, b := range []*v2.SignedBeaconBlockMerge{b1, b2} {
-		wsb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(ctx, wsb))
-	}
-
-	filter := filters.NewFilter().SetStartSlot(b1.Block.Slot).SetEndSlot(b2.Block.Slot)
-	roots, err := db.BlockRoots(ctx, filter)
-	require.NoError(t, err)
-
-	assert.DeepEqual(t, [][32]byte{r1, r2}, roots)
-}
-
-func TestStore_MergeBlocks_Retrieve_SlotRange(t *testing.T) {
-	db := setupDB(t)
-	totalBlocks := make([]block.SignedBeaconBlock, 500)
-	for i := 0; i < 500; i++ {
-		b := util.NewBeaconBlockMerge()
-		b.Block.Slot = types.Slot(i)
-		b.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		wb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		totalBlocks[i] = wb
-	}
-	ctx := context.Background()
-	require.NoError(t, db.SaveBlocks(ctx, totalBlocks))
-	retrieved, _, err := db.Blocks(ctx, filters.NewFilter().SetStartSlot(100).SetEndSlot(399))
-	require.NoError(t, err)
-	assert.Equal(t, 300, len(retrieved))
-}
-
-func TestStore_MergeBlocks_Retrieve_Epoch(t *testing.T) {
-	db := setupDB(t)
-	slots := params.BeaconConfig().SlotsPerEpoch.Mul(7)
-	totalBlocks := make([]block.SignedBeaconBlock, slots)
-	for i := types.Slot(0); i < slots; i++ {
-		b := util.NewBeaconBlockMerge()
-		b.Block.Slot = i
-		b.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		wb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		totalBlocks[i] = wb
-	}
-	ctx := context.Background()
-	require.NoError(t, db.SaveBlocks(ctx, totalBlocks))
-	retrieved, _, err := db.Blocks(ctx, filters.NewFilter().SetStartEpoch(5).SetEndEpoch(6))
-	require.NoError(t, err)
-	want := params.BeaconConfig().SlotsPerEpoch.Mul(2)
-	assert.Equal(t, uint64(want), uint64(len(retrieved)))
-	retrieved, _, err = db.Blocks(ctx, filters.NewFilter().SetStartEpoch(0).SetEndEpoch(0))
-	require.NoError(t, err)
-	want = params.BeaconConfig().SlotsPerEpoch
-	assert.Equal(t, uint64(want), uint64(len(retrieved)))
-}
-
-func TestStore_MergeBlocks_Retrieve_SlotRangeWithStep(t *testing.T) {
-	db := setupDB(t)
-	totalBlocks := make([]block.SignedBeaconBlock, 500)
-	for i := 0; i < 500; i++ {
-		b := util.NewBeaconBlockMerge()
-		b.Block.Slot = types.Slot(i)
-		b.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		wb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		totalBlocks[i] = wb
-	}
-	const step = 2
-	ctx := context.Background()
-	require.NoError(t, db.SaveBlocks(ctx, totalBlocks))
-	retrieved, _, err := db.Blocks(ctx, filters.NewFilter().SetStartSlot(100).SetEndSlot(399).SetSlotStep(step))
-	require.NoError(t, err)
-	assert.Equal(t, 150, len(retrieved))
-	for _, b := range retrieved {
-		assert.Equal(t, types.Slot(0), (b.Block().Slot()-100)%step, "Unexpect block slot %d", b.Block().Slot())
-	}
-}
-
-func TestStore_SaveMergeBlock_CanGetHighestAt(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	block1 := util.NewBeaconBlockMerge()
-	block1.Block.Slot = 1
-	block2 := util.NewBeaconBlockMerge()
-	block2.Block.Slot = 10
-	block3 := util.NewBeaconBlockMerge()
-	block3.Block.Slot = 100
-
-	for _, b := range []*v2.SignedBeaconBlockMerge{block1, block2, block3} {
-		wsb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(ctx, wsb))
-	}
-
-	highestAt, err := db.HighestSlotBlocksBelow(ctx, 2)
-	require.NoError(t, err)
-	assert.Equal(t, false, len(highestAt) <= 0, "Got empty highest at slice")
-	assert.Equal(t, true, proto.Equal(block1, highestAt[0].Proto()), "Wanted: %v, received: %v", block1, highestAt[0])
-	highestAt, err = db.HighestSlotBlocksBelow(ctx, 11)
-	require.NoError(t, err)
-	assert.Equal(t, false, len(highestAt) <= 0, "Got empty highest at slice")
-	assert.Equal(t, true, proto.Equal(block2, highestAt[0].Proto()), "Wanted: %v, received: %v", block2, highestAt[0])
-	highestAt, err = db.HighestSlotBlocksBelow(ctx, 101)
-	require.NoError(t, err)
-	assert.Equal(t, false, len(highestAt) <= 0, "Got empty highest at slice")
-	assert.Equal(t, true, proto.Equal(block3, highestAt[0].Proto()), "Wanted: %v, received: %v", block3, highestAt[0])
-
-	r3, err := block3.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, db.deleteBlock(ctx, r3))
-
-	highestAt, err = db.HighestSlotBlocksBelow(ctx, 101)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(block2, highestAt[0].Proto()), "Wanted: %v, received: %v", block2, highestAt[0])
-}
-
-func TestStore_GenesisMergeBlock_CanGetHighestAt(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	genesisBlock := util.NewBeaconBlockMerge()
-	genesisRoot, err := genesisBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisRoot))
-	wsb, err := wrapper.WrappedMergeSignedBeaconBlock(genesisBlock)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
-	block1 := util.NewBeaconBlockMerge()
-	block1.Block.Slot = 1
-	wsb, err = wrapper.WrappedMergeSignedBeaconBlock(block1)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
-
-	highestAt, err := db.HighestSlotBlocksBelow(ctx, 2)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(block1, highestAt[0].Proto()), "Wanted: %v, received: %v", block1, highestAt[0])
-	highestAt, err = db.HighestSlotBlocksBelow(ctx, 1)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(genesisBlock, highestAt[0].Proto()), "Wanted: %v, received: %v", genesisBlock, highestAt[0])
-	highestAt, err = db.HighestSlotBlocksBelow(ctx, 0)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(genesisBlock, highestAt[0].Proto()), "Wanted: %v, received: %v", genesisBlock, highestAt[0])
-}
-
-func TestStore_SaveMergeBlocks_HasCachedBlocks(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	var err error
-	b := make([]block.SignedBeaconBlock, 500)
-	for i := 0; i < 500; i++ {
-		blk := util.NewBeaconBlockMerge()
-		blk.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		blk.Block.Slot = types.Slot(i)
-		b[i], err = wrapper.WrappedMergeSignedBeaconBlock(blk)
-		require.NoError(t, err)
-	}
-
-	require.NoError(t, db.SaveBlock(ctx, b[0]))
-	require.NoError(t, db.SaveBlocks(ctx, b))
-	f := filters.NewFilter().SetStartSlot(0).SetEndSlot(500)
-
-	blks, _, err := db.Blocks(ctx, f)
-	require.NoError(t, err)
-	assert.Equal(t, 500, len(blks), "Did not get wanted blocks")
-}
-
-func TestStore_SaveMergeBlocks_HasRootsMatched(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	var err error
-	b := make([]block.SignedBeaconBlock, 500)
-	for i := 0; i < 500; i++ {
-		blk := util.NewBeaconBlockMerge()
-		blk.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
-		blk.Block.Slot = types.Slot(i)
-		b[i], err = wrapper.WrappedMergeSignedBeaconBlock(blk)
-		require.NoError(t, err)
-	}
-
-	require.NoError(t, db.SaveBlocks(ctx, b))
-	f := filters.NewFilter().SetStartSlot(0).SetEndSlot(500)
-
-	blks, roots, err := db.Blocks(ctx, f)
-	require.NoError(t, err)
-	assert.Equal(t, 500, len(blks), "Did not get wanted blocks")
-
-	for i, blk := range blks {
-		rt, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
-		assert.Equal(t, roots[i], rt, "mismatch of block roots")
-	}
-}
-
-func TestStore_MergeBlocksBySlot_BlockRootsBySlot(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	b1 := util.NewBeaconBlockMerge()
-	b1.Block.Slot = 20
-	b2 := util.NewBeaconBlockMerge()
-	b2.Block.Slot = 100
-	b2.Block.ParentRoot = bytesutil.PadTo([]byte("parent1"), 32)
-	b3 := util.NewBeaconBlockMerge()
-	b3.Block.Slot = 100
-	b3.Block.ParentRoot = bytesutil.PadTo([]byte("parent2"), 32)
-
-	for _, b := range []*v2.SignedBeaconBlockMerge{b1, b2, b3} {
-		wsb, err := wrapper.WrappedMergeSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(ctx, wsb))
-	}
-
-	r1, err := b1.Block.HashTreeRoot()
-	require.NoError(t, err)
-	r2, err := b2.Block.HashTreeRoot()
-	require.NoError(t, err)
-	r3, err := b3.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	hasBlocks, retrievedBlocks, err := db.BlocksBySlot(ctx, 1)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(retrievedBlocks), "Unexpected number of blocks received, expected none")
-	assert.Equal(t, false, hasBlocks, "Expected no blocks")
-	hasBlocks, retrievedBlocks, err = db.BlocksBySlot(ctx, 20)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(b1, retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b1, retrievedBlocks[0])
-	assert.Equal(t, true, hasBlocks, "Expected to have blocks")
-	hasBlocks, retrievedBlocks, err = db.BlocksBySlot(ctx, 100)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(b2, retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b2, retrievedBlocks[0])
-	assert.Equal(t, true, proto.Equal(b3, retrievedBlocks[1].Proto()), "Wanted: %v, received: %v", b3, retrievedBlocks[1])
-	assert.Equal(t, true, hasBlocks, "Expected to have blocks")
-
-	hasBlockRoots, retrievedBlockRoots, err := db.BlockRootsBySlot(ctx, 1)
-	require.NoError(t, err)
-	assert.DeepEqual(t, [][32]byte{}, retrievedBlockRoots)
-	assert.Equal(t, false, hasBlockRoots, "Expected no block roots")
-	hasBlockRoots, retrievedBlockRoots, err = db.BlockRootsBySlot(ctx, 20)
-	require.NoError(t, err)
-	assert.DeepEqual(t, [][32]byte{r1}, retrievedBlockRoots)
-	assert.Equal(t, true, hasBlockRoots, "Expected no block roots")
-	hasBlockRoots, retrievedBlockRoots, err = db.BlockRootsBySlot(ctx, 100)
-	require.NoError(t, err)
-	assert.DeepEqual(t, [][32]byte{r2, r3}, retrievedBlockRoots)
-	assert.Equal(t, true, hasBlockRoots, "Expected no block roots")
-}

beacon-chain/db/kv/blocks.go

@@ -23,7 +23,6 @@ import (
 
 // used to represent errors for inconsistent slot ranges.
 var errInvalidSlotRange = errors.New("invalid end slot and start slot provided")
-var errEmptyBucket = errors.New("unexpectedly empty bucket")
 
 // Block retrieval by root.
 func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (block.SignedBeaconBlock, error) {
@@ -47,47 +46,6 @@ func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (block.SignedBeac
 	return blk, err
 }
 
-// OriginCheckpointBlockRoot returns the value written to the db in SaveOriginCheckpointBlockRoot
-// This is the root of a finalized block within the weak subjectivity period
-// at the time the chain was started, used to initialize the database and chain
-// without syncing from genesis.
-func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.OriginCheckpointBlockRoot")
-	defer span.End()
-
-	var root [32]byte
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(blocksBucket)
-		rootSlice := bkt.Get(originCheckpointBlockRootKey)
-		if rootSlice == nil {
-			return ErrNotFoundOriginBlockRoot
-		}
-		copy(root[:], rootSlice)
-		return nil
-	})
-
-	return root, err
-}
-
-// LowestSyncedBlockSlot returns the lowest slot number in the block root index
-func (s *Store) LowestSyncedBlockSlot(ctx context.Context) (types.Slot, error) {
-	// start scan at zero, which will yield the lowest key in the collection.
-	var slot types.Slot
-	err := s.db.View(func(tx *bolt.Tx) error {
-		// Iterate through the index, which is in byte sorted order.
-		bkt := tx.Bucket(blockSlotIndicesBucket)
-		c := bkt.Cursor()
-		k, _ := c.First()
-		if k == nil {
-			msg := fmt.Sprintf("'%s' bucket is empty", string(blockSlotIndicesBucket))
-			return errors.Wrap(errEmptyBucket, msg)
-		}
-		slot = bytesutil.BytesToSlotBigEndian(k)
-		return nil
-	})
-	return slot, err
-}
-
 // HeadBlock returns the latest canonical block in the Ethereum Beacon Chain.
 func (s *Store) HeadBlock(ctx context.Context) (block.SignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.HeadBlock")
@@ -167,7 +125,7 @@ func (s *Store) BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]b
 
 // HasBlock checks if a block by root exists in the db.
 func (s *Store) HasBlock(ctx context.Context, blockRoot [32]byte) bool {
-	_, span := trace.StartSpan(ctx, "BeaconDB.HasBlock")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasBlock")
 	defer span.End()
 	if v, ok := s.blockCache.Get(string(blockRoot[:])); v != nil && ok {
 		return true
@@ -335,7 +293,7 @@ func (s *Store) SaveBlocks(ctx context.Context, blocks []block.SignedBeaconBlock
 
 // SaveHeadBlockRoot to the db.
 func (s *Store) SaveHeadBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveHeadBlockRoot")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveHeadBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		hasStateSummary := s.hasStateSummaryBytes(tx, blockRoot)
@@ -370,7 +328,7 @@ func (s *Store) GenesisBlock(ctx context.Context) (block.SignedBeaconBlock, erro
 
 // SaveGenesisBlockRoot to the db.
 func (s *Store) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveGenesisBlockRoot")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveGenesisBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(blocksBucket)
@@ -378,19 +336,6 @@ func (s *Store) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) er
 	})
 }
 
-// SaveOriginCheckpointBlockRoot is used to keep track of the block root used for syncing from a checkpoint origin.
-// This should be a finalized block from within the current weak subjectivity period.
-// This value is used by a running beacon chain node to locate the state at the beginning
-// of the chain history, in places where genesis would typically be used.
-func (s *Store) SaveOriginCheckpointBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveOriginCheckpointBlockRoot")
-	defer span.End()
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(blocksBucket)
-		return bucket.Put(originCheckpointBlockRootKey, blockRoot[:])
-	})
-}
-
 // HighestSlotBlocksBelow returns the block with the highest slot below the input slot from the db.
 func (s *Store) HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]block.SignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.HighestSlotBlocksBelow")
@@ -502,7 +447,7 @@ func blockRootsBySlotRange(
 	bkt *bolt.Bucket,
 	startSlotEncoded, endSlotEncoded, startEpochEncoded, endEpochEncoded, slotStepEncoded interface{},
 ) ([][]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlotRange")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlotRange")
 	defer span.End()
 
 	// Return nothing when all slot parameters are missing
@@ -567,7 +512,7 @@ func blockRootsBySlotRange(
 
 // blockRootsBySlot retrieves the block roots by slot
 func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) [][]byte {
-	_, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
 	defer span.End()
 
 	roots := make([][]byte, 0)
@@ -587,7 +532,7 @@ func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) [][]byt
 // a map of bolt DB index buckets corresponding to each particular key for indices for
 // data, such as (shard indices bucket -> shard 5).
 func createBlockIndicesFromBlock(ctx context.Context, block block.BeaconBlock) map[string][]byte {
-	_, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromBlock")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromBlock")
 	defer span.End()
 	indicesByBucket := make(map[string][]byte)
 	// Every index has a unique bucket for fast, binary-search
@@ -615,7 +560,7 @@ func createBlockIndicesFromBlock(ctx context.Context, block block.BeaconBlock) m
 // objects. If a certain filter criterion does not apply to
 // blocks, an appropriate error is returned.
 func createBlockIndicesFromFilters(ctx context.Context, f *filters.QueryFilter) (map[string][]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromFilters")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromFilters")
 	defer span.End()
 	indicesByBucket := make(map[string][]byte)
 	for k, v := range f.Filters() {
@@ -656,13 +601,6 @@ func unmarshalBlock(_ context.Context, enc []byte) (block.SignedBeaconBlock, err
 			return nil, err
 		}
 		return wrapper.WrappedAltairSignedBeaconBlock(rawBlock)
-	case hasMergeKey(enc):
-		rawBlock := &ethpb.SignedBeaconBlockMerge{}
-		err := rawBlock.UnmarshalSSZ(enc[len(mergeKey):])
-		if err != nil {
-			return nil, err
-		}
-		return wrapper.WrappedMergeSignedBeaconBlock(rawBlock)
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock := &ethpb.SignedBeaconBlock{}
@@ -681,8 +619,6 @@ func marshalBlock(_ context.Context, blk block.SignedBeaconBlock) ([]byte, error
 		return nil, err
 	}
 	switch blk.Version() {
-	case version.Merge:
-		return snappy.Encode(nil, append(mergeKey, obj...)), nil
 	case version.Altair:
 		return snappy.Encode(nil, append(altairKey, obj...)), nil
 	case version.Phase0:

beacon-chain/db/kv/blocks_test.go

@@ -17,30 +17,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-func TestStore_LowestSyncedBlockSlot(t *testing.T) {
-	// test case: make sure expected error is returned w/ an empty bucket
-	db := setupDB(t)
-	ctx := context.Background()
-	_, err := db.LowestSyncedBlockSlot(ctx)
-	require.ErrorIs(t, err, errEmptyBucket)
-
-	// test case: make sure that the right value is returned using a non-zero key
-	block := util.NewBeaconBlock()
-	block.Block.Slot = types.Slot(1 << 32)
-	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block)))
-	slot, err := db.LowestSyncedBlockSlot(ctx)
-	require.NoError(t, err)
-	require.Equal(t, slot, block.Block.Slot)
-
-	// test case: write a lower value and make sure that it is returned instead of the existing value
-	zero := util.NewBeaconBlock()
-	zero.Block.Slot = types.Slot(0)
-	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(zero)))
-	zslot, err := db.LowestSyncedBlockSlot(ctx)
-	require.NoError(t, err)
-	require.Equal(t, zslot, zero.Block.Slot)
-}
-
 func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
 	BlockCacheSize = 1
 	db := setupDB(t)

beacon-chain/db/kv/deposit_contract.go

@@ -12,7 +12,7 @@ import (
 // DepositContractAddress returns contract address is the address of
 // the deposit contract on the proof of work chain.
 func (s *Store) DepositContractAddress(ctx context.Context) ([]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.DepositContractAddress")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.DepositContractAddress")
 	defer span.End()
 	var addr []byte
 	if err := s.db.View(func(tx *bolt.Tx) error {
@@ -27,7 +27,7 @@ func (s *Store) DepositContractAddress(ctx context.Context) ([]byte, error) {
 
 // SaveDepositContractAddress to the db. It returns an error if an address has been previously saved.
 func (s *Store) SaveDepositContractAddress(ctx context.Context, addr common.Address) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.VerifyContractAddress")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.VerifyContractAddress")
 	defer span.End()
 
 	return s.db.Update(func(tx *bolt.Tx) error {

beacon-chain/db/kv/encoding.go

@@ -13,7 +13,7 @@ import (
 )
 
 func decode(ctx context.Context, data []byte, dst proto.Message) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.decode")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.decode")
 	defer span.End()
 
 	data, err := snappy.Decode(nil, data)
@@ -27,7 +27,7 @@ func decode(ctx context.Context, data []byte, dst proto.Message) error {
 }
 
 func encode(ctx context.Context, msg proto.Message) ([]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.encode")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.encode")
 	defer span.End()
 
 	if msg == nil || reflect.ValueOf(msg).IsNil() {

beacon-chain/db/kv/error.go

@@ -1,46 +0,0 @@
-package kv
-
-import "errors"
-
-// ErrNotFound can be used directly, or as a wrapped DBError, whenever a db method needs to
-// indicate that a value couldn't be found.
-var ErrNotFound = errors.New("not found in db")
-
-// ErrNotFoundOriginBlockRoot is an error specifically for the origin block root getter
-var ErrNotFoundOriginBlockRoot = WrapDBError(ErrNotFound, "OriginCheckpointBlockRoot")
-
-// WrapDBError wraps an error in a DBError. See commentary on DBError for more context.
-func WrapDBError(e error, outer string) error {
-	return DBError{
-		Wraps: e,
-		Outer: errors.New(outer),
-	}
-}
-
-// DBError implements the Error method so that it can be asserted as an error.
-// The Unwrap method supports error wrapping, enabling it to be used with errors.Is/As.
-// The primary use case is to make it simple for database methods to return errors
-// that wrap ErrNotFound, allowing calling code to check for "not found" errors
-// like: `error.Is(err, ErrNotFound)`. This is intended to improve error handling
-// in db lookup methods that need to differentiate between a missing value and some
-// other database error. for more background see:
-// https://go.dev/blog/go1.13-errors
-type DBError struct {
-	Wraps error
-	Outer error
-}
-
-// Error satisfies the error interface, so that DBErrors can be used anywhere that
-// expects an `error`.
-func (e DBError) Error() string {
-	es := e.Outer.Error()
-	if e.Wraps != nil {
-		es += ": " + e.Wraps.Error()
-	}
-	return es
-}
-
-// Unwrap is used by the errors package Is and As methods.
-func (e DBError) Unwrap() error {
-	return e.Wraps
-}

beacon-chain/db/kv/error_test.go

@@ -1,24 +0,0 @@
-package kv
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestWrappedSentinelError(t *testing.T) {
-	e := ErrNotFoundOriginBlockRoot
-	if !errors.Is(e, ErrNotFoundOriginBlockRoot) {
-		t.Error("expected that a copy of ErrNotFoundOriginBlockRoot would have an is-a relationship")
-	}
-
-	outer := errors.New("wrapped error")
-	e2 := DBError{Wraps: ErrNotFoundOriginBlockRoot, Outer: outer}
-	if !errors.Is(e2, ErrNotFoundOriginBlockRoot) {
-		t.Error("expected that errors.Is would know DBError wraps ErrNotFoundOriginBlockRoot")
-	}
-
-	// test that the innermost not found error is detected
-	if !errors.Is(e2, ErrNotFound) {
-		t.Error("expected that errors.Is would know ErrNotFoundOriginBlockRoot wraps ErrNotFound")
-	}
-}

beacon-chain/db/kv/finalized_block_roots.go

@@ -8,6 +8,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
+	dbpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	bolt "go.etcd.io/bbolt"
@@ -46,7 +47,6 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 	root := checkpoint.Root
 	var previousRoot []byte
 	genesisRoot := tx.Bucket(blocksBucket).Get(genesisBlockRootKey)
-	initCheckpointRoot := tx.Bucket(blocksBucket).Get(originCheckpointBlockRootKey)
 
 	// De-index recent finalized block roots, to be re-indexed.
 	previousFinalizedCheckpoint := &ethpb.Checkpoint{}
@@ -75,7 +75,7 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 	// Walk up the ancestry chain until we reach a block root present in the finalized block roots
 	// index bucket or genesis block root.
 	for {
-		if bytes.Equal(root, genesisRoot) || bytes.Equal(root, initCheckpointRoot) {
+		if bytes.Equal(root, genesisRoot) {
 			break
 		}
 
@@ -90,7 +90,7 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 		}
 		block := signedBlock.Block()
 
-		container := &ethpb.FinalizedBlockRootContainer{
+		container := &dbpb.FinalizedBlockRootContainer{
 			ParentRoot: block.ParentRoot(),
 			ChildRoot:  previousRoot,
 		}
@@ -107,7 +107,7 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 
 		// Found parent, loop exit condition.
 		if parentBytes := bkt.Get(block.ParentRoot()); parentBytes != nil {
-			parent := &ethpb.FinalizedBlockRootContainer{}
+			parent := &dbpb.FinalizedBlockRootContainer{}
 			if err := decode(ctx, parentBytes, parent); err != nil {
 				tracing.AnnotateError(span, err)
 				return err
@@ -160,7 +160,7 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 // Note: beacon blocks from the latest finalized epoch return true, whether or not they are
 // considered canonical in the "head view" of the beacon node.
 func (s *Store) IsFinalizedBlock(ctx context.Context, blockRoot [32]byte) bool {
-	_, span := trace.StartSpan(ctx, "BeaconDB.IsFinalizedBlock")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.IsFinalizedBlock")
 	defer span.End()
 
 	var exists bool
@@ -195,7 +195,7 @@ func (s *Store) FinalizedChildBlock(ctx context.Context, blockRoot [32]byte) (bl
 		if bytes.Equal(blkBytes, containerFinalizedButNotCanonical) {
 			return nil
 		}
-		ctr := &ethpb.FinalizedBlockRootContainer{}
+		ctr := &dbpb.FinalizedBlockRootContainer{}
 		if err := decode(ctx, blkBytes, ctr); err != nil {
 			tracing.AnnotateError(span, err)
 			return err

beacon-chain/db/kv/powchain.go

@@ -13,7 +13,7 @@ import (
 
 // SavePowchainData saves the pow chain data.
 func (s *Store) SavePowchainData(ctx context.Context, data *v2.ETH1ChainData) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SavePowchainData")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SavePowchainData")
 	defer span.End()
 
 	if data == nil {
@@ -36,7 +36,7 @@ func (s *Store) SavePowchainData(ctx context.Context, data *v2.ETH1ChainData) er
 
 // PowchainData retrieves the powchain data.
 func (s *Store) PowchainData(ctx context.Context) (*v2.ETH1ChainData, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.PowchainData")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.PowchainData")
 	defer span.End()
 
 	var data *v2.ETH1ChainData

beacon-chain/db/kv/schema.go

@@ -43,13 +43,9 @@ var (
 	justifiedCheckpointKey    = []byte("justified-checkpoint")
 	finalizedCheckpointKey    = []byte("finalized-checkpoint")
 	powchainDataKey           = []byte("powchain-data")
-
-	// Below keys are used to identify objects are to be fork compatible.
-	// Objects that are only compatible with specific forks should be prefixed with such keys.
+	// Altair key used to identify object is altair compatible.
+	// Objects that are only compatible with altair should be prefixed with such key.
 	altairKey = []byte("altair")
-	mergeKey  = []byte("merge")
-	// block root included in the beacon state used by weak subjectivity initial sync
-	originCheckpointBlockRootKey = []byte("origin-checkpoint-block-root")
 
 	// Deprecated: This index key was migrated in PR 6461. Do not use, except for migrations.
 	lastArchivedIndexKey = []byte("last-archived")

beacon-chain/db/kv/state.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/genesis"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -276,7 +275,7 @@ func (s *Store) SaveStatesEfficient(ctx context.Context, states []state.ReadOnly
 
 // HasState checks if a state by root exists in the db.
 func (s *Store) HasState(ctx context.Context, blockRoot [32]byte) bool {
-	_, span := trace.StartSpan(ctx, "BeaconDB.HasState")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasState")
 	defer span.End()
 	hasState := false
 	err := s.db.View(func(tx *bolt.Tx) error {
@@ -386,20 +385,6 @@ func (s *Store) unmarshalState(_ context.Context, enc []byte, validatorEntries [
 	}
 
 	switch {
-	case hasMergeKey(enc):
-		// Marshal state bytes to altair beacon state.
-		protoState := &ethpb.BeaconStateMerge{}
-		if err := protoState.UnmarshalSSZ(enc[len(mergeKey):]); err != nil {
-			return nil, errors.Wrap(err, "failed to unmarshal encoding for altair")
-		}
-		ok, err := s.isStateValidatorMigrationOver()
-		if err != nil {
-			return nil, err
-		}
-		if ok {
-			protoState.Validators = validatorEntries
-		}
-		return v3.InitializeFromProtoUnsafe(protoState)
 	case hasAltairKey(enc):
 		// Marshal state bytes to altair beacon state.
 		protoState := &ethpb.BeaconStateAltair{}
@@ -453,19 +438,6 @@ func marshalState(ctx context.Context, st state.ReadOnlyBeaconState) ([]byte, er
 			return nil, err
 		}
 		return snappy.Encode(nil, append(altairKey, rawObj...)), nil
-	case *ethpb.BeaconStateMerge:
-		rState, ok := st.InnerStateUnsafe().(*ethpb.BeaconStateMerge)
-		if !ok {
-			return nil, errors.New("non valid inner state")
-		}
-		if rState == nil {
-			return nil, errors.New("nil state")
-		}
-		rawObj, err := rState.MarshalSSZ()
-		if err != nil {
-			return nil, err
-		}
-		return snappy.Encode(nil, append(mergeKey, rawObj...)), nil
 	default:
 		return nil, errors.New("invalid inner state")
 	}
@@ -541,7 +513,7 @@ func (s *Store) validatorEntries(ctx context.Context, blockRoot [32]byte) ([]*et
 
 // retrieves and assembles the state information from multiple buckets.
 func (s *Store) stateBytes(ctx context.Context, blockRoot [32]byte) ([]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.stateBytes")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.stateBytes")
 	defer span.End()
 	var dst []byte
 	err := s.db.View(func(tx *bolt.Tx) error {
@@ -660,7 +632,7 @@ func (s *Store) HighestSlotStatesBelow(ctx context.Context, slot types.Slot) ([]
 // a map of bolt DB index buckets corresponding to each particular key for indices for
 // data, such as (shard indices bucket -> shard 5).
 func createStateIndicesFromStateSlot(ctx context.Context, slot types.Slot) map[string][]byte {
-	_, span := trace.StartSpan(ctx, "BeaconDB.createStateIndicesFromState")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.createStateIndicesFromState")
 	defer span.End()
 	indicesByBucket := make(map[string][]byte)
 	// Every index has a unique bucket for fast, binary-search

beacon-chain/db/kv/state_summary.go

@@ -64,7 +64,7 @@ func (s *Store) StateSummary(ctx context.Context, blockRoot [32]byte) (*ethpb.St
 
 // HasStateSummary returns true if a state summary exists in DB.
 func (s *Store) HasStateSummary(ctx context.Context, blockRoot [32]byte) bool {
-	_, span := trace.StartSpan(ctx, "BeaconDB.HasStateSummary")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasStateSummary")
 	defer span.End()
 
 	var hasSummary bool

beacon-chain/db/kv/state_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	v1alpha "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -182,7 +183,7 @@ func TestState_CanSaveRetrieveValidatorEntriesFromCache(t *testing.T) {
 		assert.Equal(t, true, ok)
 		require.NotNil(t, data)
 
-		valEntry, vType := data.(*ethpb.Validator)
+		valEntry, vType := data.(*v1alpha.Validator)
 		assert.Equal(t, true, vType)
 		require.NotNil(t, valEntry)
 
@@ -781,100 +782,6 @@ func checkStateReadTime(b *testing.B, saveCount int) {
 	}
 }
 
-func TestStateMerge_CanSaveRetrieveValidatorEntries(t *testing.T) {
-	db := setupDB(t)
-
-	// enable historical state representation flag to test this
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnableHistoricalSpaceRepresentation: true,
-	})
-	defer resetCfg()
-
-	r := [32]byte{'A'}
-
-	require.Equal(t, false, db.HasState(context.Background(), r))
-
-	stateValidators := validators(10)
-	st, _ := util.DeterministicGenesisStateMerge(t, 20)
-	require.NoError(t, st.SetSlot(100))
-	require.NoError(t, st.SetValidators(stateValidators))
-
-	ctx := context.Background()
-	require.NoError(t, db.SaveState(ctx, st, r))
-	assert.Equal(t, true, db.HasState(context.Background(), r))
-
-	savedS, err := db.State(context.Background(), r)
-	require.NoError(t, err)
-
-	require.DeepSSZEqual(t, st.InnerStateUnsafe(), savedS.InnerStateUnsafe(), "saved state with validators and retrieved state are not matching")
-
-	// check if the index of the second state is still present.
-	err = db.db.Update(func(tx *bolt.Tx) error {
-		idxBkt := tx.Bucket(blockRootValidatorHashesBucket)
-		data := idxBkt.Get(r[:])
-		require.NotEqual(t, 0, len(data))
-		return nil
-	})
-	require.NoError(t, err)
-
-	// check if all the validator entries are still intact in the validator entry bucket.
-	err = db.db.Update(func(tx *bolt.Tx) error {
-		valBkt := tx.Bucket(stateValidatorsBucket)
-		// if any of the original validator entry is not present, then fail the test.
-		for _, val := range stateValidators {
-			hash, hashErr := val.HashTreeRoot()
-			assert.NoError(t, hashErr)
-			data := valBkt.Get(hash[:])
-			require.NotNil(t, data)
-			require.NotEqual(t, 0, len(data))
-		}
-		return nil
-	})
-	require.NoError(t, err)
-}
-
-func TestMergeState_CanSaveRetrieve(t *testing.T) {
-	db := setupDB(t)
-
-	r := [32]byte{'A'}
-
-	require.Equal(t, false, db.HasState(context.Background(), r))
-
-	st, _ := util.DeterministicGenesisStateMerge(t, 1)
-	require.NoError(t, st.SetSlot(100))
-
-	require.NoError(t, db.SaveState(context.Background(), st, r))
-	require.Equal(t, true, db.HasState(context.Background(), r))
-
-	savedS, err := db.State(context.Background(), r)
-	require.NoError(t, err)
-
-	require.DeepSSZEqual(t, st.InnerStateUnsafe(), savedS.InnerStateUnsafe())
-
-	savedS, err = db.State(context.Background(), [32]byte{'B'})
-	require.NoError(t, err)
-	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
-}
-
-func TestMergeState_CanDelete(t *testing.T) {
-	db := setupDB(t)
-
-	r := [32]byte{'A'}
-
-	require.Equal(t, false, db.HasState(context.Background(), r))
-
-	st, _ := util.DeterministicGenesisStateMerge(t, 1)
-	require.NoError(t, st.SetSlot(100))
-
-	require.NoError(t, db.SaveState(context.Background(), st, r))
-	require.Equal(t, true, db.HasState(context.Background(), r))
-
-	require.NoError(t, db.DeleteState(context.Background(), r))
-	savedS, err := db.State(context.Background(), r)
-	require.NoError(t, err)
-	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
-}
-
 func BenchmarkState_CheckStateSaveTime_1(b *testing.B)  { checkStateSaveTime(b, 1) }
 func BenchmarkState_CheckStateSaveTime_10(b *testing.B) { checkStateSaveTime(b, 10) }
 

beacon-chain/db/kv/utils.go

@@ -16,7 +16,7 @@ import (
 // we might find roots `0x23` and `0x45` stored under that index. We can then
 // do a batch read for attestations corresponding to those roots.
 func lookupValuesForIndices(ctx context.Context, indicesByBucket map[string][]byte, tx *bolt.Tx) [][][]byte {
-	_, span := trace.StartSpan(ctx, "BeaconDB.lookupValuesForIndices")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.lookupValuesForIndices")
 	defer span.End()
 	values := make([][][]byte, 0, len(indicesByBucket))
 	for k, v := range indicesByBucket {
@@ -35,7 +35,7 @@ func lookupValuesForIndices(ctx context.Context, indicesByBucket map[string][]by
 // values stored at said index. Typically, indices are roots of data that can then
 // be used for reads or batch reads from the DB.
 func updateValueForIndices(ctx context.Context, indicesByBucket map[string][]byte, root []byte, tx *bolt.Tx) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.updateValueForIndices")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.updateValueForIndices")
 	defer span.End()
 	for k, idx := range indicesByBucket {
 		bkt := tx.Bucket([]byte(k))
@@ -61,7 +61,7 @@ func updateValueForIndices(ctx context.Context, indicesByBucket map[string][]byt
 
 // deleteValueForIndices clears a root stored at each index.
 func deleteValueForIndices(ctx context.Context, indicesByBucket map[string][]byte, root []byte, tx *bolt.Tx) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.deleteValueForIndices")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteValueForIndices")
 	defer span.End()
 	for k, idx := range indicesByBucket {
 		bkt := tx.Bucket([]byte(k))

beacon-chain/db/kv/wss.go

@@ -1,90 +0,0 @@
-package kv
-
-import (
-	"context"
-	"fmt"
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/sniff"
-)
-
-// SaveOrigin loads an ssz serialized Block & BeaconState from an io.Reader
-// (ex: an open file) prepares the database so that the beacon node can begin
-// syncing, using the provided values as their point of origin. This is an alternative
-// to syncing from genesis, and should only be run on an empty database.
-func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error {
-	cf, err := sniff.ConfigForkForState(serState)
-	if err != nil {
-		return errors.Wrap(err, "could not sniff config+fork for origin state bytes")
-	}
-	_, ok := params.BeaconConfig().ForkVersionSchedule[cf.Version]
-	if !ok {
-		return fmt.Errorf("config mismatch, beacon node configured to connect to %s, detected state is for %s", params.BeaconConfig().ConfigName, cf.ConfigName.String())
-	}
-
-	log.Printf("detected supported config for state & block version detection, name=%s, fork=%s", cf.ConfigName.String(), cf.Fork)
-	state, err := sniff.BeaconStateForConfigFork(serState, cf)
-	if err != nil {
-		return errors.Wrap(err, "failed to initialize origin state w/ bytes + config+fork")
-	}
-
-	wblk, err := sniff.BlockForConfigFork(serBlock, cf)
-	if err != nil {
-		return errors.Wrap(err, "failed to initialize origin block w/ bytes + config+fork")
-	}
-	blk := wblk.Block()
-
-	// save block
-	blockRoot, err := blk.HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not compute HashTreeRoot of checkpoint block")
-	}
-	log.Infof("saving checkpoint block to db, w/ root=%#x", blockRoot)
-	if err := s.SaveBlock(ctx, wblk); err != nil {
-		return errors.Wrap(err, "could not save checkpoint block")
-	}
-
-	// save state
-	log.Infof("calling SaveState w/ blockRoot=%x", blockRoot)
-	if err = s.SaveState(ctx, state, blockRoot); err != nil {
-		return errors.Wrap(err, "could not save state")
-	}
-	if err = s.SaveStateSummary(ctx, &ethpb.StateSummary{
-		Slot: state.Slot(),
-		Root: blockRoot[:],
-	}); err != nil {
-		return errors.Wrap(err, "could not save state summary")
-	}
-
-	// save origin block root in special key, to be used when the canonical
-	// origin (start of chain, ie alternative to genesis) block or state is needed
-	if err = s.SaveOriginCheckpointBlockRoot(ctx, blockRoot); err != nil {
-		return errors.Wrap(err, "could not save origin block root")
-	}
-
-	// mark block as head of chain, so that processing will pick up from this point
-	if err = s.SaveHeadBlockRoot(ctx, blockRoot); err != nil {
-		return errors.Wrap(err, "could not save head block root")
-	}
-
-	// rebuild the checkpoint from the block
-	// use it to mark the block as justified and finalized
-	slotEpoch, err := blk.Slot().SafeDivSlot(params.BeaconConfig().SlotsPerEpoch)
-	if err != nil {
-		return err
-	}
-	chkpt := &ethpb.Checkpoint{
-		Epoch: types.Epoch(slotEpoch),
-		Root:  blockRoot[:],
-	}
-	if err = s.SaveJustifiedCheckpoint(ctx, chkpt); err != nil {
-		return errors.Wrap(err, "could not mark checkpoint sync block as justified")
-	}
-	if err = s.SaveFinalizedCheckpoint(ctx, chkpt); err != nil {
-		return errors.Wrap(err, "could not mark checkpoint sync block as finalized")
-	}
-
-	return nil
-}

beacon-chain/db/slasherkv/pruning.go

@@ -14,7 +14,7 @@ import (
 // PruneAttestationsAtEpoch deletes all attestations from the slasher DB with target epoch
 // less than or equal to the specified epoch.
 func (s *Store) PruneAttestationsAtEpoch(
-	_ context.Context, maxEpoch types.Epoch,
+	ctx context.Context, maxEpoch types.Epoch,
 ) (numPruned uint, err error) {
 	// We can prune everything less than the current epoch - history length.
 	encodedEndPruneEpoch := fssz.MarshalUint64([]byte{}, uint64(maxEpoch))
@@ -128,9 +128,6 @@ func (s *Store) PruneProposalsAtEpoch(
 		c := proposalBkt.Cursor()
 		// We begin a pruning iteration starting from the first item in the bucket.
 		for k, _ := c.First(); k != nil; k, _ = c.Next() {
-			if ctx.Err() != nil {
-				return ctx.Err()
-			}
 			// We check the slot from the current key in the database.
 			// If we have hit a slot that is greater than the end slot of the pruning process,
 			// we then completely exit the process as we are done.

beacon-chain/db/slasherkv/pruning_test.go

@@ -53,10 +53,11 @@ func TestStore_PruneProposalsAtEpoch(t *testing.T) {
 	t.Run("prune_and_verify_deletions", func(t *testing.T) {
 		beaconDB := setupDB(t)
 
-		params.SetupTestConfigCleanup(t)
 		config := params.BeaconConfig()
-		config.SlotsPerEpoch = 2
-		params.OverrideBeaconConfig(config)
+		copyConfig := config.Copy()
+		copyConfig.SlotsPerEpoch = 2
+		params.OverrideBeaconConfig(copyConfig)
+		defer params.OverrideBeaconConfig(config)
 
 		historyLength := types.Epoch(10)
 		currentEpoch := types.Epoch(20)
@@ -152,10 +153,11 @@ func TestStore_PruneAttestations_OK(t *testing.T) {
 	t.Run("prune_and_verify_deletions", func(t *testing.T) {
 		beaconDB := setupDB(t)
 
-		params.SetupTestConfigCleanup(t)
 		config := params.BeaconConfig()
-		config.SlotsPerEpoch = 2
-		params.OverrideBeaconConfig(config)
+		copyConfig := config.Copy()
+		copyConfig.SlotsPerEpoch = 2
+		params.OverrideBeaconConfig(copyConfig)
+		defer params.OverrideBeaconConfig(config)
 
 		historyLength := types.Epoch(10)
 		currentEpoch := types.Epoch(20)

beacon-chain/db/slasherkv/slasher.go

@@ -15,6 +15,7 @@ import (
 	slashertypes "github.com/prysmaticlabs/prysm/beacon-chain/slasher/types"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	slashpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
 	"golang.org/x/sync/errgroup"
@@ -31,7 +32,7 @@ const (
 func (s *Store) LastEpochWrittenForValidators(
 	ctx context.Context, validatorIndices []types.ValidatorIndex,
 ) ([]*slashertypes.AttestedEpochForValidator, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.LastEpochWrittenForValidators")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LastEpochWrittenForValidators")
 	defer span.End()
 	attestedEpochs := make([]*slashertypes.AttestedEpochForValidator, 0)
 	encodedIndices := make([][]byte, len(validatorIndices))
@@ -41,73 +42,47 @@ func (s *Store) LastEpochWrittenForValidators(
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(attestedEpochsByValidator)
 		for i, encodedIndex := range encodedIndices {
-			var epoch types.Epoch
 			epochBytes := bkt.Get(encodedIndex)
 			if epochBytes != nil {
+				var epoch types.Epoch
 				if err := epoch.UnmarshalSSZ(epochBytes); err != nil {
 					return err
 				}
+				attestedEpochs = append(attestedEpochs, &slashertypes.AttestedEpochForValidator{
+					ValidatorIndex: validatorIndices[i],
+					Epoch:          epoch,
+				})
 			}
-			attestedEpochs = append(attestedEpochs, &slashertypes.AttestedEpochForValidator{
-				ValidatorIndex: validatorIndices[i],
-				Epoch:          epoch,
-			})
 		}
 		return nil
 	})
 	return attestedEpochs, err
 }
 
-// SaveLastEpochsWrittenForValidators updates the latest epoch a slice
+// SaveLastEpochWrittenForValidators updates the latest epoch a slice
 // of validator indices has attested to.
-func (s *Store) SaveLastEpochsWrittenForValidators(
-	ctx context.Context, epochByValidator map[types.ValidatorIndex]types.Epoch,
+func (s *Store) SaveLastEpochWrittenForValidators(
+	ctx context.Context, validatorIndices []types.ValidatorIndex, epoch types.Epoch,
 ) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveLastEpochsWrittenForValidators")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveLastEpochWrittenForValidators")
 	defer span.End()
-	encodedIndices := make([][]byte, 0, len(epochByValidator))
-	encodedEpochs := make([][]byte, 0, len(epochByValidator))
-	for valIdx, epoch := range epochByValidator {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		encodedEpoch, err := epoch.MarshalSSZ()
-		if err != nil {
-			return err
-		}
-		encodedIndices = append(encodedIndices, encodeValidatorIndex(valIdx))
-		encodedEpochs = append(encodedEpochs, encodedEpoch)
+	encodedIndices := make([][]byte, len(validatorIndices))
+	for i, valIdx := range validatorIndices {
+		encodedIndices[i] = encodeValidatorIndex(valIdx)
 	}
-	// The list of validators might be too massive for boltdb to handle in a single transaction,
-	// so instead we split it into batches and write each batch.
-	batchSize := 10000
-	for i := 0; i < len(encodedIndices); i += batchSize {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		if err := s.db.Update(func(tx *bolt.Tx) error {
-			if ctx.Err() != nil {
-				return ctx.Err()
-			}
-			bkt := tx.Bucket(attestedEpochsByValidator)
-			min := i + batchSize
-			if min > len(encodedIndices) {
-				min = len(encodedIndices)
-			}
-			for j, encodedIndex := range encodedIndices[i:min] {
-				if ctx.Err() != nil {
-					return ctx.Err()
-				}
-				if err := bkt.Put(encodedIndex, encodedEpochs[j]); err != nil {
-					return err
-				}
-			}
-			return nil
-		}); err != nil {
-			return err
-		}
+	encodedEpoch, err := epoch.MarshalSSZ()
+	if err != nil {
+		return err
 	}
-	return nil
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(attestedEpochsByValidator)
+		for _, encodedIndex := range encodedIndices {
+			if err = bkt.Put(encodedIndex, encodedEpoch); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
 }
 
 // CheckAttesterDoubleVotes retries any slashable double votes that exist
@@ -183,7 +158,7 @@ func (s *Store) CheckAttesterDoubleVotes(
 func (s *Store) AttestationRecordForValidator(
 	ctx context.Context, validatorIdx types.ValidatorIndex, targetEpoch types.Epoch,
 ) (*slashertypes.IndexedAttestationWrapper, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.AttestationRecordForValidator")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.AttestationRecordForValidator")
 	defer span.End()
 	var record *slashertypes.IndexedAttestationWrapper
 	encIdx := encodeValidatorIndex(validatorIdx)
@@ -215,7 +190,7 @@ func (s *Store) SaveAttestationRecordsForValidators(
 	ctx context.Context,
 	attestations []*slashertypes.IndexedAttestationWrapper,
 ) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveAttestationRecordsForValidators")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveAttestationRecordsForValidators")
 	defer span.End()
 	encodedTargetEpoch := make([][]byte, len(attestations))
 	encodedRecords := make([][]byte, len(attestations))
@@ -259,7 +234,7 @@ func (s *Store) SaveAttestationRecordsForValidators(
 func (s *Store) LoadSlasherChunks(
 	ctx context.Context, kind slashertypes.ChunkKind, diskKeys [][]byte,
 ) ([][]uint16, []bool, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.LoadSlasherChunk")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LoadSlasherChunk")
 	defer span.End()
 	chunks := make([][]uint16, 0)
 	var exists []bool
@@ -290,7 +265,7 @@ func (s *Store) LoadSlasherChunks(
 func (s *Store) SaveSlasherChunks(
 	ctx context.Context, kind slashertypes.ChunkKind, chunkKeys [][]byte, chunks [][]uint16,
 ) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveSlasherChunks")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveSlasherChunks")
 	defer span.End()
 	encodedKeys := make([][]byte, len(chunkKeys))
 	encodedChunks := make([][]byte, len(chunkKeys))
@@ -320,7 +295,7 @@ func (s *Store) SaveSlasherChunks(
 func (s *Store) CheckDoubleBlockProposals(
 	ctx context.Context, proposals []*slashertypes.SignedBlockHeaderWrapper,
 ) ([]*ethpb.ProposerSlashing, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.CheckDoubleBlockProposals")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.CheckDoubleBlockProposals")
 	defer span.End()
 	proposerSlashings := make([]*ethpb.ProposerSlashing, 0, len(proposals))
 	err := s.db.View(func(tx *bolt.Tx) error {
@@ -359,7 +334,7 @@ func (s *Store) CheckDoubleBlockProposals(
 func (s *Store) BlockProposalForValidator(
 	ctx context.Context, validatorIdx types.ValidatorIndex, slot types.Slot,
 ) (*slashertypes.SignedBlockHeaderWrapper, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.BlockProposalForValidator")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.BlockProposalForValidator")
 	defer span.End()
 	var record *slashertypes.SignedBlockHeaderWrapper
 	key, err := keyForValidatorProposal(slot, validatorIdx)
@@ -387,7 +362,7 @@ func (s *Store) BlockProposalForValidator(
 func (s *Store) SaveBlockProposals(
 	ctx context.Context, proposals []*slashertypes.SignedBlockHeaderWrapper,
 ) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveBlockProposals")
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveBlockProposals")
 	defer span.End()
 	encodedKeys := make([][]byte, len(proposals))
 	encodedProposals := make([][]byte, len(proposals))
@@ -419,9 +394,9 @@ func (s *Store) SaveBlockProposals(
 
 // HighestAttestations retrieves the last attestation data from the database for all indices.
 func (s *Store) HighestAttestations(
-	_ context.Context,
+	ctx context.Context,
 	indices []types.ValidatorIndex,
-) ([]*ethpb.HighestAttestation, error) {
+) ([]*slashpb.HighestAttestation, error) {
 	if len(indices) == 0 {
 		return nil, nil
 	}
@@ -436,7 +411,7 @@ func (s *Store) HighestAttestations(
 		encodedIndices[i] = encodeValidatorIndex(valIdx)
 	}
 
-	history := make([]*ethpb.HighestAttestation, 0, len(encodedIndices))
+	history := make([]*slashpb.HighestAttestation, 0, len(encodedIndices))
 	err = s.db.View(func(tx *bolt.Tx) error {
 		signingRootsBkt := tx.Bucket(attestationDataRootsBucket)
 		attRecordsBkt := tx.Bucket(attestationRecordsBucket)
@@ -452,7 +427,7 @@ func (s *Store) HighestAttestations(
 					if err != nil {
 						return err
 					}
-					highestAtt := &ethpb.HighestAttestation{
+					highestAtt := &slashpb.HighestAttestation{
 						ValidatorIndex:     uint64(indices[i]),
 						HighestSourceEpoch: attWrapper.IndexedAttestation.Data.Source.Epoch,
 						HighestTargetEpoch: attWrapper.IndexedAttestation.Data.Target.Epoch,

beacon-chain/db/slasherkv/slasher_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	slashpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
@@ -51,17 +52,9 @@ func TestStore_LastEpochWrittenForValidators(t *testing.T) {
 
 	attestedEpochs, err := beaconDB.LastEpochWrittenForValidators(ctx, indices)
 	require.NoError(t, err)
-	require.Equal(t, true, len(attestedEpochs) == len(indices))
-	for _, item := range attestedEpochs {
-		require.Equal(t, types.Epoch(0), item.Epoch)
-	}
+	require.Equal(t, true, len(attestedEpochs) == 0)
 
-	epochsByValidator := map[types.ValidatorIndex]types.Epoch{
-		1: epoch,
-		2: epoch,
-		3: epoch,
-	}
-	err = beaconDB.SaveLastEpochsWrittenForValidators(ctx, epochsByValidator)
+	err = beaconDB.SaveLastEpochWrittenForValidators(ctx, indices, epoch)
 	require.NoError(t, err)
 
 	retrievedEpochs, err := beaconDB.LastEpochWrittenForValidators(ctx, indices)
@@ -345,7 +338,7 @@ func TestStore_HighestAttestations(t *testing.T) {
 	tests := []struct {
 		name             string
 		attestationsInDB []*slashertypes.IndexedAttestationWrapper
-		expected         []*ethpb.HighestAttestation
+		expected         []*slashpb.HighestAttestation
 		indices          []types.ValidatorIndex
 		wantErr          bool
 	}{
@@ -355,7 +348,7 @@ func TestStore_HighestAttestations(t *testing.T) {
 				createAttestationWrapper(0, 3, []uint64{1}, []byte{1}),
 			},
 			indices: []types.ValidatorIndex{1},
-			expected: []*ethpb.HighestAttestation{
+			expected: []*slashpb.HighestAttestation{
 				{
 					ValidatorIndex:     1,
 					HighestSourceEpoch: 0,
@@ -372,7 +365,7 @@ func TestStore_HighestAttestations(t *testing.T) {
 				createAttestationWrapper(5, 6, []uint64{5}, []byte{4}),
 			},
 			indices: []types.ValidatorIndex{2, 3, 4, 5},
-			expected: []*ethpb.HighestAttestation{
+			expected: []*slashpb.HighestAttestation{
 				{
 					ValidatorIndex:     2,
 					HighestSourceEpoch: 0,
@@ -404,7 +397,7 @@ func TestStore_HighestAttestations(t *testing.T) {
 				createAttestationWrapper(6, 7, []uint64{5}, []byte{4}),
 			},
 			indices: []types.ValidatorIndex{2, 3, 4, 5},
-			expected: []*ethpb.HighestAttestation{
+			expected: []*slashpb.HighestAttestation{
 				{
 					ValidatorIndex:     2,
 					HighestSourceEpoch: 4,

beacon-chain/deterministic-genesis/service.go

@@ -102,21 +102,21 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 }
 
 // Start initializes the genesis state from configured flags.
-func (_ *Service) Start() {
+func (s *Service) Start() {
 }
 
 // Stop does nothing.
-func (_ *Service) Stop() error {
+func (s *Service) Stop() error {
 	return nil
 }
 
 // Status always returns nil.
-func (_ *Service) Status() error {
+func (s *Service) Status() error {
 	return nil
 }
 
 // AllDeposits mocks out the deposit cache functionality for interop.
-func (_ *Service) AllDeposits(_ context.Context, _ *big.Int) []*ethpb.Deposit {
+func (s *Service) AllDeposits(_ context.Context, _ *big.Int) []*ethpb.Deposit {
 	return []*ethpb.Deposit{}
 }
 
@@ -126,37 +126,37 @@ func (s *Service) ChainStartDeposits() []*ethpb.Deposit {
 }
 
 // ChainStartEth1Data mocks out the powchain functionality for interop.
-func (_ *Service) ChainStartEth1Data() *ethpb.Eth1Data {
+func (s *Service) ChainStartEth1Data() *ethpb.Eth1Data {
 	return &ethpb.Eth1Data{}
 }
 
 // PreGenesisState returns an empty beacon state.
-func (_ *Service) PreGenesisState() state.BeaconState {
+func (s *Service) PreGenesisState() state.BeaconState {
 	return &v1.BeaconState{}
 }
 
 // ClearPreGenesisData --
-func (_ *Service) ClearPreGenesisData() {
+func (s *Service) ClearPreGenesisData() {
 	// no-op
 }
 
 // DepositByPubkey mocks out the deposit cache functionality for interop.
-func (_ *Service) DepositByPubkey(_ context.Context, _ []byte) (*ethpb.Deposit, *big.Int) {
+func (s *Service) DepositByPubkey(_ context.Context, _ []byte) (*ethpb.Deposit, *big.Int) {
 	return &ethpb.Deposit{}, nil
 }
 
 // DepositsNumberAndRootAtHeight mocks out the deposit cache functionality for interop.
-func (_ *Service) DepositsNumberAndRootAtHeight(_ context.Context, _ *big.Int) (uint64, [32]byte) {
+func (s *Service) DepositsNumberAndRootAtHeight(_ context.Context, _ *big.Int) (uint64, [32]byte) {
 	return 0, [32]byte{}
 }
 
 // FinalizedDeposits mocks out the deposit cache functionality for interop.
-func (_ *Service) FinalizedDeposits(_ context.Context) *depositcache.FinalizedDeposits {
+func (s *Service) FinalizedDeposits(_ context.Context) *depositcache.FinalizedDeposits {
 	return nil
 }
 
 // NonFinalizedDeposits mocks out the deposit cache functionality for interop.
-func (_ *Service) NonFinalizedDeposits(_ context.Context, _ *big.Int) []*ethpb.Deposit {
+func (s *Service) NonFinalizedDeposits(_ context.Context, _ *big.Int) []*ethpb.Deposit {
 	return []*ethpb.Deposit{}
 }
 

beacon-chain/forkchoice/protoarray/helpers.go

@@ -15,7 +15,7 @@ func computeDeltas(
 	votes []Vote,
 	oldBalances, newBalances []uint64,
 ) ([]int, []Vote, error) {
-	_, span := trace.StartSpan(ctx, "protoArrayForkChoice.computeDeltas")
+	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.computeDeltas")
 	defer span.End()
 
 	deltas := make([]int, len(blockIndices))

beacon-chain/forkchoice/protoarray/store.go

@@ -74,7 +74,7 @@ func (f *ForkChoice) Head(
 // ProcessAttestation processes attestation for vote accounting, it iterates around validator indices
 // and update their votes accordingly.
 func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []uint64, blockRoot [32]byte, targetEpoch types.Epoch) {
-	_, span := trace.StartSpan(ctx, "protoArrayForkChoice.ProcessAttestation")
+	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.ProcessAttestation")
 	defer span.End()
 	f.votesLock.Lock()
 	defer f.votesLock.Unlock()
@@ -327,7 +327,7 @@ func (s *Store) insert(ctx context.Context,
 	slot types.Slot,
 	root, parent, graffiti [32]byte,
 	justifiedEpoch, finalizedEpoch types.Epoch) error {
-	_, span := trace.StartSpan(ctx, "protoArrayForkChoice.insert")
+	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.insert")
 	defer span.End()
 
 	s.nodesLock.Lock()
@@ -379,7 +379,7 @@ func (s *Store) insert(ctx context.Context,
 // back propagate the nodes delta to its parents delta. After scoring changes,
 // the best child is then updated along with best descendant.
 func (s *Store) applyWeightChanges(ctx context.Context, justifiedEpoch, finalizedEpoch types.Epoch, delta []int) error {
-	_, span := trace.StartSpan(ctx, "protoArrayForkChoice.applyWeightChanges")
+	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.applyWeightChanges")
 	defer span.End()
 
 	// The length of the nodes can not be different than length of the delta.
@@ -557,7 +557,7 @@ func (s *Store) updateBestChildAndDescendant(parentIndex, childIndex uint64) err
 // pruned if the input finalized root are different than the one in stored and
 // the number of the nodes in store has met prune threshold.
 func (s *Store) prune(ctx context.Context, finalizedRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "protoArrayForkChoice.prune")
+	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.prune")
 	defer span.End()
 
 	s.nodesLock.Lock()

beacon-chain/light/BUILD.bazel

@@ -0,0 +1,32 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "service.go",
+        "update_comparison.go",
+        "updater.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/light",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/blockchain:go_default_library",
+        "//beacon-chain/core/feed:go_default_library",
+        "//beacon-chain/core/feed/state:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/db/iface:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stategen:go_default_library",
+        "//beacon-chain/sync:go_default_library",
+        "//config/params:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//network/forks:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/prysm/v1alpha1/block:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)

beacon-chain/light/service.go

@@ -0,0 +1,209 @@
+package light
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db/iface"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	syncSrv "github.com/prysmaticlabs/prysm/beacon-chain/sync"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/io/file"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	block2 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/time/slots"
+)
+
+type UpdatesFetcher interface {
+	BestUpdateForPeriod(ctx context.Context, period uint64) (*ethpb.LightClientUpdate, error)
+	LatestFinalizedUpdate(ctx context.Context) *ethpb.LightClientUpdate
+	LatestNonFinalizedUpdate(ctx context.Context) *ethpb.LightClientUpdate
+}
+
+type Config struct {
+	StateGen            stategen.StateManager
+	Database            iface.Database
+	HeadFetcher         blockchain.HeadFetcher
+	FinalizationFetcher blockchain.FinalizationFetcher
+	StateNotifier       statefeed.Notifier
+	TimeFetcher         blockchain.TimeFetcher
+	SyncChecker         syncSrv.Checker
+}
+
+type Service struct {
+	cfg                      *Config
+	cancelFunc               context.CancelFunc
+	prevHeadData             map[[32]byte]*ethpb.SyncAttestedData
+	lock                     sync.RWMutex
+	genesisTime              time.Time
+	finalizedByEpoch         map[types.Epoch]*ethpb.LightClientFinalizedCheckpoint
+	bestUpdateByPeriod       map[uint64]*ethpb.LightClientUpdate
+	latestFinalizedUpdate    *ethpb.LightClientUpdate
+	latestNonFinalizedUpdate *ethpb.LightClientUpdate
+}
+
+// New --
+func New(ctx context.Context, cfg *Config) *Service {
+	return &Service{
+		cfg:                cfg,
+		prevHeadData:       make(map[[32]byte]*ethpb.SyncAttestedData),
+		finalizedByEpoch:   make(map[types.Epoch]*ethpb.LightClientFinalizedCheckpoint),
+		bestUpdateByPeriod: make(map[uint64]*ethpb.LightClientUpdate),
+	}
+}
+
+func (s *Service) Start() {
+	go s.run()
+}
+
+func (s *Service) Stop() error {
+	s.cancelFunc()
+	return nil
+}
+
+func (s *Service) Status() error {
+	return nil
+}
+
+func (s *Service) BestUpdateForPeriod(ctx context.Context, period uint64) (*ethpb.LightClientUpdate, error) {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+	update, ok := s.bestUpdateByPeriod[period]
+	if !ok {
+		return nil, fmt.Errorf("no update found for period %d", period)
+	}
+	return update, nil
+}
+
+func (s *Service) LatestFinalizedUpdate(ctx context.Context) *ethpb.LightClientUpdate {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+	return s.latestFinalizedUpdate
+}
+
+func (s *Service) LatestNonFinalizedUpdate(ctx context.Context) *ethpb.LightClientUpdate {
+	return s.latestNonFinalizedUpdate
+}
+
+func (s *Service) run() {
+	ctx, cancel := context.WithCancel(context.Background())
+	s.cancelFunc = cancel
+	s.waitForChainInitialization(ctx)
+	s.waitForSync(ctx)
+	// Initialize the service from finalized (state, block) data.
+	log.Info("Initializing from finalized data")
+	if err := s.initializeFromFinalizedData(ctx); err != nil {
+		log.Fatal(err)
+	}
+	log.Info("Beginning subscriptions")
+	// Begin listening for new chain head and finalized checkpoint events.
+	go s.subscribeHeadEvent(ctx)
+	go s.subscribeFinalizedEvent(ctx)
+}
+
+func (s *Service) waitForChainInitialization(ctx context.Context) {
+	stateChannel := make(chan *feed.Event, 1)
+	stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
+	defer stateSub.Unsubscribe()
+	defer close(stateChannel)
+	for {
+		select {
+		case stateEvent := <-stateChannel:
+			// Wait for us to receive the genesis time via a chain started notification.
+			if stateEvent.Type == statefeed.Initialized {
+				// Alternatively, if the chain has already started, we then read the genesis
+				// time value from this data.
+				data, ok := stateEvent.Data.(*statefeed.InitializedData)
+				if !ok {
+					log.Error(
+						"Could not receive chain start notification, want *statefeed.ChainStartedData",
+					)
+					return
+				}
+				s.genesisTime = data.StartTime
+				log.WithField("genesisTime", s.genesisTime).Info(
+					"Received chain initialization event",
+				)
+				return
+			}
+		case err := <-stateSub.Err():
+			log.WithError(err).Error(
+				"Could not subscribe to state events",
+			)
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (s *Service) waitForSync(ctx context.Context) {
+	slotTicker := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+	defer slotTicker.Done()
+	for {
+		select {
+		case <-slotTicker.C():
+			if slots.ToEpoch(slots.SinceGenesis(s.genesisTime)) < 6 {
+				continue
+			}
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (s *Service) finalizedBlockOrGenesis(ctx context.Context, cpt *ethpb.Checkpoint) (block2.SignedBeaconBlock, error) {
+	checkpointRoot := bytesutil.ToBytes32(cpt.Root)
+	block, err := s.cfg.Database.Block(ctx, checkpointRoot)
+	if err != nil {
+		return nil, err
+	}
+	if block == nil || block.IsNil() {
+		return s.cfg.Database.GenesisBlock(ctx)
+	}
+	return block, nil
+}
+
+func (s *Service) finalizedStateOrGenesis(ctx context.Context, cpt *ethpb.Checkpoint) (state.BeaconState, error) {
+	checkpointRoot := bytesutil.ToBytes32(cpt.Root)
+	st, err := s.cfg.StateGen.StateByRoot(ctx, checkpointRoot)
+	if err != nil {
+		return nil, err
+	}
+	if st == nil || st.IsNil() {
+		return s.cfg.Database.GenesisState(ctx)
+	}
+	return st, nil
+}
+
+func (s *Service) initializeFromFinalizedData(ctx context.Context) error {
+	cpt, err := s.cfg.Database.FinalizedCheckpoint(ctx)
+	if err != nil {
+		return err
+	}
+	finalizedBlock, err := s.finalizedBlockOrGenesis(ctx, cpt)
+	if err != nil {
+		return err
+	}
+	finalizedState, err := s.finalizedStateOrGenesis(ctx, cpt)
+	if err != nil {
+		return err
+	}
+	enc, err := finalizedState.MarshalSSZ()
+	if err != nil {
+		return err
+	}
+	if err := file.WriteFile("/tmp/state.ssz", enc); err != nil {
+		return err
+	}
+	return s.onFinalized(ctx, finalizedBlock, finalizedState)
+}

beacon-chain/light/subscribe_finalized_event.go

@@ -0,0 +1,120 @@
+package light
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/encoding/ssz"
+	v1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/time/slots"
+)
+
+const (
+	finalizedCheckpointStateIndex = 20
+	nextSyncCommitteeStateIndex   = 23
+)
+
+func (s *Service) subscribeFinalizedEvent(ctx context.Context) {
+	stateChan := make(chan *feed.Event, 1)
+	sub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChan)
+	defer sub.Unsubscribe()
+	for {
+		select {
+		case ev := <-stateChan:
+			if ev.Type == statefeed.FinalizedCheckpoint {
+				blk, beaconState, err := s.parseFinalizedEvent(ctx, ev.Data)
+				if err != nil {
+					log.Error(err)
+					continue
+				}
+				if err := s.onFinalized(ctx, blk, beaconState); err != nil {
+					log.Error(err)
+					continue
+				}
+			}
+		}
+	}
+}
+
+func (s *Service) parseFinalizedEvent(
+	ctx context.Context, eventData interface{},
+) (block.SignedBeaconBlock, state.BeaconState, error) {
+	finalizedCheckpoint, ok := eventData.(*v1.EventFinalizedCheckpoint)
+	if !ok {
+		return nil, nil, errors.New("expected finalized checkpoint event")
+	}
+	checkpointRoot := bytesutil.ToBytes32(finalizedCheckpoint.Block)
+	blk, err := s.cfg.Database.Block(ctx, checkpointRoot)
+	if err != nil {
+		return nil, nil, err
+	}
+	if blk == nil || blk.IsNil() {
+		return nil, nil, err
+	}
+	st, err := s.cfg.StateGen.StateByRoot(ctx, checkpointRoot)
+	if err != nil {
+		return nil, nil, err
+	}
+	if st == nil || st.IsNil() {
+		return nil, nil, err
+	}
+	return blk, st, nil
+}
+
+func (s *Service) onFinalized(
+	ctx context.Context, signedBlock block.SignedBeaconBlock, postState state.BeaconStateAltair,
+) error {
+	if _, ok := postState.InnerStateUnsafe().(*ethpb.BeaconStateAltair); !ok {
+		return errors.New("expected an Altair beacon state")
+	}
+	blk := signedBlock.Block()
+	header, err := block.BeaconBlockHeaderFromBlockInterface(blk)
+	if err != nil {
+		return err
+	}
+	tb, err := ssz.NewTreeBackedState(postState)
+	if err != nil {
+		return err
+	}
+	proof, gIndex, err := tb.Proof(nextSyncCommitteeStateIndex)
+	if err != nil {
+		return err
+	}
+	nextSyncCommittee, err := postState.NextSyncCommittee()
+	if err != nil {
+		return err
+	}
+	root, err := postState.HashTreeRoot(ctx)
+	if err != nil {
+		return err
+	}
+	nextSyncCommitteeRoot, err := nextSyncCommittee.HashTreeRoot()
+	if err != nil {
+		return err
+	}
+	log.Info("On finalized update")
+	log.Infof("Header state root %#x, state hash tree root %#x", header.StateRoot, root)
+	log.Infof("Generating proof against root %#x with gindex %d and leaf root %#x", root, gIndex, nextSyncCommitteeRoot)
+	log.Info("-----")
+	log.Infof("Proof with length %d", len(proof))
+	for _, elem := range proof {
+		log.Infof("%#x", bytesutil.Trunc(elem))
+	}
+	log.Info("-----")
+
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	currentEpoch := slots.ToEpoch(blk.Slot())
+	s.finalizedByEpoch[currentEpoch] = &ethpb.LightClientFinalizedCheckpoint{
+		Header:                  header,
+		NextSyncCommittee:       nextSyncCommittee,
+		NextSyncCommitteeBranch: proof,
+	}
+	return nil
+}

beacon-chain/light/subscribe_head_event.go

@@ -0,0 +1,154 @@
+package light
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/encoding/ssz"
+	"github.com/prysmaticlabs/prysm/network/forks"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/time/slots"
+)
+
+func (s *Service) subscribeHeadEvent(ctx context.Context) {
+	stateChan := make(chan *feed.Event, 1)
+	sub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChan)
+	defer sub.Unsubscribe()
+	for {
+		select {
+		case ev := <-stateChan:
+			if ev.Type == statefeed.NewHead {
+				head, beaconState, err := s.getChainHeadAndState(ctx)
+				if err != nil {
+					log.Error(err)
+					continue
+				}
+				if err := s.onHead(ctx, head, beaconState); err != nil {
+					log.Error(err)
+					continue
+				}
+			}
+		case <-sub.Err():
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (s *Service) getChainHeadAndState(ctx context.Context) (block.SignedBeaconBlock, state.BeaconState, error) {
+	head, err := s.cfg.HeadFetcher.HeadBlock(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	if head == nil || head.IsNil() {
+		return nil, nil, errors.New("head block is nil")
+	}
+	st, err := s.cfg.HeadFetcher.HeadState(ctx)
+	if err != nil {
+		return nil, nil, errors.New("head state is nil")
+	}
+	if st == nil || st.IsNil() {
+		return nil, nil, err
+	}
+	return head, st, nil
+}
+
+func (s *Service) onHead(ctx context.Context, head block.SignedBeaconBlock, postState state.BeaconStateAltair) error {
+	if _, ok := postState.InnerStateUnsafe().(*ethpb.BeaconStateAltair); !ok {
+		return errors.New("expected an Altair beacon state")
+	}
+	blk := head.Block()
+	tb, err := ssz.NewTreeBackedState(postState)
+	if err != nil {
+		return err
+	}
+	header, err := block.BeaconBlockHeaderFromBlockInterface(blk)
+	if err != nil {
+		return err
+	}
+	finalityBranch, _, err := tb.Proof(finalizedCheckpointStateIndex)
+	if err != nil {
+		return err
+	}
+	nextSyncCommitteeBranch, gIndex, err := tb.Proof(nextSyncCommitteeStateIndex)
+	if err != nil {
+		return err
+	}
+	stRoot, err := postState.HashTreeRoot(ctx)
+	if err != nil {
+		return err
+	}
+	blkRoot, err := blk.HashTreeRoot()
+	if err != nil {
+		return err
+	}
+	log.Infof("On head, generating sync committee proof for root %#x and index %d, block root %#x, header state root %#x", stRoot[:], gIndex, blkRoot, header.StateRoot)
+	nextSyncCommittee, err := postState.NextSyncCommittee()
+	if err != nil {
+		return err
+	}
+
+	s.lock.Lock()
+	s.prevHeadData[blkRoot] = &ethpb.SyncAttestedData{
+		Header:                  header,
+		FinalityCheckpoint:      postState.FinalizedCheckpoint(),
+		FinalityBranch:          finalityBranch,
+		NextSyncCommittee:       nextSyncCommittee,
+		NextSyncCommitteeBranch: nextSyncCommitteeBranch,
+	}
+	s.lock.Unlock()
+	syncAttestedBlockRoot, err := helpers.BlockRootAtSlot(postState, postState.Slot()-1)
+	if err != nil {
+		return err
+	}
+
+	fork, err := forks.Fork(slots.ToEpoch(blk.Slot()))
+	if err != nil {
+		return err
+	}
+	syncAggregate, err := blk.Body().SyncAggregate()
+	if err != nil {
+		return err
+	}
+	sigData := &signatureData{
+		slot:          blk.Slot(),
+		forkVersion:   fork.CurrentVersion,
+		syncAggregate: syncAggregate,
+	}
+
+	s.lock.Lock()
+	syncAttestedData, ok := s.prevHeadData[bytesutil.ToBytes32(syncAttestedBlockRoot)]
+	if !ok {
+		s.lock.Unlock()
+		log.Info("Got useless data, skipping")
+		return nil // Useless data.
+	}
+	s.lock.Unlock()
+	commmitteePeriodWithFinalized, err := s.persistBestFinalizedUpdate(ctx, syncAttestedData, sigData)
+	if err != nil {
+		return err
+	}
+
+	if err := s.persistBestNonFinalizedUpdate(ctx, syncAttestedData, sigData, commmitteePeriodWithFinalized); err != nil {
+		return err
+	}
+
+	s.lock.Lock()
+	if len(s.prevHeadData) > PrevDataMaxSize {
+		for k := range s.prevHeadData {
+			delete(s.prevHeadData, k)
+			if len(s.prevHeadData) <= PrevDataMaxSize {
+				break
+			}
+		}
+	}
+	s.lock.Unlock()
+	return nil
+}

beacon-chain/light/update_comparison.go

@@ -0,0 +1,50 @@
+package light
+
+import (
+	"bytes"
+
+	"github.com/prysmaticlabs/prysm/config/params"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+func isBetterUpdate(prevUpdate *ethpb.LightClientUpdate, newUpdate *ethpb.LightClientUpdate) bool {
+	prevIsFinalized := isFinalizedUpdate(prevUpdate)
+	newIsFinalized := isFinalizedUpdate(newUpdate)
+	// newUpdate becomes finalized, it's better.
+	if newIsFinalized && !prevIsFinalized {
+		return true
+	}
+	// newUpdate is no longer finalized, it's worse.
+	if !newIsFinalized && prevIsFinalized {
+		return false
+	}
+	return hasMoreBits(newUpdate, prevUpdate)
+}
+
+func isLatestBestFinalizedUpdate(prevUpdate *ethpb.LightClientUpdate, newUpdate *ethpb.LightClientUpdate) bool {
+	if newUpdate.FinalityHeader.Slot > prevUpdate.FinalityHeader.Slot {
+		return true
+	}
+	if newUpdate.FinalityHeader.Slot < prevUpdate.FinalityHeader.Slot {
+		return false
+	}
+	return hasMoreBits(newUpdate, prevUpdate)
+}
+
+func isLatestBestNonFinalizedUpdate(prevUpdate *ethpb.LightClientUpdate, newUpdate *ethpb.LightClientUpdate) bool {
+	if newUpdate.Header.Slot > prevUpdate.Header.Slot {
+		return true
+	}
+	if newUpdate.Header.Slot < prevUpdate.Header.Slot {
+		return false
+	}
+	return hasMoreBits(newUpdate, prevUpdate)
+}
+
+func isFinalizedUpdate(update *ethpb.LightClientUpdate) bool {
+	return !bytes.Equal(params.BeaconConfig().ZeroHash[:], update.FinalityHeader.StateRoot)
+}
+
+func hasMoreBits(a *ethpb.LightClientUpdate, b *ethpb.LightClientUpdate) bool {
+	return a.SyncCommitteeBits.Count() > b.SyncCommitteeBits.Count()
+}

beacon-chain/light/updater.go

@@ -0,0 +1,134 @@
+package light
+
+import (
+	"context"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/sirupsen/logrus"
+)
+
+// Precomputed values for generalized indices.
+const (
+	FinalizedRootIndex     = 105
+	NextSyncCommitteeIndex = 55
+	PrevDataMaxSize        = 64
+)
+
+var log = logrus.WithField("prefix", "light")
+
+type signatureData struct {
+	slot          types.Slot
+	forkVersion   []byte
+	syncAggregate *ethpb.SyncAggregate
+}
+
+func (s *Service) persistBestFinalizedUpdate(ctx context.Context, syncAttestedData *ethpb.SyncAttestedData, sigData *signatureData) (uint64, error) {
+	finalizedEpoch := syncAttestedData.FinalityCheckpoint.Epoch
+
+	s.lock.RLock()
+	finalizedData := s.finalizedByEpoch[finalizedEpoch]
+	s.lock.RUnlock()
+
+	if finalizedData == nil {
+		return 0, nil
+	}
+
+	committeePeriod := slots.SyncCommitteePeriod(slots.ToEpoch(syncAttestedData.Header.Slot))
+	signaturePeriod := slots.SyncCommitteePeriod(slots.ToEpoch(sigData.slot))
+	if committeePeriod != signaturePeriod {
+		return 0, nil
+	}
+
+	newUpdate := &ethpb.LightClientUpdate{
+		Header:                  finalizedData.Header,
+		NextSyncCommittee:       finalizedData.NextSyncCommittee,
+		NextSyncCommitteeBranch: finalizedData.NextSyncCommitteeBranch,
+		FinalityHeader:          syncAttestedData.Header,
+		FinalityBranch:          syncAttestedData.FinalityBranch,
+		SyncCommitteeBits:       sigData.syncAggregate.SyncCommitteeBits,
+		SyncCommitteeSignature:  sigData.syncAggregate.SyncCommitteeSignature,
+		ForkVersion:             sigData.forkVersion,
+	}
+
+	s.lock.RLock()
+	prevBestUpdate := s.bestUpdateByPeriod[committeePeriod]
+	s.lock.RUnlock()
+
+	if prevBestUpdate == nil || isBetterUpdate(prevBestUpdate, newUpdate) {
+		s.lock.Lock()
+		s.bestUpdateByPeriod[committeePeriod] = newUpdate
+		s.lock.Unlock()
+	}
+
+	s.lock.RLock()
+	prevLatestUpdate := s.latestFinalizedUpdate
+	s.lock.RUnlock()
+
+	if prevLatestUpdate == nil || isLatestBestFinalizedUpdate(prevLatestUpdate, newUpdate) {
+		s.lock.Lock()
+		s.latestFinalizedUpdate = newUpdate
+		s.lock.Unlock()
+		log.Info("Putting latest best finalized update")
+		rt, err := newUpdate.NextSyncCommittee.HashTreeRoot()
+		if err != nil {
+			return 0, err
+		}
+		log.Infof("Header state root %#x, state hash tree root %#x", newUpdate.Header.StateRoot, newUpdate.Header.StateRoot)
+		log.Infof("Generating proof against root %#x with gindex %d and leaf root %#x", newUpdate.Header.StateRoot, 55, rt)
+		log.Info("-----")
+		log.Infof("Proof with length %d", len(newUpdate.NextSyncCommitteeBranch))
+		for _, elem := range newUpdate.NextSyncCommitteeBranch {
+			log.Infof("%#x", bytesutil.Trunc(elem))
+		}
+		log.Info("-----")
+	}
+	return committeePeriod, nil
+}
+
+func (s *Service) persistBestNonFinalizedUpdate(ctx context.Context, syncAttestedData *ethpb.SyncAttestedData, sigData *signatureData, period uint64) error {
+	committeePeriod := slots.SyncCommitteePeriod(slots.ToEpoch(syncAttestedData.Header.Slot))
+	signaturePeriod := slots.SyncCommitteePeriod(slots.ToEpoch(sigData.slot))
+	if committeePeriod != signaturePeriod {
+		return nil
+	}
+
+	newUpdate := &ethpb.LightClientUpdate{
+		Header:                  syncAttestedData.Header,
+		NextSyncCommittee:       syncAttestedData.NextSyncCommittee,
+		NextSyncCommitteeBranch: syncAttestedData.NextSyncCommitteeBranch,
+		FinalityHeader:          nil,
+		FinalityBranch:          nil,
+		SyncCommitteeBits:       sigData.syncAggregate.SyncCommitteeBits,
+		SyncCommitteeSignature:  sigData.syncAggregate.SyncCommitteeSignature,
+		ForkVersion:             sigData.forkVersion,
+	}
+
+	// Optimization: If there's already a finalized update for this committee period, no need to
+	// create a non-finalized update>
+	if committeePeriod != period {
+		s.lock.RLock()
+		prevBestUpdate := s.bestUpdateByPeriod[committeePeriod]
+		s.lock.RUnlock()
+		if prevBestUpdate == nil || isBetterUpdate(prevBestUpdate, newUpdate) {
+			s.lock.Lock()
+			s.bestUpdateByPeriod[committeePeriod] = newUpdate
+			s.lock.Unlock()
+		}
+	}
+
+	// Store the latest update here overall. Not checking it's the best
+	s.lock.RLock()
+	prevLatestUpdate := s.latestNonFinalizedUpdate
+	s.lock.RUnlock()
+
+	if prevLatestUpdate == nil || isLatestBestNonFinalizedUpdate(prevLatestUpdate, newUpdate) {
+		// TODO: Don't store nextCommittee, that can be fetched through getBestUpdates()
+		s.lock.Lock()
+		s.latestNonFinalizedUpdate = newUpdate
+		s.lock.Unlock()
+	}
+	return nil
+}

beacon-chain/monitor/BUILD.bazel

@@ -8,19 +8,13 @@ go_library(
         "process_attestation.go",
         "process_block.go",
         "process_exit.go",
-        "process_sync_committee.go",
         "service.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/monitor",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//async/event:go_default_library",
-        "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/feed:go_default_library",
-        "//beacon-chain/core/feed/operation:go_default_library",
-        "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
@@ -44,15 +38,10 @@ go_test(
         "process_attestation_test.go",
         "process_block_test.go",
         "process_exit_test.go",
-        "process_sync_committee_test.go",
         "service_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/feed:go_default_library",
-        "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//config/params:go_default_library",
@@ -61,7 +50,6 @@ go_test(
         "//proto/prysm/v1alpha1/wrapper:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/monitor/metrics.go

@@ -56,17 +56,6 @@ var (
 		},
 	)
 
-	// proposedSlotsCounter used to track proposed blocks
-	proposedSlotsCounter = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "monitor",
-			Name:      "proposed_slots_total",
-			Help:      "Number of proposed blocks included",
-		},
-		[]string{
-			"validator_index",
-		},
-	)
 	// aggregationCounter used to track aggregations
 	aggregationCounter = promauto.NewCounterVec(
 		prometheus.CounterOpts{
@@ -78,16 +67,4 @@ var (
 			"validator_index",
 		},
 	)
-	// syncCommitteeContributionCounter used to track sync committee
-	// contributions
-	syncCommitteeContributionCounter = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "monitor",
-			Name:      "sync_committee_contributions_total",
-			Help:      "Number of Sync committee contributions performed",
-		},
-		[]string{
-			"validator_index",
-		},
-	)
 )

beacon-chain/monitor/process_attestation.go

@@ -20,13 +20,12 @@ import (
 
 // updatedPerformanceFromTrackedVal returns true if the validator is tracked and if the
 // given slot is different than the last attested slot from this validator.
-// It assumes that a read lock is held on the monitor service.
 func (s *Service) updatedPerformanceFromTrackedVal(idx types.ValidatorIndex, slot types.Slot) bool {
-	if !s.trackedIndex(idx) {
+	if !s.TrackedIndex(types.ValidatorIndex(idx)) {
 		return false
 	}
 
-	if lp, ok := s.latestPerformance[idx]; ok {
+	if lp, ok := s.latestPerformance[types.ValidatorIndex(idx)]; ok {
 		return lp.attestedSlot != slot
 	}
 	return false
@@ -74,8 +73,6 @@ func (s *Service) processIncludedAttestation(ctx context.Context, state state.Be
 		log.WithError(err).Error("Could not get attesting indices")
 		return
 	}
-	s.Lock()
-	defer s.Unlock()
 	for _, idx := range attestingIndices {
 		if s.updatedPerformanceFromTrackedVal(types.ValidatorIndex(idx), att.Data.Slot) {
 			logFields := logMessageTimelyFlagsForIndex(types.ValidatorIndex(idx), att.Data)
@@ -90,7 +87,7 @@ func (s *Service) processIncludedAttestation(ctx context.Context, state state.Be
 			aggregatedPerf.totalRequestedCount++
 
 			latestPerf := s.latestPerformance[types.ValidatorIndex(idx)]
-			balanceChg := int64(balance - latestPerf.balance)
+			balanceChg := balance - latestPerf.balance
 			latestPerf.balanceChange = balanceChg
 			latestPerf.balance = balance
 			latestPerf.attestedSlot = att.Data.Slot
@@ -168,13 +165,10 @@ func (s *Service) processIncludedAttestation(ctx context.Context, state state.Be
 // processUnaggregatedAttestation logs when the beacon node sees an unaggregated attestation from one of our
 // tracked validators
 func (s *Service) processUnaggregatedAttestation(ctx context.Context, att *ethpb.Attestation) {
-	s.RLock()
-	defer s.RUnlock()
 	root := bytesutil.ToBytes32(att.Data.BeaconBlockRoot)
 	state := s.config.StateGen.StateByRootIfCachedNoCopy(root)
 	if state == nil {
-		log.WithField("BeaconBlockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(root[:]))).Debug(
-			"Skipping unaggregated attestation due to state not found in cache")
+		log.Debug("Skipping unaggregated attestation due to state not found in cache")
 		return
 	}
 	attestingIndices, err := attestingIndices(ctx, state, att)
@@ -193,18 +187,9 @@ func (s *Service) processUnaggregatedAttestation(ctx context.Context, att *ethpb
 // processAggregatedAttestation logs when we see an aggregation from one of our tracked validators or an aggregated
 // attestation from one of our tracked validators
 func (s *Service) processAggregatedAttestation(ctx context.Context, att *ethpb.AggregateAttestationAndProof) {
-	s.Lock()
-	defer s.Unlock()
-	if s.trackedIndex(att.AggregatorIndex) {
+	if s.TrackedIndex(att.AggregatorIndex) {
 		log.WithFields(logrus.Fields{
-			"AggregatorIndex": att.AggregatorIndex,
-			"Slot":            att.Aggregate.Data.Slot,
-			"BeaconBlockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(
-				att.Aggregate.Data.BeaconBlockRoot)),
-			"SourceRoot": fmt.Sprintf("%#x", bytesutil.Trunc(
-				att.Aggregate.Data.Source.Root)),
-			"TargetRoot": fmt.Sprintf("%#x", bytesutil.Trunc(
-				att.Aggregate.Data.Target.Root)),
+			"ValidatorIndex": att.AggregatorIndex,
 		}).Info("Processed attestation aggregation")
 		aggregatedPerf := s.aggregatedPerformance[att.AggregatorIndex]
 		aggregatedPerf.totalAggregations++
@@ -216,8 +201,7 @@ func (s *Service) processAggregatedAttestation(ctx context.Context, att *ethpb.A
 	copy(root[:], att.Aggregate.Data.BeaconBlockRoot)
 	state := s.config.StateGen.StateByRootIfCachedNoCopy(root)
 	if state == nil {
-		log.WithField("BeaconBlockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(root[:]))).Debug(
-			"Skipping agregated attestation due to state not found in cache")
+		log.Debug("Skipping agregated attestation due to state not found in cache")
 		return
 	}
 	attestingIndices, err := attestingIndices(ctx, state, att.Aggregate)

beacon-chain/monitor/process_attestation_test.go

@@ -5,7 +5,10 @@ import (
 	"context"
 	"testing"
 
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/go-bitfield"
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
@@ -15,6 +18,42 @@ import (
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
+func setupService(t *testing.T) *Service {
+	beaconDB := testDB.SetupDB(t)
+
+	trackedVals := map[types.ValidatorIndex]interface{}{
+		1:  nil,
+		2:  nil,
+		12: nil,
+	}
+	latestPerformance := map[types.ValidatorIndex]ValidatorLatestPerformance{
+		1: {
+			balance: 32000000000,
+		},
+		2: {
+			balance: 32000000000,
+		},
+		12: {
+			balance: 31900000000,
+		},
+	}
+
+	aggregatedPerformance := map[types.ValidatorIndex]ValidatorAggregatedPerformance{
+		1:  {},
+		2:  {},
+		12: {},
+	}
+
+	return &Service{
+		config: &ValidatorMonitorConfig{
+			StateGen:          stategen.New(beaconDB),
+			TrackedValidators: trackedVals,
+		},
+		latestPerformance:     latestPerformance,
+		aggregatedPerformance: aggregatedPerformance,
+	}
+}
+
 func TestGetAttestingIndices(t *testing.T) {
 	ctx := context.Background()
 	beaconState, _ := util.DeterministicGenesisState(t, 256)
@@ -162,7 +201,7 @@ func TestProcessAggregatedAttestationStateNotCached(t *testing.T) {
 		},
 	}
 	s.processAggregatedAttestation(ctx, att)
-	require.LogsContain(t, hook, "\"Processed attestation aggregation\" AggregatorIndex=2 BeaconBlockRoot=0x000000000000 Slot=1 SourceRoot=0x68656c6c6f2d TargetRoot=0x68656c6c6f2d prefix=monitor")
+	require.LogsContain(t, hook, "\"Processed attestation aggregation\" ValidatorIndex=2 prefix=monitor")
 	require.LogsContain(t, hook, "Skipping agregated attestation due to state not found in cache")
 	logrus.SetLevel(logrus.InfoLevel)
 }
@@ -200,7 +239,7 @@ func TestProcessAggregatedAttestationStateCached(t *testing.T) {
 
 	require.NoError(t, s.config.StateGen.SaveState(ctx, root, state))
 	s.processAggregatedAttestation(ctx, att)
-	require.LogsContain(t, hook, "\"Processed attestation aggregation\" AggregatorIndex=2 BeaconBlockRoot=0x68656c6c6f2d Slot=1 SourceRoot=0x68656c6c6f2d TargetRoot=0x68656c6c6f2d prefix=monitor")
+	require.LogsContain(t, hook, "\"Processed attestation aggregation\" ValidatorIndex=2 prefix=monitor")
 	require.LogsContain(t, hook, "\"Processed aggregated attestation\" Head=0x68656c6c6f2d Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=2 prefix=monitor")
 	require.LogsDoNotContain(t, hook, "\"Processed aggregated attestation\" Head=0x68656c6c6f2d Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=12 prefix=monitor")
 }

beacon-chain/monitor/process_block.go

@@ -1,115 +1,23 @@
 package monitor
 
 import (
-	"context"
 	"fmt"
 
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 )
 
-// Number of epochs between aggregate reports
-const AggregateReportingPeriod = 5
-
-// processBlock handles the cases when
-// 1) A block was proposed by one of our tracked validators
-// 2) An attestation by one of our tracked validators was included
-// 3) An Exit by one of our validators was included
-// 4) A Slashing by one of our tracked validators was included
-// 5) A Sync Committe Contribution by one of our tracked validators was included
-func (s *Service) processBlock(ctx context.Context, b block.SignedBeaconBlock) {
-	if b == nil || b.Block() == nil {
-		return
-	}
-	blk := b.Block()
-
-	s.processSlashings(blk)
-	s.processExitsFromBlock(blk)
-
-	root, err := blk.HashTreeRoot()
-	if err != nil {
-		log.WithError(err).Error("Could not compute block's hash tree root")
-		return
-	}
-	state := s.config.StateGen.StateByRootIfCachedNoCopy(root)
-	if state == nil {
-		log.WithField("BeaconBlockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(root[:]))).Debug(
-			"Skipping block collection due to state not found in cache")
-		return
-	}
-
-	currEpoch := slots.ToEpoch(blk.Slot())
-	s.RLock()
-	lastSyncedEpoch := s.lastSyncedEpoch
-	s.RUnlock()
-
-	if currEpoch != lastSyncedEpoch &&
-		slots.SyncCommitteePeriod(currEpoch) == slots.SyncCommitteePeriod(lastSyncedEpoch) {
-		s.updateSyncCommitteeTrackedVals(state)
-	}
-
-	s.processSyncAggregate(state, blk)
-	s.processProposedBlock(state, root, blk)
-	s.processAttestations(ctx, state, blk)
-
-	if blk.Slot()%(AggregateReportingPeriod*params.BeaconConfig().SlotsPerEpoch) == 0 {
-		s.logAggregatedPerformance()
-	}
-}
-
-// processProposedBlock logs the event that one of our tracked validators proposed a block that was included
-func (s *Service) processProposedBlock(state state.BeaconState, root [32]byte, blk block.BeaconBlock) {
-	s.Lock()
-	defer s.Unlock()
-	if s.trackedIndex(blk.ProposerIndex()) {
-		// update metrics
-		proposedSlotsCounter.WithLabelValues(fmt.Sprintf("%d", blk.ProposerIndex())).Inc()
-
-		// update the performance map
-		balance, err := state.BalanceAtIndex(blk.ProposerIndex())
-		if err != nil {
-			log.WithError(err).Error("Could not get balance")
-			return
-		}
-
-		latestPerf := s.latestPerformance[blk.ProposerIndex()]
-		balanceChg := int64(balance - latestPerf.balance)
-		latestPerf.balanceChange = balanceChg
-		latestPerf.balance = balance
-		s.latestPerformance[blk.ProposerIndex()] = latestPerf
-
-		aggPerf := s.aggregatedPerformance[blk.ProposerIndex()]
-		aggPerf.totalProposedCount++
-		s.aggregatedPerformance[blk.ProposerIndex()] = aggPerf
-
-		log.WithFields(logrus.Fields{
-			"ProposerIndex": blk.ProposerIndex(),
-			"Slot":          blk.Slot(),
-			"Version":       blk.Version(),
-			"ParentRoot":    fmt.Sprintf("%#x", bytesutil.Trunc(blk.ParentRoot())),
-			"BlockRoot":     fmt.Sprintf("%#x", bytesutil.Trunc(root[:])),
-			"NewBalance":    balance,
-			"BalanceChange": balanceChg,
-		}).Info("Proposed block was included")
-	}
-}
-
 // processSlashings logs the event of one of our tracked validators was slashed
 func (s *Service) processSlashings(blk block.BeaconBlock) {
-	s.RLock()
-	defer s.RUnlock()
 	for _, slashing := range blk.Body().ProposerSlashings() {
 		idx := slashing.Header_1.Header.ProposerIndex
-		if s.trackedIndex(idx) {
+		if s.TrackedIndex(idx) {
 			log.WithFields(logrus.Fields{
 				"ProposerIndex": idx,
-				"Slot":          blk.Slot(),
+				"Slot:":         blk.Slot(),
 				"SlashingSlot":  slashing.Header_1.Header.Slot,
 				"Root1":         fmt.Sprintf("%#x", bytesutil.Trunc(slashing.Header_1.Header.BodyRoot)),
 				"Root2":         fmt.Sprintf("%#x", bytesutil.Trunc(slashing.Header_2.Header.BodyRoot)),
@@ -119,10 +27,10 @@ func (s *Service) processSlashings(blk block.BeaconBlock) {
 
 	for _, slashing := range blk.Body().AttesterSlashings() {
 		for _, idx := range blocks.SlashableAttesterIndices(slashing) {
-			if s.trackedIndex(types.ValidatorIndex(idx)) {
+			if s.TrackedIndex(types.ValidatorIndex(idx)) {
 				log.WithFields(logrus.Fields{
 					"AttesterIndex": idx,
-					"Slot":          blk.Slot(),
+					"Slot:":         blk.Slot(),
 					"Slot1":         slashing.Attestation_1.Data.Slot,
 					"Root1":         fmt.Sprintf("%#x", bytesutil.Trunc(slashing.Attestation_1.Data.BeaconBlockRoot)),
 					"SourceEpoch1":  slashing.Attestation_1.Data.Source.Epoch,
@@ -137,41 +45,3 @@ func (s *Service) processSlashings(blk block.BeaconBlock) {
 		}
 	}
 }
-
-// logAggregatedPerformance logs the performance statistics collected since the run started
-func (s *Service) logAggregatedPerformance() {
-	s.RLock()
-	defer s.RUnlock()
-
-	for idx, p := range s.aggregatedPerformance {
-		if p.totalAttestedCount == 0 || p.totalRequestedCount == 0 || p.startBalance == 0 {
-			break
-		}
-		l, ok := s.latestPerformance[idx]
-		if !ok {
-			break
-		}
-		percentAtt := float64(p.totalAttestedCount) / float64(p.totalRequestedCount)
-		percentBal := float64(l.balance-p.startBalance) / float64(p.startBalance)
-		percentDistance := float64(p.totalDistance) / float64(p.totalAttestedCount)
-		percentCorrectSource := float64(p.totalCorrectSource) / float64(p.totalAttestedCount)
-		percentCorrectHead := float64(p.totalCorrectHead) / float64(p.totalAttestedCount)
-		percentCorrectTarget := float64(p.totalCorrectTarget) / float64(p.totalAttestedCount)
-
-		log.WithFields(logrus.Fields{
-			"ValidatorIndex":           idx,
-			"StartEpoch":               p.startEpoch,
-			"StartBalance":             p.startBalance,
-			"TotalRequested":           p.totalRequestedCount,
-			"AttestationInclusion":     fmt.Sprintf("%.2f%%", percentAtt*100),
-			"BalanceChangePct":         fmt.Sprintf("%.2f%%", percentBal*100),
-			"CorrectlyVotedSourcePct":  fmt.Sprintf("%.2f%%", percentCorrectSource*100),
-			"CorrectlyVotedTargetPct":  fmt.Sprintf("%.2f%%", percentCorrectTarget*100),
-			"CorrectlyVotedHeadPct":    fmt.Sprintf("%.2f%%", percentCorrectHead*100),
-			"AverageInclusionDistance": fmt.Sprintf("%.1f", percentDistance),
-			"TotalProposedBlocks":      p.totalProposedCount,
-			"TotalAggregations":        p.totalAggregations,
-			"TotalSyncContributions":   p.totalSyncComitteeContributions,
-		}).Info("Aggregated performance since launch")
-	}
-}