separate out into specific files

.well-known/security.txt

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

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.5"
+consensus_spec_version = "v1.1.3"
 
 bls_test_version = "v0.1.1"
 
@@ -241,7 +241,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "a7d7173d953494c0dfde432c9fc064c25d46d666b024749b3474ae0cdfc50050",
+    sha256 = "e572f8c57e2dbbaeee056a600dc9d08396010dd5134a3a95e43c540470acf6f5",
     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 = "f86872061588c0197516b23025d39e9365b4716c112218a618739dc0d6f4666a",
+    sha256 = "7e2f62eaae9fd541690cc61d252556d0c5deb585ca1873aacbeb5b02d06f1362",
     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 = "7a06975360fd37fbb4694d0e06abb78d2a0835146c1d9b26d33569edff8b98f0",
+    sha256 = "05cbb89810c8acd6c57c4773ddfd167305cd4539960e9b4d7b69e1a988b35ad2",
     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 = "87d8089200163340484d61212fbdffbb5d9d03e1244622761dcb91e641a65761",
+    sha256 = "0cef67b08448f7eb43bf66c464451c9e7a4852df8ef90555cca6d440e3436882",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

beacon-chain/blockchain/BUILD.bazel

@@ -18,7 +18,6 @@ go_library(
         "receive_attestation.go",
         "receive_block.go",
         "service.go",
-        "state_balance_cache.go",
         "weak_subjectivity_checks.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain",
@@ -96,7 +95,6 @@ go_test(
         "init_test.go",
         "log_test.go",
         "metrics_test.go",
-        "mock_test.go",
         "process_attestation_test.go",
         "process_block_test.go",
         "receive_attestation_test.go",
@@ -143,7 +141,6 @@ go_test(
         "chain_info_norace_test.go",
         "checktags_test.go",
         "init_test.go",
-        "mock_test.go",
         "receive_block_test.go",
         "service_norace_test.go",
     ],

beacon-chain/blockchain/head.go

@@ -10,6 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
@@ -41,6 +42,9 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 	// ensure head gets its best justified info.
 	if s.bestJustifiedCheckpt.Epoch > s.justifiedCheckpt.Epoch {
 		s.justifiedCheckpt = s.bestJustifiedCheckpt
+		if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+			return err
+		}
 	}
 
 	// Get head from the fork choice service.
@@ -269,6 +273,57 @@ func (s *Service) hasHeadState() bool {
 	return s.head != nil && s.head.state != nil
 }
 
+// This caches justified state balances to be used for fork choice.
+func (s *Service) cacheJustifiedStateBalances(ctx context.Context, justifiedRoot [32]byte) error {
+	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
+		return err
+	}
+
+	s.clearInitSyncBlocks()
+
+	var justifiedState state.BeaconState
+	var err error
+	if justifiedRoot == s.genesisRoot {
+		justifiedState, err = s.cfg.BeaconDB.GenesisState(ctx)
+		if err != nil {
+			return err
+		}
+	} else {
+		justifiedState, err = s.cfg.StateGen.StateByRoot(ctx, justifiedRoot)
+		if err != nil {
+			return err
+		}
+	}
+	if justifiedState == nil || justifiedState.IsNil() {
+		return errors.New("justified state can't be nil")
+	}
+
+	epoch := time.CurrentEpoch(justifiedState)
+
+	justifiedBalances := make([]uint64, justifiedState.NumValidators())
+	if err := justifiedState.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
+		if helpers.IsActiveValidatorUsingTrie(val, epoch) {
+			justifiedBalances[idx] = val.EffectiveBalance()
+		} else {
+			justifiedBalances[idx] = 0
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	s.justifiedBalancesLock.Lock()
+	defer s.justifiedBalancesLock.Unlock()
+	s.justifiedBalances = justifiedBalances
+	return nil
+}
+
+func (s *Service) getJustifiedBalances() []uint64 {
+	s.justifiedBalancesLock.RLock()
+	defer s.justifiedBalancesLock.RUnlock()
+	return s.justifiedBalances
+}
+
 // Notifies a common event feed of a new chain head event. Called right after a new
 // chain head is determined, set, and saved to disk.
 func (s *Service) notifyNewHeadEvent(

beacon-chain/blockchain/head_test.go

@@ -123,15 +123,13 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
-	ctx := context.Background()
 
 	state, _ := util.DeterministicGenesisState(t, 100)
 	r := [32]byte{'a'}
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: r[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), state, r))
-	balances, err := service.justifiedBalances.get(ctx, r)
-	require.NoError(t, err)
-	require.DeepEqual(t, balances, state.Balances(), "Incorrect justified balances")
+	require.NoError(t, service.cacheJustifiedStateBalances(context.Background(), r))
+	require.DeepEqual(t, service.getJustifiedBalances(), state.Balances(), "Incorrect justified balances")
 }
 
 func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {

beacon-chain/blockchain/info_test.go

@@ -25,18 +25,18 @@ func TestService_TreeHandler(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetBalances([]uint64{params.BeaconConfig().GweiPerEth}))
-	fcs := protoarray.New(
-		0, // justifiedEpoch
-		0, // finalizedEpoch
-		[32]byte{'a'},
-	)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		ForkChoiceStore: protoarray.New(
+			0, // justifiedEpoch
+			0, // finalizedEpoch
+			[32]byte{'a'},
+		),
+		StateGen: stategen.New(beaconDB),
 	}
-	s, err := NewService(ctx, opts...)
+	s, err := NewService(ctx)
 	require.NoError(t, err)
+	s.cfg = cfg
 	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, [32]byte{'a'}, [32]byte{'g'}, [32]byte{'c'}, 0, 0))
 	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'c'}, 0, 0))
 	s.setHead([32]byte{'a'}, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), headState)

beacon-chain/blockchain/metrics.go

@@ -130,14 +130,6 @@ var (
 		Name: "sync_head_state_hit",
 		Help: "The number of sync head state requests that are present in the cache.",
 	})
-	stateBalanceCacheHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "state_balance_cache_hit",
-		Help: "Count the number of state balance cache hits.",
-	})
-	stateBalanceCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "state_balance_cache_miss",
-		Help: "Count the number of state balance cache hits.",
-	})
 )
 
 // reportSlotMetrics reports slot related metrics.

beacon-chain/blockchain/mock_test.go

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

beacon-chain/blockchain/options.go

@@ -130,13 +130,6 @@ func WithSlasherAttestationsFeed(f *event.Feed) Option {
 	}
 }
 
-func withStateBalanceCache(c *stateBalanceCache) Option {
-	return func(s *Service) error {
-		s.justifiedBalances = c
-		return nil
-	}
-}
-
 // WithFinalizedStateAtStartUp to store finalized state at start up.
 func WithFinalizedStateAtStartUp(st state.BeaconState) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_attestation_test.go

@@ -24,13 +24,14 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New(0, 0, [32]byte{})),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	_, err = blockTree1(t, beaconDB, []byte{'g'})
 	require.NoError(t, err)
@@ -130,14 +131,14 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	require.NoError(t, genesisState.SetGenesisTime(uint64(time.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
@@ -156,12 +157,13 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -228,12 +230,13 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	epoch := types.Epoch(1)
 	baseState, _ := util.DeterministicGenesisState(t, 1)
@@ -265,10 +268,12 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 
 func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsNoDB()
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)}))
@@ -276,10 +281,12 @@ func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 
 func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsNoDB()
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
@@ -287,10 +294,12 @@ func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 
 func TestAttEpoch_NotMatch(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsNoDB()
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	nowTime := 2 * uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	err = service.verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, 32)})
@@ -299,9 +308,12 @@ func TestAttEpoch_NotMatch(t *testing.T) {
 
 func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	beaconDB := testDB.SetupDB(t)
+
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	d := util.HydrateAttestationData(&ethpb.AttestationData{})
 	assert.ErrorContains(t, "signed beacon block can't be nil", service.verifyBeaconBlock(ctx, d))
@@ -309,10 +321,12 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 
 func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
@@ -326,10 +340,12 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 
 func TestVerifyBeaconBlock_OK(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
@@ -345,14 +361,10 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -375,10 +387,12 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 
 func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -401,10 +415,12 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 
 func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32

beacon-chain/blockchain/process_block.go

@@ -151,12 +151,7 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		s.finalizedCheckpt = postState.FinalizedCheckpoint()
 	}
 
-	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
-	if err != nil {
-		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", s.justifiedCheckpt.Root)
-		return errors.Wrap(err, msg)
-	}
-	if err := s.updateHead(ctx, balances); err != nil {
+	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
 

beacon-chain/blockchain/process_block_helpers.go

@@ -193,6 +193,9 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 	if canUpdate {
 		s.prevJustifiedCheckpt = s.justifiedCheckpt
 		s.justifiedCheckpt = cpt
+		if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+			return err
+		}
 	}
 
 	return nil
@@ -203,13 +206,12 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 // This method does not have defense against fork choice bouncing attack, which is why it's only recommend to be used during initial syncing.
 func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpoint) error {
 	s.prevJustifiedCheckpt = s.justifiedCheckpt
-
-	if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cp); err != nil {
+	s.justifiedCheckpt = cp
+	if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
 		return err
 	}
-	s.justifiedCheckpt = cp
 
-	return nil
+	return s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cp)
 }
 
 func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
@@ -328,9 +330,7 @@ func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state state.
 	if !attestation.CheckPointIsEqual(s.justifiedCheckpt, state.CurrentJustifiedCheckpoint()) {
 		if state.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
 			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
-			// we don't need to check if the previous justified checkpoint was an ancestor since the new
-			// finalized checkpoint is overriding it.
-			return nil
+			return s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
 		}
 
 		// Update justified if store justified is not in chain with finalized check point.
@@ -345,6 +345,9 @@ func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state state.
 		}
 		if !bytes.Equal(anc, s.finalizedCheckpt.Root) {
 			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
+			if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+				return err
+			}
 		}
 	}
 	return nil

beacon-chain/blockchain/process_block_test.go

@@ -35,17 +35,16 @@ import (
 
 func TestStore_OnBlock(t *testing.T) {
 	ctx := context.Background()
-
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
 
-	service, err := NewService(ctx, opts...)
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		StateGen:        stategen.New(beaconDB),
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+	}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
@@ -135,12 +134,13 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -186,12 +186,14 @@ func TestStore_OnBlockBatch(t *testing.T) {
 
 func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	service.genesisTime = time.Now()
 
 	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: make([]byte, 32)})
@@ -219,13 +221,16 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 
 func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
+
 	lastJustifiedBlk := util.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
@@ -250,12 +255,13 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
 	require.NoError(t, err)
@@ -283,12 +289,13 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		StateGen: stategen.New(beaconDB),
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -320,13 +327,10 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New(0, 0, [32]byte{})),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	signedBlock := util.NewBeaconBlock()
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock)))
@@ -357,12 +361,10 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
 
@@ -398,12 +400,10 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
 
@@ -442,12 +442,10 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	// Set finalized epoch to 1.
 	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
@@ -588,8 +586,7 @@ func TestCurrentSlot_HandlesOverflow(t *testing.T) {
 }
 func TestAncestorByDB_CtxErr(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
 
 	cancel()
@@ -601,14 +598,10 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
@@ -649,9 +642,10 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 
 func TestAncestor_CanUseForkchoice(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
@@ -688,14 +682,10 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
@@ -730,9 +720,10 @@ func TestAncestor_CanUseDB(t *testing.T) {
 
 func TestEnsureRootNotZeroHashes(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsNoDB()
-	service, err := NewService(ctx, opts...)
+	cfg := &config{}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 	service.genesisRoot = [32]byte{'a'}
 
 	r := service.ensureRootNotZeros(params.BeaconConfig().ZeroHash)
@@ -744,12 +735,6 @@ func TestEnsureRootNotZeroHashes(t *testing.T) {
 
 func TestFinalizedImpliesNewJustified(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
 	ctx := context.Background()
 	type args struct {
 		cachedCheckPoint        *ethpb.Checkpoint
@@ -791,8 +776,9 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
 		beaconState, err := util.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(test.args.stateCheckPoint))
-		service, err := NewService(ctx, opts...)
+		service, err := NewService(ctx)
 		require.NoError(t, err)
+		service.cfg = &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
 		service.justifiedCheckpt = test.args.cachedCheckPoint
 		require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
 		genesisState, err := util.NewBeaconState()
@@ -829,12 +815,6 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
 	r, err := b.Block.HashTreeRoot()
@@ -889,8 +869,9 @@ func TestVerifyBlkDescendant(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		service, err := NewService(ctx, opts...)
+		service, err := NewService(ctx)
 		require.NoError(t, err)
+		service.cfg = &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
 		service.finalizedCheckpt = &ethpb.Checkpoint{
 			Root: tt.args.finalizedRoot[:],
 		}
@@ -904,10 +885,12 @@ func TestVerifyBlkDescendant(t *testing.T) {
 }
 
 func TestUpdateJustifiedInitSync(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	gBlk := util.NewBeaconBlock()
 	gRoot, err := gBlk.Block.HashTreeRoot()
@@ -933,9 +916,10 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 
 func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsNoDB()
-	service, err := NewService(ctx, opts...)
+	cfg := &config{}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -947,9 +931,10 @@ func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 
 func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsNoDB()
-	service, err := NewService(ctx, opts...)
+	cfg := &config{}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	s, _ := util.DeterministicGenesisState(t, 1024)
 	service.head = &head{state: s}
@@ -961,18 +946,18 @@ func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 func TestOnBlock_CanFinalize(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-		WithDepositCache(depositCache),
-		WithStateNotifier(&mock.MockStateNotifier{}),
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		StateGen:        stategen.New(beaconDB),
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		DepositCache:    depositCache,
+		StateNotifier:   &mock.MockStateNotifier{},
 	}
-	service, err := NewService(ctx, opts...)
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	gs, keys := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
@@ -1006,12 +991,18 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 
 func TestInsertFinalizedDeposits(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
+	beaconDB := testDB.SetupDB(t)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
-	opts = append(opts, WithDepositCache(depositCache))
-	service, err := NewService(ctx, opts...)
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		StateGen:        stategen.New(beaconDB),
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		DepositCache:    depositCache,
+	}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	gs, _ := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))

beacon-chain/blockchain/receive_attestation.go

@@ -131,13 +131,7 @@ func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan<- stru
 				continue
 			}
 			s.processAttestations(s.ctx)
-
-			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 {
+			if err := s.updateHead(s.ctx, s.getJustifiedBalances()); err != nil {
 				log.Warnf("Resolving fork due to new attestation: %v", err)
 			}
 		}

beacon-chain/blockchain/receive_attestation_test.go

@@ -9,7 +9,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -40,10 +42,12 @@ func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 
 func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
+	beaconDB := testDB.SetupDB(t)
 
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -67,10 +71,12 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 
 func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
 
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
+	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
+	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -95,12 +101,18 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 func TestProcessAttestations_Ok(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	opts = append(opts, WithAttestationPool(attestations.NewPool()))
+	beaconDB := testDB.SetupDB(t)
 
-	service, err := NewService(ctx, opts...)
+	cfg := &config{
+		BeaconDB:        beaconDB,
+		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+		StateGen:        stategen.New(beaconDB),
+		AttPool:         attestations.NewPool(),
+	}
+	service, err := NewService(ctx)
 	require.NoError(t, err)
 	service.genesisTime = prysmTime.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
+	service.cfg = cfg
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	require.NoError(t, genesisState.SetGenesisTime(uint64(prysmTime.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))

beacon-chain/blockchain/receive_block_test.go

@@ -124,16 +124,21 @@ func TestService_ReceiveBlock(t *testing.T) {
 			genesisBlockRoot := bytesutil.ToBytes32(nil)
 			require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
 
-			opts := []Option{
-				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New(0, 0, genesisBlockRoot)),
-				WithAttestationPool(attestations.NewPool()),
-				WithExitPool(voluntaryexits.NewPool()),
-				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
-				WithStateGen(stategen.New(beaconDB)),
+			cfg := &config{
+				BeaconDB: beaconDB,
+				ForkChoiceStore: protoarray.New(
+					0, // justifiedEpoch
+					0, // finalizedEpoch
+					genesisBlockRoot,
+				),
+				AttPool:       attestations.NewPool(),
+				ExitPool:      voluntaryexits.NewPool(),
+				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+				StateGen:      stategen.New(beaconDB),
 			}
-			s, err := NewService(ctx, opts...)
+			s, err := NewService(ctx)
 			require.NoError(t, err)
+			s.cfg = cfg
 			require.NoError(t, s.saveGenesisData(ctx, genesis))
 			gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
 			require.NoError(t, err)
@@ -161,17 +166,21 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	genesisBlockRoot := bytesutil.ToBytes32(nil)
 	require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New(0, 0, genesisBlockRoot)),
-		WithAttestationPool(attestations.NewPool()),
-		WithExitPool(voluntaryexits.NewPool()),
-		WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
-		WithStateGen(stategen.New(beaconDB)),
+	cfg := &config{
+		BeaconDB: beaconDB,
+		ForkChoiceStore: protoarray.New(
+			0, // justifiedEpoch
+			0, // finalizedEpoch
+			genesisBlockRoot,
+		),
+		AttPool:       attestations.NewPool(),
+		ExitPool:      voluntaryexits.NewPool(),
+		StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+		StateGen:      stategen.New(beaconDB),
 	}
-
-	s, err := NewService(ctx, opts...)
+	s, err := NewService(ctx)
 	require.NoError(t, err)
+	s.cfg = cfg
 	require.NoError(t, s.saveGenesisData(ctx, genesis))
 	gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
 	require.NoError(t, err)
@@ -241,14 +250,19 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			beaconDB := testDB.SetupDB(t)
 			genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
 			require.NoError(t, err)
-			opts := []Option{
-				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New(0, 0, genesisBlockRoot)),
-				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
-				WithStateGen(stategen.New(beaconDB)),
+			cfg := &config{
+				BeaconDB: beaconDB,
+				ForkChoiceStore: protoarray.New(
+					0, // justifiedEpoch
+					0, // finalizedEpoch
+					genesisBlockRoot,
+				),
+				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
+				StateGen:      stategen.New(beaconDB),
 			}
-			s, err := NewService(ctx, opts...)
+			s, err := NewService(ctx)
 			require.NoError(t, err)
+			s.cfg = cfg
 			err = s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
 			gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
@@ -273,10 +287,9 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 }
 
 func TestService_HasInitSyncBlock(t *testing.T) {
-	opts := testServiceOptsNoDB()
-	opts = append(opts, WithStateNotifier(&blockchainTesting.MockStateNotifier{}))
-	s, err := NewService(context.Background(), opts...)
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
+	s.cfg = &config{StateNotifier: &blockchainTesting.MockStateNotifier{}}
 	r := [32]byte{'a'}
 	if s.HasInitSyncBlock(r) {
 		t.Error("Should not have block")
@@ -288,10 +301,11 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 }
 
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
-	opts := testServiceOptsWithDB(t)
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background(), opts...)
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
+	s.cfg = &config{StateGen: stategen.New(beaconDB)}
 	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
 	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
 	s.finalizedCheckpt = &ethpb.Checkpoint{}
@@ -301,10 +315,11 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 }
 
 func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	opts := testServiceOptsWithDB(t)
-	s, err := NewService(context.Background(), opts...)
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
+	s.cfg = &config{StateGen: stategen.New(beaconDB)}
 	s.finalizedCheckpt = &ethpb.Checkpoint{}
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	s.genesisTime = time.Now()
@@ -314,10 +329,11 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 }
 
 func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	opts := testServiceOptsWithDB(t)
-	s, err := NewService(context.Background(), opts...)
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
+	s.cfg = &config{StateGen: stategen.New(beaconDB)}
 	s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
 	s.genesisTime = time.Now()
 

beacon-chain/blockchain/service.go

@@ -62,9 +62,9 @@ type Service struct {
 	checkpointStateCache  *cache.CheckpointStateCache
 	initSyncBlocks        map[[32]byte]block.SignedBeaconBlock
 	initSyncBlocksLock    sync.RWMutex
-	//justifiedBalances     []uint64
-	justifiedBalances *stateBalanceCache
-	wsVerifier        *WeakSubjectivityVerifier
+	justifiedBalances     []uint64
+	justifiedBalancesLock sync.RWMutex
+	wsVerifier            *WeakSubjectivityVerifier
 }
 
 // config options for the service.
@@ -97,6 +97,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		boundaryRoots:        [][32]byte{},
 		checkpointStateCache: cache.NewCheckpointStateCache(),
 		initSyncBlocks:       make(map[[32]byte]block.SignedBeaconBlock),
+		justifiedBalances:    make([]uint64, 0),
 		cfg:                  &config{},
 	}
 	for _, opt := range opts {
@@ -105,12 +106,6 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		}
 	}
 	var err error
-	if srv.justifiedBalances == nil {
-		srv.justifiedBalances, err = newStateBalanceCache(srv.cfg.StateGen)
-		if err != nil {
-			return nil, err
-		}
-	}
 	srv.wsVerifier, err = NewWeakSubjectivityVerifier(srv.cfg.WeakSubjectivityCheckpt, srv.cfg.BeaconDB)
 	if err != nil {
 		return nil, err
@@ -156,6 +151,9 @@ func (s *Service) Start() {
 
 		// Resume fork choice.
 		s.justifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
+		if err := s.cacheJustifiedStateBalances(s.ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))); err != nil {
+			log.Fatalf("Could not cache justified state balances: %v", err)
+		}
 		s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
 		s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(justifiedCheckpoint)
 		s.finalizedCheckpt = ethpb.CopyCheckpoint(finalizedCheckpoint)
@@ -342,6 +340,9 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	genesisCheckpoint := genesisState.FinalizedCheckpoint()
 
 	s.justifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	if err := s.cacheJustifiedStateBalances(ctx, genesisBlkRoot); err != nil {
+		return err
+	}
 	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
 	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
 	s.finalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)

beacon-chain/blockchain/service_test.go

@@ -108,24 +108,25 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	stateGen := stategen.New(beaconDB)
-	// Safe a state in stategen to purposes of testing a service stop / shutdown.
-	require.NoError(t, stateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithDepositCache(depositCache),
-		WithChainStartFetcher(web3Service),
-		WithAttestationPool(attestations.NewPool()),
-		WithP2PBroadcaster(&mockBroadcaster{}),
-		WithStateNotifier(&mockBeaconNode{}),
-		WithForkChoiceStore(protoarray.New(0, 0, params.BeaconConfig().ZeroHash)),
-		WithAttestationService(attService),
-		WithStateGen(stateGen),
+	cfg := &config{
+		BeaconBlockBuf:    0,
+		BeaconDB:          beaconDB,
+		DepositCache:      depositCache,
+		ChainStartFetcher: web3Service,
+		P2p:               &mockBroadcaster{},
+		StateNotifier:     &mockBeaconNode{},
+		AttPool:           attestations.NewPool(),
+		StateGen:          stategen.New(beaconDB),
+		ForkChoiceStore:   protoarray.New(0, 0, params.BeaconConfig().ZeroHash),
+		AttService:        attService,
 	}
 
-	chainService, err := NewService(ctx, opts...)
+	// Safe a state in stategen to purposes of testing a service stop / shutdown.
+	require.NoError(t, cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
+
+	chainService, err := NewService(ctx)
 	require.NoError(t, err, "Unable to setup chain service")
+	chainService.cfg = cfg
 	chainService.genesisTime = time.Unix(1, 0) // non-zero time
 
 	return chainService

beacon-chain/blockchain/state_balance_cache.go

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

beacon-chain/blockchain/state_balance_cache_test.go

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

beacon-chain/cache/depositcache/deposits_cache.go

@@ -5,6 +5,7 @@
 package depositcache
 
 import (
+	"bytes"
 	"context"
 	"encoding/hex"
 	"math/big"
@@ -53,7 +54,6 @@ type DepositCache struct {
 	pendingDeposits   []*dbpb.DepositContainer
 	deposits          []*dbpb.DepositContainer
 	finalizedDeposits *FinalizedDeposits
-	depositsByKey     map[[48]byte][]*dbpb.DepositContainer
 	depositsLock      sync.RWMutex
 }
 
@@ -69,7 +69,6 @@ func New() (*DepositCache, error) {
 	return &DepositCache{
 		pendingDeposits:   []*dbpb.DepositContainer{},
 		deposits:          []*dbpb.DepositContainer{},
-		depositsByKey:     map[[48]byte][]*ethpb.DepositContainer{},
 		finalizedDeposits: &FinalizedDeposits{Deposits: finalizedDepositsTrie, MerkleTrieIndex: -1},
 	}, nil
 }
@@ -96,15 +95,10 @@ 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 := &dbpb.DepositContainer{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}
 	newDeposits := append(
-		[]*dbpb.DepositContainer{depCtr},
+		[]*dbpb.DepositContainer{{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}},
 		dc.deposits[heightIdx:]...)
 	dc.deposits = append(dc.deposits[:heightIdx], newDeposits...)
-	// Append the deposit to our map, in the event no deposits
-	// exist for the pubkey , it is simply added to the map.
-	pubkey := bytesutil.ToBytes48(d.Data.PublicKey)
-	dc.depositsByKey[pubkey] = append(dc.depositsByKey[pubkey], depCtr)
 	historicalDepositsCount.Inc()
 	return nil
 }
@@ -118,13 +112,6 @@ func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*dbp
 
 	sort.SliceStable(ctrs, func(i int, j int) bool { return ctrs[i].Index < ctrs[j].Index })
 	dc.deposits = ctrs
-	for _, c := range ctrs {
-		// Use a new value, as the reference
-		// of c changes in the next iteration.
-		newPtr := c
-		pKey := bytesutil.ToBytes48(newPtr.Deposit.Data.PublicKey)
-		dc.depositsByKey[pKey] = append(dc.depositsByKey[pKey], newPtr)
-	}
 	historicalDepositsCount.Add(float64(len(ctrs)))
 }
 
@@ -215,15 +202,13 @@ func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*et
 
 	var deposit *ethpb.Deposit
 	var blockNum *big.Int
-	deps, ok := dc.depositsByKey[bytesutil.ToBytes48(pubKey)]
-	if !ok || len(deps) == 0 {
-		return deposit, blockNum
+	for _, ctnr := range dc.deposits {
+		if bytes.Equal(ctnr.Deposit.Data.PublicKey, pubKey) {
+			deposit = ctnr.Deposit
+			blockNum = big.NewInt(int64(ctnr.Eth1BlockHeight))
+			break
+		}
 	}
-	// We always return the first deposit if a particular
-	// validator key has multiple deposits assigned to
-	// it.
-	deposit = deps[0].Deposit
-	blockNum = big.NewInt(int64(deps[0].Eth1BlockHeight))
 	return deposit, blockNum
 }
 

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -44,31 +44,31 @@ func TestInsertDeposit_MaintainsSortedOrderByIndex(t *testing.T) {
 	}{
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'A'}}},
+			deposit:     &ethpb.Deposit{},
 			index:       0,
 			expectedErr: "",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'B'}}},
