tree test

* Stop packing deposits early if we reach max allowed

* Add logs to proposals without deposits

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

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

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

* reinsert debug log

Co-authored-by: Radosław Kapka <rkapka@wp.pl>
Co-authored-by: terence tsao <terence@prysmaticlabs.com>
Co-authored-by: Nishant Das <nishdas93@gmail.com>

beacon-chain/blockchain/BUILD.bazel

@@ -18,6 +18,7 @@ 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",
@@ -95,6 +96,7 @@ 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",
@@ -141,6 +143,7 @@ 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,7 +10,6 @@ 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"
@@ -42,9 +41,6 @@ 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.
@@ -273,57 +269,6 @@ 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,13 +123,15 @@ 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))
-	require.NoError(t, service.cacheJustifiedStateBalances(context.Background(), r))
-	require.DeepEqual(t, service.getJustifiedBalances(), state.Balances(), "Incorrect justified balances")
+	balances, err := service.justifiedBalances.get(ctx, r)
+	require.NoError(t, err)
+	require.DeepEqual(t, balances, 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}))
-	cfg := &config{
-		BeaconDB: beaconDB,
-		ForkChoiceStore: protoarray.New(
-			0, // justifiedEpoch
-			0, // finalizedEpoch
-			[32]byte{'a'},
-		),
-		StateGen: stategen.New(beaconDB),
+	fcs := protoarray.New(
+		0, // justifiedEpoch
+		0, // finalizedEpoch
+		[32]byte{'a'},
+	)
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
 	}
-	s, err := NewService(ctx)
+	s, err := NewService(ctx, opts...)
 	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,6 +130,14 @@ 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

@@ -0,0 +1,50 @@
+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,6 +130,13 @@ 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,14 +24,13 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB:        beaconDB,
-		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
-		StateGen:        stategen.New(beaconDB),
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithForkChoiceStore(protoarray.New(0, 0, [32]byte{})),
+		WithStateGen(stategen.New(beaconDB)),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	_, err = blockTree1(t, beaconDB, []byte{'g'})
 	require.NoError(t, err)
@@ -131,14 +130,14 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB:        beaconDB,
-		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
-		StateGen:        stategen.New(beaconDB),
+	fcs := protoarray.New(0, 0, [32]byte{'a'})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	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))
@@ -157,13 +156,12 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB: beaconDB,
-		StateGen: stategen.New(beaconDB),
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -230,13 +228,12 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB: beaconDB,
-		StateGen: stategen.New(beaconDB),
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	epoch := types.Epoch(1)
 	baseState, _ := util.DeterministicGenesisState(t, 1)
@@ -268,12 +265,10 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 
 func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
 	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)}))
@@ -281,12 +276,10 @@ func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
 
 func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
 	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}))
@@ -294,12 +287,10 @@ func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
 
 func TestAttEpoch_NotMatch(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
 	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)})
@@ -308,12 +299,9 @@ func TestAttEpoch_NotMatch(t *testing.T) {
 
 func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	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))
@@ -321,12 +309,10 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 
 func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
@@ -340,12 +326,10 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 
 func TestVerifyBeaconBlock_OK(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
@@ -361,10 +345,14 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	fcs := protoarray.New(0, 0, [32]byte{'a'})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -387,12 +375,10 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 
 func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -415,12 +401,10 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 
 func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32

beacon-chain/blockchain/process_block.go

@@ -151,7 +151,12 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		s.finalizedCheckpt = postState.FinalizedCheckpoint()
 	}
 
-	if err := s.updateHead(ctx, s.getJustifiedBalances()); err != nil {
+	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 {
 		log.WithError(err).Warn("Could not update head")
 	}
 

beacon-chain/blockchain/process_block_helpers.go

@@ -193,9 +193,6 @@ 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
@@ -206,12 +203,13 @@ 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
-	s.justifiedCheckpt = cp
-	if err := s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root)); err != nil {
+
+	if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cp); err != nil {
 		return err
 	}
+	s.justifiedCheckpt = cp
 
-	return s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cp)
+	return nil
 }
 
 func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
@@ -330,7 +328,9 @@ 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()
-			return s.cacheJustifiedStateBalances(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+			// we don't need to check if the previous justified checkpoint was an ancestor since the new
+			// finalized checkpoint is overriding it.
+			return nil
 		}
 
 		// Update justified if store justified is not in chain with finalized check point.
@@ -345,9 +345,6 @@ 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,16 +35,17 @@ import (
 
 func TestStore_OnBlock(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB:        beaconDB,
-		StateGen:        stategen.New(beaconDB),
-		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
+	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)
+
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
@@ -134,13 +135,12 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB: beaconDB,
-		StateGen: stategen.New(beaconDB),
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -186,14 +186,12 @@ func TestStore_OnBlockBatch(t *testing.T) {
 
 func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 	service.genesisTime = time.Now()
 
 	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: make([]byte, 32)})
@@ -221,16 +219,13 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 
 func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	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()
@@ -255,13 +250,12 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB: beaconDB,
-		StateGen: stategen.New(beaconDB),
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
 	require.NoError(t, err)
@@ -289,13 +283,12 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{
-		BeaconDB: beaconDB,
-		StateGen: stategen.New(beaconDB),
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -327,10 +320,13 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB), ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(protoarray.New(0, 0, [32]byte{})),
+	}
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	signedBlock := util.NewBeaconBlock()
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock)))
@@ -361,10 +357,12 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+	}
+	service, err := NewService(ctx, opts...)
 	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)}
 
@@ -400,10 +398,12 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+	}
+	service, err := NewService(ctx, opts...)
 	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,10 +442,12 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+	}
+	service, err := NewService(ctx, opts...)
 	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}