+			deposit:     &ethpb.Deposit{},
 			index:       3,
 			expectedErr: "wanted deposit with index 1 to be inserted but received 3",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'C'}}},
+			deposit:     &ethpb.Deposit{},
 			index:       1,
 			expectedErr: "",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'D'}}},
+			deposit:     &ethpb.Deposit{},
 			index:       4,
 			expectedErr: "wanted deposit with index 2 to be inserted but received 4",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'E'}}},
+			deposit:     &ethpb.Deposit{},
 			index:       2,
 			expectedErr: "",
 		},
@@ -316,7 +316,8 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
-	ctrs := []*dbpb.DepositContainer{
+
+	dc.deposits = []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 9,
 			Deposit: &ethpb.Deposit{
@@ -358,7 +359,6 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 			},
 		},
 	}
-	dc.InsertDepositContainers(context.Background(), ctrs)
 
 	pk1 := bytesutil.PadTo([]byte("pk1"), 48)
 	dep, blkNum := dc.DepositByPubkey(context.Background(), pk1)
@@ -626,28 +626,24 @@ func TestPruneProofs_Ok(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk0"), 48)}},
-			index: 0,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   0,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk1"), 48)}},
-			index: 1,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   1,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk2"), 48)}},
-			index: 2,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   2,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
-			index: 3,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   3,
 		},
 	}
 
@@ -673,26 +669,24 @@ func TestPruneProofs_SomeAlreadyPruned(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: nil, Data: &ethpb.Deposit_Data{
-				PublicKey: bytesutil.PadTo([]byte("pk0"), 48)}},
-			index: 0,
-		},
-		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: nil, Data: &ethpb.Deposit_Data{
-				PublicKey: bytesutil.PadTo([]byte("pk1"), 48)}}, index: 1,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: nil},
+			index:   0,
 		},
 		{
 			blkNum:  0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(), Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk2"), 48)}},
+			deposit: &ethpb.Deposit{Proof: nil},
+			index:   1,
+		},
+		{
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
 			index:   2,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
-			index: 3,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   3,
 		},
 	}
 
@@ -715,28 +709,24 @@ func TestPruneProofs_PruneAllWhenDepositIndexTooBig(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk0"), 48)}},
-			index: 0,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   0,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk1"), 48)}},
-			index: 1,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   1,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk2"), 48)}},
-			index: 2,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   2,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
-			index: 3,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   3,
 		},
 	}
 
@@ -762,28 +752,24 @@ func TestPruneProofs_CorrectlyHandleLastIndex(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk0"), 48)}},
-			index: 0,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   0,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk1"), 48)}},
-			index: 1,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   1,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk2"), 48)}},
-			index: 2,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   2,
 		},
 		{
-			blkNum: 0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
-				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
-			index: 3,
+			blkNum:  0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			index:   3,
 		},
 	}
 
@@ -799,36 +785,6 @@ func TestPruneProofs_CorrectlyHandleLastIndex(t *testing.T) {
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[3].Deposit.Proof)
 }
 