@@ -586,7 +588,8 @@ func TestCurrentSlot_HandlesOverflow(t *testing.T) {
 }
 func TestAncestorByDB_CtxErr(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 
 	cancel()
@@ -598,10 +601,14 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	fcs := protoarray.New(0, 0, [32]byte{'a'})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
@@ -642,10 +649,9 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 
 func TestAncestor_CanUseForkchoice(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
@@ -682,10 +688,14 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	fcs := protoarray.New(0, 0, [32]byte{'a'})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
@@ -720,10 +730,9 @@ func TestAncestor_CanUseDB(t *testing.T) {
 
 func TestEnsureRootNotZeroHashes(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{}
-	service, err := NewService(ctx)
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 	service.genesisRoot = [32]byte{'a'}
 
 	r := service.ensureRootNotZeros(params.BeaconConfig().ZeroHash)
@@ -735,6 +744,12 @@ 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
@@ -776,9 +791,8 @@ 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)
+		service, err := NewService(ctx, opts...)
 		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()
@@ -815,6 +829,12 @@ 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()
@@ -869,9 +889,8 @@ func TestVerifyBlkDescendant(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		service, err := NewService(ctx)
+		service, err := NewService(ctx, opts...)
 		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[:],
 		}
@@ -885,12 +904,10 @@ func TestVerifyBlkDescendant(t *testing.T) {
 }
 
 func TestUpdateJustifiedInitSync(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	cfg := &config{BeaconDB: beaconDB}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	gBlk := util.NewBeaconBlock()
 	gRoot, err := gBlk.Block.HashTreeRoot()
@@ -916,10 +933,9 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 
 func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{}
-	service, err := NewService(ctx)
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -931,10 +947,9 @@ func TestHandleEpochBoundary_BadMetrics(t *testing.T) {
 
 func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 	ctx := context.Background()
-	cfg := &config{}
-	service, err := NewService(ctx)
+	opts := testServiceOptsNoDB()
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	s, _ := util.DeterministicGenesisState(t, 1024)
 	service.head = &head{state: s}
@@ -946,18 +961,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)
-	cfg := &config{
-		BeaconDB:        beaconDB,
-		StateGen:        stategen.New(beaconDB),
-		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
-		DepositCache:    depositCache,
-		StateNotifier:   &mock.MockStateNotifier{},
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+		WithDepositCache(depositCache),
+		WithStateNotifier(&mock.MockStateNotifier{}),
 	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	gs, keys := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
@@ -991,18 +1006,12 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 
 func TestInsertFinalizedDeposits(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
+	opts := testServiceOptsWithDB(t)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
-	cfg := &config{
-		BeaconDB:        beaconDB,
-		StateGen:        stategen.New(beaconDB),
-		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
-		DepositCache:    depositCache,
-	}
-	service, err := NewService(ctx)
+	opts = append(opts, WithDepositCache(depositCache))
+	service, err := NewService(ctx, opts...)
 	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,7 +131,13 @@ func (s *Service) processAttestationsRoutine(subscribedToStateEvents chan<- stru
 				continue
 			}
 			s.processAttestations(s.ctx)
-			if err := s.updateHead(s.ctx, s.getJustifiedBalances()); err != nil {
+
+			balances, err := s.justifiedBalances.get(s.ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+			if err != nil {
+				log.Errorf("Unable to get justified balances for root %v w/ error %s", s.justifiedCheckpt.Root, err)
+				continue
+			}
+			if err := s.updateHead(s.ctx, balances); err != nil {
 				log.Warnf("Resolving fork due to new attestation: %v", err)
 			}
 		}

beacon-chain/blockchain/receive_attestation_test.go

@@ -9,9 +9,7 @@ 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"
@@ -42,12 +40,10 @@ func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 
 func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
+	opts := testServiceOptsWithDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -71,12 +67,10 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 
 func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
 
-	cfg := &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}
-	service, err := NewService(ctx)
+	opts := testServiceOptsWithDB(t)
+	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg = cfg
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
@@ -101,18 +95,12 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 func TestProcessAttestations_Ok(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
+	opts := testServiceOptsWithDB(t)
+	opts = append(opts, WithAttestationPool(attestations.NewPool()))
 
-	cfg := &config{
-		BeaconDB:        beaconDB,
-		ForkChoiceStore: protoarray.New(0, 0, [32]byte{}),
-		StateGen:        stategen.New(beaconDB),
-		AttPool:         attestations.NewPool(),
-	}
-	service, err := NewService(ctx)
+	service, err := NewService(ctx, opts...)
 	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,21 +124,16 @@ func TestService_ReceiveBlock(t *testing.T) {
 			genesisBlockRoot := bytesutil.ToBytes32(nil)
 			require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
 
-			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),
+			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)),
 			}
-			s, err := NewService(ctx)
+			s, err := NewService(ctx, opts...)
 			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)
@@ -166,21 +161,17 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	genesisBlockRoot := bytesutil.ToBytes32(nil)
 	require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
-	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),
+	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)),
 	}
-	s, err := NewService(ctx)
+
+	s, err := NewService(ctx, opts...)
 	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)
@@ -250,19 +241,14 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			beaconDB := testDB.SetupDB(t)
 			genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
 			require.NoError(t, err)
-			cfg := &config{
-				BeaconDB: beaconDB,
-				ForkChoiceStore: protoarray.New(
-					0, // justifiedEpoch
-					0, // finalizedEpoch
-					genesisBlockRoot,
-				),
-				StateNotifier: &blockchainTesting.MockStateNotifier{RecordEvents: true},
-				StateGen:      stategen.New(beaconDB),
+			opts := []Option{
+				WithDatabase(beaconDB),
+				WithForkChoiceStore(protoarray.New(0, 0, genesisBlockRoot)),
+				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
+				WithStateGen(stategen.New(beaconDB)),
 			}
-			s, err := NewService(ctx)
+			s, err := NewService(ctx, opts...)
 			require.NoError(t, err)
-			s.cfg = cfg
 			err = s.saveGenesisData(ctx, genesis)
 			require.NoError(t, err)
 			gBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
@@ -287,9 +273,10 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 }
 
 func TestService_HasInitSyncBlock(t *testing.T) {
-	s, err := NewService(context.Background())
+	opts := testServiceOptsNoDB()
+	opts = append(opts, WithStateNotifier(&blockchainTesting.MockStateNotifier{}))
+	s, err := NewService(context.Background(), opts...)
 	require.NoError(t, err)
-	s.cfg = &config{StateNotifier: &blockchainTesting.MockStateNotifier{}}
 	r := [32]byte{'a'}
 	if s.HasInitSyncBlock(r) {
 		t.Error("Should not have block")
@@ -301,11 +288,10 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 }
 
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
+	opts := testServiceOptsWithDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background())
+	s, err := NewService(context.Background(), opts...)
 	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{}
@@ -315,11 +301,10 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 }
 
 func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background())
+	opts := testServiceOptsWithDB(t)
+	s, err := NewService(context.Background(), opts...)
 	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()
@@ -329,11 +314,10 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 }
 
 func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	hook := logTest.NewGlobal()
-	s, err := NewService(context.Background())
+	opts := testServiceOptsWithDB(t)
+	s, err := NewService(context.Background(), opts...)
 	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
-	justifiedBalancesLock sync.RWMutex
-	wsVerifier            *WeakSubjectivityVerifier
+	//justifiedBalances     []uint64
+	justifiedBalances *stateBalanceCache
+	wsVerifier        *WeakSubjectivityVerifier
 }
 
 // config options for the service.
@@ -97,7 +97,6 @@ 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 {
@@ -106,6 +105,12 @@ 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
@@ -151,9 +156,6 @@ 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)
@@ -340,9 +342,6 @@ 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,25 +108,24 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	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,
+	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),
 	}
 
-	// Safe a state in stategen to purposes of testing a service stop / shutdown.
-	require.NoError(t, cfg.StateGen.SaveState(ctx, bytesutil.ToBytes32(bState.FinalizedCheckpoint().Root), bState))
-
-	chainService, err := NewService(ctx)
+	chainService, err := NewService(ctx, opts...)
 	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

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

@@ -0,0 +1,225 @@
+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,7 +5,6 @@
 package depositcache
 
 import (
-	"bytes"
 	"context"
 	"encoding/hex"
 	"math/big"
@@ -54,6 +53,7 @@ type DepositCache struct {
 	pendingDeposits   []*dbpb.DepositContainer
 	deposits          []*dbpb.DepositContainer
 	finalizedDeposits *FinalizedDeposits
+	depositsByKey     map[[48]byte][]*dbpb.DepositContainer
 	depositsLock      sync.RWMutex
 }
 
@@ -69,6 +69,7 @@ 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
 }
@@ -95,10 +96,15 @@ 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{{Deposit: d, Eth1BlockHeight: blockNum, DepositRoot: depositRoot[:], Index: index}},
+		[]*dbpb.DepositContainer{depCtr},
 		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
 }
@@ -112,6 +118,13 @@ 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)))
 }
 
@@ -202,13 +215,15 @@ func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*et
 
 	var deposit *ethpb.Deposit
 	var blockNum *big.Int
-	for _, ctnr := range dc.deposits {
-		if bytes.Equal(ctnr.Deposit.Data.PublicKey, pubKey) {
-			deposit = ctnr.Deposit
-			blockNum = big.NewInt(int64(ctnr.Eth1BlockHeight))
-			break
-		}
+	deps, ok := dc.depositsByKey[bytesutil.ToBytes48(pubKey)]
+	if !ok || len(deps) == 0 {
+		return deposit, blockNum
 	}
+	// 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{},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'A'}}},
 			index:       0,
 			expectedErr: "",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'B'}}},
 			index:       3,
 			expectedErr: "wanted deposit with index 1 to be inserted but received 3",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'C'}}},
 			index:       1,
 			expectedErr: "",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'D'}}},
 			index:       4,
 			expectedErr: "wanted deposit with index 2 to be inserted but received 4",
 		},
 		{
 			blkNum:      0,
-			deposit:     &ethpb.Deposit{},
+			deposit:     &ethpb.Deposit{Data: &dbpb.Deposit_Data{PublicKey: []byte{'E'}}},
 			index:       2,
 			expectedErr: "",
 		},
@@ -316,8 +316,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
-
-	dc.deposits = []*dbpb.DepositContainer{
+	ctrs := []*dbpb.DepositContainer{
 		{
 			Eth1BlockHeight: 9,
 			Deposit: &ethpb.Deposit{
@@ -359,6 +358,7 @@ 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,24 +626,28 @@ func TestPruneProofs_Ok(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
-			index:   0,
+			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:   1,
+			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:   2,
+			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:   3,
+			blkNum: 0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
+				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
+			index: 3,
 		},
 	}
 
@@ -669,24 +673,26 @@ func TestPruneProofs_SomeAlreadyPruned(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{Proof: nil},
-			index:   0,
+			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:   1,
-		},
-		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
+			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:   3,
+			blkNum: 0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
+				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
+			index: 3,
 		},
 	}
 
@@ -709,24 +715,28 @@ func TestPruneProofs_PruneAllWhenDepositIndexTooBig(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
-			index:   0,
+			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:   1,
+			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:   2,
+			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:   3,
+			blkNum: 0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
+				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
+			index: 3,
 		},
 	}
 
@@ -752,24 +762,28 @@ func TestPruneProofs_CorrectlyHandleLastIndex(t *testing.T) {
 		index   int64
 	}{
 		{
-			blkNum:  0,
-			deposit: &ethpb.Deposit{Proof: makeDepositProof()},
-			index:   0,
+			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:   1,
+			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:   2,
+			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:   3,
+			blkNum: 0,
+			deposit: &ethpb.Deposit{Proof: makeDepositProof(),
+				Data: &ethpb.Deposit_Data{PublicKey: bytesutil.PadTo([]byte("pk3"), 48)}},
+			index: 3,
 		},
 	}
 
@@ -785,6 +799,36 @@ 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,26 +120,22 @@ 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) error {
+func (c *SkipSlotCache) MarkNotInProgress(r [32]byte) {
 	if c.disabled {
-		return nil
+		return
 	}
 
 	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) error {
+func (c *SkipSlotCache) Put(_ context.Context, r [32]byte, state state.BeaconState) {
 	if c.disabled {
-		return nil
+		return
 	}
-
 	// 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)
 
-	require.NoError(t, c.Put(ctx, r, s))
-	require.NoError(t, c.MarkNotInProgress(r))
+	c.Put(ctx, r, s)
+	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,7 +152,8 @@ func IsSlashableAttestationData(data1, data2 *ethpb.AttestationData) bool {
 	return isDoubleVote || isSurroundVote
 }
 
-func slashableAttesterIndices(slashing *ethpb.AttesterSlashing) []uint64 {
+// SlashableAttesterIndices returns the intersection of attester indices from both attestations in this slashing.
+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/signing/domain.go

@@ -2,9 +2,9 @@ package signing
 
 import (
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/eth2-types"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	eth "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"
 
-	"github.com/prysmaticlabs/eth2-types"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )

beacon-chain/core/transition/transition.go

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

beacon-chain/db/iface/interface.go

@@ -39,14 +39,6 @@ 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)
@@ -75,11 +67,6 @@ 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
@@ -160,7 +147,6 @@ type Database interface {
 	io.Closer
 	backup.BackupExporter
 	HeadAccessDatabase
-
 	DatabasePath() string
 	ClearDB() error
 }

beacon-chain/db/kv/BUILD.bazel

@@ -13,15 +13,14 @@ 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",
@@ -88,9 +87,7 @@ 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,11 +150,7 @@ 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, err := blockRootsBySlot(ctx, tx, slot)
-		if err != nil {
-			return err
-		}
-
+		keys := blockRootsBySlot(ctx, tx, slot)
 		for i := 0; i < len(keys); i++ {
 			encoded := bkt.Get(keys[i])
 			blk, err := unmarshalBlock(ctx, encoded)
@@ -174,11 +170,7 @@ 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, err := blockRootsBySlot(ctx, tx, slot)
-		if err != nil {
-			return err
-		}
-
+		keys := blockRootsBySlot(ctx, tx, slot)
 		for i := 0; i < len(keys); i++ {
 			blockRoots = append(blockRoots, bytesutil.ToBytes32(keys[i]))
 		}
@@ -519,7 +511,7 @@ func blockRootsBySlotRange(
 }
 
 // blockRootsBySlot retrieves the block roots by slot
-func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) ([][]byte, error) {
+func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) [][]byte {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
 	defer span.End()
 
@@ -533,7 +525,7 @@ func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) ([][]by
 			roots = append(roots, v[i:i+32])
 		}
 	}
-	return roots, nil
+	return roots
 }
 
 // createBlockIndicesFromBlock takes in a beacon block and returns

beacon-chain/db/kv/operations.go

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

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

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

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

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

beacon-chain/light/service.go

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

beacon-chain/light/subscribe_finalized_event.go

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

beacon-chain/light/subscribe_head_event.go

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

beacon-chain/light/update_comparison.go

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

beacon-chain/light/updater.go

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

beacon-chain/monitor/BUILD.bazel

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+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,6 +26,7 @@ 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",

beacon-chain/node/node.go

@@ -28,6 +28,7 @@ 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"
@@ -193,6 +194,10 @@ 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
 	}
@@ -681,6 +686,11 @@ 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 {
@@ -757,6 +767,7 @@ func (b *BeaconNode) registerRPCService() error {
 		StateGen:                b.stateGen,
 		EnableDebugRPCEndpoints: enableDebugRPCEndpoints,
 		MaxMsgSize:              maxMsgSize,
+		LightUpdatesFetcher:     lightService,
 	})
 
 	return b.services.RegisterService(rpcService)
@@ -854,7 +865,37 @@ 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/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")}}},
-		{Index: 1, Eth1BlockHeight: 4, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("B")}}},
-		{Index: 2, Eth1BlockHeight: 6, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("c")}}},
+		{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{}}}},
 	}
 	gs, _ := util.DeterministicGenesisState(t, 1)
 	beaconDB := dbutil.SetupDB(t)

beacon-chain/rpc/BUILD.bazel

@@ -29,6 +29,7 @@ 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/prysm/v1alpha1/light/BUILD.bazel

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

@@ -0,0 +1,38 @@
+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/proposer_deposits.go