-func TestDepositMap_WorksCorrectly(t *testing.T) {
-	dc, err := New()
-	require.NoError(t, err)
-
-	pk0 := bytesutil.PadTo([]byte("pk0"), 48)
-	dep, _ := dc.DepositByPubkey(context.Background(), pk0)
-	var nilDep *ethpb.Deposit
-	assert.DeepEqual(t, nilDep, dep)
-
-	dep = &ethpb.Deposit{Proof: makeDepositProof(), Data: &ethpb.Deposit_Data{PublicKey: pk0, Amount: 1000}}
-	assert.NoError(t, dc.InsertDeposit(context.Background(), dep, 1000, 0, [32]byte{}))
-
-	dep, _ = dc.DepositByPubkey(context.Background(), pk0)
-	assert.NotEqual(t, nilDep, dep)
-	assert.Equal(t, uint64(1000), dep.Data.Amount)
-
-	dep = &ethpb.Deposit{Proof: makeDepositProof(), Data: &ethpb.Deposit_Data{PublicKey: pk0, Amount: 10000}}
-	assert.NoError(t, dc.InsertDeposit(context.Background(), dep, 1000, 1, [32]byte{}))
-
-	// Make sure we have the same deposit returned over here.
-	dep, _ = dc.DepositByPubkey(context.Background(), pk0)
-	assert.NotEqual(t, nilDep, dep)
-	assert.Equal(t, uint64(1000), dep.Data.Amount)
-
-	// Make sure another key doesn't work.
-	pk1 := bytesutil.PadTo([]byte("pk1"), 48)
-	dep, _ = dc.DepositByPubkey(context.Background(), pk1)
-	assert.DeepEqual(t, nilDep, dep)
-}
-
 func makeDepositProof() [][]byte {
 	proof := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
 	for i := range proof {

beacon-chain/cache/skip_slot_cache.go

@@ -120,22 +120,26 @@ func (c *SkipSlotCache) MarkInProgress(r [32]byte) error {
 
 // MarkNotInProgress will release the lock on a given request. This should be
 // called after put.
-func (c *SkipSlotCache) MarkNotInProgress(r [32]byte) {
+func (c *SkipSlotCache) MarkNotInProgress(r [32]byte) error {
 	if c.disabled {
-		return
+		return nil
 	}
 
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
 	delete(c.inProgress, r)
+	return nil
 }
 
 // Put the response in the cache.
-func (c *SkipSlotCache) Put(_ context.Context, r [32]byte, state state.BeaconState) {
+func (c *SkipSlotCache) Put(_ context.Context, r [32]byte, state state.BeaconState) error {
 	if c.disabled {
-		return
+		return nil
 	}
+
 	// Copy state so cached value is not mutated.
 	c.cache.Add(r, state.Copy())
+
+	return nil
 }

beacon-chain/cache/skip_slot_cache_test.go

@@ -28,8 +28,8 @@ func TestSkipSlotCache_RoundTrip(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	c.Put(ctx, r, s)
-	c.MarkNotInProgress(r)
+	require.NoError(t, c.Put(ctx, r, s))
+	require.NoError(t, c.MarkNotInProgress(r))
 
 	res, err := c.Get(ctx, r)
 	require.NoError(t, err)

beacon-chain/core/blocks/attester_slashing.go

@@ -62,7 +62,7 @@ func ProcessAttesterSlashing(
 	if err := VerifyAttesterSlashing(ctx, beaconState, slashing); err != nil {
 		return nil, errors.Wrap(err, "could not verify attester slashing")
 	}
-	slashableIndices := SlashableAttesterIndices(slashing)
+	slashableIndices := slashableAttesterIndices(slashing)
 	sort.SliceStable(slashableIndices, func(i, j int) bool {
 		return slashableIndices[i] < slashableIndices[j]
 	})
@@ -152,8 +152,7 @@ func IsSlashableAttestationData(data1, data2 *ethpb.AttestationData) bool {
 	return isDoubleVote || isSurroundVote
 }
 
-// SlashableAttesterIndices returns the intersection of attester indices from both attestations in this slashing.
-func SlashableAttesterIndices(slashing *ethpb.AttesterSlashing) []uint64 {
+func slashableAttesterIndices(slashing *ethpb.AttesterSlashing) []uint64 {
 	if slashing == nil || slashing.Attestation_1 == nil || slashing.Attestation_2 == nil {
 		return nil
 	}

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -245,7 +245,7 @@ func TestFuzzslashableAttesterIndices_10000(t *testing.T) {
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(attesterSlashing)
-		SlashableAttesterIndices(attesterSlashing)
+		slashableAttesterIndices(attesterSlashing)
 	}
 }
 

beacon-chain/core/helpers/beacon_committee.go

@@ -199,7 +199,7 @@ func CommitteeAssignments(
 	// Each slot in an epoch has a different set of committees. This value is derived from the
 	// active validator set, which does not change.
 	numCommitteesPerSlot := SlotCommitteeCount(uint64(len(activeValidatorIndices)))
-	validatorIndexToCommittee := make(map[types.ValidatorIndex]*CommitteeAssignmentContainer, len(activeValidatorIndices))
+	validatorIndexToCommittee := make(map[types.ValidatorIndex]*CommitteeAssignmentContainer, params.BeaconConfig().SlotsPerEpoch.Mul(numCommitteesPerSlot))
 
 	// Compute all committees for all slots.
 	for i := types.Slot(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {

beacon-chain/core/signing/domain.go

@@ -2,9 +2,9 @@ package signing
 
 import (
 	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
 // Domain returns the domain version for BLS private key to sign and verify.

beacon-chain/core/signing/domain_test.go

@@ -3,9 +3,9 @@ package signing
 import (
 	"testing"
 
-	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )

beacon-chain/core/time/slot_epoch.go

@@ -60,16 +60,6 @@ func CanUpgradeToAltair(slot types.Slot) bool {
 	return epochStart && altairEpoch
 }
 
-// CanUpgradeToMerge returns true if the input `slot` can upgrade to Merge fork.
-//
-// Spec code:
-// If state.slot % SLOTS_PER_EPOCH == 0 and compute_epoch_at_slot(state.slot) == MERGE_FORK_EPOCH
-func CanUpgradeToMerge(slot types.Slot) bool {
-	epochStart := slots.IsEpochStart(slot)
-	mergeEpoch := slots.ToEpoch(slot) == params.BeaconConfig().MergeForkEpoch
-	return epochStart && mergeEpoch
-}
-
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //

beacon-chain/core/time/slot_epoch_test.go

@@ -114,40 +114,6 @@ func TestCanUpgradeToAltair(t *testing.T) {
 	}
 }
 
-func TestCanUpgradeToMerge(t *testing.T) {
-	bc := params.BeaconConfig()
-	bc.MergeForkEpoch = 5
-	params.OverrideBeaconConfig(bc)
-	tests := []struct {
-		name string
-		slot types.Slot
-		want bool
-	}{
-		{
-			name: "not epoch start",
-			slot: 1,
-			want: false,
-		},
-		{
-			name: "not merge epoch",
-			slot: params.BeaconConfig().SlotsPerEpoch,
-			want: false,
-		},
-		{
-			name: "merge epoch",
-			slot: types.Slot(params.BeaconConfig().MergeForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
-			want: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := CanUpgradeToMerge(tt.slot); got != tt.want {
-				t.Errorf("CanUpgradeToMerge() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestCanProcessEpoch_TrueOnEpochsLastSlot(t *testing.T) {
 	tests := []struct {
 		slot            types.Slot

beacon-chain/core/transition/transition.go

@@ -214,7 +214,10 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 		return nil, err
 	}
 	defer func() {
-		SkipSlotCache.MarkNotInProgress(key)
+		if err := SkipSlotCache.MarkNotInProgress(key); err != nil {
+			tracing.AnnotateError(span, err)
+			log.WithError(err).Error("Failed to mark skip slot no longer in progress")
+		}
 	}()
 
 	for state.Slot() < slot {
@@ -222,7 +225,7 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 			tracing.AnnotateError(span, ctx.Err())
 			// Cache last best value.
 			if highestSlot < state.Slot() {
-				if SkipSlotCache.Put(ctx, key, state); err != nil {
+				if err := SkipSlotCache.Put(ctx, key, state); err != nil {
 					log.WithError(err).Error("Failed to put skip slot cache value")
 				}
 			}
@@ -266,7 +269,10 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 	}
 
 	if highestSlot < state.Slot() {
-		SkipSlotCache.Put(ctx, key, state)
+		if err := SkipSlotCache.Put(ctx, key, state); err != nil {
+			log.WithError(err).Error("Failed to put skip slot cache value")
+			tracing.AnnotateError(span, err)
+		}
 	}
 
 	return state, nil

beacon-chain/db/iface/interface.go

@@ -39,6 +39,14 @@ type ReadOnlyDatabase interface {
 	StateSummary(ctx context.Context, blockRoot [32]byte) (*ethpb.StateSummary, error)
 	HasStateSummary(ctx context.Context, blockRoot [32]byte) bool
 	HighestSlotStatesBelow(ctx context.Context, slot types.Slot) ([]state.ReadOnlyBeaconState, error)
+	// Slashing operations.
+	ProposerSlashing(ctx context.Context, slashingRoot [32]byte) (*eth.ProposerSlashing, error)
+	AttesterSlashing(ctx context.Context, slashingRoot [32]byte) (*eth.AttesterSlashing, error)
+	HasProposerSlashing(ctx context.Context, slashingRoot [32]byte) bool
+	HasAttesterSlashing(ctx context.Context, slashingRoot [32]byte) bool
+	// Block operations.
+	VoluntaryExit(ctx context.Context, exitRoot [32]byte) (*eth.VoluntaryExit, error)
+	HasVoluntaryExit(ctx context.Context, exitRoot [32]byte) bool
 	// Checkpoint operations.
 	JustifiedCheckpoint(ctx context.Context) (*eth.Checkpoint, error)
 	FinalizedCheckpoint(ctx context.Context) (*eth.Checkpoint, error)
@@ -67,6 +75,11 @@ type NoHeadAccessDatabase interface {
 	DeleteStates(ctx context.Context, blockRoots [][32]byte) error
 	SaveStateSummary(ctx context.Context, summary *ethpb.StateSummary) error
 	SaveStateSummaries(ctx context.Context, summaries []*ethpb.StateSummary) error
+	// Slashing operations.
+	SaveProposerSlashing(ctx context.Context, slashing *eth.ProposerSlashing) error
+	SaveAttesterSlashing(ctx context.Context, slashing *eth.AttesterSlashing) error
+	// Block operations.
+	SaveVoluntaryExit(ctx context.Context, exit *eth.VoluntaryExit) error
 	// Checkpoint operations.
 	SaveJustifiedCheckpoint(ctx context.Context, checkpoint *eth.Checkpoint) error
 	SaveFinalizedCheckpoint(ctx context.Context, checkpoint *eth.Checkpoint) error
@@ -147,6 +160,7 @@ type Database interface {
 	io.Closer
 	backup.BackupExporter
 	HeadAccessDatabase
+
 	DatabasePath() string
 	ClearDB() error
 }

beacon-chain/db/kv/BUILD.bazel

@@ -13,14 +13,15 @@ go_library(
         "finalized_block_roots.go",
         "genesis.go",
         "kv.go",
-        "light.go",
         "log.go",
         "migration.go",
         "migration_archived_index.go",
         "migration_block_slot_index.go",
         "migration_state_validators.go",
+        "operations.go",
         "powchain.go",
         "schema.go",
+        "slashings.go",
         "state.go",
         "state_summary.go",
         "state_summary_cache.go",
@@ -87,7 +88,9 @@ go_test(
         "migration_archived_index_test.go",
         "migration_block_slot_index_test.go",
         "migration_state_validators_test.go",
+        "operations_test.go",
         "powchain_test.go",
+        "slashings_test.go",
         "state_summary_test.go",
         "state_test.go",
         "utils_test.go",

beacon-chain/db/kv/blocks.go

@@ -150,7 +150,11 @@ func (s *Store) BlocksBySlot(ctx context.Context, slot types.Slot) (bool, []bloc
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
 
-		keys := blockRootsBySlot(ctx, tx, slot)
+		keys, err := blockRootsBySlot(ctx, tx, slot)
+		if err != nil {
+			return err
+		}
+
 		for i := 0; i < len(keys); i++ {
 			encoded := bkt.Get(keys[i])
 			blk, err := unmarshalBlock(ctx, encoded)
@@ -170,7 +174,11 @@ func (s *Store) BlockRootsBySlot(ctx context.Context, slot types.Slot) (bool, []
 	defer span.End()
 	blockRoots := make([][32]byte, 0)
 	err := s.db.View(func(tx *bolt.Tx) error {
-		keys := blockRootsBySlot(ctx, tx, slot)
+		keys, err := blockRootsBySlot(ctx, tx, slot)
+		if err != nil {
+			return err
+		}
+
 		for i := 0; i < len(keys); i++ {
 			blockRoots = append(blockRoots, bytesutil.ToBytes32(keys[i]))
 		}
@@ -511,7 +519,7 @@ func blockRootsBySlotRange(
 }
 
 // blockRootsBySlot retrieves the block roots by slot
-func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) [][]byte {
+func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) ([][]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
 	defer span.End()
 
@@ -525,7 +533,7 @@ func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) [][]byt
 			roots = append(roots, v[i:i+32])
 		}
 	}
-	return roots
+	return roots, nil
 }
 
 // createBlockIndicesFromBlock takes in a beacon block and returns

beacon-chain/db/kv/operations.go

@@ -0,0 +1,78 @@
+package kv
+
+import (
+	"context"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
+)
+
+// VoluntaryExit retrieval by signing root.
+func (s *Store) VoluntaryExit(ctx context.Context, exitRoot [32]byte) (*ethpb.VoluntaryExit, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.VoluntaryExit")
+	defer span.End()
+	enc, err := s.voluntaryExitBytes(ctx, exitRoot)
+	if err != nil {
+		return nil, err
+	}
+	if len(enc) == 0 {
+		return nil, nil
+	}
+	exit := &ethpb.VoluntaryExit{}
+	if err := decode(ctx, enc, exit); err != nil {
+		return nil, err
+	}
+	return exit, nil
+}
+
+// HasVoluntaryExit verifies if a voluntary exit is stored in the db by its signing root.
+func (s *Store) HasVoluntaryExit(ctx context.Context, exitRoot [32]byte) bool {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasVoluntaryExit")
+	defer span.End()
+	enc, err := s.voluntaryExitBytes(ctx, exitRoot)
+	if err != nil {
+		panic(err)
+	}
+	return len(enc) > 0
+}
+
+// SaveVoluntaryExit to the db by its signing root.
+func (s *Store) SaveVoluntaryExit(ctx context.Context, exit *ethpb.VoluntaryExit) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveVoluntaryExit")
+	defer span.End()
+	exitRoot, err := exit.HashTreeRoot()
+	if err != nil {
+		return err
+	}
+	enc, err := encode(ctx, exit)
+	if err != nil {
+		return err
+	}
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(voluntaryExitsBucket)
+		return bucket.Put(exitRoot[:], enc)
+	})
+}
+
+func (s *Store) voluntaryExitBytes(ctx context.Context, exitRoot [32]byte) ([]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.voluntaryExitBytes")
+	defer span.End()
+	var dst []byte
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(voluntaryExitsBucket)
+		dst = bkt.Get(exitRoot[:])
+		return nil
+	})
+	return dst, err
+}
+
+// deleteVoluntaryExit clears a voluntary exit from the db by its signing root.
+func (s *Store) deleteVoluntaryExit(ctx context.Context, exitRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteVoluntaryExit")
+	defer span.End()
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(voluntaryExitsBucket)
+		return bucket.Delete(exitRoot[:])
+	})
+}

beacon-chain/db/kv/operations_test.go

@@ -0,0 +1,31 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestStore_VoluntaryExits_CRUD(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	exit := &ethpb.VoluntaryExit{
+		Epoch: 5,
+	}
+	exitRoot, err := exit.HashTreeRoot()
+	require.NoError(t, err)
+	retrieved, err := db.VoluntaryExit(ctx, exitRoot)
+	require.NoError(t, err)
+	assert.Equal(t, (*ethpb.VoluntaryExit)(nil), retrieved, "Expected nil voluntary exit")
+	require.NoError(t, db.SaveVoluntaryExit(ctx, exit))
+	assert.Equal(t, true, db.HasVoluntaryExit(ctx, exitRoot), "Expected voluntary exit to exist in the db")
+	retrieved, err = db.VoluntaryExit(ctx, exitRoot)
+	require.NoError(t, err)
+	assert.Equal(t, true, proto.Equal(exit, retrieved), "Wanted %v, received %v", exit, retrieved)
+	require.NoError(t, db.deleteVoluntaryExit(ctx, exitRoot))
+	assert.Equal(t, false, db.HasVoluntaryExit(ctx, exitRoot), "Expected voluntary exit to have been deleted from the db")
+}

beacon-chain/db/kv/slashings.go

@@ -0,0 +1,147 @@
+package kv
+
+import (
+	"context"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
+)
+
+// ProposerSlashing retrieval by slashing root.
+func (s *Store) ProposerSlashing(ctx context.Context, slashingRoot [32]byte) (*ethpb.ProposerSlashing, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.ProposerSlashing")
+	defer span.End()
+	enc, err := s.proposerSlashingBytes(ctx, slashingRoot)
+	if err != nil {
+		return nil, err
+	}
+	if len(enc) == 0 {
+		return nil, nil
+	}
+	proposerSlashing := &ethpb.ProposerSlashing{}
+	if err := decode(ctx, enc, proposerSlashing); err != nil {
+		return nil, err
+	}
+	return proposerSlashing, nil
+}
+
+// HasProposerSlashing verifies if a slashing is stored in the db.
+func (s *Store) HasProposerSlashing(ctx context.Context, slashingRoot [32]byte) bool {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasProposerSlashing")
+	defer span.End()
+	enc, err := s.proposerSlashingBytes(ctx, slashingRoot)
+	if err != nil {
+		panic(err)
+	}
+	return len(enc) > 0
+}
+
+// SaveProposerSlashing to the db by its hash tree root.
+func (s *Store) SaveProposerSlashing(ctx context.Context, slashing *ethpb.ProposerSlashing) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveProposerSlashing")
+	defer span.End()
+	slashingRoot, err := slashing.HashTreeRoot()
+	if err != nil {
+		return err
+	}
+	enc, err := encode(ctx, slashing)
+	if err != nil {
+		return err
+	}
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(proposerSlashingsBucket)
+		return bucket.Put(slashingRoot[:], enc)
+	})
+}
+
+func (s *Store) proposerSlashingBytes(ctx context.Context, slashingRoot [32]byte) ([]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.proposerSlashingBytes")
+	defer span.End()
+	var dst []byte
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(proposerSlashingsBucket)
+		dst = bkt.Get(slashingRoot[:])
+		return nil
+	})
+	return dst, err
+}
+
+// deleteProposerSlashing clears a proposer slashing from the db by its hash tree root.
+func (s *Store) deleteProposerSlashing(ctx context.Context, slashingRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteProposerSlashing")
+	defer span.End()
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(proposerSlashingsBucket)
+		return bucket.Delete(slashingRoot[:])
+	})
+}
+
+// AttesterSlashing retrieval by hash tree root.
+func (s *Store) AttesterSlashing(ctx context.Context, slashingRoot [32]byte) (*ethpb.AttesterSlashing, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.AttesterSlashing")
+	defer span.End()
+	enc, err := s.attesterSlashingBytes(ctx, slashingRoot)
+	if err != nil {
+		return nil, err
+	}
+	if len(enc) == 0 {
+		return nil, nil
+	}
+	attSlashing := &ethpb.AttesterSlashing{}
+	if err := decode(ctx, enc, attSlashing); err != nil {
+		return nil, err
+	}
+	return attSlashing, nil
+}
+
+// HasAttesterSlashing verifies if a slashing is stored in the db.
+func (s *Store) HasAttesterSlashing(ctx context.Context, slashingRoot [32]byte) bool {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasAttesterSlashing")
+	defer span.End()
+	enc, err := s.attesterSlashingBytes(ctx, slashingRoot)
+	if err != nil {
+		panic(err)
+	}
+	return len(enc) > 0
+}
+
+// SaveAttesterSlashing to the db by its hash tree root.
+func (s *Store) SaveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveAttesterSlashing")
+	defer span.End()
+	slashingRoot, err := slashing.HashTreeRoot()
+	if err != nil {
+		return err
+	}
+	enc, err := encode(ctx, slashing)
+	if err != nil {
+		return err
+	}
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(attesterSlashingsBucket)
+		return bucket.Put(slashingRoot[:], enc)
+	})
+}
+
+func (s *Store) attesterSlashingBytes(ctx context.Context, slashingRoot [32]byte) ([]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.attesterSlashingBytes")
+	defer span.End()
+	var dst []byte
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(attesterSlashingsBucket)
+		dst = bkt.Get(slashingRoot[:])
+		return nil
+	})
+	return dst, err
+}
+
+// deleteAttesterSlashing clears an attester slashing from the db by its hash tree root.
+func (s *Store) deleteAttesterSlashing(ctx context.Context, slashingRoot [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteAttesterSlashing")
+	defer span.End()
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(attesterSlashingsBucket)
+		return bucket.Delete(slashingRoot[:])
+	})
+}

beacon-chain/db/kv/slashings_test.go

@@ -0,0 +1,67 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestStore_ProposerSlashing_CRUD(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	prop := &ethpb.ProposerSlashing{
+		Header_1: util.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
+			Header: &ethpb.BeaconBlockHeader{
+				ProposerIndex: 5,
+			},
+		}),
+		Header_2: util.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
+			Header: &ethpb.BeaconBlockHeader{
+				ProposerIndex: 5,
+			},
+		}),
+	}
+	slashingRoot, err := prop.HashTreeRoot()
+	require.NoError(t, err)
+	retrieved, err := db.ProposerSlashing(ctx, slashingRoot)
+	require.NoError(t, err)
+	assert.Equal(t, (*ethpb.ProposerSlashing)(nil), retrieved, "Expected nil proposer slashing")
+	require.NoError(t, db.SaveProposerSlashing(ctx, prop))
+	assert.Equal(t, true, db.HasProposerSlashing(ctx, slashingRoot), "Expected proposer slashing to exist in the db")
+	retrieved, err = db.ProposerSlashing(ctx, slashingRoot)
+	require.NoError(t, err)
+	assert.Equal(t, true, proto.Equal(prop, retrieved), "Wanted %v, received %v", prop, retrieved)
+	require.NoError(t, db.deleteProposerSlashing(ctx, slashingRoot))
+	assert.Equal(t, false, db.HasProposerSlashing(ctx, slashingRoot), "Expected proposer slashing to have been deleted from the db")
+}
+
+func TestStore_AttesterSlashing_CRUD(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	att := &ethpb.AttesterSlashing{
+		Attestation_1: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+			Data: &ethpb.AttestationData{
+				Slot: 5,
+			}}),
+		Attestation_2: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+			Data: &ethpb.AttestationData{
+				Slot: 7,
+			}})}
+	slashingRoot, err := att.HashTreeRoot()
+	require.NoError(t, err)
+	retrieved, err := db.AttesterSlashing(ctx, slashingRoot)
+	require.NoError(t, err)
+	assert.Equal(t, (*ethpb.AttesterSlashing)(nil), retrieved, "Expected nil attester slashing")
+	require.NoError(t, db.SaveAttesterSlashing(ctx, att))
+	assert.Equal(t, true, db.HasAttesterSlashing(ctx, slashingRoot), "Expected attester slashing to exist in the db")
+	retrieved, err = db.AttesterSlashing(ctx, slashingRoot)
+	require.NoError(t, err)
+	assert.Equal(t, true, proto.Equal(att, retrieved), "Wanted %v, received %v", att, retrieved)
+	require.NoError(t, db.deleteAttesterSlashing(ctx, slashingRoot))
+	assert.Equal(t, false, db.HasAttesterSlashing(ctx, slashingRoot), "Expected attester slashing to have been deleted from the db")
+}

beacon-chain/light/BUILD.bazel

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

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

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

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

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

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

@@ -1,58 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "doc.go",
-        "metrics.go",
-        "process_attestation.go",
-        "process_block.go",
-        "process_exit.go",
-        "service.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/monitor",
-    visibility = ["//beacon-chain:__subpackages__"],
-    deps = [
-        "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/stategen:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
-        "//proto/prysm/v1alpha1/block:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "process_attestation_test.go",
-        "process_block_test.go",
-        "process_exit_test.go",
-        "service_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/state/stategen:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util: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",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-    ],
-)

beacon-chain/monitor/doc.go

@@ -1,7 +0,0 @@
-/*
-Package monitor defines a runtime service which receives
-notifications triggered by events related to performance of tracked
-validating keys. It then logs and emits metrics for a user to keep finely
-detailed performance measures.
-*/
-package monitor

beacon-chain/monitor/metrics.go

@@ -1,70 +0,0 @@
-package monitor
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/sirupsen/logrus"
-)
-
-var (
-	log = logrus.WithField("prefix", "monitor")
-	// TODO: The Prometheus gauge vectors and counters in this package deprecate the
-	// corresponding gauge vectors and counters in the validator client.
-
-	// inclusionSlotGauge used to track attestation inclusion distance
-	inclusionSlotGauge = promauto.NewGaugeVec(
-		prometheus.GaugeOpts{
-			Namespace: "monitor",
-			Name:      "inclusion_slot",
-			Help:      "Attestations inclusion slot",
-		},
-		[]string{
-			"validator_index",
-		},
-	)
-	// timelyHeadCounter used to track attestation timely head flags
-	timelyHeadCounter = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "monitor",
-			Name:      "timely_head",
-			Help:      "Attestation timely Head flag",
-		},
-		[]string{
-			"validator_index",
-		},
-	)
-	// timelyTargetCounter used to track attestation timely head flags
-	timelyTargetCounter = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "monitor",
-			Name:      "timely_target",
-			Help:      "Attestation timely Target flag",
-		},
-		[]string{
-			"validator_index",
-		},
-	)
-	// timelySourceCounter used to track attestation timely head flags
-	timelySourceCounter = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "monitor",
-			Name:      "timely_source",
-			Help:      "Attestation timely Source flag",
-		},
-		[]string{
-			"validator_index",
-		},
-	)
-
-	// aggregationCounter used to track aggregations
-	aggregationCounter = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "monitor",
-			Name:      "aggregations",
-			Help:      "Number of aggregation duties performed",
-		},
-		[]string{
-			"validator_index",
-		},
-	)
-)

beacon-chain/monitor/process_attestation.go