@@ -94,7 +94,12 @@ func (vs *Server) deposits(
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.deposits")
 	defer span.End()
 
-	if vs.MockEth1Votes || !vs.Eth1InfoFetcher.IsConnectedToETH1() {
+	if vs.MockEth1Votes {
+		return []*ethpb.Deposit{}, nil
+	}
+
+	if !vs.Eth1InfoFetcher.IsConnectedToETH1() {
+		log.Warn("not connected to eth1 node, skip pending deposit insertion")
 		return []*ethpb.Deposit{}, nil
 	}
 	// Need to fetch if the deposits up to the state's latest eth1 data matches
@@ -112,6 +117,7 @@ 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
 	}
 
@@ -127,21 +133,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 < params.BeaconConfig().MaxDeposits; i++ {
+	for i := uint64(0); i < uint64(len(pendingDeps)); i++ {
 		pendingDeposits = append(pendingDeposits, pendingDeps[i].Deposit)
 	}
 	return pendingDeposits, nil

beacon-chain/rpc/service.go

@@ -20,6 +20,7 @@ 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"
@@ -33,6 +34,7 @@ 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"
@@ -108,6 +110,7 @@ type Config struct {
 	OperationNotifier       opfeed.Notifier
 	StateGen                *stategen.State
 	MaxMsgSize              int
+	LightUpdatesFetcher     light.UpdatesFetcher
 }
 
 // NewService instantiates a new RPC service instance that will
@@ -279,6 +282,10 @@ 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,6 +12,8 @@ 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",
@@ -26,6 +28,7 @@ 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,6 +18,7 @@ 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
@@ -26,18 +27,19 @@ 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,
+			field:      field,
+			dataType:   dataType,
+			reference:  stateutil.NewRef(1),
+			RWMutex:    new(sync.RWMutex),
+			length:     length,
+			numOfElems: 0,
 		}, nil
 	}
 	fieldRoots, err := fieldConverters(field, []uint64{}, elements, true)
 	if err != nil {
 		return nil, err
 	}
-	if err := validateElements(field, elements, length); err != nil {
+	if err := validateElements(field, dataType, elements, length); err != nil {
 		return nil, err
 	}
 	switch dataType {
@@ -53,8 +55,9 @@ 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:
+	case types.CompositeArray, types.CompressedArray:
 		return &FieldTrie{
 			fieldLayers: stateutil.ReturnTrieLayerVariable(fieldRoots, length),
 			field:       field,
@@ -62,6 +65,7 @@ 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())
@@ -92,13 +96,40 @@ 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())
 	}
@@ -109,11 +140,12 @@ 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,
+			field:      f.field,
+			dataType:   f.dataType,
+			reference:  stateutil.NewRef(1),
+			RWMutex:    new(sync.RWMutex),
+			length:     f.length,
+			numOfElems: f.numOfElems,
 		}
 	}
 	dstFieldTrie := make([][]*[32]byte, len(f.fieldLayers))
@@ -128,6 +160,7 @@ func (f *FieldTrie) CopyTrie() *FieldTrie {
 		reference:   stateutil.NewRef(1),
 		RWMutex:     new(sync.RWMutex),
 		length:      f.length,
+		numOfElems:  f.numOfElems,
 	}
 }
 
@@ -139,6 +172,9 @@ 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,6 +1,7 @@
 package fieldtrie
 
 import (
+	"encoding/binary"
 	"fmt"
 	"reflect"
 
@@ -8,20 +9,37 @@ 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 >= f.length {
-			return errors.Errorf("invalid index for field %s: %d >= length %d", f.field.String(version.Phase0), idx, f.length)
+		if idx >= length {
+			return errors.Errorf("invalid index for field %s: %d >= length %d", f.field.String(version.Phase0), idx, length)
 		}
 	}
 	return nil
 }
 
-func validateElements(field types.FieldIndex, elements interface{}, length uint64) error {
+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
+	}
 	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)
@@ -38,21 +56,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 stateutil.HandleByteArrays(val, indices, convertAll)
+		return 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 stateutil.HandleValidatorSlice(val, indices, convertAll)
+		return handleValidatorSlice(val, indices, convertAll)
 	case types.PreviousEpochAttestations, types.CurrentEpochAttestations:
 		val, ok := elements.([]*ethpb.PendingAttestation)
 		if !ok {
@@ -60,13 +78,87 @@ 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())
 	}
 }
 