@@ -1,218 +0,0 @@
-package monitor
-
-import (
-	"context"
-	"fmt"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	"github.com/sirupsen/logrus"
-)
-
-// updatedPerformanceFromTrackedVal returns true if the validator is tracked and if the
-// given slot is different than the last attested slot from this validator.
-func (s *Service) updatedPerformanceFromTrackedVal(idx types.ValidatorIndex, slot types.Slot) bool {
-	if !s.TrackedIndex(types.ValidatorIndex(idx)) {
-		return false
-	}
-
-	if lp, ok := s.latestPerformance[types.ValidatorIndex(idx)]; ok {
-		return lp.attestedSlot != slot
-	}
-	return false
-}
-
-// attestingIndices returns the indices of validators that appear in the
-// given aggregated atestation.
-func attestingIndices(ctx context.Context, state state.BeaconState, att *ethpb.Attestation) ([]uint64, error) {
-	committee, err := helpers.BeaconCommitteeFromState(ctx, state, att.Data.Slot, att.Data.CommitteeIndex)
-	if err != nil {
-		return nil, err
-	}
-	return attestation.AttestingIndices(att.AggregationBits, committee)
-}
-
-// logMessageTimelyFlagsForIndex returns the log message with the basic
-// performance indicators for the attestation (head, source, target)
-func logMessageTimelyFlagsForIndex(idx types.ValidatorIndex, data *ethpb.AttestationData) logrus.Fields {
-	return logrus.Fields{
-		"ValidatorIndex": idx,
-		"Slot":           data.Slot,
-		"Source":         fmt.Sprintf("%#x", bytesutil.Trunc(data.Source.Root)),
-		"Target":         fmt.Sprintf("%#x", bytesutil.Trunc(data.Target.Root)),
-		"Head":           fmt.Sprintf("%#x", bytesutil.Trunc(data.BeaconBlockRoot)),
-	}
-}
-
-// processAttestations logs the event that one of our tracked validators'
-// attestations was included in a block
-func (s *Service) processAttestations(ctx context.Context, state state.BeaconState, blk block.BeaconBlock) {
-	if blk == nil || blk.Body() == nil {
-		return
-	}
-	for _, attestation := range blk.Body().Attestations() {
-		s.processIncludedAttestation(ctx, state, attestation)
-	}
-}
-
-// processIncludedAttestation logs in the event that one of our tracked validators'
-// appears in the attesting indices and this included attestation was not included
-// before.
-func (s *Service) processIncludedAttestation(ctx context.Context, state state.BeaconState, att *ethpb.Attestation) {
-	attestingIndices, err := attestingIndices(ctx, state, att)
-	if err != nil {
-		log.WithError(err).Error("Could not get attesting indices")
-		return
-	}
-	for _, idx := range attestingIndices {
-		if s.updatedPerformanceFromTrackedVal(types.ValidatorIndex(idx), att.Data.Slot) {
-			logFields := logMessageTimelyFlagsForIndex(types.ValidatorIndex(idx), att.Data)
-			balance, err := state.BalanceAtIndex(types.ValidatorIndex(idx))
-			if err != nil {
-				log.WithError(err).Error("Could not get balance")
-				return
-			}
-
-			aggregatedPerf := s.aggregatedPerformance[types.ValidatorIndex(idx)]
-			aggregatedPerf.totalAttestedCount++
-			aggregatedPerf.totalRequestedCount++
-
-			latestPerf := s.latestPerformance[types.ValidatorIndex(idx)]
-			balanceChg := balance - latestPerf.balance
-			latestPerf.balanceChange = balanceChg
-			latestPerf.balance = balance
-			latestPerf.attestedSlot = att.Data.Slot
-			latestPerf.inclusionSlot = state.Slot()
-			inclusionSlotGauge.WithLabelValues(fmt.Sprintf("%d", idx)).Set(float64(latestPerf.inclusionSlot))
-			aggregatedPerf.totalDistance += uint64(latestPerf.inclusionSlot - latestPerf.attestedSlot)
-
-			if state.Version() == version.Altair {
-				targetIdx := params.BeaconConfig().TimelyTargetFlagIndex
-				sourceIdx := params.BeaconConfig().TimelySourceFlagIndex
-				headIdx := params.BeaconConfig().TimelyHeadFlagIndex
-
-				var participation []byte
-				if slots.ToEpoch(latestPerf.inclusionSlot) ==
-					slots.ToEpoch(latestPerf.attestedSlot) {
-					participation, err = state.CurrentEpochParticipation()
-					if err != nil {
-						log.WithError(err).Error("Could not get current epoch participation")
-						return
-					}
-				} else {
-					participation, err = state.PreviousEpochParticipation()
-					if err != nil {
-						log.WithError(err).Error("Could not get previous epoch participation")
-						return
-					}
-				}
-				flags := participation[idx]
-				hasFlag, err := altair.HasValidatorFlag(flags, sourceIdx)
-				if err != nil {
-					log.WithError(err).Error("Could not get timely Source flag")
-					return
-				}
-				latestPerf.timelySource = hasFlag
-				hasFlag, err = altair.HasValidatorFlag(flags, headIdx)
-				if err != nil {
-					log.WithError(err).Error("Could not get timely Head flag")
-					return
-				}
-				latestPerf.timelyHead = hasFlag
-				hasFlag, err = altair.HasValidatorFlag(flags, targetIdx)
-				if err != nil {
-					log.WithError(err).Error("Could not get timely Target flag")
-					return
-				}
-				latestPerf.timelyTarget = hasFlag
-
-				if latestPerf.timelySource {
-					timelySourceCounter.WithLabelValues(fmt.Sprintf("%d", idx)).Inc()
-					aggregatedPerf.totalCorrectSource++
-				}
-				if latestPerf.timelyHead {
-					timelyHeadCounter.WithLabelValues(fmt.Sprintf("%d", idx)).Inc()
-					aggregatedPerf.totalCorrectHead++
-				}
-				if latestPerf.timelyTarget {
-					timelyTargetCounter.WithLabelValues(fmt.Sprintf("%d", idx)).Inc()
-					aggregatedPerf.totalCorrectTarget++
-				}
-			}
-			logFields["CorrectHead"] = latestPerf.timelyHead
-			logFields["CorrectSource"] = latestPerf.timelySource
-			logFields["CorrectTarget"] = latestPerf.timelyTarget
-			logFields["InclusionSlot"] = latestPerf.inclusionSlot
-			logFields["NewBalance"] = balance
-			logFields["BalanceChange"] = balanceChg
-
-			s.latestPerformance[types.ValidatorIndex(idx)] = latestPerf
-			s.aggregatedPerformance[types.ValidatorIndex(idx)] = aggregatedPerf
-			log.WithFields(logFields).Info("Attestation included")
-		}
-	}
-}
-
-// 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) {
-	root := bytesutil.ToBytes32(att.Data.BeaconBlockRoot)
-	state := s.config.StateGen.StateByRootIfCachedNoCopy(root)
-	if state == nil {
-		log.Debug("Skipping unaggregated attestation due to state not found in cache")
-		return
-	}
-	attestingIndices, err := attestingIndices(ctx, state, att)
-	if err != nil {
-		log.WithError(err).Error("Could not get attesting indices")
-		return
-	}
-	for _, idx := range attestingIndices {
-		if s.updatedPerformanceFromTrackedVal(types.ValidatorIndex(idx), att.Data.Slot) {
-			logFields := logMessageTimelyFlagsForIndex(types.ValidatorIndex(idx), att.Data)
-			log.WithFields(logFields).Info("Processed unaggregated attestation")
-		}
-	}
-}
-
-// 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) {
-	if s.TrackedIndex(att.AggregatorIndex) {
-		log.WithFields(logrus.Fields{
-			"ValidatorIndex": att.AggregatorIndex,
-		}).Info("Processed attestation aggregation")
-		aggregatedPerf := s.aggregatedPerformance[att.AggregatorIndex]
-		aggregatedPerf.totalAggregations++
-		s.aggregatedPerformance[att.AggregatorIndex] = aggregatedPerf
-		aggregationCounter.WithLabelValues(fmt.Sprintf("%d", att.AggregatorIndex)).Inc()
-	}
-
-	var root [32]byte
-	copy(root[:], att.Aggregate.Data.BeaconBlockRoot)
-	state := s.config.StateGen.StateByRootIfCachedNoCopy(root)
-	if state == nil {
-		log.Debug("Skipping agregated attestation due to state not found in cache")
-		return
-	}
-	attestingIndices, err := attestingIndices(ctx, state, att.Aggregate)
-	if err != nil {
-		log.WithError(err).Error("Could not get attesting indices")
-		return
-	}
-	for _, idx := range attestingIndices {
-		if s.updatedPerformanceFromTrackedVal(types.ValidatorIndex(idx), att.Aggregate.Data.Slot) {
-			logFields := logMessageTimelyFlagsForIndex(types.ValidatorIndex(idx), att.Aggregate.Data)
-			log.WithFields(logFields).Info("Processed aggregated attestation")
-		}
-	}
-}

beacon-chain/monitor/process_attestation_test.go

@@ -1,287 +0,0 @@
-package monitor
-
-import (
-	"bytes"
-	"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"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/sirupsen/logrus"
-	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)
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Slot:           1,
-			CommitteeIndex: 0,
-		},
-		AggregationBits: bitfield.Bitlist{0b11, 0b1},
-	}
-	attestingIndices, err := attestingIndices(ctx, beaconState, att)
-	require.NoError(t, err)
-	require.DeepEqual(t, attestingIndices, []uint64{0xc, 0x2})
-
-}
-
-func TestProcessIncludedAttestationTwoTracked(t *testing.T) {
-	hook := logTest.NewGlobal()
-	s := setupService(t)
-	state, _ := util.DeterministicGenesisStateAltair(t, 256)
-	require.NoError(t, state.SetSlot(2))
-	require.NoError(t, state.SetCurrentParticipationBits(bytes.Repeat([]byte{0xff}, 13)))
-
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  0,
-			BeaconBlockRoot: bytesutil.PadTo([]byte("hello-world"), 32),
-			Source: &ethpb.Checkpoint{
-				Epoch: 0,
-				Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-			},
-			Target: &ethpb.Checkpoint{
-				Epoch: 1,
-				Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-			},
-		},
-		AggregationBits: bitfield.Bitlist{0b11, 0b1},
-	}
-	s.processIncludedAttestation(context.Background(), state, att)
-	wanted1 := "\"Attestation included\" BalanceChange=0 CorrectHead=true CorrectSource=true CorrectTarget=true Head=0x68656c6c6f2d InclusionSlot=2 NewBalance=32000000000 Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=2 prefix=monitor"
-	wanted2 := "\"Attestation included\" BalanceChange=100000000 CorrectHead=true CorrectSource=true CorrectTarget=true Head=0x68656c6c6f2d InclusionSlot=2 NewBalance=32000000000 Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=12 prefix=monitor"
-	require.LogsContain(t, hook, wanted1)
-	require.LogsContain(t, hook, wanted2)
-}
-
-func TestProcessUnaggregatedAttestationStateNotCached(t *testing.T) {
-	logrus.SetLevel(logrus.DebugLevel)
-	hook := logTest.NewGlobal()
-	ctx := context.Background()
-
-	s := setupService(t)
-	state, _ := util.DeterministicGenesisStateAltair(t, 256)
-	require.NoError(t, state.SetSlot(2))
-	header := state.LatestBlockHeader()
-	participation := []byte{0xff, 0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-	require.NoError(t, state.SetCurrentParticipationBits(participation))
-
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  0,
-			BeaconBlockRoot: header.GetStateRoot(),
-			Source: &ethpb.Checkpoint{
-				Epoch: 0,
-				Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-			},
-			Target: &ethpb.Checkpoint{
-				Epoch: 1,
-				Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-			},
-		},
-		AggregationBits: bitfield.Bitlist{0b11, 0b1},
-	}
-	s.processUnaggregatedAttestation(ctx, att)
-	require.LogsContain(t, hook, "Skipping unaggregated attestation due to state not found in cache")
-	logrus.SetLevel(logrus.InfoLevel)
-}
-
-func TestProcessUnaggregatedAttestationStateCached(t *testing.T) {
-	ctx := context.Background()
-	hook := logTest.NewGlobal()
-
-	s := setupService(t)
-	state, _ := util.DeterministicGenesisStateAltair(t, 256)
-	participation := []byte{0xff, 0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-	require.NoError(t, state.SetCurrentParticipationBits(participation))
-
-	root := [32]byte{}
-	copy(root[:], "hello-world")
-
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  0,
-			BeaconBlockRoot: root[:],
-			Source: &ethpb.Checkpoint{
-				Epoch: 0,
-				Root:  root[:],
-			},
-			Target: &ethpb.Checkpoint{
-				Epoch: 1,
-				Root:  root[:],
-			},
-		},
-		AggregationBits: bitfield.Bitlist{0b11, 0b1},
-	}
-	require.NoError(t, s.config.StateGen.SaveState(ctx, root, state))
-	s.processUnaggregatedAttestation(context.Background(), att)
-	wanted1 := "\"Processed unaggregated attestation\" Head=0x68656c6c6f2d Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=2 prefix=monitor"
-	wanted2 := "\"Processed unaggregated attestation\" Head=0x68656c6c6f2d Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=12 prefix=monitor"
-	require.LogsContain(t, hook, wanted1)
-	require.LogsContain(t, hook, wanted2)
-}
-
-func TestProcessAggregatedAttestationStateNotCached(t *testing.T) {
-	logrus.SetLevel(logrus.DebugLevel)
-	hook := logTest.NewGlobal()
-	ctx := context.Background()
-
-	s := setupService(t)
-	state, _ := util.DeterministicGenesisStateAltair(t, 256)
-	require.NoError(t, state.SetSlot(2))
-	header := state.LatestBlockHeader()
-	participation := []byte{0xff, 0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-	require.NoError(t, state.SetCurrentParticipationBits(participation))
-
-	att := &ethpb.AggregateAttestationAndProof{
-		AggregatorIndex: 2,
-		Aggregate: &ethpb.Attestation{
-			Data: &ethpb.AttestationData{
-				Slot:            1,
-				CommitteeIndex:  0,
-				BeaconBlockRoot: header.GetStateRoot(),
-				Source: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-				},
-				Target: &ethpb.Checkpoint{
-					Epoch: 1,
-					Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-				},
-			},
-			AggregationBits: bitfield.Bitlist{0b11, 0b1},
-		},
-	}
-	s.processAggregatedAttestation(ctx, att)
-	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)
-}
-
-func TestProcessAggregatedAttestationStateCached(t *testing.T) {
-	hook := logTest.NewGlobal()
-	ctx := context.Background()
-	s := setupService(t)
-	state, _ := util.DeterministicGenesisStateAltair(t, 256)
-	participation := []byte{0xff, 0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-	require.NoError(t, state.SetCurrentParticipationBits(participation))
-
-	root := [32]byte{}
-	copy(root[:], "hello-world")
-
-	att := &ethpb.AggregateAttestationAndProof{
-		AggregatorIndex: 2,
-		Aggregate: &ethpb.Attestation{
-			Data: &ethpb.AttestationData{
-				Slot:            1,
-				CommitteeIndex:  0,
-				BeaconBlockRoot: root[:],
-				Source: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  root[:],
-				},
-				Target: &ethpb.Checkpoint{
-					Epoch: 1,
-					Root:  root[:],
-				},
-			},
-			AggregationBits: bitfield.Bitlist{0b10, 0b1},
-		},
-	}
-
-	require.NoError(t, s.config.StateGen.SaveState(ctx, root, state))
-	s.processAggregatedAttestation(ctx, att)
-	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")
-}
-
-func TestProcessAttestations(t *testing.T) {
-	hook := logTest.NewGlobal()
-	s := setupService(t)
-	ctx := context.Background()
-	state, _ := util.DeterministicGenesisStateAltair(t, 256)
-	require.NoError(t, state.SetSlot(2))
-	require.NoError(t, state.SetCurrentParticipationBits(bytes.Repeat([]byte{0xff}, 13)))
-
-	att := &ethpb.Attestation{
-		Data: &ethpb.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  0,
-			BeaconBlockRoot: bytesutil.PadTo([]byte("hello-world"), 32),
-			Source: &ethpb.Checkpoint{
-				Epoch: 0,
-				Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-			},
-			Target: &ethpb.Checkpoint{
-				Epoch: 1,
-				Root:  bytesutil.PadTo([]byte("hello-world"), 32),
-			},
-		},
-		AggregationBits: bitfield.Bitlist{0b11, 0b1},
-	}
-
-	block := &ethpb.BeaconBlockAltair{
-		Slot: 2,
-		Body: &ethpb.BeaconBlockBodyAltair{
-			Attestations: []*ethpb.Attestation{att},
-		},
-	}
-
-	wrappedBlock, err := wrapper.WrappedAltairBeaconBlock(block)
-	require.NoError(t, err)
-	s.processAttestations(ctx, state, wrappedBlock)
-	wanted1 := "\"Attestation included\" BalanceChange=0 CorrectHead=true CorrectSource=true CorrectTarget=true Head=0x68656c6c6f2d InclusionSlot=2 NewBalance=32000000000 Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=2 prefix=monitor"
-	wanted2 := "\"Attestation included\" BalanceChange=100000000 CorrectHead=true CorrectSource=true CorrectTarget=true Head=0x68656c6c6f2d InclusionSlot=2 NewBalance=32000000000 Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=12 prefix=monitor"
-	require.LogsContain(t, hook, wanted1)
-	require.LogsContain(t, hook, wanted2)
-
-}

beacon-chain/monitor/process_block.go

@@ -1,47 +0,0 @@
-package monitor
-
-import (
-	"fmt"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/sirupsen/logrus"
-)
-
-// processSlashings logs the event of one of our tracked validators was slashed
-func (s *Service) processSlashings(blk block.BeaconBlock) {
-	for _, slashing := range blk.Body().ProposerSlashings() {
-		idx := slashing.Header_1.Header.ProposerIndex
-		if s.TrackedIndex(idx) {
-			log.WithFields(logrus.Fields{
-				"ProposerIndex": idx,
-				"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)),
-			}).Info("Proposer slashing was included")
-		}
-	}
-
-	for _, slashing := range blk.Body().AttesterSlashings() {
-		for _, idx := range blocks.SlashableAttesterIndices(slashing) {
-			if s.TrackedIndex(types.ValidatorIndex(idx)) {
-				log.WithFields(logrus.Fields{
-					"AttesterIndex": idx,
-					"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,
-					"TargetEpoch1":  slashing.Attestation_1.Data.Target.Epoch,
-					"Slot2":         slashing.Attestation_2.Data.Slot,
-					"Root2":         fmt.Sprintf("%#x", bytesutil.Trunc(slashing.Attestation_2.Data.BeaconBlockRoot)),
-					"SourceEpoch2":  slashing.Attestation_2.Data.Source.Epoch,
-					"TargetEpoch2":  slashing.Attestation_2.Data.Target.Epoch,
-				}).Info("Attester slashing was included")
-
-			}
-		}
-	}
-}

beacon-chain/monitor/process_block_test.go

@@ -1,131 +0,0 @@
-package monitor
-
-import (
-	"testing"
-
-	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/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-)
-
-func TestProcessSlashings(t *testing.T) {
-	tests := []struct {
-		name      string
-		block     *ethpb.BeaconBlock
-		wantedErr string
-	}{
-		{
-			name: "Proposer slashing a tracked index",
-			block: &ethpb.BeaconBlock{
-				Body: &ethpb.BeaconBlockBody{
-					ProposerSlashings: []*ethpb.ProposerSlashing{
-						{
-							Header_1: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									ProposerIndex: 2,
-									Slot:          params.BeaconConfig().SlotsPerEpoch + 1,
-								},
-							},
-							Header_2: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									ProposerIndex: 2,
-									Slot:          0,
-								},
-							},
-						},
-					},
-				},
-			},
-			wantedErr: "\"Proposer slashing was included\" ProposerIndex=2",
-		},
-		{
-			name: "Proposer slashing an untracked index",
-			block: &ethpb.BeaconBlock{
-				Body: &ethpb.BeaconBlockBody{
-					ProposerSlashings: []*ethpb.ProposerSlashing{
-						{
-							Header_1: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									ProposerIndex: 3,
-									Slot:          params.BeaconConfig().SlotsPerEpoch + 4,
-								},
-							},
-							Header_2: &ethpb.SignedBeaconBlockHeader{
-								Header: &ethpb.BeaconBlockHeader{
-									ProposerIndex: 3,
-									Slot:          0,
-								},
-							},
-						},
-					},
-				},
-			},
-			wantedErr: "",
-		},
-		{
-			name: "Attester slashing a tracked index",
-			block: &ethpb.BeaconBlock{
-				Body: &ethpb.BeaconBlockBody{
-					AttesterSlashings: []*ethpb.AttesterSlashing{
-						{
-							Attestation_1: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
-								Data: &ethpb.AttestationData{
-									Source: &ethpb.Checkpoint{Epoch: 1},
-								},
-								AttestingIndices: []uint64{1, 3, 4},
-							}),
-							Attestation_2: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{1, 5, 6},
-							}),
-						},
-					},
-				},
-			},
-			wantedErr: "\"Attester slashing was included\" AttesterIndex=1",
-		},
-		{
-			name: "Attester slashing untracked index",
-			block: &ethpb.BeaconBlock{
-				Body: &ethpb.BeaconBlockBody{
-					AttesterSlashings: []*ethpb.AttesterSlashing{
-						{
-							Attestation_1: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
-								Data: &ethpb.AttestationData{
-									Source: &ethpb.Checkpoint{Epoch: 1},
-								},
-								AttestingIndices: []uint64{1, 3, 4},
-							}),
-							Attestation_2: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
-								AttestingIndices: []uint64{3, 5, 6},
-							}),
-						},
-					},
-				},
-			},
-			wantedErr: "",
-		}}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			hook := logTest.NewGlobal()
-			s := &Service{
-				config: &ValidatorMonitorConfig{
-					TrackedValidators: map[types.ValidatorIndex]interface{}{
-						1: nil,
-						2: nil,
-					},
-				},
-			}
-			s.processSlashings(wrapper.WrappedPhase0BeaconBlock(tt.block))
-			if tt.wantedErr != "" {
-				require.LogsContain(t, hook, tt.wantedErr)
-			} else {
-				require.LogsDoNotContain(t, hook, "slashing")
-			}
-		})
-	}
-}