-// HandleEth1DataSlice processes a list of eth1data and indices into the appropriate roots.
-func HandleEth1DataSlice(val []*ethpb.Eth1Data, indices []uint64, convertAll bool) ([][32]byte, error) {
+// 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) {
 	length := len(indices)
 	if convertAll {
 		length = len(val)
@@ -141,3 +233,48 @@ 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,8 +1,13 @@
 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"
 )
@@ -17,7 +22,64 @@ 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,7 +148,6 @@ 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,6 +37,15 @@ 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,6 +56,44 @@ 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,6 +23,11 @@ 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,6 +31,7 @@ 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,7 +3,6 @@ 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",
@@ -49,7 +48,6 @@ 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

@@ -1,35 +0,0 @@
-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,7 +2,6 @@ package stateutil
 
 import (
 	"encoding/binary"
-	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -127,42 +126,3 @@ 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

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

beacon-chain/state/types/types.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
@@ -18,6 +19,10 @@ 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.
@@ -54,12 +59,12 @@ func (f FieldIndex) String(stateVersion int) string {
 	case Slashings:
 		return "slashings"
 	case PreviousEpochAttestations:
-		if version.Altair == stateVersion {
+		if version.Altair == stateVersion || version.Merge == stateVersion {
 			return "previousEpochParticipationBits"
 		}
 		return "previousEpochAttestations"
 	case CurrentEpochAttestations:
-		if version.Altair == stateVersion {
+		if version.Altair == stateVersion || version.Merge == stateVersion {
 			return "currentEpochParticipationBits"
 		}
 		return "currentEpochAttestations"
@@ -77,11 +82,24 @@ 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
@@ -114,12 +132,13 @@ 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,6 +87,7 @@ 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,6 +5,7 @@ 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,6 +173,10 @@ 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,24 +5,6 @@ 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,6 +103,7 @@ func (b *BeaconState) SetBalances(val []uint64) error {
 
 	b.state.Balances = val
 	b.markFieldAsDirty(balances)
+	b.rebuildTrie[balances] = true
 	return nil
 }
 
@@ -128,6 +129,7 @@ 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
 }
 
@@ -219,6 +221,8 @@ 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,10 +1,13 @@
 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"
@@ -104,3 +107,90 @@ 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,6 +12,7 @@ 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"
@@ -319,6 +320,20 @@ 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,6 +7,7 @@ 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"
@@ -16,6 +17,12 @@ 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,7 +17,6 @@ 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
@@ -28,6 +27,7 @@ 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,11 +79,13 @@ 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,6 +5,7 @@ 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"
@@ -171,6 +172,10 @@ 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,24 +5,6 @@ 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,10 +2,15 @@ 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"
@@ -57,3 +62,100 @@ 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")
+}

beacon-chain/state/v2/setters_validator.go

@@ -102,6 +102,7 @@ func (b *BeaconState) SetBalances(val []uint64) error {
 	b.sharedFieldReferences[balances] = stateutil.NewRef(1)
 
 	b.state.Balances = val
+	b.rebuildTrie[balances] = true
 	b.markFieldAsDirty(balances)
 	return nil
 }
@@ -128,6 +129,7 @@ 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
 }
 
@@ -219,7 +221,9 @@ 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/v2/state_trie.go

@@ -12,6 +12,7 @@ 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"
@@ -324,6 +325,20 @@ 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/v2/state_trie_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	"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"
@@ -13,6 +14,12 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
+func TestMain(m *testing.M) {
+	resetCfg := features.InitWithReset(&features.Flags{EnableBalanceTrieComputation: true})
+	defer resetCfg()
+	m.Run()
+}
+
 func TestValidatorMap_DistinctCopy(t *testing.T) {
 	count := uint64(100)
 	vals := make([]*ethpb.Validator, 0, count)

beacon-chain/state/v2/types.go

@@ -22,6 +22,9 @@ func init() {
 	// Initialize the composite arrays.
 	fieldMap[types.Eth1DataVotes] = types.CompositeArray
 	fieldMap[types.Validators] = types.CompositeArray
+
+	// Initialize Compressed Arrays
+	fieldMap[types.Balances] = types.CompressedArray
 }
 
 // fieldMap keeps track of each field

beacon-chain/state/v3/BUILD.bazel

@@ -0,0 +1,34 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "field_root_eth1.go",
+        "field_root_validator.go",
+        "field_root_vector.go",
+        "field_roots.go",
+        "types.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/state/v3",
+    visibility = ["//beacon-chain:__pkg__"],
+    deps = [
+        "//beacon-chain/state/fieldtrie: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",
+        "//crypto/hash:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_dgraph_io_ristretto//:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["field_root_test.go"],
+    embed = [":go_default_library"],
+    deps = ["//testing/assert:go_default_library"],
+)

beacon-chain/state/v3/field_root_eth1.go

@@ -0,0 +1,59 @@
+package v3
+
+import (
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/encoding/ssz"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+// eth1Root computes the HashTreeRoot Merkleization of
+// a BeaconBlockHeader struct according to the eth2
+// Simple Serialize specification.
+func eth1Root(hasher ssz.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) {
+	if eth1Data == nil {
+		return [32]byte{}, errors.New("nil eth1 data")
+	}
+
+	enc := stateutil.Eth1DataEncKey(eth1Data)
+	if features.Get().EnableSSZCache {
+		if found, ok := cachedHasher.rootsCache.Get(string(enc)); ok && found != nil {
+			return found.([32]byte), nil
+		}
+	}
+
+	root, err := stateutil.Eth1DataRootWithHasher(hasher, eth1Data)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	if features.Get().EnableSSZCache {
+		cachedHasher.rootsCache.Set(string(enc), root, 32)
+	}
+	return root, nil
+}
+
+// eth1DataVotesRoot computes the HashTreeRoot Merkleization of
+// a list of Eth1Data structs according to the eth2
+// Simple Serialize specification.
+func eth1DataVotesRoot(eth1DataVotes []*ethpb.Eth1Data) ([32]byte, error) {
+	hashKey, err := stateutil.Eth1DatasEncKey(eth1DataVotes)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	if features.Get().EnableSSZCache {
+		if found, ok := cachedHasher.rootsCache.Get(string(hashKey[:])); ok && found != nil {
+			return found.([32]byte), nil
+		}
+	}
+	root, err := stateutil.Eth1DatasRoot(eth1DataVotes)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	if features.Get().EnableSSZCache {
+		cachedHasher.rootsCache.Set(string(hashKey[:]), root, 32)
+	}
+	return root, nil
+}

beacon-chain/state/v3/field_root_test.go

@@ -0,0 +1,23 @@
+package v3
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/testing/assert"
+)
+
+func TestArraysTreeRoot_OnlyPowerOf2(t *testing.T) {
+	_, err := nocachedHasher.arraysRoot([][]byte{}, 1, "testing")
+	assert.NoError(t, err)
+	_, err = nocachedHasher.arraysRoot([][]byte{}, 4, "testing")
+	assert.NoError(t, err)
+	_, err = nocachedHasher.arraysRoot([][]byte{}, 8, "testing")
+	assert.NoError(t, err)
+	_, err = nocachedHasher.arraysRoot([][]byte{}, 10, "testing")
+	assert.ErrorContains(t, "hash layer is a non power of 2", err)
+}
+
+func TestArraysTreeRoot_ZeroLength(t *testing.T) {
+	_, err := nocachedHasher.arraysRoot([][]byte{}, 0, "testing")
+	assert.ErrorContains(t, "zero leaves provided", err)
+}

beacon-chain/state/v3/field_root_validator.go

@@ -0,0 +1,89 @@
+package v3
+
+import (
+	"bytes"
+	"encoding/binary"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/crypto/hash"
+	"github.com/prysmaticlabs/prysm/encoding/ssz"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+func (h *stateRootHasher) validatorRegistryRoot(validators []*ethpb.Validator) ([32]byte, error) {
+	hashKeyElements := make([]byte, len(validators)*32)
+	roots := make([][32]byte, len(validators))
+	emptyKey := hash.FastSum256(hashKeyElements)
+	hasher := hash.CustomSHA256Hasher()
+	bytesProcessed := 0
+	for i := 0; i < len(validators); i++ {
+		val, err := h.validatorRoot(hasher, validators[i])
+		if err != nil {
+			return [32]byte{}, errors.Wrap(err, "could not compute validators merkleization")
+		}
+		copy(hashKeyElements[bytesProcessed:bytesProcessed+32], val[:])
+		roots[i] = val
+		bytesProcessed += 32
+	}
+
+	hashKey := hash.FastSum256(hashKeyElements)
+	if hashKey != emptyKey && h.rootsCache != nil {
+		if found, ok := h.rootsCache.Get(string(hashKey[:])); found != nil && ok {
+			return found.([32]byte), nil
+		}
+	}
+
+	validatorsRootsRoot, err := ssz.BitwiseMerkleizeArrays(hasher, roots, uint64(len(roots)), params.BeaconConfig().ValidatorRegistryLimit)
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not compute validator registry merkleization")
+	}
+	validatorsRootsBuf := new(bytes.Buffer)
+	if err := binary.Write(validatorsRootsBuf, binary.LittleEndian, uint64(len(validators))); err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not marshal validator registry length")
+	}
+	// We need to mix in the length of the slice.
+	var validatorsRootsBufRoot [32]byte
+	copy(validatorsRootsBufRoot[:], validatorsRootsBuf.Bytes())
+	res := ssz.MixInLength(validatorsRootsRoot, validatorsRootsBufRoot[:])
+	if hashKey != emptyKey && h.rootsCache != nil {
+		h.rootsCache.Set(string(hashKey[:]), res, 32)
+	}
+	return res, nil
+}
+
+func (h *stateRootHasher) validatorRoot(hasher ssz.HashFn, validator *ethpb.Validator) ([32]byte, error) {
+	if validator == nil {
+		return [32]byte{}, errors.New("nil validator")
+	}
+
+	enc := stateutil.ValidatorEncKey(validator)
+	// Check if it exists in cache:
+	if h.rootsCache != nil {
+		if found, ok := h.rootsCache.Get(string(enc)); found != nil && ok {
+			return found.([32]byte), nil
+		}
+	}
+
+	valRoot, err := stateutil.ValidatorRootWithHasher(hasher, validator)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	if h.rootsCache != nil {
+		h.rootsCache.Set(string(enc), valRoot, 32)
+	}
+	return valRoot, nil
+}
+
+// ValidatorRegistryRoot computes the HashTreeRoot Merkleization of
+// a list of validator structs according to the eth2
+// Simple Serialize specification.
+func ValidatorRegistryRoot(vals []*ethpb.Validator) ([32]byte, error) {
+	if features.Get().EnableSSZCache {
+		return cachedHasher.validatorRegistryRoot(vals)
+	}
+	return nocachedHasher.validatorRegistryRoot(vals)
+}

beacon-chain/state/v3/field_root_vector.go

@@ -0,0 +1,146 @@
+package v3
+
+import (
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	"github.com/prysmaticlabs/prysm/crypto/hash"
+	"github.com/prysmaticlabs/prysm/encoding/ssz"
+)
+
+func (h *stateRootHasher) arraysRoot(input [][]byte, length uint64, fieldName string) ([32]byte, error) {
+	lock.Lock()
+	defer lock.Unlock()
+	hashFunc := hash.CustomSHA256Hasher()
+	if _, ok := layersCache[fieldName]; !ok && h.rootsCache != nil {
+		depth := ssz.Depth(length)
+		layersCache[fieldName] = make([][][32]byte, depth+1)
+	}
+
+	leaves := make([][32]byte, length)
+	for i, chunk := range input {
+		copy(leaves[i][:], chunk)
+	}
+	bytesProcessed := 0
+	changedIndices := make([]int, 0)
+	prevLeaves, ok := leavesCache[fieldName]
+	if len(prevLeaves) == 0 || h.rootsCache == nil {
+		prevLeaves = leaves
+	}
+
+	for i := 0; i < len(leaves); i++ {
+		// We check if any items changed since the roots were last recomputed.
+		notEqual := leaves[i] != prevLeaves[i]
+		if ok && h.rootsCache != nil && notEqual {
+			changedIndices = append(changedIndices, i)
+		}
+		bytesProcessed += 32
+	}
+	if len(changedIndices) > 0 && h.rootsCache != nil {
+		var rt [32]byte
+		var err error
+		// If indices did change since last computation, we only recompute
+		// the modified branches in the cached Merkle tree for this state field.
+		chunks := leaves
+
+		// We need to ensure we recompute indices of the Merkle tree which
+		// changed in-between calls to this function. This check adds an offset
+		// to the recomputed indices to ensure we do so evenly.
+		maxChangedIndex := changedIndices[len(changedIndices)-1]
+		if maxChangedIndex+2 == len(chunks) && maxChangedIndex%2 != 0 {
+			changedIndices = append(changedIndices, maxChangedIndex+1)
+		}
+		for i := 0; i < len(changedIndices); i++ {
+			rt, err = recomputeRoot(changedIndices[i], chunks, fieldName, hashFunc)
+			if err != nil {
+				return [32]byte{}, err
+			}
+		}
+		leavesCache[fieldName] = chunks
+		return rt, nil
+	}
+
+	res, err := h.merkleizeWithCache(leaves, length, fieldName, hashFunc)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	if h.rootsCache != nil {
+		leavesCache[fieldName] = leaves
+	}
+	return res, nil
+}
+
+func recomputeRoot(idx int, chunks [][32]byte, fieldName string, hasher func([]byte) [32]byte) ([32]byte, error) {
+	items, ok := layersCache[fieldName]
+	if !ok {
+		return [32]byte{}, errors.New("could not recompute root as there was no cache found")
+	}
+	if items == nil {
+		return [32]byte{}, errors.New("could not recompute root as there were no items found in the layers cache")
+	}
+	layers := items
+	root := chunks[idx]
+	layers[0] = chunks
+	// The merkle tree structure looks as follows:
+	// [[r1, r2, r3, r4], [parent1, parent2], [root]]
+	// Using information about the index which changed, idx, we recompute
+	// only its branch up the tree.
+	currentIndex := idx
+	for i := 0; i < len(layers)-1; i++ {
+		isLeft := currentIndex%2 == 0
+		neighborIdx := currentIndex ^ 1
+
+		neighbor := [32]byte{}
+		if layers[i] != nil && len(layers[i]) != 0 && neighborIdx < len(layers[i]) {
+			neighbor = layers[i][neighborIdx]
+		}
+		if isLeft {
+			parentHash := hasher(append(root[:], neighbor[:]...))
+			root = parentHash
+		} else {
+			parentHash := hasher(append(neighbor[:], root[:]...))
+			root = parentHash
+		}
+		parentIdx := currentIndex / 2
+		// Update the cached layers at the parent index.
+		if len(layers[i+1]) == 0 {
+			layers[i+1] = append(layers[i+1], root)
+		} else {
+			layers[i+1][parentIdx] = root
+		}
+		currentIndex = parentIdx
+	}
+	layersCache[fieldName] = layers
+	// If there is only a single leaf, we return it (the identity element).
+	if len(layers[0]) == 1 {
+		return layers[0][0], nil
+	}
+	return root, nil
+}
+
+func (h *stateRootHasher) merkleizeWithCache(leaves [][32]byte, length uint64,
+	fieldName string, hasher func([]byte) [32]byte) ([32]byte, error) {
+	if len(leaves) == 0 {
+		return [32]byte{}, errors.New("zero leaves provided")
+	}
+	if len(leaves) == 1 {
+		return leaves[0], nil
+	}
+	hashLayer := leaves
+	layers := make([][][32]byte, ssz.Depth(length)+1)
+	if items, ok := layersCache[fieldName]; ok && h.rootsCache != nil {
+		if len(items[0]) == len(leaves) {
+			layers = items
+		}
+	}
+	layers[0] = hashLayer
+	var err error
+	layers, hashLayer, err = stateutil.MerkleizeTrieLeaves(layers, hashLayer, hasher)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	root := hashLayer[0]
+	if h.rootsCache != nil {
+		layersCache[fieldName] = layers
+	}
+	return root, nil
+}

beacon-chain/state/v3/field_roots.go

@@ -0,0 +1,226 @@
+package v3
+
+import (
+	"encoding/binary"
+	"sync"
+
+	"github.com/dgraph-io/ristretto"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
+	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"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"
+)
+
+var (
+	leavesCache = make(map[string][][32]byte, params.BeaconConfig().BeaconStateMergeFieldCount)
+	layersCache = make(map[string][][][32]byte, params.BeaconConfig().BeaconStateMergeFieldCount)
+	lock        sync.RWMutex
+)
+
+const cacheSize = 100000
+
+var nocachedHasher *stateRootHasher
+var cachedHasher *stateRootHasher
+
+func init() {
+	rootsCache, err := ristretto.NewCache(&ristretto.Config{
+		NumCounters: cacheSize, // number of keys to track frequency of (1M).
+		MaxCost:     1 << 22,   // maximum cost of cache (3MB).
+		// 100,000 roots will take up approximately 3 MB in memory.
+		BufferItems: 64, // number of keys per Get buffer.
+	})
+	if err != nil {
+		panic(err)
+	}
+	// Temporarily disable roots cache until cache issues can be resolved.
+	cachedHasher = &stateRootHasher{rootsCache: rootsCache}
+	nocachedHasher = &stateRootHasher{}
+}
+
+type stateRootHasher struct {
+	rootsCache *ristretto.Cache
+}
+
+// computeFieldRoots returns the hash tree root computations of every field in
+// the beacon state as a list of 32 byte roots.
+//nolint:deadcode
+func computeFieldRoots(state *ethpb.BeaconStateMerge) ([][]byte, error) {
+	if features.Get().EnableSSZCache {
+		return cachedHasher.computeFieldRootsWithHasher(state)
+	}
+	return nocachedHasher.computeFieldRootsWithHasher(state)
+}
+
+func (h *stateRootHasher) computeFieldRootsWithHasher(state *ethpb.BeaconStateMerge) ([][]byte, error) {
+	if state == nil {
+		return nil, errors.New("nil state")
+	}
+	hasher := hash.CustomSHA256Hasher()
+	fieldRoots := make([][]byte, params.BeaconConfig().BeaconStateMergeFieldCount)
+
+	// Genesis time root.
+	genesisRoot := ssz.Uint64Root(state.GenesisTime)
+	fieldRoots[0] = genesisRoot[:]
+
+	// Genesis validator root.
+	r := [32]byte{}
+	copy(r[:], state.GenesisValidatorsRoot)
+	fieldRoots[1] = r[:]
+
+	// Slot root.
+	slotRoot := ssz.Uint64Root(uint64(state.Slot))
+	fieldRoots[2] = slotRoot[:]
+
+	// Fork data structure root.
+	forkHashTreeRoot, err := ssz.ForkRoot(state.Fork)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute fork merkleization")
+	}
+	fieldRoots[3] = forkHashTreeRoot[:]
+
+	// BeaconBlockHeader data structure root.
+	headerHashTreeRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute block header merkleization")
+	}
+	fieldRoots[4] = headerHashTreeRoot[:]
+
+	// BlockRoots array root.
+	blockRootsRoot, err := h.arraysRoot(state.BlockRoots, uint64(params.BeaconConfig().SlotsPerHistoricalRoot), "BlockRoots")
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute block roots merkleization")
+	}
+	fieldRoots[5] = blockRootsRoot[:]
+
+	// StateRoots array root.
+	stateRootsRoot, err := h.arraysRoot(state.StateRoots, uint64(params.BeaconConfig().SlotsPerHistoricalRoot), "StateRoots")
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute state roots merkleization")
+	}
+	fieldRoots[6] = stateRootsRoot[:]
+
+	// HistoricalRoots slice root.
+	historicalRootsRt, err := ssz.ByteArrayRootWithLimit(state.HistoricalRoots, params.BeaconConfig().HistoricalRootsLimit)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute historical roots merkleization")
+	}
+	fieldRoots[7] = historicalRootsRt[:]
+
+	// Eth1Data data structure root.
+	eth1HashTreeRoot, err := eth1Root(hasher, state.Eth1Data)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute eth1data merkleization")
+	}
+	fieldRoots[8] = eth1HashTreeRoot[:]
+
+	// Eth1DataVotes slice root.
+	eth1VotesRoot, err := eth1DataVotesRoot(state.Eth1DataVotes)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute eth1data votes merkleization")
+	}
+	fieldRoots[9] = eth1VotesRoot[:]
+
+	// Eth1DepositIndex root.
+	eth1DepositIndexBuf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(eth1DepositIndexBuf, state.Eth1DepositIndex)
+	eth1DepositBuf := bytesutil.ToBytes32(eth1DepositIndexBuf)
+	fieldRoots[10] = eth1DepositBuf[:]
+
+	// Validators slice root.
+	validatorsRoot, err := h.validatorRegistryRoot(state.Validators)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute validator registry merkleization")
+	}
+	fieldRoots[11] = validatorsRoot[:]
+
+	// Balances slice root.
+	balancesRoot, err := stateutil.Uint64ListRootWithRegistryLimit(state.Balances)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute validator balances merkleization")
+	}
+	fieldRoots[12] = balancesRoot[:]
+
+	// RandaoMixes array root.
+	randaoRootsRoot, err := h.arraysRoot(state.RandaoMixes, uint64(params.BeaconConfig().EpochsPerHistoricalVector), "RandaoMixes")
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute randao roots merkleization")
+	}
+	fieldRoots[13] = randaoRootsRoot[:]
+
+	// Slashings array root.
+	slashingsRootsRoot, err := ssz.SlashingsRoot(state.Slashings)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute slashings merkleization")
+	}
+	fieldRoots[14] = slashingsRootsRoot[:]
+
+	// PreviousEpochParticipation slice root.
+	prevParticipationRoot, err := stateutil.ParticipationBitsRoot(state.PreviousEpochParticipation)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute previous epoch participation merkleization")
+	}
+	fieldRoots[15] = prevParticipationRoot[:]
+
+	// CurrentEpochParticipation slice root.
+	currParticipationRoot, err := stateutil.ParticipationBitsRoot(state.CurrentEpochParticipation)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute current epoch participation merkleization")
+	}
+	fieldRoots[16] = currParticipationRoot[:]
+
+	// JustificationBits root.
+	justifiedBitsRoot := bytesutil.ToBytes32(state.JustificationBits)
+	fieldRoots[17] = justifiedBitsRoot[:]
+
+	// PreviousJustifiedCheckpoint data structure root.
+	prevCheckRoot, err := ssz.CheckpointRoot(hasher, state.PreviousJustifiedCheckpoint)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute previous justified checkpoint merkleization")
+	}
+	fieldRoots[18] = prevCheckRoot[:]
+
+	// CurrentJustifiedCheckpoint data structure root.
+	currJustRoot, err := ssz.CheckpointRoot(hasher, state.CurrentJustifiedCheckpoint)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute current justified checkpoint merkleization")
+	}
+	fieldRoots[19] = currJustRoot[:]
+
+	// FinalizedCheckpoint data structure root.
+	finalRoot, err := ssz.CheckpointRoot(hasher, state.FinalizedCheckpoint)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute finalized checkpoint merkleization")
+	}
+	fieldRoots[20] = finalRoot[:]
+
+	// Inactivity scores root.
+	inactivityScoresRoot, err := stateutil.Uint64ListRootWithRegistryLimit(state.InactivityScores)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute inactivityScoreRoot")
+	}
+	fieldRoots[21] = inactivityScoresRoot[:]
+
+	// Current sync committee root.
+	currentSyncCommitteeRoot, err := stateutil.SyncCommitteeRoot(state.CurrentSyncCommittee)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute sync committee merkleization")
+	}
+	fieldRoots[22] = currentSyncCommitteeRoot[:]
+
+	// Next sync committee root.
+	nextSyncCommitteeRoot, err := stateutil.SyncCommitteeRoot(state.NextSyncCommittee)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute sync committee merkleization")
+	}
+	fieldRoots[23] = nextSyncCommitteeRoot[:]
+
+	// Execution payload root.
+	//TODO: Blocked by https://github.com/ferranbt/fastssz/pull/65
+	fieldRoots[24] = []byte{}
+
+	return fieldRoots, nil
+}