beacon-chain/monitor/process_exit.go

@@ -1,31 +0,0 @@
-package monitor
-
-import (
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/sirupsen/logrus"
-)
-
-// processExitsFromBlock logs the event of one of our tracked validators' exit was
-// included in a block
-func (s *Service) processExitsFromBlock(blk block.BeaconBlock) {
-	for _, exit := range blk.Body().VoluntaryExits() {
-		idx := exit.Exit.ValidatorIndex
-		if s.TrackedIndex(idx) {
-			log.WithFields(logrus.Fields{
-				"ValidatorIndex": idx,
-				"Slot":           blk.Slot(),
-			}).Info("Voluntary exit was included")
-		}
-	}
-}
-
-// processExit logs the event of one of our tracked validators' exit was processed
-func (s *Service) processExit(exit *ethpb.SignedVoluntaryExit) {
-	idx := exit.Exit.ValidatorIndex
-	if s.TrackedIndex(idx) {
-		log.WithFields(logrus.Fields{
-			"ValidatorIndex": idx,
-		}).Info("Voluntary exit was processed")
-	}
-}

beacon-chain/monitor/process_exit_test.go

@@ -1,126 +0,0 @@
-package monitor
-
-import (
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-)
-
-func TestProcessExitsFromBlockTrackedIndices(t *testing.T) {
-	hook := logTest.NewGlobal()
-	s := &Service{
-		config: &ValidatorMonitorConfig{
-			TrackedValidators: map[types.ValidatorIndex]interface{}{
-				1: nil,
-				2: nil,
-			},
-		},
-	}
-
-	exits := []*ethpb.SignedVoluntaryExit{
-		{
-			Exit: &ethpb.VoluntaryExit{
-				ValidatorIndex: 3,
-				Epoch:          1,
-			},
-		},
-		{
-			Exit: &ethpb.VoluntaryExit{
-				ValidatorIndex: 2,
-				Epoch:          0,
-			},
-		},
-	}
-
-	block := &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			VoluntaryExits: exits,
-		},
-	}
-
-	s.processExitsFromBlock(wrapper.WrappedPhase0BeaconBlock(block))
-	require.LogsContain(t, hook, "\"Voluntary exit was included\" Slot=0 ValidatorIndex=2")
-}
-
-func TestProcessExitsFromBlockUntrackedIndices(t *testing.T) {
-	hook := logTest.NewGlobal()
-	s := &Service{
-		config: &ValidatorMonitorConfig{
-			TrackedValidators: map[types.ValidatorIndex]interface{}{
-				1: nil,
-				2: nil,
-			},
-		},
-	}
-
-	exits := []*ethpb.SignedVoluntaryExit{
-		{
-			Exit: &ethpb.VoluntaryExit{
-				ValidatorIndex: 3,
-				Epoch:          1,
-			},
-		},
-		{
-			Exit: &ethpb.VoluntaryExit{
-				ValidatorIndex: 4,
-				Epoch:          0,
-			},
-		},
-	}
-
-	block := &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			VoluntaryExits: exits,
-		},
-	}
-
-	s.processExitsFromBlock(wrapper.WrappedPhase0BeaconBlock(block))
-	require.LogsDoNotContain(t, hook, "\"Voluntary exit was included\"")
-}
-
-func TestProcessExitP2PTrackedIndices(t *testing.T) {
-	hook := logTest.NewGlobal()
-	s := &Service{
-		config: &ValidatorMonitorConfig{
-			TrackedValidators: map[types.ValidatorIndex]interface{}{
-				1: nil,
-				2: nil,
-			},
-		},
-	}
-
-	exit := &ethpb.SignedVoluntaryExit{
-		Exit: &ethpb.VoluntaryExit{
-			ValidatorIndex: 1,
-			Epoch:          1,
-		},
-		Signature: make([]byte, 96),
-	}
-	s.processExit(exit)
-	require.LogsContain(t, hook, "\"Voluntary exit was processed\" ValidatorIndex=1")
-}
-
-func TestProcessExitP2PUntrackedIndices(t *testing.T) {
-	hook := logTest.NewGlobal()
-	s := &Service{
-		config: &ValidatorMonitorConfig{
-			TrackedValidators: map[types.ValidatorIndex]interface{}{
-				1: nil,
-				2: nil,
-			},
-		},
-	}
-
-	exit := &ethpb.SignedVoluntaryExit{
-		Exit: &ethpb.VoluntaryExit{
-			ValidatorIndex: 3,
-			Epoch:          1,
-		},
-	}
-	s.processExit(exit)
-	require.LogsDoNotContain(t, hook, "\"Voluntary exit was processed\"")
-}

beacon-chain/monitor/service.go

@@ -1,52 +0,0 @@
-package monitor
-
-import (
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-)
-
-// ValidatorLatestPerformance keeps track of the latest participation of the validator
-type ValidatorLatestPerformance struct {
-	attestedSlot  types.Slot
-	inclusionSlot types.Slot
-	timelySource  bool
-	timelyTarget  bool
-	timelyHead    bool
-	balance       uint64
-	balanceChange uint64
-}
-
-// ValidatorAggregatedPerformance keeps track of the accumulated performance of
-// the validator since launch
-type ValidatorAggregatedPerformance struct {
-	totalAttestedCount  uint64
-	totalRequestedCount uint64
-	totalDistance       uint64
-	totalCorrectSource  uint64
-	totalCorrectTarget  uint64
-	totalCorrectHead    uint64
-	totalAggregations   uint64
-}
-
-// ValidatorMonitorConfig contains the list of validator indices that the
-// monitor service tracks, as well as the event feed notifier that the
-// monitor needs to subscribe.
-type ValidatorMonitorConfig struct {
-	StateGen          stategen.StateManager
-	TrackedValidators map[types.ValidatorIndex]interface{}
-}
-
-// Service is the main structure that tracks validators and reports logs and
-// metrics of their performances throughout their lifetime.
-type Service struct {
-	config                *ValidatorMonitorConfig
-	latestPerformance     map[types.ValidatorIndex]ValidatorLatestPerformance
-	aggregatedPerformance map[types.ValidatorIndex]ValidatorAggregatedPerformance
-}
-
-// TrackedIndex returns if the given validator index corresponds to one of the
-// validators we follow
-func (s *Service) TrackedIndex(idx types.ValidatorIndex) bool {
-	_, ok := s.config.TrackedValidators[idx]
-	return ok
-}

beacon-chain/monitor/service_test.go

@@ -1,21 +0,0 @@
-package monitor
-
-import (
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestTrackedIndex(t *testing.T) {
-	s := &Service{
-		config: &ValidatorMonitorConfig{
-			TrackedValidators: map[types.ValidatorIndex]interface{}{
-				1: nil,
-				2: nil,
-			},
-		},
-	}
-	require.Equal(t, s.TrackedIndex(types.ValidatorIndex(1)), true)
-	require.Equal(t, s.TrackedIndex(types.ValidatorIndex(3)), false)
-}

beacon-chain/node/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/gateway:go_default_library",
-        "//beacon-chain/light:go_default_library",
         "//beacon-chain/node/registration:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
@@ -78,7 +77,6 @@ go_test(
         "//config/params:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",

beacon-chain/node/config.go

@@ -1,7 +1,6 @@
 package node
 
 import (
-	"github.com/ethereum/go-ethereum/common"
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/cmd"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
@@ -96,26 +95,3 @@ func configureInteropConfig(cliCtx *cli.Context) {
 		params.OverrideBeaconConfig(bCfg)
 	}
 }
-
-func configureExecutionSetting(cliCtx *cli.Context) {
-	if cliCtx.IsSet(flags.TerminalTotalDifficultyOverride.Name) {
-		c := params.BeaconConfig()
-		c.TerminalTotalDifficulty = cliCtx.Uint64(flags.TerminalTotalDifficultyOverride.Name)
-		params.OverrideBeaconConfig(c)
-	}
-	if cliCtx.IsSet(flags.TerminalBlockHashOverride.Name) {
-		c := params.BeaconConfig()
-		c.TerminalBlockHash = common.HexToHash(cliCtx.String(flags.TerminalBlockHashOverride.Name))
-		params.OverrideBeaconConfig(c)
-	}
-	if cliCtx.IsSet(flags.TerminalBlockHashActivationEpochOverride.Name) {
-		c := params.BeaconConfig()
-		c.TerminalBlockHashActivationEpoch = types.Epoch(cliCtx.Uint64(flags.TerminalBlockHashActivationEpochOverride.Name))
-		params.OverrideBeaconConfig(c)
-	}
-	if cliCtx.IsSet(flags.Coinbase.Name) {
-		c := params.BeaconConfig()
-		c.Coinbase = common.HexToAddress(cliCtx.String(flags.Coinbase.Name))
-		params.OverrideBeaconConfig(c)
-	}
-}

beacon-chain/node/config_test.go

@@ -6,7 +6,6 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/ethereum/go-ethereum/common"
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/cmd"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
@@ -71,29 +70,6 @@ func TestConfigureProofOfWork(t *testing.T) {
 	assert.Equal(t, "deposit-contract", params.BeaconConfig().DepositContractAddress)
 }
 
-func TestConfigureExecutionSetting(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-
-	app := cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	set.Uint64(flags.TerminalTotalDifficultyOverride.Name, 0, "")
-	set.String(flags.TerminalBlockHashOverride.Name, "", "")
-	set.Uint64(flags.TerminalBlockHashActivationEpochOverride.Name, 0, "")
-	set.String(flags.Coinbase.Name, "", "")
-	require.NoError(t, set.Set(flags.TerminalTotalDifficultyOverride.Name, strconv.Itoa(100)))
-	require.NoError(t, set.Set(flags.TerminalBlockHashOverride.Name, "0xA"))
-	require.NoError(t, set.Set(flags.TerminalBlockHashActivationEpochOverride.Name, strconv.Itoa(200)))
-	require.NoError(t, set.Set(flags.Coinbase.Name, "0xB"))
-	cliCtx := cli.NewContext(&app, set, nil)
-
-	configureExecutionSetting(cliCtx)
-
-	assert.Equal(t, uint64(100), params.BeaconConfig().TerminalTotalDifficulty)
-	assert.Equal(t, common.HexToHash("0xA"), params.BeaconConfig().TerminalBlockHash)
-	assert.Equal(t, types.Epoch(200), params.BeaconConfig().TerminalBlockHashActivationEpoch)
-	assert.Equal(t, common.HexToAddress("0xB"), params.BeaconConfig().Coinbase)
-}
-
 func TestConfigureNetwork(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 

beacon-chain/node/node.go

@@ -28,7 +28,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/gateway"
-	"github.com/prysmaticlabs/prysm/beacon-chain/light"
 	"github.com/prysmaticlabs/prysm/beacon-chain/node/registration"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
@@ -194,10 +193,6 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 		return nil, err
 	}
 
-	if err := beacon.registerLightClientServer(); err != nil {
-		return nil, err
-	}
-
 	if err := beacon.registerSlasherService(); err != nil {
 		return nil, err
 	}
@@ -686,11 +681,6 @@ func (b *BeaconNode) registerRPCService() error {
 		return err
 	}
 
-	var lightService *light.Service
-	if err := b.services.FetchService(&lightService); err != nil {
-		return err
-	}
-
 	var slasherService *slasher.Service
 	if features.Get().EnableSlasher {
 		if err := b.services.FetchService(&slasherService); err != nil {
@@ -767,7 +757,6 @@ func (b *BeaconNode) registerRPCService() error {
 		StateGen:                b.stateGen,
 		EnableDebugRPCEndpoints: enableDebugRPCEndpoints,
 		MaxMsgSize:              maxMsgSize,
-		LightUpdatesFetcher:     lightService,
 	})
 
 	return b.services.RegisterService(rpcService)
@@ -865,37 +854,7 @@ func (b *BeaconNode) registerDeterminsticGenesisService() error {
 			GenesisPath:   genesisStatePath,
 		})
 
-		// Register genesis state as start-up state when interop mode.
-		// The start-up state gets reused across services.
-		st, err := b.db.GenesisState(b.ctx)
-		if err != nil {
-			return err
-		}
-		b.finalizedStateAtStartUp = st
-
 		return b.services.RegisterService(svc)
 	}
 	return nil
 }
-
-func (b *BeaconNode) registerLightClientServer() error {
-	var chainService *blockchain.Service
-	if err := b.services.FetchService(&chainService); err != nil {
-		return err
-	}
-	var syncService *initialsync.Service
-	if err := b.services.FetchService(&syncService); err != nil {
-		return err
-	}
-	svc := light.New(b.ctx, &light.Config{
-		Database:            b.db,
-		StateGen:            b.stateGen,
-		HeadFetcher:         chainService,
-		FinalizationFetcher: chainService,
-		StateNotifier:       b,
-		TimeFetcher:         chainService,
-		SyncChecker:         syncService,
-	})
-
-	return b.services.RegisterService(svc)
-}

beacon-chain/p2p/gossip_scoring_params.go

@@ -103,13 +103,13 @@ func (s *Service) topicScoreParams(topic string) (*pubsub.TopicScoreParams, erro
 	case strings.Contains(topic, GossipBlockMessage):
 		return defaultBlockTopicParams(), nil
 	case strings.Contains(topic, GossipAggregateAndProofMessage):
-		return defaultAggregateTopicParams(activeValidators), nil
+		return defaultAggregateTopicParams(activeValidators)
 	case strings.Contains(topic, GossipAttestationMessage):
-		return defaultAggregateSubnetTopicParams(activeValidators), nil
+		return defaultAggregateSubnetTopicParams(activeValidators)
 	case strings.Contains(topic, GossipSyncCommitteeMessage):
-		return defaultSyncSubnetTopicParams(activeValidators), nil
+		return defaultSyncSubnetTopicParams(activeValidators)
 	case strings.Contains(topic, GossipContributionAndProofMessage):
-		return defaultSyncContributionTopicParams(), nil
+		return defaultSyncContributionTopicParams()
 	case strings.Contains(topic, GossipExitMessage):
 		return defaultVoluntaryExitTopicParams(), nil
 	case strings.Contains(topic, GossipProposerSlashingMessage):
@@ -191,19 +191,19 @@ func defaultBlockTopicParams() *pubsub.TopicScoreParams {
 	}
 }
 
-func defaultAggregateTopicParams(activeValidators uint64) *pubsub.TopicScoreParams {
+func defaultAggregateTopicParams(activeValidators uint64) (*pubsub.TopicScoreParams, error) {
 	// Determine the expected message rate for the particular gossip topic.
 	aggPerSlot := aggregatorsPerSlot(activeValidators)
 	firstMessageCap, err := decayLimit(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot*2/gossipSubD))
 	if err != nil {
 		log.Warnf("skipping initializing topic scoring: %v", err)
-		return nil
+		return nil, nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	meshThreshold, err := decayThreshold(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot)/dampeningFactor)
 	if err != nil {
 		log.Warnf("skipping initializing topic scoring: %v", err)
-		return nil
+		return nil, nil
 	}
 	meshWeight := -scoreByWeight(aggregateWeight, meshThreshold)
 	meshCap := 4 * meshThreshold
@@ -230,22 +230,22 @@ func defaultAggregateTopicParams(activeValidators uint64) *pubsub.TopicScorePara
 		MeshFailurePenaltyDecay:         scoreDecay(1 * oneEpochDuration()),
 		InvalidMessageDeliveriesWeight:  -maxScore() / aggregateWeight,
 		InvalidMessageDeliveriesDecay:   scoreDecay(invalidDecayPeriod),
-	}
+	}, nil
 }
 
-func defaultSyncContributionTopicParams() *pubsub.TopicScoreParams {
+func defaultSyncContributionTopicParams() (*pubsub.TopicScoreParams, error) {
 	// Determine the expected message rate for the particular gossip topic.
 	aggPerSlot := params.BeaconConfig().SyncCommitteeSubnetCount * params.BeaconConfig().TargetAggregatorsPerSyncSubcommittee
 	firstMessageCap, err := decayLimit(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot*2/gossipSubD))
 	if err != nil {
 		log.Warnf("skipping initializing topic scoring: %v", err)
-		return nil
+		return nil, nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	meshThreshold, err := decayThreshold(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot)/dampeningFactor)
 	if err != nil {
 		log.Warnf("skipping initializing topic scoring: %v", err)
-		return nil
+		return nil, nil
 	}
 	meshWeight := -scoreByWeight(syncContributionWeight, meshThreshold)
 	meshCap := 4 * meshThreshold
@@ -272,23 +272,23 @@ func defaultSyncContributionTopicParams() *pubsub.TopicScoreParams {
 		MeshFailurePenaltyDecay:         scoreDecay(1 * oneEpochDuration()),
 		InvalidMessageDeliveriesWeight:  -maxScore() / syncContributionWeight,
 		InvalidMessageDeliveriesDecay:   scoreDecay(invalidDecayPeriod),
-	}
+	}, nil
 }
 
-func defaultAggregateSubnetTopicParams(activeValidators uint64) *pubsub.TopicScoreParams {
+func defaultAggregateSubnetTopicParams(activeValidators uint64) (*pubsub.TopicScoreParams, error) {
 	subnetCount := params.BeaconNetworkConfig().AttestationSubnetCount
 	// Get weight for each specific subnet.
 	topicWeight := attestationTotalWeight / float64(subnetCount)
 	subnetWeight := activeValidators / subnetCount
 	if subnetWeight == 0 {
 		log.Warn("Subnet weight is 0, skipping initializing topic scoring")
-		return nil
+		return nil, nil
 	}
 	// Determine the amount of validators expected in a subnet in a single slot.
 	numPerSlot := time.Duration(subnetWeight / uint64(params.BeaconConfig().SlotsPerEpoch))
 	if numPerSlot == 0 {
 		log.Warn("numPerSlot is 0, skipping initializing topic scoring")
-		return nil
+		return nil, nil
 	}
 	comsPerSlot := committeeCountPerSlot(activeValidators)
 	exceedsThreshold := comsPerSlot >= 2*subnetCount/uint64(params.BeaconConfig().SlotsPerEpoch)
@@ -301,20 +301,20 @@ func defaultAggregateSubnetTopicParams(activeValidators uint64) *pubsub.TopicSco
 	rate := numPerSlot * 2 / gossipSubD
 	if rate == 0 {
 		log.Warn("rate is 0, skipping initializing topic scoring")
-		return nil
+		return nil, nil
 	}
 	// Determine expected first deliveries based on the message rate.
 	firstMessageCap, err := decayLimit(scoreDecay(firstDecay*oneEpochDuration()), float64(rate))
 	if err != nil {
 		log.Warnf("skipping initializing topic scoring: %v", err)
-		return nil
+		return nil, nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	// Determine expected mesh deliveries based on message rate applied with a dampening factor.
 	meshThreshold, err := decayThreshold(scoreDecay(meshDecay*oneEpochDuration()), float64(numPerSlot)/dampeningFactor)
 	if err != nil {
 		log.Warnf("skipping initializing topic scoring: %v", err)
-		return nil
+		return nil, nil
 	}
 	meshWeight := -scoreByWeight(topicWeight, meshThreshold)
 	meshCap := 4 * meshThreshold
@@ -341,10 +341,10 @@ func defaultAggregateSubnetTopicParams(activeValidators uint64) *pubsub.TopicSco
 		MeshFailurePenaltyDecay:         scoreDecay(meshDecay * oneEpochDuration()),
 		InvalidMessageDeliveriesWeight:  -maxScore() / topicWeight,
 		InvalidMessageDeliveriesDecay:   scoreDecay(invalidDecayPeriod),
-	}
+	}, nil
 }
 