beacon-chain/state/v3/types.go

@@ -0,0 +1,49 @@
+package v3
+
+import (
+	"sync"
+
+	"github.com/pkg/errors"
+	"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/params"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+func init() {
+	fieldMap = make(map[types.FieldIndex]types.DataType, params.BeaconConfig().BeaconStateMergeFieldCount)
+
+	// Initialize the fixed sized arrays.
+	fieldMap[types.BlockRoots] = types.BasicArray
+	fieldMap[types.StateRoots] = types.BasicArray
+	fieldMap[types.RandaoMixes] = types.BasicArray
+
+	// Initialize the composite arrays.
+	fieldMap[types.Eth1DataVotes] = types.CompositeArray
+	fieldMap[types.Validators] = types.CompositeArray
+}
+
+// TODO: Add field Aliases for values from the types package. It'll come in part 2.
+
+// fieldMap keeps track of each field
+// to its corresponding data type.
+var fieldMap map[types.FieldIndex]types.DataType
+
+// ErrNilInnerState returns when the inner state is nil and no copy set or get
+// operations can be performed on state.
+var ErrNilInnerState = errors.New("nil inner state")
+
+// BeaconState defines a struct containing utilities for the eth2 chain state, defining
+// getters and setters for its respective values and helpful functions such as HashTreeRoot().
+type BeaconState struct {
+	state                 *ethpb.BeaconStateMerge
+	lock                  sync.RWMutex
+	dirtyFields           map[types.FieldIndex]bool
+	dirtyIndices          map[types.FieldIndex][]uint64
+	stateFieldLeaves      map[types.FieldIndex]*fieldtrie.FieldTrie
+	rebuildTrie           map[types.FieldIndex]bool
+	valMapHandler         *stateutil.ValidatorMapHandler
+	merkleLayers          [][][]byte
+	sharedFieldReferences map[types.FieldIndex]*stateutil.Reference
+}

beacon-chain/sync/pending_blocks_queue.go

@@ -88,16 +88,29 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 				continue
 			}
 