-func defaultSyncSubnetTopicParams(activeValidators uint64) *pubsub.TopicScoreParams {
+func defaultSyncSubnetTopicParams(activeValidators uint64) (*pubsub.TopicScoreParams, error) {
 	subnetCount := params.BeaconConfig().SyncCommitteeSubnetCount
 	// Get weight for each specific subnet.
 	topicWeight := syncCommitteesTotalWeight / float64(subnetCount)
@@ -356,7 +356,7 @@ func defaultSyncSubnetTopicParams(activeValidators uint64) *pubsub.TopicScorePar
 	subnetWeight := activeValidators / subnetCount
 	if subnetWeight == 0 {
 		log.Warn("Subnet weight is 0, skipping initializing topic scoring")
-		return nil
+		return nil, nil
 	}
 	firstDecay := time.Duration(1)
 	meshDecay := time.Duration(4)
@@ -364,20 +364,20 @@ func defaultSyncSubnetTopicParams(activeValidators uint64) *pubsub.TopicScorePar
 	rate := subnetWeight * 2 / gossipSubD
 	if rate == 0 {
 		log.Warn("rate is 0, skipping initializing topic scoring")
-		return nil
+		return nil, nil
 	}
 	// Determine expected first deliveries based on the message rate.
 	firstMessageCap, err := decayLimit(scoreDecay(firstDecay*oneEpochDuration()), float64(rate))
 	if err != nil {
 		log.WithError(err).Warn("Skipping initializing topic scoring")
-		return nil
+		return nil, nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	// Determine expected mesh deliveries based on message rate applied with a dampening factor.
 	meshThreshold, err := decayThreshold(scoreDecay(meshDecay*oneEpochDuration()), float64(subnetWeight)/dampeningFactor)
 	if err != nil {
 		log.WithError(err).Warn("Skipping initializing topic scoring")
-		return nil
+		return nil, nil
 	}
 	meshWeight := -scoreByWeight(topicWeight, meshThreshold)
 	meshCap := 4 * meshThreshold
@@ -404,7 +404,7 @@ func defaultSyncSubnetTopicParams(activeValidators uint64) *pubsub.TopicScorePar
 		MeshFailurePenaltyDecay:         scoreDecay(meshDecay * oneEpochDuration()),
 		InvalidMessageDeliveriesWeight:  -maxScore() / topicWeight,
 		InvalidMessageDeliveriesDecay:   scoreDecay(invalidDecayPeriod),
-	}
+	}, nil
 }
 
 func defaultAttesterSlashingTopicParams() *pubsub.TopicScoreParams {

beacon-chain/p2p/gossip_scoring_params_test.go

@@ -68,9 +68,11 @@ func TestLoggingParameters(t *testing.T) {
 	logGossipParameters("testing", &pubsub.TopicScoreParams{})
 	// Test out actual gossip parameters.
 	logGossipParameters("testing", defaultBlockTopicParams())
-	p := defaultAggregateSubnetTopicParams(10000)
+	p, err := defaultAggregateSubnetTopicParams(10000)
+	assert.NoError(t, err)
 	logGossipParameters("testing", p)
-	p = defaultAggregateTopicParams(10000)
+	p, err = defaultAggregateTopicParams(10000)
+	assert.NoError(t, err)
 	logGossipParameters("testing", p)
 	logGossipParameters("testing", defaultAttesterSlashingTopicParams())
 	logGossipParameters("testing", defaultProposerSlashingTopicParams())

beacon-chain/p2p/peers/scorers/service.go

@@ -183,16 +183,8 @@ func (s *Service) loop(ctx context.Context) {
 	for {
 		select {
 		case <-decayBadResponsesStats.C:
-			// Exit early if context is canceled.
-			if ctx.Err() != nil {
-				return
-			}
 			s.scorers.badResponsesScorer.Decay()
 		case <-decayBlockProviderStats.C:
-			// Exit early if context is canceled.
-			if ctx.Err() != nil {
-				return
-			}
 			s.scorers.blockProviderScorer.Decay()
 		case <-ctx.Done():
 			return

beacon-chain/powchain/service_test.go

@@ -437,9 +437,9 @@ func TestLogTillGenesis_OK(t *testing.T) {
 
 func TestInitDepositCache_OK(t *testing.T) {
 	ctrs := []*protodb.DepositContainer{
-		{Index: 0, Eth1BlockHeight: 2, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("A")}, Data: &ethpb.Deposit_Data{PublicKey: []byte{}}}},
-		{Index: 1, Eth1BlockHeight: 4, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("B")}, Data: &ethpb.Deposit_Data{PublicKey: []byte{}}}},
-		{Index: 2, Eth1BlockHeight: 6, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("c")}, Data: &ethpb.Deposit_Data{PublicKey: []byte{}}}},
+		{Index: 0, Eth1BlockHeight: 2, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("A")}}},
+		{Index: 1, Eth1BlockHeight: 4, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("B")}}},
+		{Index: 2, Eth1BlockHeight: 6, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("c")}}},
 	}
 	gs, _ := util.DeterministicGenesisState(t, 1)
 	beaconDB := dbutil.SetupDB(t)

beacon-chain/rpc/BUILD.bazel