-			s.pendingQueueLock.RLock()
-			inPendingQueue := s.seenPendingBlocks[bytesutil.ToBytes32(b.Block().ParentRoot())]
-			s.pendingQueueLock.RUnlock()
-
 			blkRoot, err := b.Block().HashTreeRoot()
 			if err != nil {
 				tracing.AnnotateError(span, err)
 				span.End()
 				return err
 			}
+			inDB := s.cfg.beaconDB.HasBlock(ctx, blkRoot)
+			// No need to process the same block twice.
+			if inDB {
+				s.pendingQueueLock.Lock()
+				if err := s.deleteBlockFromPendingQueue(slot, b, blkRoot); err != nil {
+					s.pendingQueueLock.Unlock()
+					return err
+				}
+				s.pendingQueueLock.Unlock()
+				span.End()
+				continue
+			}
+
+			s.pendingQueueLock.RLock()
+			inPendingQueue := s.seenPendingBlocks[bytesutil.ToBytes32(b.Block().ParentRoot())]
+			s.pendingQueueLock.RUnlock()
+
 			parentIsBad := s.hasBadBlock(bytesutil.ToBytes32(b.Block().ParentRoot()))
 			blockIsBad := s.hasBadBlock(blkRoot)
 			// Check if parent is a bad block.
@@ -117,12 +130,12 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 				continue
 			}
 
-			inDB := s.cfg.beaconDB.HasBlock(ctx, bytesutil.ToBytes32(b.Block().ParentRoot()))
+			parentInDb := s.cfg.beaconDB.HasBlock(ctx, bytesutil.ToBytes32(b.Block().ParentRoot()))
 			hasPeer := len(pids) != 0
 
 			// Only request for missing parent block if it's not in beaconDB, not in pending cache
 			// and has peer in the peer list.
-			if !inPendingQueue && !inDB && hasPeer {
+			if !inPendingQueue && !parentInDb && hasPeer {
 				log.WithFields(logrus.Fields{
 					"currentSlot": b.Block().Slot(),
 					"parentRoot":  hex.EncodeToString(bytesutil.Trunc(b.Block().ParentRoot())),
@@ -133,7 +146,7 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 				continue
 			}
 
-			if !inDB {
+			if !parentInDb {
 				span.End()
 				continue
 			}
@@ -167,6 +180,7 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 
 			s.pendingQueueLock.Lock()
 			if err := s.deleteBlockFromPendingQueue(slot, b, blkRoot); err != nil {
+				s.pendingQueueLock.Unlock()
 				return err
 			}
 			s.pendingQueueLock.Unlock()
@@ -321,6 +335,7 @@ func (s *Service) deleteBlockFromPendingQueue(slot types.Slot, b block.SignedBea
 	}
 	if len(newBlks) == 0 {
 		s.slotToPendingBlocks.Delete(slotToCacheKey(slot))
+		delete(s.seenPendingBlocks, r)
 		return nil
 	}
 

beacon-chain/sync/pending_blocks_queue_test.go

@@ -84,9 +84,13 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks1(t *testing.T) {
 	require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b1), b1Root))
 	require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b1)))
 
-	// Insert bad b1 in the cache to verify the good one doesn't get replaced.
-	require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), [32]byte{}))
+	nBlock := util.NewBeaconBlock()
+	nBlock.Block.Slot = b1.Block.Slot
+	nRoot, err := nBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
 
+	// Insert bad b1 in the cache to verify the good one doesn't get replaced.
+	require.NoError(t, r.insertBlockToPendingQueue(nBlock.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(nBlock), nRoot))
 	require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad
 	require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run
 
@@ -140,6 +144,46 @@ func TestRegularSync_InsertDuplicateBlocks(t *testing.T) {
 
 }
 
+func TestRegularSyncBeaconBlockSubscriber_DoNotReprocessBlock(t *testing.T) {
+	db := dbtest.SetupDB(t)
+
+	p1 := p2ptest.NewTestP2P(t)
+	r := &Service{
+		cfg: &config{
+			p2p:      p1,
+			beaconDB: db,
+			chain: &mock.ChainService{
+				FinalizedCheckPoint: &ethpb.Checkpoint{
+					Epoch: 0,
+				},
+			},
+			stateGen: stategen.New(db),
+		},
+		slotToPendingBlocks: gcache.New(time.Second, 2*time.Second),
+		seenPendingBlocks:   make(map[[32]byte]bool),
+	}
+	r.initCaches()
+
+	b0 := util.NewBeaconBlock()
+	require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b0)))
+	b0Root, err := b0.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b3 := util.NewBeaconBlock()
+	b3.Block.Slot = 3
+	b3.Block.ParentRoot = b0Root[:]
+	b3Root, err := b3.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b3)))
+
+	// Add b3 to the cache
+	require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b3), b3Root))
+
+	require.NoError(t, r.processPendingBlocks(context.Background()))
+	assert.Equal(t, 0, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache")
+	assert.Equal(t, 0, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
+}
+
 //    /- b1 - b2 - b5
 // b0
 //    \- b3 - b4
@@ -237,7 +281,7 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks_2Chains(t *testin
 	require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run
 
 	assert.Equal(t, 1, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache")
-	assert.Equal(t, 3, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
+	assert.Equal(t, 1, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
 
 	// Add b2 to the cache
 	require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b2), b2Root))
@@ -248,7 +292,7 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks_2Chains(t *testin
 	require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run
 
 	assert.Equal(t, 0, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache")
-	assert.Equal(t, 4, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
+	assert.Equal(t, 0, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
 }
 
 func TestRegularSyncBeaconBlockSubscriber_PruneOldPendingBlocks(t *testing.T) {
@@ -318,7 +362,7 @@ func TestRegularSyncBeaconBlockSubscriber_PruneOldPendingBlocks(t *testing.T) {
 
 	require.NoError(t, r.processPendingBlocks(context.Background()))
 	assert.Equal(t, 0, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache")
-	assert.Equal(t, 4, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
+	assert.Equal(t, 0, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
 }
 
 func TestService_sortedPendingSlots(t *testing.T) {
@@ -429,7 +473,7 @@ func TestService_BatchRootRequest(t *testing.T) {
 	assert.Equal(t, 4, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
 }
 
-func TestService_AddPeningBlockToQueueOverMax(t *testing.T) {
+func TestService_AddPendingBlockToQueueOverMax(t *testing.T) {
 	r := &Service{
 		slotToPendingBlocks: gcache.New(time.Second, 2*time.Second),
 		seenPendingBlocks:   make(map[[32]byte]bool),

cmd/light/BUILD.bazel

@@ -0,0 +1,50 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_binary")
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "client.go",
+        "main.go",
+        "process_update.go",
+        "server.go",
+        "validate_update.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/cmd/light",
+    visibility = ["//visibility:private"],
+    deps = [
+        "//beacon-chain/core/signing:go_default_library",
+        "//config/params:go_default_library",
+        "//container/trie:go_default_library",
+        "//crypto/bls/blst:go_default_library",
+        "//crypto/bls/common:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/eth/service:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
+        "//proto/prysm/v1alpha1: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_prysmaticlabs_go_bitfield//:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+        "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
+    ],
+)
+
+go_binary(
+    name = "light",
+    embed = [":go_default_library"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["client_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+    ],
+)