@@ -29,7 +29,6 @@ go_library(
         "//beacon-chain/rpc/eth/validator:go_default_library",
         "//beacon-chain/rpc/prysm/v1alpha1/beacon:go_default_library",
         "//beacon-chain/rpc/prysm/v1alpha1/debug:go_default_library",
-        "//beacon-chain/rpc/prysm/v1alpha1/light:go_default_library",
         "//beacon-chain/rpc/prysm/v1alpha1/node:go_default_library",
         "//beacon-chain/rpc/prysm/v1alpha1/validator:go_default_library",
         "//beacon-chain/rpc/statefetcher:go_default_library",

beacon-chain/rpc/eth/beacon/BUILD.bazel

@@ -104,7 +104,6 @@ go_test(
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

beacon-chain/rpc/eth/beacon/config_test.go

@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"testing"
 
-	"github.com/ethereum/go-ethereum/common"
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -97,10 +96,6 @@ func TestGetSpec(t *testing.T) {
 	config.ProportionalSlashingMultiplierAltair = 69
 	config.InactivityScoreRecoveryRate = 70
 	config.MinSyncCommitteeParticipants = 71
-	config.TerminalBlockHash = common.HexToHash("TerminalBlockHash")
-	config.TerminalBlockHashActivationEpoch = 72
-	config.TerminalTotalDifficulty = 73
-	config.Coinbase = common.HexToAddress("Coinbase")
 
 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -130,7 +125,7 @@ func TestGetSpec(t *testing.T) {
 	resp, err := server.GetSpec(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)
 
-	assert.Equal(t, 94, len(resp.Data))
+	assert.Equal(t, 91, len(resp.Data))
 	for k, v := range resp.Data {
 		switch k {
 		case "CONFIG_NAME":
@@ -323,14 +318,6 @@ func TestGetSpec(t *testing.T) {
 			assert.Equal(t, "0x09000000", v)
 		case "TRANSITION_TOTAL_DIFFICULTY":
 			assert.Equal(t, "0", v)
-		case "TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH":
-			assert.Equal(t, "72", v)
-		case "TERMINAL_BLOCK_HASH":
-			assert.Equal(t, common.HexToHash("TerminalBlockHash"), common.HexToHash(v))
-		case "TERMINAL_TOTAL_DIFFICULTY":
-			assert.Equal(t, "73", v)
-		case "COINBASE":
-			assert.Equal(t, common.HexToAddress("Coinbase"), v)
 		default:
 			t.Errorf("Incorrect key: %s", k)
 		}

beacon-chain/rpc/prysm/v1alpha1/beacon/validators.go

@@ -16,7 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/cmd"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -675,23 +674,11 @@ func (bs *Server) GetValidatorPerformance(
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
 	}
-	currSlot := bs.GenesisTimeFetcher.CurrentSlot()
 
-	if currSlot > headState.Slot() {
-		if features.Get().EnableNextSlotStateCache {
-			headRoot, err := bs.HeadFetcher.HeadRoot(ctx)
-			if err != nil {
-				return nil, status.Errorf(codes.Internal, "Could not retrieve head root: %v", err)
-			}
-			headState, err = transition.ProcessSlotsUsingNextSlotCache(ctx, headState, headRoot, currSlot)
-			if err != nil {
-				return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", currSlot, err)
-			}
-		} else {
-			headState, err = transition.ProcessSlots(ctx, headState, currSlot)
-			if err != nil {
-				return nil, status.Errorf(codes.Internal, "Could not process slots: %v", err)
-			}
+	if bs.GenesisTimeFetcher.CurrentSlot() > headState.Slot() {
+		headState, err = transition.ProcessSlots(ctx, headState, bs.GenesisTimeFetcher.CurrentSlot())
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not process slots: %v", err)
 		}
 	}
 	var validatorSummary []*precompute.Validator

beacon-chain/rpc/prysm/v1alpha1/light/BUILD.bazel

@@ -1,17 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["server.go"],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/light",
-    visibility = ["//beacon-chain:__subpackages__"],
-    deps = [
-        "//beacon-chain/db/iface:go_default_library",
-        "//beacon-chain/db/kv:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@io_bazel_rules_go//proto/wkt:empty_go_proto",
-        "@org_golang_google_grpc//codes:go_default_library",
-        "@org_golang_google_grpc//status:go_default_library",
-    ],
-)

beacon-chain/rpc/prysm/v1alpha1/light/server.go

@@ -1,38 +0,0 @@
-package light
-
-import (
-	"context"
-
-	"github.com/golang/protobuf/ptypes/empty"
-	"github.com/prysmaticlabs/prysm/beacon-chain/light"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	log "github.com/sirupsen/logrus"
-)
-
-type Server struct {
-	Fetcher light.UpdatesFetcher
-}
-
-// BestUpdates GET /eth/v1alpha1/lightclient/best_update/:periods.
-func (s *Server) BestUpdates(ctx context.Context, req *ethpb.BestUpdatesRequest) (*ethpb.BestUpdatesResponse, error) {
-	updates := make([]*ethpb.LightClientUpdate, 0)
-	for _, period := range req.SyncCommitteePeriods {
-		update, err := s.Fetcher.BestUpdateForPeriod(ctx, period)
-		if err != nil {
-			log.Error(err)
-			continue
-		}
-		updates = append(updates, update)
-	}
-	return &ethpb.BestUpdatesResponse{Updates: updates}, nil
-}
-
-// LatestUpdateFinalized GET /eth/v1alpha1/lightclient/latest_update_finalized/
-func (s *Server) LatestUpdateFinalized(ctx context.Context, _ *empty.Empty) (*ethpb.LightClientUpdate, error) {
-	return s.Fetcher.LatestFinalizedUpdate(ctx), nil
-}
-
-// LatestUpdateNonFinalized /eth/v1alpha1/lightclient/latest_update_nonfinalized/
-func (s *Server) LatestUpdateNonFinalized(ctx context.Context, _ *empty.Empty) (*ethpb.LightClientUpdate, error) {
-	return s.Fetcher.LatestNonFinalizedUpdate(ctx), nil
-}

beacon-chain/rpc/prysm/v1alpha1/validator/assignments.go

@@ -13,7 +13,6 @@ import (
 	coreTime "github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	beaconState "github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/rand"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -125,20 +124,9 @@ func (vs *Server) duties(ctx context.Context, req *ethpb.DutiesRequest) (*ethpb.
 		return nil, err
 	}
 	if s.Slot() < epochStartSlot {
-		if features.Get().EnableNextSlotStateCache {
-			headRoot, err := vs.HeadFetcher.HeadRoot(ctx)
-			if err != nil {
-				return nil, status.Errorf(codes.Internal, "Could not retrieve head root: %v", err)
-			}
-			s, err = transition.ProcessSlotsUsingNextSlotCache(ctx, s, headRoot, epochStartSlot)
-			if err != nil {
-				return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", epochStartSlot, err)
-			}
-		} else {
-			s, err = transition.ProcessSlots(ctx, s, epochStartSlot)
-			if err != nil {
-				return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", epochStartSlot, err)
-			}
+		s, err = transition.ProcessSlots(ctx, s, epochStartSlot)
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", epochStartSlot, err)
 		}
 	}
 	committeeAssignments, proposerIndexToSlots, err := helpers.CommitteeAssignments(ctx, s, req.Epoch)

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_deposits.go

@@ -94,12 +94,7 @@ func (vs *Server) deposits(
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.deposits")
 	defer span.End()
 
-	if vs.MockEth1Votes {
-		return []*ethpb.Deposit{}, nil
-	}
-
-	if !vs.Eth1InfoFetcher.IsConnectedToETH1() {
-		log.Warn("not connected to eth1 node, skip pending deposit insertion")
+	if vs.MockEth1Votes || !vs.Eth1InfoFetcher.IsConnectedToETH1() {
 		return []*ethpb.Deposit{}, nil
 	}
 	// Need to fetch if the deposits up to the state's latest eth1 data matches
@@ -117,7 +112,6 @@ func (vs *Server) deposits(
 	// If there are no pending deposits, exit early.
 	allPendingContainers := vs.PendingDepositsFetcher.PendingContainers(ctx, canonicalEth1DataHeight)
 	if len(allPendingContainers) == 0 {
-		log.Debug("no pending deposits for inclusion in block")
 		return []*ethpb.Deposit{}, nil
 	}
 
@@ -133,21 +127,21 @@ func (vs *Server) deposits(
 		if uint64(dep.Index) >= beaconState.Eth1DepositIndex() && uint64(dep.Index) < canonicalEth1Data.DepositCount {
 			pendingDeps = append(pendingDeps, dep)
 		}
-		// Don't try to pack more than the max allowed in a block
-		if uint64(len(pendingDeps)) == params.BeaconConfig().MaxDeposits {
-			break
-		}
 	}
 
 	for i := range pendingDeps {
+		// Don't construct merkle proof if the number of deposits is more than max allowed in block.
+		if uint64(i) == params.BeaconConfig().MaxDeposits {
+			break
+		}
 		pendingDeps[i].Deposit, err = constructMerkleProof(depositTrie, int(pendingDeps[i].Index), pendingDeps[i].Deposit)
 		if err != nil {
 			return nil, err
 		}
 	}
-
+	// Limit the return of pending deposits to not be more than max deposits allowed in block.
 	var pendingDeposits []*ethpb.Deposit
-	for i := uint64(0); i < uint64(len(pendingDeps)); i++ {
+	for i := uint64(0); i < uint64(len(pendingDeps)) && i < params.BeaconConfig().MaxDeposits; i++ {
 		pendingDeposits = append(pendingDeposits, pendingDeps[i].Deposit)
 	}
 	return pendingDeposits, nil

beacon-chain/rpc/service.go

@@ -20,7 +20,6 @@ import (
 	opfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/light"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/synccommittee"
@@ -34,7 +33,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/eth/validator"
 	beaconv1alpha1 "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/beacon"
 	debugv1alpha1 "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/debug"
-	lightserver "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/light"
 	nodev1alpha1 "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/node"
 	validatorv1alpha1 "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/validator"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/statefetcher"
@@ -110,7 +108,6 @@ type Config struct {
 	OperationNotifier       opfeed.Notifier
 	StateGen                *stategen.State
 	MaxMsgSize              int
-	LightUpdatesFetcher     light.UpdatesFetcher
 }
 
 // NewService instantiates a new RPC service instance that will
@@ -282,10 +279,6 @@ func (s *Service) Start() {
 		VoluntaryExitsPool:      s.cfg.ExitPool,
 		V1Alpha1ValidatorServer: validatorServer,
 	}
-	lightClientServer := &lightserver.Server{
-		Fetcher: s.cfg.LightUpdatesFetcher,
-	}
-	ethpbv1alpha1.RegisterLightClientServer(s.grpcServer, lightClientServer)
 	ethpbv1alpha1.RegisterNodeServer(s.grpcServer, nodeServer)
 	ethpbservice.RegisterBeaconNodeServer(s.grpcServer, nodeServerV1)
 	ethpbv1alpha1.RegisterHealthServer(s.grpcServer, nodeServer)

beacon-chain/state/fieldtrie/BUILD.bazel

@@ -12,8 +12,6 @@ go_library(
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/types:go_default_library",
         "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -28,7 +26,6 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/types:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//config/params:go_default_library",

beacon-chain/state/fieldtrie/field_trie.go

@@ -18,7 +18,6 @@ type FieldTrie struct {
 	field       types.FieldIndex
 	dataType    types.DataType
 	length      uint64
-	numOfElems  int
 }
 
 // NewFieldTrie is the constructor for the field trie data structure. It creates the corresponding
@@ -27,19 +26,18 @@ type FieldTrie struct {
 func NewFieldTrie(field types.FieldIndex, dataType types.DataType, elements interface{}, length uint64) (*FieldTrie, error) {
 	if elements == nil {
 		return &FieldTrie{
-			field:      field,
-			dataType:   dataType,
-			reference:  stateutil.NewRef(1),
-			RWMutex:    new(sync.RWMutex),
-			length:     length,
-			numOfElems: 0,
+			field:     field,
+			dataType:  dataType,
+			reference: stateutil.NewRef(1),
+			RWMutex:   new(sync.RWMutex),
+			length:    length,
 		}, nil
 	}
 	fieldRoots, err := fieldConverters(field, []uint64{}, elements, true)
 	if err != nil {
 		return nil, err
 	}
-	if err := validateElements(field, dataType, elements, length); err != nil {
+	if err := validateElements(field, elements, length); err != nil {
 		return nil, err
 	}
 	switch dataType {
@@ -55,9 +53,8 @@ func NewFieldTrie(field types.FieldIndex, dataType types.DataType, elements inte
 			reference:   stateutil.NewRef(1),
 			RWMutex:     new(sync.RWMutex),
 			length:      length,
-			numOfElems:  reflect.ValueOf(elements).Len(),
 		}, nil
-	case types.CompositeArray, types.CompressedArray:
+	case types.CompositeArray:
 		return &FieldTrie{
 			fieldLayers: stateutil.ReturnTrieLayerVariable(fieldRoots, length),
 			field:       field,
@@ -65,7 +62,6 @@ func NewFieldTrie(field types.FieldIndex, dataType types.DataType, elements inte
 			reference:   stateutil.NewRef(1),
 			RWMutex:     new(sync.RWMutex),
 			length:      length,
-			numOfElems:  reflect.ValueOf(elements).Len(),
 		}, nil
 	default:
 		return nil, errors.Errorf("unrecognized data type in field map: %v", reflect.TypeOf(dataType).Name())
@@ -96,40 +92,13 @@ func (f *FieldTrie) RecomputeTrie(indices []uint64, elements interface{}) ([32]b
 		if err != nil {
 			return [32]byte{}, err
 		}
-		f.numOfElems = reflect.ValueOf(elements).Len()
 		return fieldRoot, nil
 	case types.CompositeArray:
 		fieldRoot, f.fieldLayers, err = stateutil.RecomputeFromLayerVariable(fieldRoots, indices, f.fieldLayers)
 		if err != nil {
 			return [32]byte{}, err
 		}
-		f.numOfElems = reflect.ValueOf(elements).Len()
 		return stateutil.AddInMixin(fieldRoot, uint64(len(f.fieldLayers[0])))
-	case types.CompressedArray:
-		numOfElems, err := f.field.ElemsInChunk()
-		if err != nil {
-			return [32]byte{}, err
-		}
-		// We remove the duplicates here in order to prevent
-		// duplicated insertions into the trie.
-		newIndices := []uint64{}
-		indexExists := make(map[uint64]bool)
-		newRoots := make([][32]byte, 0, len(fieldRoots)/int(numOfElems))
-		for i, idx := range indices {
-			startIdx := idx / numOfElems
-			if indexExists[startIdx] {
-				continue
-			}
-			newIndices = append(newIndices, startIdx)
-			indexExists[startIdx] = true
-			newRoots = append(newRoots, fieldRoots[i])
-		}
-		fieldRoot, f.fieldLayers, err = stateutil.RecomputeFromLayerVariable(newRoots, newIndices, f.fieldLayers)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		f.numOfElems = reflect.ValueOf(elements).Len()
-		return stateutil.AddInMixin(fieldRoot, uint64(f.numOfElems))
 	default:
 		return [32]byte{}, errors.Errorf("unrecognized data type in field map: %v", reflect.TypeOf(f.dataType).Name())
 	}
@@ -140,12 +109,11 @@ func (f *FieldTrie) RecomputeTrie(indices []uint64, elements interface{}) ([32]b
 func (f *FieldTrie) CopyTrie() *FieldTrie {
 	if f.fieldLayers == nil {
 		return &FieldTrie{
-			field:      f.field,
-			dataType:   f.dataType,
-			reference:  stateutil.NewRef(1),
-			RWMutex:    new(sync.RWMutex),
-			length:     f.length,
-			numOfElems: f.numOfElems,
+			field:     f.field,
+			dataType:  f.dataType,
+			reference: stateutil.NewRef(1),
+			RWMutex:   new(sync.RWMutex),
+			length:    f.length,
 		}
 	}
 	dstFieldTrie := make([][]*[32]byte, len(f.fieldLayers))
@@ -160,7 +128,6 @@ func (f *FieldTrie) CopyTrie() *FieldTrie {
 		reference:   stateutil.NewRef(1),
 		RWMutex:     new(sync.RWMutex),
 		length:      f.length,
-		numOfElems:  f.numOfElems,
 	}
 }
 
@@ -172,9 +139,6 @@ func (f *FieldTrie) TrieRoot() ([32]byte, error) {
 	case types.CompositeArray:
 		trieRoot := *f.fieldLayers[len(f.fieldLayers)-1][0]
 		return stateutil.AddInMixin(trieRoot, uint64(len(f.fieldLayers[0])))
-	case types.CompressedArray:
-		trieRoot := *f.fieldLayers[len(f.fieldLayers)-1][0]
-		return stateutil.AddInMixin(trieRoot, uint64(f.numOfElems))
 	default:
 		return [32]byte{}, errors.Errorf("unrecognized data type in field map: %v", reflect.TypeOf(f.dataType).Name())
 	}

beacon-chain/state/fieldtrie/field_trie_helpers.go

@@ -1,7 +1,6 @@
 package fieldtrie
 
 import (
-	"encoding/binary"
 	"fmt"
 	"reflect"
 
@@ -9,37 +8,20 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/types"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 func (f *FieldTrie) validateIndices(idxs []uint64) error {
-	length := f.length
-	if f.dataType == types.CompressedArray {
-		comLength, err := f.field.ElemsInChunk()
-		if err != nil {
-			return err
-		}
-		length *= comLength
-	}
 	for _, idx := range idxs {
-		if idx >= length {
-			return errors.Errorf("invalid index for field %s: %d >= length %d", f.field.String(version.Phase0), idx, length)
+		if idx >= f.length {
+			return errors.Errorf("invalid index for field %s: %d >= length %d", f.field.String(version.Phase0), idx, f.length)
 		}
 	}
 	return nil
 }
 
-func validateElements(field types.FieldIndex, dataType types.DataType, elements interface{}, length uint64) error {
-	if dataType == types.CompressedArray {
-		comLength, err := field.ElemsInChunk()
-		if err != nil {
-			return err
-		}
-		length *= comLength
-	}
+func validateElements(field types.FieldIndex, elements interface{}, length uint64) error {
 	val := reflect.ValueOf(elements)
 	if val.Len() > int(length) {
 		return errors.Errorf("elements length is larger than expected for field %s: %d > %d", field.String(version.Phase0), val.Len(), length)
@@ -56,21 +38,21 @@ func fieldConverters(field types.FieldIndex, indices []uint64, elements interfac
 			return nil, errors.Errorf("Wanted type of %v but got %v",
 				reflect.TypeOf([][]byte{}).Name(), reflect.TypeOf(elements).Name())
 		}
-		return handleByteArrays(val, indices, convertAll)
+		return stateutil.HandleByteArrays(val, indices, convertAll)
 	case types.Eth1DataVotes:
 		val, ok := elements.([]*ethpb.Eth1Data)
 		if !ok {
 			return nil, errors.Errorf("Wanted type of %v but got %v",
 				reflect.TypeOf([]*ethpb.Eth1Data{}).Name(), reflect.TypeOf(elements).Name())
 		}
-		return handleEth1DataSlice(val, indices, convertAll)
+		return HandleEth1DataSlice(val, indices, convertAll)
 	case types.Validators:
 		val, ok := elements.([]*ethpb.Validator)
 		if !ok {
 			return nil, errors.Errorf("Wanted type of %v but got %v",
 				reflect.TypeOf([]*ethpb.Validator{}).Name(), reflect.TypeOf(elements).Name())
 		}
-		return handleValidatorSlice(val, indices, convertAll)
+		return stateutil.HandleValidatorSlice(val, indices, convertAll)
 	case types.PreviousEpochAttestations, types.CurrentEpochAttestations:
 		val, ok := elements.([]*ethpb.PendingAttestation)
 		if !ok {
@@ -78,87 +60,13 @@ func fieldConverters(field types.FieldIndex, indices []uint64, elements interfac
 				reflect.TypeOf([]*ethpb.PendingAttestation{}).Name(), reflect.TypeOf(elements).Name())
 		}
 		return handlePendingAttestation(val, indices, convertAll)
-	case types.Balances:
-		val, ok := elements.([]uint64)
-		if !ok {
-			return nil, errors.Errorf("Wanted type of %v but got %v",
-				reflect.TypeOf([]uint64{}).Name(), reflect.TypeOf(elements).Name())
-		}
-		return handleBalanceSlice(val, indices, convertAll)
 	default:
 		return [][32]byte{}, errors.Errorf("got unsupported type of %v", reflect.TypeOf(elements).Name())
 	}
 }
 
-// handleByteArrays computes and returns byte arrays in a slice of root format.
-func handleByteArrays(val [][]byte, indices []uint64, convertAll bool) ([][32]byte, error) {
-	length := len(indices)
-	if convertAll {
-		length = len(val)
-	}
-	roots := make([][32]byte, 0, length)
-	rootCreator := func(input []byte) {
-		newRoot := bytesutil.ToBytes32(input)
-		roots = append(roots, newRoot)
-	}
-	if convertAll {
-		for i := range val {
-			rootCreator(val[i])
-		}
-		return roots, nil
-	}
-	if len(val) > 0 {
-		for _, idx := range indices {
-			if idx > uint64(len(val))-1 {
-				return nil, fmt.Errorf("index %d greater than number of byte arrays %d", idx, len(val))
-			}
-			rootCreator(val[idx])
-		}
-	}
-	return roots, nil
-}
-
-// handleValidatorSlice returns the validator indices in a slice of root format.
-func handleValidatorSlice(val []*ethpb.Validator, indices []uint64, convertAll bool) ([][32]byte, error) {
-	length := len(indices)
-	if convertAll {
-		length = len(val)
-	}
-	roots := make([][32]byte, 0, length)
-	hasher := hash.CustomSHA256Hasher()
-	rootCreator := func(input *ethpb.Validator) error {
-		newRoot, err := stateutil.ValidatorRootWithHasher(hasher, input)
-		if err != nil {
-			return err
-		}
-		roots = append(roots, newRoot)
-		return nil
-	}
-	if convertAll {
-		for i := range val {
-			err := rootCreator(val[i])
-			if err != nil {
-				return nil, err
-			}
-		}
-		return roots, nil
-	}
-	if len(val) > 0 {
-		for _, idx := range indices {
-			if idx > uint64(len(val))-1 {
-				return nil, fmt.Errorf("index %d greater than number of validators %d", idx, len(val))
-			}
-			err := rootCreator(val[idx])
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-	return roots, nil
-}
-
-// handleEth1DataSlice processes a list of eth1data and indices into the appropriate roots.
-func handleEth1DataSlice(val []*ethpb.Eth1Data, indices []uint64, convertAll bool) ([][32]byte, error) {
+// HandleEth1DataSlice processes a list of eth1data and indices into the appropriate roots.
+func HandleEth1DataSlice(val []*ethpb.Eth1Data, indices []uint64, convertAll bool) ([][32]byte, error) {
 	length := len(indices)
 	if convertAll {
 		length = len(val)
@@ -233,48 +141,3 @@ func handlePendingAttestation(val []*ethpb.PendingAttestation, indices []uint64,
 	}
 	return roots, nil
 }
-
-func handleBalanceSlice(val []uint64, indices []uint64, convertAll bool) ([][32]byte, error) {
-	if convertAll {
-		balancesMarshaling := make([][]byte, 0)
-		for _, b := range val {
-			balanceBuf := make([]byte, 8)
-			binary.LittleEndian.PutUint64(balanceBuf, b)
-			balancesMarshaling = append(balancesMarshaling, balanceBuf)
-		}
-		balancesChunks, err := ssz.PackByChunk(balancesMarshaling)
-		if err != nil {
-			return [][32]byte{}, errors.Wrap(err, "could not pack balances into chunks")
-		}
-		return balancesChunks, nil
-	}
-	if len(val) > 0 {
-		numOfElems, err := types.Balances.ElemsInChunk()
-		if err != nil {
-			return nil, err
-		}
-		roots := [][32]byte{}
-		for _, idx := range indices {
-			// We split the indexes into their relevant groups. Balances
-			// are compressed according to 4 values -> 1 chunk.
-			startIdx := idx / numOfElems
-			startGroup := startIdx * numOfElems
-			chunk := [32]byte{}
-			sizeOfElem := len(chunk) / int(numOfElems)
-			for i, j := 0, startGroup; j < startGroup+numOfElems; i, j = i+sizeOfElem, j+1 {
-				wantedVal := uint64(0)
-				// We are adding chunks in sets of 4, if the set is at the edge of the array
-				// then you will need to zero out the rest of the chunk. Ex : 41 indexes,
-				// so 41 % 4 = 1 . There are 3 indexes, which do not exist yet but we
-				// have to add in as a root. These 3 indexes are then given a 'zero' value.
-				if int(j) < len(val) {
-					wantedVal = val[j]
-				}
-				binary.LittleEndian.PutUint64(chunk[i:i+sizeOfElem], wantedVal)
-			}
-			roots = append(roots, chunk)
-		}
-		return roots, nil
-	}
-	return [][32]byte{}, nil
-}

beacon-chain/state/fieldtrie/helpers_test.go

@@ -1,13 +1,8 @@
 package fieldtrie
 
 import (
-	"encoding/binary"
-	"sync"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/types"
-	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 )
@@ -22,64 +17,7 @@ func Test_handlePendingAttestation_OutOfRange(t *testing.T) {
 func Test_handleEth1DataSlice_OutOfRange(t *testing.T) {
 	items := make([]*ethpb.Eth1Data, 1)
 	indices := []uint64{3}
-	_, err := handleEth1DataSlice(items, indices, false)
+	_, err := HandleEth1DataSlice(items, indices, false)
 	assert.ErrorContains(t, "index 3 greater than number of items in eth1 data slice 1", err)
 
 }
-
-func Test_handleValidatorSlice_OutOfRange(t *testing.T) {
-	vals := make([]*ethpb.Validator, 1)
-	indices := []uint64{3}
-	_, err := handleValidatorSlice(vals, indices, false)
-	assert.ErrorContains(t, "index 3 greater than number of validators 1", err)
-}
-
-func TestBalancesSlice_CorrectRoots_All(t *testing.T) {
-	balances := []uint64{5, 2929, 34, 1291, 354305}
-	roots, err := handleBalanceSlice(balances, []uint64{}, true)
-	assert.NoError(t, err)
-
-	root1 := [32]byte{}
-	binary.LittleEndian.PutUint64(root1[:8], balances[0])
-	binary.LittleEndian.PutUint64(root1[8:16], balances[1])
-	binary.LittleEndian.PutUint64(root1[16:24], balances[2])
-	binary.LittleEndian.PutUint64(root1[24:32], balances[3])
-
-	root2 := [32]byte{}
-	binary.LittleEndian.PutUint64(root2[:8], balances[4])
-
-	assert.DeepEqual(t, roots, [][32]byte{root1, root2})
-}
-
-func TestBalancesSlice_CorrectRoots_Some(t *testing.T) {
-	balances := []uint64{5, 2929, 34, 1291, 354305}
-	roots, err := handleBalanceSlice(balances, []uint64{2, 3}, false)
-	assert.NoError(t, err)
-
-	root1 := [32]byte{}
-	binary.LittleEndian.PutUint64(root1[:8], balances[0])
-	binary.LittleEndian.PutUint64(root1[8:16], balances[1])
-	binary.LittleEndian.PutUint64(root1[16:24], balances[2])
-	binary.LittleEndian.PutUint64(root1[24:32], balances[3])
-
-	// Returns root for each indice(even if duplicated)
-	assert.DeepEqual(t, roots, [][32]byte{root1, root1})
-}
-
-func TestValidateIndices_CompressedField(t *testing.T) {
-	fakeTrie := &FieldTrie{
-		RWMutex:     new(sync.RWMutex),
-		reference:   stateutil.NewRef(0),
-		fieldLayers: nil,
-		field:       types.Balances,
-		dataType:    types.CompressedArray,
-		length:      params.BeaconConfig().ValidatorRegistryLimit / 4,
-		numOfElems:  0,
-	}
-	goodIdx := params.BeaconConfig().ValidatorRegistryLimit - 1
-	assert.NoError(t, fakeTrie.validateIndices([]uint64{goodIdx}))
-
-	badIdx := goodIdx + 1
-	assert.ErrorContains(t, "invalid index for field balances", fakeTrie.validateIndices([]uint64{badIdx}))
-
-}

beacon-chain/state/phase0.go

@@ -148,6 +148,7 @@ type WriteOnlyBlockRoots interface {
 
 // WriteOnlyStateRoots defines a struct which only has write access to state roots methods.
 type WriteOnlyStateRoots interface {
+	SetStateRoots(val [][]byte) error
 	UpdateStateRootAtIndex(idx uint64, stateRoot [32]byte) error
 }
 

beacon-chain/state/stategen/getter.go

@@ -37,15 +37,6 @@ func (s *State) HasStateInCache(ctx context.Context, blockRoot [32]byte) (bool,
 	return has, nil
 }
 
-// StateByRootIfCached retrieves a state using the input block root only if the state is already in the cache
-func (s *State) StateByRootIfCachedNoCopy(blockRoot [32]byte) state.BeaconState {
-	if !s.hotStateCache.has(blockRoot) {
-		return nil
-	}
-	state := s.hotStateCache.getWithoutCopy(blockRoot)
-	return state
-}
-
 // StateByRoot retrieves the state using input block root.
 func (s *State) StateByRoot(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "stateGen.StateByRoot")

beacon-chain/state/stategen/getter_test.go

@@ -56,44 +56,6 @@ func TestStateByRoot_ColdState(t *testing.T) {
 	require.DeepSSZEqual(t, loadedState.InnerStateUnsafe(), beaconState.InnerStateUnsafe())
 }
 
-func TestStateByRootIfCachedNoCopy_HotState(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	service := New(beaconDB)
-
-	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	r := [32]byte{'A'}
-	require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: r[:]}))
-	service.hotStateCache.put(r, beaconState)
-
-	loadedState := service.StateByRootIfCachedNoCopy(r)
-	require.DeepSSZEqual(t, loadedState.InnerStateUnsafe(), beaconState.InnerStateUnsafe())
-}
-
-func TestStateByRootIfCachedNoCopy_ColdState(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	service := New(beaconDB)
-	service.finalizedInfo.slot = 2
-	service.slotsPerArchivedPoint = 1
-
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 1
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
-	bRoot, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	require.NoError(t, beaconState.SetSlot(1))
-	require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot))
-	require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
-	require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
-	loadedState := service.StateByRootIfCachedNoCopy(bRoot)
-	require.NoError(t, err)
-	require.Equal(t, loadedState, nil)
-}
-
 func TestStateByRoot_HotStateUsingEpochBoundaryCacheNoReplay(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

beacon-chain/state/stategen/mock.go

@@ -23,11 +23,6 @@ func NewMockService() *MockStateManager {
 	}
 }
 
-// StateByRootIfCached
-func (m *MockStateManager) StateByRootIfCachedNoCopy(_ [32]byte) state.BeaconState { // skipcq: RVV-B0013
-	panic("implement me")
-}
-
 // Resume --
 func (m *MockStateManager) Resume(_ context.Context, _ state.BeaconState) (state.BeaconState, error) {
 	panic("implement me")

beacon-chain/state/stategen/service.go

@@ -31,7 +31,6 @@ type StateManager interface {
 	HasState(ctx context.Context, blockRoot [32]byte) (bool, error)
 	HasStateInCache(ctx context.Context, blockRoot [32]byte) (bool, error)
 	StateByRoot(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
-	StateByRootIfCachedNoCopy(blockRoot [32]byte) state.BeaconState
 	StateByRootInitialSync(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
 	StateBySlot(ctx context.Context, slot types.Slot) (state.BeaconState, error)
 	RecoverStateSummary(ctx context.Context, blockRoot [32]byte) (*ethpb.StateSummary, error)

beacon-chain/state/stateutil/BUILD.bazel

@@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "array_root.go",
         "block_header_root.go",
         "eth1_root.go",
         "participation_bit_root.go",
@@ -48,6 +49,7 @@ go_test(
         "state_root_test.go",
         "stateutil_test.go",
         "trie_helpers_test.go",
+        "validator_root_test.go",
     ],
     embed = [":go_default_library"],
     deps = [

beacon-chain/state/stateutil/array_root.go

@@ -0,0 +1,35 @@
+package stateutil
+
+import (
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+)
+
+// HandleByteArrays computes and returns byte arrays in a slice of root format.
+func HandleByteArrays(val [][]byte, indices []uint64, convertAll bool) ([][32]byte, error) {
+	length := len(indices)
+	if convertAll {
+		length = len(val)
+	}
+	roots := make([][32]byte, 0, length)
+	rootCreator := func(input []byte) {
+		newRoot := bytesutil.ToBytes32(input)
+		roots = append(roots, newRoot)
+	}
+	if convertAll {
+		for i := range val {
+			rootCreator(val[i])
+		}
+		return roots, nil
+	}
+	if len(val) > 0 {
+		for _, idx := range indices {
+			if idx > uint64(len(val))-1 {
+				return nil, fmt.Errorf("index %d greater than number of byte arrays %d", idx, len(val))
+			}
+			rootCreator(val[idx])
+		}
+	}
+	return roots, nil
+}

beacon-chain/state/stateutil/validator_root.go

@@ -2,6 +2,7 @@ package stateutil
 
 import (
 	"encoding/binary"
+	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -126,3 +127,42 @@ func ValidatorEncKey(validator *ethpb.Validator) []byte {
 
 	return enc
 }
+
+// HandleValidatorSlice returns the validator indices in a slice of root format.
+func HandleValidatorSlice(val []*ethpb.Validator, indices []uint64, convertAll bool) ([][32]byte, error) {
+	length := len(indices)
+	if convertAll {
+		length = len(val)
+	}
+	roots := make([][32]byte, 0, length)
+	hasher := hash.CustomSHA256Hasher()
+	rootCreator := func(input *ethpb.Validator) error {
+		newRoot, err := ValidatorRootWithHasher(hasher, input)
+		if err != nil {
+			return err
+		}
+		roots = append(roots, newRoot)
+		return nil
+	}
+	if convertAll {
+		for i := range val {
+			err := rootCreator(val[i])
+			if err != nil {
+				return nil, err
+			}
+		}
+		return roots, nil
+	}
+	if len(val) > 0 {
+		for _, idx := range indices {
+			if idx > uint64(len(val))-1 {
+				return nil, fmt.Errorf("index %d greater than number of validators %d", idx, len(val))
+			}
+			err := rootCreator(val[idx])
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	return roots, nil
+}

beacon-chain/state/stateutil/validator_root_test.go

@@ -0,0 +1,15 @@
+package stateutil
+
+import (
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+)
+
+func Test_handleValidatorSlice_OutOfRange(t *testing.T) {
+	vals := make([]*ethpb.Validator, 1)
+	indices := []uint64{3}
+	_, err := HandleValidatorSlice(vals, indices, false)
+	assert.ErrorContains(t, "index 3 greater than number of validators 1", err)
+}

beacon-chain/state/types/BUILD.bazel

@@ -5,10 +5,7 @@ go_library(
     srcs = ["types.go"],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/state/types",
     visibility = ["//beacon-chain:__subpackages__"],
-    deps = [
-        "//runtime/version:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
+    deps = ["//runtime/version:go_default_library"],
 )
 
 go_test(

beacon-chain/state/types/types.go

@@ -1,7 +1,6 @@
 package types
 
 import (
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
@@ -19,10 +18,6 @@ const (
 	// CompositeArray represents a variable length array with
 	// a non primitive type.
 	CompositeArray
-	// CompressedArray represents a variable length array which
-	// can pack multiple elements into a leaf of the underlying
-	// trie.
-	CompressedArray
 )
 
 // String returns the name of the field index.
@@ -59,12 +54,12 @@ func (f FieldIndex) String(stateVersion int) string {
 	case Slashings:
 		return "slashings"
 	case PreviousEpochAttestations:
-		if version.Altair == stateVersion || version.Merge == stateVersion {
+		if version.Altair == stateVersion {
 			return "previousEpochParticipationBits"
 		}
 		return "previousEpochAttestations"
 	case CurrentEpochAttestations:
-		if version.Altair == stateVersion || version.Merge == stateVersion {
+		if version.Altair == stateVersion {
 			return "currentEpochParticipationBits"
 		}
 		return "currentEpochAttestations"
@@ -82,24 +77,11 @@ func (f FieldIndex) String(stateVersion int) string {
 		return "currentSyncCommittee"
 	case NextSyncCommittee:
 		return "nextSyncCommittee"
-	case LatestExecutionPayloadHeader:
-		return "latestExecutionPayloadHeader"
 	default:
 		return ""
 	}
 }
 
-// ElemsInChunk returns the number of elements in the chunk (number of
-// elements that are able to be packed).
-func (f FieldIndex) ElemsInChunk() (uint64, error) {
-	switch f {
-	case Balances:
-		return 4, nil
-	default:
-		return 0, errors.Errorf("field %d doesn't support element compression", f)
-	}
-}
-
 // Below we define a set of useful enum values for the field
 // indices of the beacon state. For example, genesisTime is the
 // 0th field of the beacon state. This is helpful when we are
@@ -132,13 +114,12 @@ const (
 	InactivityScores
 	CurrentSyncCommittee
 	NextSyncCommittee
-	// State fields added in Merge.
-	LatestExecutionPayloadHeader
 )
 
 // Altair fields which replaced previous phase 0 fields.
 const (
-	// Epoch Attestations is switched with participation bits in Altair.
+	// Epoch Attestations is switched with participation bits in
+	// Altair.
 	PreviousEpochParticipationBits = PreviousEpochAttestations
 	CurrentEpochParticipationBits  = CurrentEpochAttestations
 )

beacon-chain/state/v1/BUILD.bazel

@@ -87,7 +87,6 @@ go_test(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/types:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/state/v1/setters_misc.go

@@ -5,7 +5,6 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	stateTypes "github.com/prysmaticlabs/prysm/beacon-chain/state/types"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"google.golang.org/protobuf/proto"
@@ -173,10 +172,6 @@ func (b *BeaconState) addDirtyIndices(index stateTypes.FieldIndex, indices []uin
 	if b.rebuildTrie[index] {
 		return
 	}
-	// Exit early if balance trie computation isn't enabled.
-	if !features.Get().EnableBalanceTrieComputation && index == balances {
-		return
-	}
 	totalIndicesLen := len(b.dirtyIndices[index]) + len(indices)
 	if totalIndicesLen > indicesLimit {
 		b.rebuildTrie[index] = true

beacon-chain/state/v1/setters_state.go

@@ -5,6 +5,24 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 )
 
+// SetStateRoots for the beacon state. Updates the state roots
+// to a new value by overwriting the previous value.
+func (b *BeaconState) SetStateRoots(val [][]byte) error {
+	if !b.hasInnerState() {
+		return ErrNilInnerState
+	}
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.sharedFieldReferences[stateRoots].MinusRef()
+	b.sharedFieldReferences[stateRoots] = stateutil.NewRef(1)
+
+	b.state.StateRoots = val
+	b.markFieldAsDirty(stateRoots)
+	b.rebuildTrie[stateRoots] = true
+	return nil
+}
+
 // UpdateStateRootAtIndex for the beacon state. Updates the state root
 // at a specific index to a new value.
 func (b *BeaconState) UpdateStateRootAtIndex(idx uint64, stateRoot [32]byte) error {

beacon-chain/state/v1/setters_validator.go

@@ -103,7 +103,6 @@ func (b *BeaconState) SetBalances(val []uint64) error {
 
 	b.state.Balances = val
 	b.markFieldAsDirty(balances)
-	b.rebuildTrie[balances] = true
 	return nil
 }
 
@@ -129,7 +128,6 @@ func (b *BeaconState) UpdateBalancesAtIndex(idx types.ValidatorIndex, val uint64
 	bals[idx] = val
 	b.state.Balances = bals
 	b.markFieldAsDirty(balances)
-	b.addDirtyIndices(balances, []uint64{uint64(idx)})
 	return nil
 }
 
@@ -221,8 +219,6 @@ func (b *BeaconState) AppendBalance(bal uint64) error {
 	}
 
 	b.state.Balances = append(bals, bal)
-	balIdx := len(b.state.Balances) - 1
 	b.markFieldAsDirty(balances)
-	b.addDirtyIndices(balances, []uint64{uint64(balIdx)})
 	return nil
 }

beacon-chain/state/v1/state_test.go

@@ -1,13 +1,10 @@
 package v1
 
 import (
-	"context"
 	"strconv"
 	"sync"
 	"testing"
 
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -107,90 +104,3 @@ func TestStateTrie_IsNil(t *testing.T) {
 	nonNilState := &BeaconState{state: &ethpb.BeaconState{}}
 	assert.Equal(t, false, nonNilState.IsNil())
 }
-
-func TestBeaconState_AppendBalanceWithTrie(t *testing.T) {
-	count := uint64(100)
-	vals := make([]*ethpb.Validator, 0, count)
-	bals := make([]uint64, 0, count)
-	for i := uint64(1); i < count; i++ {
-		someRoot := [32]byte{}
-		someKey := [48]byte{}
-		copy(someRoot[:], strconv.Itoa(int(i)))
-		copy(someKey[:], strconv.Itoa(int(i)))
-		vals = append(vals, &ethpb.Validator{
-			PublicKey:                  someKey[:],
-			WithdrawalCredentials:      someRoot[:],
-			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 1,
-			ActivationEpoch:            1,
-			ExitEpoch:                  1,
-			WithdrawableEpoch:          1,
-		})
-		bals = append(bals, params.BeaconConfig().MaxEffectiveBalance)
-	}
-	zeroHash := params.BeaconConfig().ZeroHash
-	mockblockRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := 0; i < len(mockblockRoots); i++ {
-		mockblockRoots[i] = zeroHash[:]
-	}
-
-	mockstateRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := 0; i < len(mockstateRoots); i++ {
-		mockstateRoots[i] = zeroHash[:]
-	}
-	mockrandaoMixes := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
-	for i := 0; i < len(mockrandaoMixes); i++ {
-		mockrandaoMixes[i] = zeroHash[:]
-	}
-	var pubKeys [][]byte
-	for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSize; i++ {
-		pubKeys = append(pubKeys, bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength))
-	}
-	st, err := InitializeFromProto(&ethpb.BeaconState{
-		Slot:                  1,
-		GenesisValidatorsRoot: make([]byte, 32),
-		Fork: &ethpb.Fork{
-			PreviousVersion: make([]byte, 4),
-			CurrentVersion:  make([]byte, 4),
-			Epoch:           0,
-		},
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{
-			ParentRoot: make([]byte, 32),
-			StateRoot:  make([]byte, 32),
-			BodyRoot:   make([]byte, 32),
-		},
-		Validators: vals,
-		Balances:   bals,
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: make([]byte, 32),
-			BlockHash:   make([]byte, 32),
-		},
-		BlockRoots:                  mockblockRoots,
-		StateRoots:                  mockstateRoots,
-		RandaoMixes:                 mockrandaoMixes,
-		JustificationBits:           bitfield.NewBitvector4(),
-		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
-		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{Root: make([]byte, 32)},
-		FinalizedCheckpoint:         &ethpb.Checkpoint{Root: make([]byte, 32)},
-		Slashings:                   make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
-	})
-	assert.NoError(t, err)
-	_, err = st.HashTreeRoot(context.Background())
-	assert.NoError(t, err)
-
-	for i := 0; i < 100; i++ {
-		if i%2 == 0 {
-			assert.NoError(t, st.UpdateBalancesAtIndex(types.ValidatorIndex(i), 1000))
-		}
-		if i%3 == 0 {
-			assert.NoError(t, st.AppendBalance(1000))
-		}
-	}
-	_, err = st.HashTreeRoot(context.Background())
-	assert.NoError(t, err)
-	newRt := bytesutil.ToBytes32(st.merkleLayers[0][balances])
-	wantedRt, err := stateutil.Uint64ListRootWithRegistryLimit(st.state.Balances)
-	assert.NoError(t, err)
-	assert.Equal(t, wantedRt, newRt, "state roots are unequal")
-}

beacon-chain/state/v1/state_trie.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/fieldtrie"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/types"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/container/slice"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
@@ -320,20 +319,6 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		}
 		return b.recomputeFieldTrie(validators, b.state.Validators)
 	case balances:
-		if features.Get().EnableBalanceTrieComputation {
-			if b.rebuildTrie[field] {
-				maxBalCap := params.BeaconConfig().ValidatorRegistryLimit
-				elemSize := uint64(8)
-				balLimit := (maxBalCap*elemSize + 31) / 32
-				err := b.resetFieldTrie(field, b.state.Balances, balLimit)
-				if err != nil {
-					return [32]byte{}, err
-				}
-				delete(b.rebuildTrie, field)
-				return b.stateFieldLeaves[field].TrieRoot()
-			}
-			return b.recomputeFieldTrie(balances, b.state.Balances)
-		}
 		return stateutil.Uint64ListRootWithRegistryLimit(b.state.Balances)
 	case randaoMixes:
 		if b.rebuildTrie[field] {

beacon-chain/state/v1/state_trie_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -17,12 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
-func TestMain(m *testing.M) {
-	resetCfg := features.InitWithReset(&features.Flags{EnableBalanceTrieComputation: true})
-	defer resetCfg()
-	m.Run()
-}
-
 func TestInitializeFromProto(t *testing.T) {
 	testState, _ := util.DeterministicGenesisState(t, 64)
 	pbState, err := v1.ProtobufBeaconState(testState.InnerStateUnsafe())

beacon-chain/state/v1/types.go

@@ -17,6 +17,7 @@ var _ state.BeaconState = (*BeaconState)(nil)
 
 func init() {
 	fieldMap = make(map[types.FieldIndex]types.DataType, params.BeaconConfig().BeaconStateFieldCount)
+
 	// Initialize the fixed sized arrays.
 	fieldMap[types.BlockRoots] = types.BasicArray
 	fieldMap[types.StateRoots] = types.BasicArray
@@ -27,7 +28,6 @@ func init() {
 	fieldMap[types.Validators] = types.CompositeArray
 	fieldMap[types.PreviousEpochAttestations] = types.CompositeArray
 	fieldMap[types.CurrentEpochAttestations] = types.CompositeArray
-	fieldMap[types.Balances] = types.CompressedArray
 }
 
 // fieldMap keeps track of each field

beacon-chain/state/v2/BUILD.bazel

@@ -79,13 +79,11 @@ go_test(
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/types:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

beacon-chain/state/v2/setters_misc.go

@@ -5,7 +5,6 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	stateTypes "github.com/prysmaticlabs/prysm/beacon-chain/state/types"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"google.golang.org/protobuf/proto"
@@ -172,10 +171,6 @@ func (b *BeaconState) addDirtyIndices(index stateTypes.FieldIndex, indices []uin
 	if b.rebuildTrie[index] {
 		return
 	}
-	// Exit early if balance trie computation isn't enabled.
-	if !features.Get().EnableBalanceTrieComputation && index == balances {
-		return
-	}
 	totalIndicesLen := len(b.dirtyIndices[index]) + len(indices)
 	if totalIndicesLen > indicesLimit {
 		b.rebuildTrie[index] = true

beacon-chain/state/v2/setters_state.go

@@ -5,6 +5,24 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 )
 
+// SetStateRoots for the beacon state. Updates the state roots
+// to a new value by overwriting the previous value.
+func (b *BeaconState) SetStateRoots(val [][]byte) error {
+	if !b.hasInnerState() {
+		return ErrNilInnerState
+	}
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.sharedFieldReferences[stateRoots].MinusRef()
+	b.sharedFieldReferences[stateRoots] = stateutil.NewRef(1)
+
+	b.state.StateRoots = val
+	b.markFieldAsDirty(stateRoots)
+	b.rebuildTrie[stateRoots] = true
+	return nil
+}
+
 // UpdateStateRootAtIndex for the beacon state. Updates the state root
 // at a specific index to a new value.
 func (b *BeaconState) UpdateStateRootAtIndex(idx uint64, stateRoot [32]byte) error {

beacon-chain/state/v2/setters_test.go

@@ -2,15 +2,10 @@ package v2
 
 import (
 	"context"
-	"strconv"
 	"testing"
 
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	stateTypes "github.com/prysmaticlabs/prysm/beacon-chain/state/types"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"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"
@@ -62,100 +57,3 @@ func TestAppendBeyondIndicesLimit(t *testing.T) {
 	assert.Equal(t, true, st.rebuildTrie[validators])
 	assert.Equal(t, len(st.dirtyIndices[validators]), 0)
 }
-
-func TestBeaconState_AppendBalanceWithTrie(t *testing.T) {
-	count := uint64(100)
-	vals := make([]*ethpb.Validator, 0, count)
-	bals := make([]uint64, 0, count)
-	for i := uint64(1); i < count; i++ {
-		someRoot := [32]byte{}
-		someKey := [48]byte{}
-		copy(someRoot[:], strconv.Itoa(int(i)))
-		copy(someKey[:], strconv.Itoa(int(i)))
-		vals = append(vals, &ethpb.Validator{
-			PublicKey:                  someKey[:],
-			WithdrawalCredentials:      someRoot[:],
-			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 1,
-			ActivationEpoch:            1,
-			ExitEpoch:                  1,
-			WithdrawableEpoch:          1,
-		})
-		bals = append(bals, params.BeaconConfig().MaxEffectiveBalance)
-	}
-	zeroHash := params.BeaconConfig().ZeroHash
-	mockblockRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := 0; i < len(mockblockRoots); i++ {
-		mockblockRoots[i] = zeroHash[:]
-	}
-
-	mockstateRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := 0; i < len(mockstateRoots); i++ {
-		mockstateRoots[i] = zeroHash[:]
-	}
-	mockrandaoMixes := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
-	for i := 0; i < len(mockrandaoMixes); i++ {
-		mockrandaoMixes[i] = zeroHash[:]
-	}
-	var pubKeys [][]byte
-	for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSize; i++ {
-		pubKeys = append(pubKeys, bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength))
-	}
-	st, err := InitializeFromProto(&ethpb.BeaconStateAltair{
-		Slot:                  1,
-		GenesisValidatorsRoot: make([]byte, 32),
-		Fork: &ethpb.Fork{
-			PreviousVersion: make([]byte, 4),
-			CurrentVersion:  make([]byte, 4),
-			Epoch:           0,
-		},
-		LatestBlockHeader: &ethpb.BeaconBlockHeader{
-			ParentRoot: make([]byte, 32),
-			StateRoot:  make([]byte, 32),
-			BodyRoot:   make([]byte, 32),
-		},
-		CurrentEpochParticipation:  []byte{},
-		PreviousEpochParticipation: []byte{},
-		Validators:                 vals,
-		Balances:                   bals,
-		Eth1Data: &eth.Eth1Data{
-			DepositRoot: make([]byte, 32),
-			BlockHash:   make([]byte, 32),
-		},
-		BlockRoots:                  mockblockRoots,
-		StateRoots:                  mockstateRoots,
-		RandaoMixes:                 mockrandaoMixes,
-		JustificationBits:           bitfield.NewBitvector4(),
-		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
-		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{Root: make([]byte, 32)},
-		FinalizedCheckpoint:         &ethpb.Checkpoint{Root: make([]byte, 32)},
-		Slashings:                   make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
-		CurrentSyncCommittee: &ethpb.SyncCommittee{
-			Pubkeys:         pubKeys,
-			AggregatePubkey: make([]byte, 48),
-		},
-		NextSyncCommittee: &ethpb.SyncCommittee{
-			Pubkeys:         pubKeys,
-			AggregatePubkey: make([]byte, 48),
-		},
-	})
-	assert.NoError(t, err)
-	_, err = st.HashTreeRoot(context.Background())
-	assert.NoError(t, err)
-
-	for i := 0; i < 100; i++ {
-		if i%2 == 0 {
-			assert.NoError(t, st.UpdateBalancesAtIndex(types.ValidatorIndex(i), 1000))
-		}
-		if i%3 == 0 {
-			assert.NoError(t, st.AppendBalance(1000))
-		}
-	}
-	_, err = st.HashTreeRoot(context.Background())
-	assert.NoError(t, err)
-	newRt := bytesutil.ToBytes32(st.merkleLayers[0][balances])
-	wantedRt, err := stateutil.Uint64ListRootWithRegistryLimit(st.state.Balances)
-	assert.NoError(t, err)
-	assert.Equal(t, wantedRt, newRt, "state roots are unequal")
-}