Fix process atts interval to 0 and 6s of slot

.github/workflows/go.yml

@@ -38,10 +38,10 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Set up Go 1.18
+      - name: Set up Go 1.17
         uses: actions/setup-go@v3
         with:
-          go-version: 1.18
+          go-version: 1.17
       - name: Run Gosec Security Scanner
         run: | # https://github.com/securego/gosec/issues/469
           export PATH=$PATH:$(go env GOPATH)/bin
@@ -55,16 +55,16 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
 
-      - name: Set up Go 1.18
+      - name: Set up Go 1.17
         uses: actions/setup-go@v3
         with:
-          go-version: 1.18
+          go-version: 1.17
           id: go
 
       - name: Golangci-lint
         uses: golangci/golangci-lint-action@v2
         with:
-          args: --print-issued-lines --sort-results --no-config --timeout=10m --disable-all -E deadcode  -E errcheck -E gosimple --skip-files=validator/web/site_data.go --skip-dirs=proto --go=1.18
+          args: --print-issued-lines --sort-results --no-config --timeout=10m --disable-all -E deadcode  -E errcheck -E gosimple --skip-files=validator/web/site_data.go --skip-dirs=proto --go=1.17
           version: v1.45.2
           skip-go-installation: true
 
@@ -75,7 +75,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: 1.18
+          go-version: 1.17
         id: go
 
       - name: Check out code into the Go module directory

beacon-chain/blockchain/chain_info.go

@@ -20,7 +20,7 @@ import (
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
-// directly retrieve chain info related data.
+// directly retrieves chain info related data.
 type ChainInfoFetcher interface {
 	HeadFetcher
 	FinalizationFetcher
@@ -31,12 +31,6 @@ type ChainInfoFetcher interface {
 	HeadDomainFetcher
 }
 
-// HeadUpdater defines a common interface for methods in blockchain service
-// which allow to update the head info
-type HeadUpdater interface {
-	UpdateHead(context.Context) error
-}
-
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
 type TimeFetcher interface {
 	GenesisTime() time.Time
@@ -49,7 +43,7 @@ type GenesisFetcher interface {
 }
 
 // HeadFetcher defines a common interface for methods in blockchain service which
-// directly retrieve head related data.
+// directly retrieves head related data.
 type HeadFetcher interface {
 	HeadSlot() types.Slot
 	HeadRoot(ctx context.Context) ([]byte, error)
@@ -61,6 +55,8 @@ type HeadFetcher interface {
 	HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool)
 	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error)
 	ChainHeads() ([][32]byte, []types.Slot)
+	IsOptimistic(ctx context.Context) (bool, error)
+	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
 	HeadSyncCommitteeFetcher
 	HeadDomainFetcher
 }
@@ -77,7 +73,7 @@ type CanonicalFetcher interface {
 }
 
 // FinalizationFetcher defines a common interface for methods in blockchain service which
-// directly retrieve finalization and justification related data.
+// directly retrieves finalization and justification related data.
 type FinalizationFetcher interface {
 	FinalizedCheckpt() *ethpb.Checkpoint
 	CurrentJustifiedCheckpt() *ethpb.Checkpoint
@@ -85,12 +81,6 @@ type FinalizationFetcher interface {
 	VerifyFinalizedBlkDescendant(ctx context.Context, blockRoot [32]byte) error
 }
 
-// OptimisticModeFetcher retrieves information about optimistic status of the node.
-type OptimisticModeFetcher interface {
-	IsOptimistic(ctx context.Context) (bool, error)
-	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
-}
-
 // FinalizedCheckpt returns the latest finalized checkpoint from chain store.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 	cp := s.store.FinalizedCheckpt()
@@ -242,7 +232,7 @@ func (s *Service) GenesisTime() time.Time {
 	return s.genesisTime
 }
 
-// GenesisValidatorsRoot returns the genesis validators
+// GenesisValidatorsRoot returns the genesis validator
 // root of the chain.
 func (s *Service) GenesisValidatorsRoot() [32]byte {
 	s.headLock.RLock()
@@ -309,7 +299,7 @@ func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.V
 	return v.PublicKey(), nil
 }
 
-// ForkChoicer returns the forkchoice interface.
+// ForkChoicer returns the forkchoice interface
 func (s *Service) ForkChoicer() forkchoice.ForkChoicer {
 	return s.cfg.ForkChoiceStore
 }
@@ -325,7 +315,7 @@ func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
 	return s.IsOptimisticForRoot(ctx, s.head.root)
 }
 
-// IsOptimisticForRoot takes the root as argument instead of the current head
+// IsOptimisticForRoot takes the root and slot as arguments instead of the current head
 // and returns true if it is optimistic.
 func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
 	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(root)
@@ -355,7 +345,7 @@ func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool,
 		return false, nil
 	}
 
-	// Checkpoint root could be zeros before the first finalized epoch. Use genesis root if the case.
+	// checkpoint root could be zeros before the first finalized epoch. Use genesis root if the case.
 	lastValidated, err := s.cfg.BeaconDB.StateSummary(ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(validatedCheckpoint.Root)))
 	if err != nil {
 		return false, err
@@ -373,7 +363,7 @@ func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool,
 		return false, err
 	}
 
-	// Historical non-canonical blocks here are returned as optimistic for safety.
+	// historical non-canonical blocks here are returned as optimistic for safety.
 	return !isCanonical, nil
 }
 
@@ -382,7 +372,7 @@ func (s *Service) SetGenesisTime(t time.Time) {
 	s.genesisTime = t
 }
 
-// ForkChoiceStore returns the fork choice store in the service.
+// ForkChoiceStore returns the fork choice store in the service
 func (s *Service) ForkChoiceStore() forkchoice.ForkChoicer {
 	return s.cfg.ForkChoiceStore
 }

beacon-chain/blockchain/chain_info_test.go

@@ -51,7 +51,7 @@ func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
 
 	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
 	c := setupBeaconChain(t, beaconDB)
-	c.store.SetFinalizedCheckptAndPayloadHash(cp, [32]byte{'a'})
+	c.store.SetFinalizedCheckpt(cp)
 
 	assert.Equal(t, cp.Epoch, c.FinalizedCheckpt().Epoch, "Unexpected finalized epoch")
 }
@@ -62,7 +62,7 @@ func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
 	genesisRoot := [32]byte{'A'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
 	c := setupBeaconChain(t, beaconDB)
-	c.store.SetFinalizedCheckptAndPayloadHash(cp, [32]byte{'a'})
+	c.store.SetFinalizedCheckpt(cp)
 	c.originBlockRoot = genesisRoot
 	assert.DeepEqual(t, c.originBlockRoot[:], c.FinalizedCheckpt().Root)
 }
@@ -73,7 +73,7 @@ func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
 	c := setupBeaconChain(t, beaconDB)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
 	cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
-	c.store.SetJustifiedCheckptAndPayloadHash(cp, [32]byte{})
+	c.store.SetJustifiedCheckpt(cp)
 	assert.Equal(t, cp.Epoch, c.CurrentJustifiedCheckpt().Epoch, "Unexpected justified epoch")
 }
 
@@ -83,7 +83,7 @@ func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 	c := setupBeaconChain(t, beaconDB)
 	genesisRoot := [32]byte{'B'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c.store.SetJustifiedCheckptAndPayloadHash(cp, [32]byte{})
+	c.store.SetJustifiedCheckpt(cp)
 	c.originBlockRoot = genesisRoot
 	assert.DeepEqual(t, c.originBlockRoot[:], c.CurrentJustifiedCheckpt().Root)
 }

beacon-chain/blockchain/execution_engine.go

@@ -31,9 +31,11 @@ var (
 
 // notifyForkchoiceUpdateArg is the argument for the forkchoice update notification `notifyForkchoiceUpdate`.
 type notifyForkchoiceUpdateArg struct {
-	headState state.BeaconState
-	headRoot  [32]byte
-	headBlock interfaces.BeaconBlock
+	headState     state.BeaconState
+	headRoot      [32]byte
+	headBlock     interfaces.BeaconBlock
+	finalizedRoot [32]byte
+	justifiedRoot [32]byte
 }
 
 // notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
@@ -59,12 +61,18 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get execution payload")
 	}
-	finalizedHash := s.store.FinalizedPayloadBlockHash()
-	justifiedHash := s.store.JustifiedPayloadBlockHash()
+	finalizedHash, err := s.getPayloadHash(ctx, arg.finalizedRoot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get finalized block hash")
+	}
+	justifiedHash, err := s.getPayloadHash(ctx, arg.justifiedRoot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get justified block hash")
+	}
 	fcs := &enginev1.ForkchoiceState{
 		HeadBlockHash:      headPayload.BlockHash,
-		SafeBlockHash:      justifiedHash[:],
-		FinalizedBlockHash: finalizedHash[:],
+		SafeBlockHash:      justifiedHash,
+		FinalizedBlockHash: finalizedHash,
 	}
 
 	nextSlot := s.CurrentSlot() + 1 // Cache payload ID for next slot proposer.
@@ -81,11 +89,10 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 			log.WithFields(logrus.Fields{
 				"headSlot":                  headBlk.Slot(),
 				"headPayloadBlockHash":      fmt.Sprintf("%#x", bytesutil.Trunc(headPayload.BlockHash)),
-				"finalizedPayloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash[:])),
+				"finalizedPayloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash)),
 			}).Info("Called fork choice updated with optimistic block")
 			return payloadID, s.optimisticCandidateBlock(ctx, headBlk)
 		case powchain.ErrInvalidPayloadStatus:
-			newPayloadInvalidNodeCount.Inc()
 			headRoot := arg.headRoot
 			invalidRoots, err := s.ForkChoicer().SetOptimisticToInvalid(ctx, headRoot, bytesutil.ToBytes32(headBlk.ParentRoot()), bytesutil.ToBytes32(lastValidHash))
 			if err != nil {
@@ -94,35 +101,12 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 			if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
 				return nil, err
 			}
-
-			r, err := s.updateHead(ctx, s.justifiedBalances.balances)
-			if err != nil {
-				return nil, err
-			}
-			b, err := s.getBlock(ctx, r)
-			if err != nil {
-				return nil, err
-			}
-			st, err := s.cfg.StateGen.StateByRoot(ctx, r)
-			if err != nil {
-				return nil, err
-			}
-			pid, err := s.notifyForkchoiceUpdate(ctx, &notifyForkchoiceUpdateArg{
-				headState: st,
-				headRoot:  r,
-				headBlock: b.Block(),
-			})
-			if err != nil {
-				return nil, err
-			}
-
 			log.WithFields(logrus.Fields{
 				"slot":         headBlk.Slot(),
 				"blockRoot":    fmt.Sprintf("%#x", headRoot),
 				"invalidCount": len(invalidRoots),
 			}).Warn("Pruned invalid blocks")
-			return pid, ErrInvalidPayload
-
+			return nil, ErrInvalidPayload
 		default:
 			return nil, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 		}
@@ -141,19 +125,19 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 
 // getPayloadHash returns the payload hash given the block root.
 // if the block is before bellatrix fork epoch, it returns the zero hash.
-func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, error) {
-	blk, err := s.getBlock(ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(root)))
+func (s *Service) getPayloadHash(ctx context.Context, root [32]byte) ([]byte, error) {
+	finalizedBlock, err := s.getBlock(ctx, s.ensureRootNotZeros(root))
 	if err != nil {
-		return [32]byte{}, err
+		return nil, err
 	}
-	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
-		return params.BeaconConfig().ZeroHash, nil
+	if blocks.IsPreBellatrixVersion(finalizedBlock.Block().Version()) {
+		return params.BeaconConfig().ZeroHash[:], nil
 	}
-	payload, err := blk.Block().Body().ExecutionPayload()
+	payload, err := finalizedBlock.Block().Body().ExecutionPayload()
 	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not get execution payload")
+		return nil, errors.Wrap(err, "could not get execution payload")
 	}
-	return bytesutil.ToBytes32(payload.BlockHash), nil
+	return payload.BlockHash, nil
 }
 
 // notifyForkchoiceUpdate signals execution engine on a new payload.

beacon-chain/blockchain/execution_engine_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
@@ -175,15 +174,12 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			service.cfg.ExecutionEngineCaller = &mockPOW.EngineClient{ErrForkchoiceUpdated: tt.newForkchoiceErr}
 			st, _ := util.DeterministicGenesisState(t, 1)
-			require.NoError(t, beaconDB.SaveState(ctx, st, tt.finalizedRoot))
-			require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, tt.finalizedRoot))
-			fc := &ethpb.Checkpoint{Epoch: 1, Root: tt.finalizedRoot[:]}
-			service.store.SetFinalizedCheckptAndPayloadHash(fc, [32]byte{'a'})
-			service.store.SetJustifiedCheckptAndPayloadHash(fc, [32]byte{'b'})
 			arg := &notifyForkchoiceUpdateArg{
-				headState: st,
-				headRoot:  tt.headRoot,
-				headBlock: tt.blk,
+				headState:     st,
+				headRoot:      tt.headRoot,
+				headBlock:     tt.blk,
+				finalizedRoot: tt.finalizedRoot,
+				justifiedRoot: tt.justifiedRoot,
 			}
 			_, err := service.notifyForkchoiceUpdate(ctx, arg)
 			if tt.errString != "" {
@@ -195,147 +191,6 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 	}
 }
 
-//
-//
-//  A <- B <- C <- D
-//       \
-//         ---------- E <- F
-//                     \
-//                       ------ G
-// D is the current head, attestations for F and G come late, both are invalid.
-// We switch recursively to F then G and finally to D.
-//
-// We test:
-// 1. forkchoice removes blocks F and G from the forkchoice implementation
-// 2. forkchoice removes the weights of these blocks
-// 3. the blockchain package calls fcu to obtain heads G -> F -> D.
-
-func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	// Prepare blocks
-	ba := util.NewBeaconBlockBellatrix()
-	ba.Block.Body.ExecutionPayload.BlockNumber = 1
-	wba, err := wrapper.WrappedSignedBeaconBlock(ba)
-	require.NoError(t, err)
-	bra, err := wba.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wba))
-
-	bb := util.NewBeaconBlockBellatrix()
-	bb.Block.Body.ExecutionPayload.BlockNumber = 2
-	wbb, err := wrapper.WrappedSignedBeaconBlock(bb)
-	require.NoError(t, err)
-	brb, err := wbb.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wbb))
-
-	bc := util.NewBeaconBlockBellatrix()
-	bc.Block.Body.ExecutionPayload.BlockNumber = 3
-	wbc, err := wrapper.WrappedSignedBeaconBlock(bc)
-	require.NoError(t, err)
-	brc, err := wbc.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wbc))
-
-	bd := util.NewBeaconBlockBellatrix()
-	pd := [32]byte{'D'}
-	bd.Block.Body.ExecutionPayload.BlockHash = pd[:]
-	bd.Block.Body.ExecutionPayload.BlockNumber = 4
-	wbd, err := wrapper.WrappedSignedBeaconBlock(bd)
-	require.NoError(t, err)
-	brd, err := wbd.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wbd))
-
-	be := util.NewBeaconBlockBellatrix()
-	pe := [32]byte{'E'}
-	be.Block.Body.ExecutionPayload.BlockHash = pe[:]
-	be.Block.Body.ExecutionPayload.BlockNumber = 5
-	wbe, err := wrapper.WrappedSignedBeaconBlock(be)
-	require.NoError(t, err)
-	bre, err := wbe.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wbe))
-
-	bf := util.NewBeaconBlockBellatrix()
-	pf := [32]byte{'F'}
-	bf.Block.Body.ExecutionPayload.BlockHash = pf[:]
-	bf.Block.Body.ExecutionPayload.BlockNumber = 6
-	bf.Block.ParentRoot = bre[:]
-	wbf, err := wrapper.WrappedSignedBeaconBlock(bf)
-	require.NoError(t, err)
-	brf, err := wbf.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wbf))
-
-	bg := util.NewBeaconBlockBellatrix()
-	bg.Block.Body.ExecutionPayload.BlockNumber = 7
-	pg := [32]byte{'G'}
-	bg.Block.Body.ExecutionPayload.BlockHash = pg[:]
-	bg.Block.ParentRoot = bre[:]
-	wbg, err := wrapper.WrappedSignedBeaconBlock(bg)
-	require.NoError(t, err)
-	brg, err := wbg.Block().HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wbg))
-
-	// Insert blocks into forkchoice
-	fcs := doublylinkedtree.New(0, 0)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-		WithProposerIdsCache(cache.NewProposerPayloadIDsCache()),
-	}
-	service, err := NewService(ctx, opts...)
-	service.justifiedBalances.balances = []uint64{50, 100, 200}
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, 0, 0))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 2, brb, bra, [32]byte{'B'}, 0, 0))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 3, brc, brb, [32]byte{'C'}, 0, 0))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 4, brd, brc, [32]byte{'D'}, 0, 0))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 5, bre, brb, [32]byte{'E'}, 0, 0))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 6, brf, bre, [32]byte{'F'}, 0, 0))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 7, brg, bre, [32]byte{'G'}, 0, 0))
-
-	// Insert Attestations to D, F and G so that they have higher weight than D
-	// Ensure G is head
-	fcs.ProcessAttestation(ctx, []uint64{0}, brd, 1)
-	fcs.ProcessAttestation(ctx, []uint64{1}, brf, 1)
-	fcs.ProcessAttestation(ctx, []uint64{2}, brg, 1)
-	headRoot, err := fcs.Head(ctx, 0, bra, []uint64{50, 100, 200}, 0)
-	require.NoError(t, err)
-	require.Equal(t, brg, headRoot)
-
-	// Prepare Engine Mock to return invalid unless head is D, LVH =  E
-	service.cfg.ExecutionEngineCaller = &mockPOW.EngineClient{ErrForkchoiceUpdated: powchain.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: pe[:], OverrideValidHash: [32]byte{'D'}}
-	st, _ := util.DeterministicGenesisState(t, 1)
-
-	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
-	fc := &ethpb.Checkpoint{Epoch: 0, Root: bra[:]}
-	service.store.SetFinalizedCheckptAndPayloadHash(fc, [32]byte{'a'})
-	service.store.SetJustifiedCheckptAndPayloadHash(fc, [32]byte{'b'})
-	a := &notifyForkchoiceUpdateArg{
-		headState: st,
-		headBlock: wbg.Block(),
-		headRoot:  brg,
-	}
-	_, err = service.notifyForkchoiceUpdate(ctx, a)
-	require.ErrorIs(t, ErrInvalidPayload, err)
-	// Ensure Head is D
-	headRoot, err = fcs.Head(ctx, 0, bra, service.justifiedBalances.balances, 0)
-	require.NoError(t, err)
-	require.Equal(t, brd, headRoot)
-
-	// Ensure F and G where removed but their parent E wasn't
-	require.Equal(t, false, fcs.HasNode(brf))
-	require.Equal(t, false, fcs.HasNode(brg))
-	require.Equal(t, true, fcs.HasNode(bre))
-}
-
 func Test_NotifyNewPayload(t *testing.T) {
 	cfg := params.BeaconConfig()
 	cfg.TerminalTotalDifficulty = "2"
@@ -682,11 +537,11 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 		jRoot, err := tt.justified.Block().HashTreeRoot()
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, tt.justified))
-		service.store.SetJustifiedCheckptAndPayloadHash(
+		service.store.SetJustifiedCheckpt(
 			&ethpb.Checkpoint{
 				Root:  jRoot[:],
 				Epoch: slots.ToEpoch(tt.justified.Block().Slot()),
-			}, [32]byte{'a'})
+			})
 		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrappedParentBlock))
 
 		err = service.optimisticCandidateBlock(ctx, tt.blk)
@@ -948,7 +803,7 @@ func TestService_getPayloadHash(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 
-	_, err = service.getPayloadHash(ctx, []byte{})
+	_, err = service.getPayloadHash(ctx, [32]byte{})
 	require.ErrorIs(t, errBlockNotFoundInCacheOrDB, err)
 
 	b := util.NewBeaconBlock()
@@ -958,20 +813,20 @@ func TestService_getPayloadHash(t *testing.T) {
 	require.NoError(t, err)
 	service.saveInitSyncBlock(r, wsb)
 
-	h, err := service.getPayloadHash(ctx, r[:])
+	h, err := service.getPayloadHash(ctx, r)
 	require.NoError(t, err)
-	require.DeepEqual(t, params.BeaconConfig().ZeroHash, h)
+	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], h)
 
 	bb := util.NewBeaconBlockBellatrix()
-	h = [32]byte{'a'}
-	bb.Block.Body.ExecutionPayload.BlockHash = h[:]
+	h = []byte{'a'}
+	bb.Block.Body.ExecutionPayload.BlockHash = h
 	r, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(bb)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(r, wsb)
 
-	h, err = service.getPayloadHash(ctx, r[:])
+	h, err = service.getPayloadHash(ctx, r)
 	require.NoError(t, err)
-	require.DeepEqual(t, [32]byte{'a'}, h)
+	require.DeepEqual(t, []byte{'a'}, h)
 }

beacon-chain/blockchain/head_test.go

@@ -154,8 +154,8 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r[:]}, [32]byte{'a'})
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{}, [32]byte{'b'})
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{})
 	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{})
 	headRoot, err := service.updateHead(context.Background(), []uint64{})
 	require.NoError(t, err)
@@ -298,8 +298,8 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 		Root:  bellatrixBlkRoot[:],
 		Epoch: 1,
 	}
-	service.store.SetFinalizedCheckptAndPayloadHash(fcp, [32]byte{'a'})
-	service.store.SetJustifiedCheckptAndPayloadHash(fcp, [32]byte{'b'})
+	service.store.SetFinalizedCheckpt(fcp)
+	service.store.SetJustifiedCheckpt(fcp)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bellatrixBlkRoot))
 
 	bellatrixState, _ := util.DeterministicGenesisStateBellatrix(t, 2)

beacon-chain/blockchain/mock_test.go

@@ -21,7 +21,7 @@ func testServiceOptsWithDB(t *testing.T) []Option {
 	}
 }
 
-// WARNING: only use these opts when you are certain there are no db calls
+// 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 {

beacon-chain/blockchain/new_slot.go

@@ -64,11 +64,7 @@ func (s *Service) NewSlot(ctx context.Context, slot types.Slot) error {
 			return err
 		}
 		if bytes.Equal(r, f.Root) {
-			h, err := s.getPayloadHash(ctx, bj.Root)
-			if err != nil {
-				return err
-			}
-			s.store.SetJustifiedCheckptAndPayloadHash(bj, h)
+			s.store.SetJustifiedCheckpt(bj)
 		}
 	}
 	return nil

beacon-chain/blockchain/process_attestation_test.go

@@ -324,9 +324,9 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	r := [32]byte{'g'}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, r))
 
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r[:]}, [32]byte{'a'})
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r[:]}, [32]byte{'b'})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 	service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 
 	r = bytesutil.ToBytes32([]byte{'A'})
@@ -358,9 +358,9 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
 
 	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r[:]}, [32]byte{'a'})
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r[:]}, [32]byte{'b'})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 	service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'C'})))
@@ -500,7 +500,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 1}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
@@ -535,7 +535,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 1}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
@@ -564,7 +564,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r32[:], Epoch: 1}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r32[:], Epoch: 1})
 
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
@@ -591,7 +591,7 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r32[:], Epoch: 1}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r32[:], Epoch: 1})
 
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33

beacon-chain/blockchain/process_block.go

@@ -123,13 +123,11 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 			return err
 		}
 	}
-	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState); err != nil {
-		return err
-	}
+
 	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, signed.Block(), blockRoot, postState); err != nil {
 		return errors.Wrapf(err, "could not insert block %d to fork choice store", signed.Block().Slot())
 	}
-	s.insertSlashingsToForkChoiceStore(ctx, signed.Block().Body().AttesterSlashings())
+	s.insertSlashingsToForkChoiceStore(ctx, signed.Block())
 	if isValidPayload {
 		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, blockRoot); err != nil {
 			return errors.Wrap(err, "could not set optimistic block to valid")
@@ -148,6 +146,9 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		return err
 	}
 
+	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState); err != nil {
+		return err
+	}
 	// If slasher is configured, forward the attestations in the block via
 	// an event feed for processing.
 	if features.Get().EnableSlasher {
@@ -194,19 +195,9 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	newFinalized := postState.FinalizedCheckpointEpoch() > finalized.Epoch
 	if newFinalized {
 		s.store.SetPrevFinalizedCheckpt(finalized)
-		cp := postState.FinalizedCheckpoint()
-		h, err := s.getPayloadHash(ctx, cp.Root)
-		if err != nil {
-			return err
-		}
-		s.store.SetFinalizedCheckptAndPayloadHash(cp, h)
+		s.store.SetFinalizedCheckpt(postState.FinalizedCheckpoint())
 		s.store.SetPrevJustifiedCheckpt(justified)
-		cp = postState.CurrentJustifiedCheckpoint()
-		h, err = s.getPayloadHash(ctx, cp.Root)
-		if err != nil {
-			return err
-		}
-		s.store.SetJustifiedCheckptAndPayloadHash(postState.CurrentJustifiedCheckpoint(), h)
+		s.store.SetJustifiedCheckpt(postState.CurrentJustifiedCheckpoint())
 	}
 
 	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(justified.Root))
@@ -422,10 +413,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 			}
 		}
 		s.saveInitSyncBlock(blockRoots[i], b)
-		if err = s.handleBlockAfterBatchVerify(ctx, b, blockRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
-			tracing.AnnotateError(span, err)
-			return nil, nil, err
-		}
 	}
 
 	for r, st := range boundaries {
@@ -439,10 +426,14 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
 		return nil, nil, err
 	}
+	f := fCheckpoints[len(fCheckpoints)-1]
+	j := jCheckpoints[len(jCheckpoints)-1]
 	arg := &notifyForkchoiceUpdateArg{
-		headState: preState,
-		headRoot:  lastBR,
-		headBlock: lastB.Block(),
+		headState:     preState,
+		headRoot:      lastBR,
+		headBlock:     lastB.Block(),
+		finalizedRoot: bytesutil.ToBytes32(f.Root),
+		justifiedRoot: bytesutil.ToBytes32(j.Root),
 	}
 	if _, err := s.notifyForkchoiceUpdate(ctx, arg); err != nil {
 		return nil, nil, err
@@ -493,11 +484,7 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed interf
 			return err
 		}
 		s.store.SetPrevFinalizedCheckpt(finalized)
-		h, err := s.getPayloadHash(ctx, fCheckpoint.Root)
-		if err != nil {
-			return err
-		}
-		s.store.SetFinalizedCheckptAndPayloadHash(fCheckpoint, h)
+		s.store.SetFinalizedCheckpt(fCheckpoint)
 	}
 	return nil
 }
@@ -508,15 +495,15 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 	defer span.End()
 
 	if postState.Slot()+1 == s.nextEpochBoundarySlot {
+		// Update caches for the next epoch at epoch boundary slot - 1.
+		if err := helpers.UpdateCommitteeCache(postState, coreTime.NextEpoch(postState)); err != nil {
+			return err
+		}
 		copied := postState.Copy()
 		copied, err := transition.ProcessSlots(ctx, copied, copied.Slot()+1)
 		if err != nil {
 			return err
 		}
-		// Update caches for the next epoch at epoch boundary slot - 1.
-		if err := helpers.UpdateCommitteeCache(copied, coreTime.CurrentEpoch(copied)); err != nil {
-			return err
-		}
 		if err := helpers.UpdateProposerIndicesInCache(ctx, copied); err != nil {
 			return err
 		}
@@ -589,7 +576,8 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk interfac
 
 // Inserts attester slashing indices to fork choice store.
 // To call this function, it's caller's responsibility to ensure the slashing object is valid.
-func (s *Service) insertSlashingsToForkChoiceStore(ctx context.Context, slashings []*ethpb.AttesterSlashing) {
+func (s *Service) insertSlashingsToForkChoiceStore(ctx context.Context, blk interfaces.BeaconBlock) {
+	slashings := blk.Body().AttesterSlashings()
 	for _, slashing := range slashings {
 		indices := blocks.SlashableAttesterIndices(slashing)
 		for _, index := range indices {

beacon-chain/blockchain/process_block_helpers.go

@@ -208,11 +208,7 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 			return errNilJustifiedInStore
 		}
 		s.store.SetPrevJustifiedCheckpt(justified)
-		h, err := s.getPayloadHash(ctx, cpt.Root)
-		if err != nil {
-			return err
-		}
-		s.store.SetJustifiedCheckptAndPayloadHash(cpt, h)
+		s.store.SetJustifiedCheckpt(cpt)
 	}
 
 	return nil
@@ -231,11 +227,7 @@ func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpo
 	if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cp); err != nil {
 		return err
 	}
-	h, err := s.getPayloadHash(ctx, cp.Root)
-	if err != nil {
-		return err
-	}
-	s.store.SetJustifiedCheckptAndPayloadHash(cp, h)
+	s.store.SetJustifiedCheckpt(cp)
 
 	return nil
 }

beacon-chain/blockchain/process_block_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"math/big"
 	"strconv"
-	"sync"
 	"testing"
 	"time"
 
@@ -40,7 +39,6 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
-	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 func TestStore_OnBlock_ProtoArray(t *testing.T) {
@@ -131,9 +129,9 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: validGenesisRoot[:]}, [32]byte{'a'})
+			service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
 			service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
-			service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: roots[0]}, [32]byte{'b'})
+			service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: roots[0]})
 			service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
 
 			root, err := tt.blk.Block.HashTreeRoot()
@@ -234,9 +232,9 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: validGenesisRoot[:]}, [32]byte{'a'})
+			service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
 			service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
-			service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: roots[0]}, [32]byte{'b'})
+			service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: roots[0]})
 			service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
 
 			root, err := tt.blk.Block.HashTreeRoot()
@@ -291,8 +289,7 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
@@ -356,8 +353,7 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
@@ -419,9 +415,7 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
-
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	service.saveInitSyncBlock(gRoot, wsb)
 	st, keys := util.DeterministicGenesisState(t, 64)
@@ -490,7 +484,7 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]}, [32]byte{'a'})
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]})
 	update, err = service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
 	require.NoError(t, err)
 	assert.Equal(t, true, update, "Should be able to update justified")
@@ -522,7 +516,7 @@ func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]}, [32]byte{'a'})
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]})
 
 	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
 	require.NoError(t, err)
@@ -555,7 +549,7 @@ func TestShouldUpdateJustified_ReturnFalse_DoublyLinkedTree(t *testing.T) {
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]}, [32]byte{'a'})
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]})
 
 	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
 	require.NoError(t, err)
@@ -583,7 +577,7 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
@@ -620,7 +614,7 @@ func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
@@ -654,7 +648,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
@@ -662,7 +656,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	wb, err := wrapper.WrappedBeaconBlock(b.Block)
 	require.NoError(t, err)
 	err = service.verifyBlkPreState(ctx, wb)
@@ -697,7 +691,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	r, err := signedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: []byte{'A'}}, [32]byte{'a'})
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}})
 	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}})
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -729,7 +723,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: make([]byte, 32)}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -774,7 +768,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: make([]byte, 32)}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -820,7 +814,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: make([]byte, 32)}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -869,7 +863,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: make([]byte, 32)}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -919,7 +913,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	// Set finalized epoch to 1.
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 1}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -980,7 +974,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	// Set finalized epoch to 1.
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 1}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -1356,7 +1350,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	for _, tt := range tests {
 		service, err := NewService(ctx, opts...)
 		require.NoError(t, err)
-		service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: tt.args.finalizedRoot[:]}, [32]byte{})
+		service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: tt.args.finalizedRoot[:]})
 		err = service.VerifyFinalizedBlkDescendant(ctx, tt.args.parentRoot)
 		if tt.wantedErr != "" {
 			assert.ErrorContains(t, tt.wantedErr, err)
@@ -1384,7 +1378,7 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, beaconState, gRoot))
 	service.originBlockRoot = gRoot
 	currentCp := &ethpb.Checkpoint{Epoch: 1}
-	service.store.SetJustifiedCheckptAndPayloadHash(currentCp, [32]byte{'a'})
+	service.store.SetJustifiedCheckpt(currentCp)
 	newCp := &ethpb.Checkpoint{Epoch: 2, Root: gRoot[:]}
 
 	require.NoError(t, service.updateJustifiedInitSync(ctx, newCp))
@@ -1445,7 +1439,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 
 	testState := gs.Copy()
 	for i := types.Slot(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
@@ -1499,7 +1493,7 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 
 	testState := gs.Copy()
 	for i := types.Slot(1); i < params.BeaconConfig().SlotsPerEpoch; i++ {
@@ -1530,7 +1524,7 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	gs = gs.Copy()
 	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 10}))
 	assert.NoError(t, gs.SetEth1DepositIndex(8))
@@ -1569,7 +1563,7 @@ func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	gs = gs.Copy()
 	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 7}))
 	assert.NoError(t, gs.SetEth1DepositIndex(6))
@@ -1891,84 +1885,5 @@ func TestService_insertSlashingsToForkChoiceStore(t *testing.T) {
 	b.Block.Body.AttesterSlashings = slashings
 	wb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
-	service.insertSlashingsToForkChoiceStore(ctx, wb.Block().Body().AttesterSlashings())
-}
-
-func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	depositCache, err := depositcache.New()
-	require.NoError(t, err)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-		WithDepositCache(depositCache),
-		WithStateNotifier(&mock.MockStateNotifier{}),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	gs, keys := util.DeterministicGenesisState(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-	gBlk, err := service.cfg.BeaconDB.GenesisBlock(ctx)
-	require.NoError(t, err)
-	gRoot, err := gBlk.Block().HashTreeRoot()
-	require.NoError(t, err)
-	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
-
-	blk1, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 1)
-	require.NoError(t, err)
-	r1, err := blk1.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb1, err := wrapper.WrappedSignedBeaconBlock(blk1)
-	require.NoError(t, err)
-	blk2, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 2)
-	require.NoError(t, err)
-	r2, err := blk2.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb2, err := wrapper.WrappedSignedBeaconBlock(blk2)
-	require.NoError(t, err)
-	blk3, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 3)
-	require.NoError(t, err)
-	r3, err := blk3.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb3, err := wrapper.WrappedSignedBeaconBlock(blk3)
-	require.NoError(t, err)
-	blk4, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 4)
-	require.NoError(t, err)
-	r4, err := blk4.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb4, err := wrapper.WrappedSignedBeaconBlock(blk4)
-	require.NoError(t, err)
-
-	logHook := logTest.NewGlobal()
-	for i := 0; i < 10; i++ {
-		var wg sync.WaitGroup
-		wg.Add(4)
-		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb1, r1))
-			wg.Done()
-		}()
-		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb2, r2))
-			wg.Done()
-		}()
-		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb3, r3))
-			wg.Done()
-		}()
-		go func() {
-			require.NoError(t, service.onBlock(ctx, wsb4, r4))
-			wg.Done()
-		}()
-		wg.Wait()
-		require.LogsDoNotContain(t, logHook, "New head does not exist in DB. Do nothing")
-		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r1))
-		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r2))
-		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r3))
-		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r4))
-		service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'a'})
-	}
+	service.insertSlashingsToForkChoiceStore(ctx, wb.Block())
 }

beacon-chain/blockchain/receive_attestation.go

@@ -117,7 +117,7 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 			log.Warn("Genesis time received, now available to process attestations")
 		}
 
-		st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+		st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot/2)
 		for {
 			select {
 			case <-s.ctx.Done():
@@ -128,55 +128,42 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 					return
 				}
 
-				if err := s.UpdateHead(s.ctx); err != nil {
-					log.WithError(err).Error("Could not process attestations and update head")
-					return
+				// Continue when there's no fork choice attestation, there's nothing to process and update head.
+				// This covers the condition when the node is still initial syncing to the head of the chain.
+				if s.cfg.AttPool.ForkchoiceAttestationCount() == 0 {
+					continue
 				}
+				s.processAttestations(s.ctx)
+
+				justified := s.store.JustifiedCheckpt()
+				if justified == nil {
+					log.WithError(errNilJustifiedInStore).Error("Could not get justified checkpoint")
+					continue
+				}
+				balances, err := s.justifiedBalances.get(s.ctx, bytesutil.ToBytes32(justified.Root))
+				if err != nil {
+					log.WithError(err).Errorf("Unable to get justified balances for root %v", justified.Root)
+					continue
+				}
+				newHeadRoot, err := s.updateHead(s.ctx, balances)
+				if err != nil {
+					log.WithError(err).Warn("Resolving fork due to new attestation")
+				}
+				if s.headRoot() != newHeadRoot {
+					log.WithFields(logrus.Fields{
+						"oldHeadRoot": fmt.Sprintf("%#x", s.headRoot()),
+						"newHeadRoot": fmt.Sprintf("%#x", newHeadRoot),
+					}).Debug("Head changed due to attestations")
+				}
+				s.notifyEngineIfChangedHead(s.ctx, newHeadRoot)
 			}
 		}
 	}()
 }
 
-// UpdateHead updates the canonical head of the chain based on information from fork-choice attestations and votes.
-// It requires no external inputs.
-func (s *Service) UpdateHead(ctx context.Context) error {
-	// Continue when there's no fork choice attestation, there's nothing to process and update head.
-	// This covers the condition when the node is still initial syncing to the head of the chain.
-	if s.cfg.AttPool.ForkchoiceAttestationCount() == 0 {
-		return nil
-	}
-
-	// Only one process can process attestations and update head at a time.
-	s.processAttestationsLock.Lock()
-	defer s.processAttestationsLock.Unlock()
-
-	s.processAttestations(ctx)
-
-	justified := s.store.JustifiedCheckpt()
-	if justified == nil {
-		return errNilJustifiedInStore
-	}
-	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(justified.Root))
-	if err != nil {
-		return err
-	}
-	newHeadRoot, err := s.updateHead(ctx, balances)
-	if err != nil {
-		log.WithError(err).Warn("Resolving fork due to new attestation")
-	}
-	if s.headRoot() != newHeadRoot {
-		log.WithFields(logrus.Fields{
-			"oldHeadRoot": fmt.Sprintf("%#x", s.headRoot()),
-			"newHeadRoot": fmt.Sprintf("%#x", newHeadRoot),
-		}).Debug("Head changed due to attestations")
-	}
-	s.notifyEngineIfChangedHead(ctx, newHeadRoot)
-	return nil
-}
-
 // This calls notify Forkchoice Update in the event that the head has changed
 func (s *Service) notifyEngineIfChangedHead(ctx context.Context, newHeadRoot [32]byte) {
-	if newHeadRoot == [32]byte{} || s.headRoot() == newHeadRoot {
+	if s.headRoot() == newHeadRoot {
 		return
 	}
 
@@ -185,6 +172,12 @@ func (s *Service) notifyEngineIfChangedHead(ctx context.Context, newHeadRoot [32
 		return // We don't have the block, don't notify the engine and update head.
 	}
 
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		log.WithError(errNilFinalizedInStore).Error("could not get finalized checkpoint")
+		return
+	}
+
 	newHeadBlock, err := s.getBlock(ctx, newHeadRoot)
 	if err != nil {
 		log.WithError(err).Error("Could not get new head block")
@@ -196,9 +189,11 @@ func (s *Service) notifyEngineIfChangedHead(ctx context.Context, newHeadRoot [32
 		return
 	}
 	arg := &notifyForkchoiceUpdateArg{
-		headState: headState,
-		headRoot:  newHeadRoot,
-		headBlock: newHeadBlock.Block(),
+		headState:     headState,
+		headRoot:      newHeadRoot,
+		headBlock:     newHeadBlock.Block(),
+		finalizedRoot: bytesutil.ToBytes32(finalized.Root),
+		justifiedRoot: bytesutil.ToBytes32(s.store.JustifiedCheckpt().Root),
 	}
 	_, err = s.notifyForkchoiceUpdate(s.ctx, arg)
 	if err != nil {

beacon-chain/blockchain/receive_attestation_test.go

@@ -137,14 +137,14 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 	service.cfg.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
 	service.notifyEngineIfChangedHead(ctx, service.headRoot())
 	hookErr := "could not notify forkchoice update"
-	invalidStateErr := "Could not get state from db"
-	require.LogsDoNotContain(t, hook, invalidStateErr)
+	finalizedErr := "could not get finalized checkpoint"
+	require.LogsDoNotContain(t, hook, finalizedErr)
 	require.LogsDoNotContain(t, hook, hookErr)
 	gb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	service.saveInitSyncBlock([32]byte{'a'}, gb)
 	service.notifyEngineIfChangedHead(ctx, [32]byte{'a'})
-	require.LogsContain(t, hook, invalidStateErr)
+	require.LogsContain(t, hook, finalizedErr)
 
 	hook.Reset()
 	service.head = &head{
@@ -169,9 +169,9 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 		state: st,
 	}
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1})
-	service.store.SetFinalizedCheckptAndPayloadHash(finalized, [32]byte{})
+	service.store.SetFinalizedCheckpt(finalized)
 	service.notifyEngineIfChangedHead(ctx, r1)
-	require.LogsDoNotContain(t, hook, invalidStateErr)
+	require.LogsDoNotContain(t, hook, finalizedErr)
 	require.LogsDoNotContain(t, hook, hookErr)
 
 	// Block in DB
@@ -191,51 +191,12 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 		state: st,
 	}
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1})
-	service.store.SetFinalizedCheckptAndPayloadHash(finalized, [32]byte{})
+	service.store.SetFinalizedCheckpt(finalized)
 	service.notifyEngineIfChangedHead(ctx, r1)
-	require.LogsDoNotContain(t, hook, invalidStateErr)
+	require.LogsDoNotContain(t, hook, finalizedErr)
 	require.LogsDoNotContain(t, hook, hookErr)
 	vId, payloadID, has := service.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(2)
 	require.Equal(t, true, has)
 	require.Equal(t, types.ValidatorIndex(1), vId)
 	require.Equal(t, [8]byte{1}, payloadID)
-
-	// Test zero headRoot returns immediately.
-	headRoot := service.headRoot()
-	service.notifyEngineIfChangedHead(ctx, [32]byte{})
-	require.Equal(t, service.headRoot(), headRoot)
-}
-
-func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
-	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-	opts = append(opts, WithAttestationPool(attestations.NewPool()), WithStateNotifier(&mockBeaconNode{}))
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	service.genesisTime = prysmTime.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
-	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	require.NoError(t, genesisState.SetGenesisTime(uint64(prysmTime.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
-	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	atts, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
-	require.NoError(t, err)
-	tRoot := bytesutil.ToBytes32(atts[0].Data.Target.Root)
-	copied := genesisState.Copy()
-	copied, err = transition.ProcessSlots(ctx, copied, 1)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: tRoot[:]}))
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
-	b := util.NewBeaconBlock()
-	wb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wb))
-	service.head.root = r // Old head
-	require.Equal(t, 1, len(service.cfg.AttPool.ForkchoiceAttestations()))
-	require.NoError(t, err, service.UpdateHead(ctx))
-	require.Equal(t, tRoot, service.head.root)                             // Validate head is the new one
-	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations())) // Validate att pool is empty
 }

beacon-chain/blockchain/receive_block.go

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
@@ -25,14 +24,9 @@ type BlockReceiver interface {
 	HasBlock(ctx context.Context, root [32]byte) bool
 }
 
-// SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
-type SlashingReceiver interface {
-	ReceiveAttesterSlashing(ctx context.Context, slashings *ethpb.AttesterSlashing)
-}
-
-// ReceiveBlock is a function that defines the operations (minus pubsub)
-// that are performed on a received block. The operations consist of:
-//   1. Validate block, apply state transition and update checkpoints
+// ReceiveBlock is a function that defines the the operations (minus pubsub)
+// that are performed on blocks that is received from regular sync service. The operations consists of:
+//   1. Validate block, apply state transition and update check points
 //   2. Apply fork choice to the processed block
 //   3. Save latest head info
 func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, blockRoot [32]byte) error {
@@ -85,7 +79,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 	defer span.End()
 
 	// Apply state transition on the incoming newly received block batches, one by one.
-	_, _, err := s.onBlockBatch(ctx, blocks, blkRoots)
+	fCheckpoints, jCheckpoints, err := s.onBlockBatch(ctx, blocks, blkRoots)
 	if err != nil {
 		err := errors.Wrap(err, "could not process block in batch")
 		tracing.AnnotateError(span, err)
@@ -94,6 +88,10 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 
 	for i, b := range blocks {
 		blockCopy := b.Copy()
+		if err = s.handleBlockAfterBatchVerify(ctx, blockCopy, blkRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
+			tracing.AnnotateError(span, err)
+			return err
+		}
 		// Send notification of the processed block to the state feed.
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.BlockProcessed,
@@ -135,11 +133,6 @@ func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
 	return s.hasBlockInInitSyncOrDB(ctx, root)
 }
 
-// ReceiveAttesterSlashing receives an attester slashing and inserts it to forkchoice
-func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) {
-	s.insertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
-}
-
 func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {
 	// Delete the processed block attestations from attestation pool.
 	if err := s.deletePoolAtts(b.Body().Attestations()); err != nil {

beacon-chain/blockchain/receive_block_test.go

@@ -141,8 +141,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 			require.NoError(t, err)
 			gRoot, err := gBlk.Block().HashTreeRoot()
 			require.NoError(t, err)
-			h := [32]byte{'a'}
-			s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, h)
+			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
 			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
@@ -182,7 +181,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wg := sync.WaitGroup{}
@@ -263,7 +262,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 
 			gRoot, err := gBlk.Block().HashTreeRoot()
 			require.NoError(t, err)
-			s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
+			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
 			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
@@ -313,7 +312,7 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 	require.NoError(t, err)
 	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
 	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{}, [32]byte{})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{})
 
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	assert.LogsContain(t, hook, "Entering mode to save hot states in DB")
@@ -324,7 +323,7 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	s, err := NewService(context.Background(), opts...)
 	require.NoError(t, err)
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{}, [32]byte{})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{})
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	s.genesisTime = time.Now()
 
@@ -337,7 +336,7 @@ func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	s, err := NewService(context.Background(), opts...)
 	require.NoError(t, err)
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{}, [32]byte{})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 10000000})
 	s.genesisTime = time.Now()
 
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))

beacon-chain/blockchain/service.go

@@ -50,22 +50,21 @@ const headSyncMinEpochsAfterCheckpoint = 128
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                     *config
-	ctx                     context.Context
-	cancel                  context.CancelFunc
-	genesisTime             time.Time
-	head                    *head
-	headLock                sync.RWMutex
-	originBlockRoot         [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	nextEpochBoundarySlot   types.Slot
-	boundaryRoots           [][32]byte
-	checkpointStateCache    *cache.CheckpointStateCache
-	initSyncBlocks          map[[32]byte]interfaces.SignedBeaconBlock
-	initSyncBlocksLock      sync.RWMutex
-	justifiedBalances       *stateBalanceCache
-	wsVerifier              *WeakSubjectivityVerifier
-	store                   *store.Store
-	processAttestationsLock sync.Mutex
+	cfg                   *config
+	ctx                   context.Context
+	cancel                context.CancelFunc
+	genesisTime           time.Time
+	head                  *head
+	headLock              sync.RWMutex
+	originBlockRoot       [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
+	nextEpochBoundarySlot types.Slot
+	boundaryRoots         [][32]byte
+	checkpointStateCache  *cache.CheckpointStateCache
+	initSyncBlocks        map[[32]byte]interfaces.SignedBeaconBlock
+	initSyncBlocksLock    sync.RWMutex
+	justifiedBalances     *stateBalanceCache
+	wsVerifier            *WeakSubjectivityVerifier
+	store                 *store.Store
 }
 
 // config options for the service.
@@ -144,7 +143,6 @@ func (s *Service) Stop() error {
 	defer s.cancel()
 
 	if s.cfg.StateGen != nil && s.head != nil && s.head.state != nil {
-		// Save the last finalized state so that starting up in the following run will be much faster.
 		if err := s.cfg.StateGen.ForceCheckpoint(s.ctx, s.head.state.FinalizedCheckpoint().Root); err != nil {
 			return err
 		}

beacon-chain/blockchain/service_test.go

@@ -221,8 +221,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 	require.NoError(t, err)
 	trie, _, err := util.DepositTrieFromDeposits(deposits)
 	require.NoError(t, err)
-	hashTreeRoot, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	hashTreeRoot := trie.HashTreeRoot()
 	genState, err := transition.EmptyGenesisState()
 	require.NoError(t, err)
 	err = genState.SetEth1Data(&ethpb.Eth1Data{
@@ -501,7 +500,7 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
 		cfg:   &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
 	b := util.NewBeaconBlock()
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -522,7 +521,7 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(0, 0), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
 	b := util.NewBeaconBlock()
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -595,7 +594,7 @@ func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
 		cfg:   &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
 	blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
 	r, err := blk.Block.HashTreeRoot()
 	require.NoError(b, err)
@@ -618,7 +617,7 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(0, 0), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
-	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
 	blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
 	r, err := blk.Block.HashTreeRoot()
 	require.NoError(b, err)

beacon-chain/blockchain/state_balance_cache.go

@@ -37,7 +37,7 @@ func newStateBalanceCache(sg *stategen.State) (*stateBalanceCache, error) {
 // 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
+// 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)

beacon-chain/blockchain/store/setter_getter.go

@@ -23,13 +23,6 @@ func (s *Store) JustifiedCheckpt() *ethpb.Checkpoint {
 	return s.justifiedCheckpt
 }
 
-// JustifiedPayloadBlockHash returns the justified payload block hash reflecting justified check point.
-func (s *Store) JustifiedPayloadBlockHash() [32]byte {
-	s.RLock()
-	defer s.RUnlock()
-	return s.justifiedPayloadBlockHash
-}
-
 // PrevFinalizedCheckpt returns the previous finalized checkpoint in the Store.
 func (s *Store) PrevFinalizedCheckpt() *ethpb.Checkpoint {
 	s.RLock()
@@ -44,13 +37,6 @@ func (s *Store) FinalizedCheckpt() *ethpb.Checkpoint {
 	return s.finalizedCheckpt
 }
 
-// FinalizedPayloadBlockHash returns the finalized payload block hash reflecting finalized check point.
-func (s *Store) FinalizedPayloadBlockHash() [32]byte {
-	s.RLock()
-	defer s.RUnlock()
-	return s.finalizedPayloadBlockHash
-}
-
 // SetPrevJustifiedCheckpt sets the previous justified checkpoint in the Store.
 func (s *Store) SetPrevJustifiedCheckpt(cp *ethpb.Checkpoint) {
 	s.Lock()
@@ -65,20 +51,18 @@ func (s *Store) SetBestJustifiedCheckpt(cp *ethpb.Checkpoint) {
 	s.bestJustifiedCheckpt = cp
 }
 
-// SetJustifiedCheckptAndPayloadHash sets the justified checkpoint and blockhash in the Store.
-func (s *Store) SetJustifiedCheckptAndPayloadHash(cp *ethpb.Checkpoint, h [32]byte) {
+// SetJustifiedCheckpt sets the justified checkpoint in the Store.
+func (s *Store) SetJustifiedCheckpt(cp *ethpb.Checkpoint) {
 	s.Lock()
 	defer s.Unlock()
 	s.justifiedCheckpt = cp
-	s.justifiedPayloadBlockHash = h
 }
 
-// SetFinalizedCheckptAndPayloadHash sets the finalized checkpoint and blockhash in the Store.
-func (s *Store) SetFinalizedCheckptAndPayloadHash(cp *ethpb.Checkpoint, h [32]byte) {
+// SetFinalizedCheckpt sets the finalized checkpoint in the Store.
+func (s *Store) SetFinalizedCheckpt(cp *ethpb.Checkpoint) {
 	s.Lock()
 	defer s.Unlock()
 	s.finalizedCheckpt = cp
-	s.finalizedPayloadBlockHash = h
 }
 
 // SetPrevFinalizedCheckpt sets the previous finalized checkpoint in the Store.

beacon-chain/blockchain/store/setter_getter_test.go

@@ -30,10 +30,8 @@ func Test_store_JustifiedCheckpt(t *testing.T) {
 	var cp *ethpb.Checkpoint
 	require.Equal(t, cp, s.JustifiedCheckpt())
 	cp = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}}
-	h := [32]byte{'b'}
-	s.SetJustifiedCheckptAndPayloadHash(cp, h)
+	s.SetJustifiedCheckpt(cp)
 	require.Equal(t, cp, s.JustifiedCheckpt())
-	require.Equal(t, h, s.JustifiedPayloadBlockHash())
 }
 
 func Test_store_FinalizedCheckpt(t *testing.T) {
@@ -41,10 +39,8 @@ func Test_store_FinalizedCheckpt(t *testing.T) {
 	var cp *ethpb.Checkpoint
 	require.Equal(t, cp, s.FinalizedCheckpt())
 	cp = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}}
-	h := [32]byte{'b'}
-	s.SetFinalizedCheckptAndPayloadHash(cp, h)
+	s.SetFinalizedCheckpt(cp)
 	require.Equal(t, cp, s.FinalizedCheckpt())
-	require.Equal(t, h, s.FinalizedPayloadBlockHash())
 }
 
 func Test_store_PrevFinalizedCheckpt(t *testing.T) {

beacon-chain/blockchain/store/type.go

@@ -17,11 +17,9 @@ import (
 //    best_justified_checkpoint: Checkpoint
 //    proposerBoostRoot: Root
 type Store struct {
-	justifiedCheckpt          *ethpb.Checkpoint
-	justifiedPayloadBlockHash [32]byte
-	finalizedCheckpt          *ethpb.Checkpoint
-	finalizedPayloadBlockHash [32]byte
-	bestJustifiedCheckpt      *ethpb.Checkpoint
+	justifiedCheckpt     *ethpb.Checkpoint
+	finalizedCheckpt     *ethpb.Checkpoint
+	bestJustifiedCheckpt *ethpb.Checkpoint
 	sync.RWMutex
 	// These are not part of the consensus spec, but we do use them to return gRPC API requests.
 	// TODO(10094): Consider removing in v3.

beacon-chain/blockchain/testing/mock.go

@@ -450,9 +450,3 @@ func (s *ChainService) IsOptimistic(_ context.Context) (bool, error) {
 func (s *ChainService) IsOptimisticForRoot(_ context.Context, _ [32]byte) (bool, error) {
 	return s.Optimistic, nil
 }
-
-// ProcessAttestationsAndUpdateHead mocks the same method in the chain service.
-func (s *ChainService) UpdateHead(_ context.Context) error { return nil }
-
-// ReceiveAttesterSlashing mocks the same method in the chain service.
-func (s *ChainService) ReceiveAttesterSlashing(context.Context, *ethpb.AttesterSlashing) {}

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -79,7 +79,7 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 				store:      &store.Store{},
 				wsVerifier: wv,
 			}
-			s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: tt.finalizedEpoch}, [32]byte{})
+			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: tt.finalizedEpoch})
 			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), s.store.FinalizedCheckpt().Epoch)
 			if tt.wantErr == nil {
 				require.NoError(t, err)

beacon-chain/cache/depositcache/deposits_cache_test.go

@@ -430,11 +430,7 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 	}
 	trie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate deposit trie")
-	rootA, err := trie.HashTreeRoot()
-	require.NoError(t, err)
-	rootB, err := cachedDeposits.Deposits.HashTreeRoot()
-	require.NoError(t, err)
-	assert.Equal(t, rootA, rootB)
+	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
 }
 
 func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
@@ -492,11 +488,7 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 	}
 	trie, err := trie.GenerateTrieFromItems(deps, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err, "Could not generate deposit trie")
-	rootA, err := trie.HashTreeRoot()
-	require.NoError(t, err)
-	rootB, err := cachedDeposits.Deposits.HashTreeRoot()
-	require.NoError(t, err)
-	assert.Equal(t, rootA, rootB)
+	assert.Equal(t, trie.HashTreeRoot(), cachedDeposits.Deposits.HashTreeRoot())
 }
 
 func TestFinalizedDeposits_HandleZeroDeposits(t *testing.T) {

beacon-chain/core/altair/BUILD.bazel

@@ -16,7 +16,6 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/altair",
     visibility = [
         "//beacon-chain:__subpackages__",
-        "//testing/endtoend/evaluators:__subpackages__",
         "//testing/spectest:__subpackages__",
         "//testing/util:__pkg__",
         "//validator/client:__pkg__",

beacon-chain/core/altair/deposit_test.go

@@ -143,8 +143,7 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 		},
 	}
 	balances := []uint64{0, 50}
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
+	root := depositTrie.HashTreeRoot()
 	beaconState, err := stateAltair.InitializeFromProto(&ethpb.BeaconStateAltair{
 		Validators: registry,
 		Balances:   balances,
@@ -203,8 +202,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 	dep[0].Data.Signature = make([]byte, 96)
 	trie, _, err := util.DepositTrieFromDeposits(dep)
 	require.NoError(t, err)
-	root, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	root := trie.HashTreeRoot()
 	eth1Data := &ethpb.Eth1Data{
 		DepositRoot:  root[:],
 		DepositCount: 1,

beacon-chain/core/blocks/deposit_test.go

@@ -173,8 +173,7 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 		},
 	}
 	balances := []uint64{0, 50}
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
+	root := depositTrie.HashTreeRoot()
 	beaconState, err := v1.InitializeFromProto(&ethpb.BeaconState{
 		Validators: registry,
 		Balances:   balances,
@@ -234,8 +233,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 	dep[0].Data.Signature = make([]byte, 96)
 	trie, _, err := util.DepositTrieFromDeposits(dep)
 	require.NoError(t, err)
-	root, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	root := trie.HashTreeRoot()
 	eth1Data := &ethpb.Eth1Data{
 		DepositRoot:  root[:],
 		DepositCount: 1,
@@ -291,9 +289,7 @@ func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) {
 		require.NoError(t, err)
 		dep[i].Proof = proof
 	}
-	root, err := trie.HashTreeRoot()
-	require.NoError(t, err)
-
+	root := trie.HashTreeRoot()
 	eth1Data := &ethpb.Eth1Data{
 		DepositRoot:  root[:],
 		DepositCount: 1,
@@ -380,9 +376,7 @@ func TestProcessDeposit_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 		},
 	}
 	balances := []uint64{0, 50}
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-
+	root := depositTrie.HashTreeRoot()
 	beaconState, err := v1.InitializeFromProto(&ethpb.BeaconState{
 		Validators: registry,
 		Balances:   balances,

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

@@ -106,7 +106,7 @@ func weighJustificationAndFinalization(state state.BeaconState,
 		if err := state.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: prevEpoch, Root: blockRoot}); err != nil {
 			return nil, err
 		}
-		newBits = state.JustificationBits()
+		newBits := state.JustificationBits()
 		newBits.SetBitAt(1, true)
 		if err := state.SetJustificationBits(newBits); err != nil {
 			return nil, err
@@ -122,7 +122,7 @@ func weighJustificationAndFinalization(state state.BeaconState,
 		if err := state.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: currentEpoch, Root: blockRoot}); err != nil {
 			return nil, err
 		}
-		newBits = state.JustificationBits()
+		newBits := state.JustificationBits()
 		newBits.SetBitAt(0, true)
 		if err := state.SetJustificationBits(newBits); err != nil {
 			return nil, err

beacon-chain/core/helpers/genesis.go

@@ -41,10 +41,7 @@ func UpdateGenesisEth1Data(state state.BeaconState, deposits []*ethpb.Deposit, e
 		}
 	}
 
-	depositRoot, err := t.HashTreeRoot()
-	if err != nil {
-		return nil, err
-	}
+	depositRoot := t.HashTreeRoot()
 	eth1Data.DepositRoot = depositRoot[:]
 	err = state.SetEth1Data(eth1Data)
 	if err != nil {

beacon-chain/db/kv/BUILD.bazel

@@ -40,7 +40,6 @@ go_library(
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/genesis:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//beacon-chain/state/v2:go_default_library",
         "//beacon-chain/state/v3:go_default_library",

beacon-chain/db/kv/error.go

@@ -21,5 +21,3 @@ var ErrNotFoundBackfillBlockRoot = errors.Wrap(ErrNotFound, "BackfillBlockRoot")
 
 // ErrNotFoundFeeRecipient is a not found error specifically for the fee recipient getter
 var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")
-
-var errCheckpointBlockRootMismatch = errors.New("checkpoint block root does not match state.latest_block_header")

beacon-chain/db/kv/genesis_test.go

@@ -83,7 +83,7 @@ func TestEnsureEmbeddedGenesis(t *testing.T) {
 	// Embedded Genesis works with Mainnet config
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig()
-	cfg.ConfigName = params.MainnetName
+	cfg.ConfigName = params.ConfigNames[params.Mainnet]
 	params.OverrideBeaconConfig(cfg)
 
 	ctx := context.Background()

beacon-chain/db/kv/state.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/genesis"
-	state_native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
@@ -205,13 +204,7 @@ func (s *Store) SaveStatesEfficient(ctx context.Context, states []state.ReadOnly
 			// look at issue https://github.com/prysmaticlabs/prysm/issues/9262.
 			switch rawType := states[i].InnerStateUnsafe().(type) {
 			case *ethpb.BeaconState:
-				var pbState *ethpb.BeaconState
-				var err error
-				if features.Get().EnableNativeState {
-					pbState, err = state_native.ProtobufBeaconStatePhase0(rawType)
-				} else {
-					pbState, err = v1.ProtobufBeaconState(rawType)
-				}
+				pbState, err := v1.ProtobufBeaconState(rawType)
 				if err != nil {
 					return err
 				}
@@ -232,13 +225,7 @@ func (s *Store) SaveStatesEfficient(ctx context.Context, states []state.ReadOnly
 					return err
 				}
 			case *ethpb.BeaconStateAltair:
-				var pbState *ethpb.BeaconStateAltair
-				var err error
-				if features.Get().EnableNativeState {
-					pbState, err = state_native.ProtobufBeaconStateAltair(rawType)
-				} else {
-					pbState, err = v2.ProtobufBeaconState(rawType)
-				}
+				pbState, err := v2.ProtobufBeaconState(rawType)
 				if err != nil {
 					return err
 				}
@@ -260,13 +247,7 @@ func (s *Store) SaveStatesEfficient(ctx context.Context, states []state.ReadOnly
 					return err
 				}
 			case *ethpb.BeaconStateBellatrix:
-				var pbState *ethpb.BeaconStateBellatrix
-				var err error
-				if features.Get().EnableNativeState {
-					pbState, err = state_native.ProtobufBeaconStateBellatrix(rawType)
-				} else {
-					pbState, err = v3.ProtobufBeaconState(rawType)
-				}
+				pbState, err := v3.ProtobufBeaconState(rawType)
 				if err != nil {
 					return err
 				}
@@ -293,7 +274,28 @@ func (s *Store) SaveStatesEfficient(ctx context.Context, states []state.ReadOnly
 		}
 
 		// store the validator entries separately to save space.
-		return s.storeValidatorEntriesSeparately(ctx, tx, validatorsEntries)
+		valBkt := tx.Bucket(stateValidatorsBucket)
+		for hashStr, validatorEntry := range validatorsEntries {
+			key := []byte(hashStr)
+			// if the entry is not in the cache and not in the DB,
+			// then insert it in the DB and add to the cache.
+			if _, ok := s.validatorEntryCache.Get(key); !ok {
+				validatorEntryCacheMiss.Inc()
+				if valEntry := valBkt.Get(key); valEntry == nil {
+					valBytes, encodeErr := encode(ctx, validatorEntry)
+					if encodeErr != nil {
+						return encodeErr
+					}
+					if putErr := valBkt.Put(key, valBytes); putErr != nil {
+						return putErr
+					}
+					s.validatorEntryCache.Set(key, validatorEntry, int64(len(valBytes)))
+				}
+			} else {
+				validatorEntryCacheHit.Inc()
+			}
+		}
+		return nil
 	}); err != nil {
 		return err
 	}
@@ -301,31 +303,6 @@ func (s *Store) SaveStatesEfficient(ctx context.Context, states []state.ReadOnly
 	return nil
 }
 
-func (s *Store) storeValidatorEntriesSeparately(ctx context.Context, tx *bolt.Tx, validatorsEntries map[string]*ethpb.Validator) error {
-	valBkt := tx.Bucket(stateValidatorsBucket)
-	for hashStr, validatorEntry := range validatorsEntries {
-		key := []byte(hashStr)
-		// if the entry is not in the cache and not in the DB,
-		// then insert it in the DB and add to the cache.
-		if _, ok := s.validatorEntryCache.Get(key); !ok {
-			validatorEntryCacheMiss.Inc()
-			if valEntry := valBkt.Get(key); valEntry == nil {
-				valBytes, encodeErr := encode(ctx, validatorEntry)
-				if encodeErr != nil {
-					return encodeErr
-				}
-				if putErr := valBkt.Put(key, valBytes); putErr != nil {
-					return putErr
-				}
-				s.validatorEntryCache.Set(key, validatorEntry, int64(len(valBytes)))
-			}
-		} else {
-			validatorEntryCacheHit.Inc()
-		}
-	}
-	return nil
-}
-
 // HasState checks if a state by root exists in the db.
 func (s *Store) HasState(ctx context.Context, blockRoot [32]byte) bool {
 	_, span := trace.StartSpan(ctx, "BeaconDB.HasState")

beacon-chain/db/kv/wss.go

@@ -55,21 +55,13 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 	if err != nil {
 		return errors.Wrap(err, "could not compute HashTreeRoot of checkpoint block")
 	}
-	headerRoot, err := state.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not compute HashTreeRoot of state.latest_block_header to validate checkpoint block root")
-	}
-	if headerRoot != blockRoot {
-		return errors.Wrapf(errCheckpointBlockRootMismatch, "htr(state.latest_block_header)=%#x, htr(block)=%#x", headerRoot, blockRoot)
-	}
-
-	log.Infof("saving checkpoint block to db, w/ slot=%d, root=%#x", blk.Slot(), blockRoot)
+	log.Infof("saving checkpoint block to db, w/ root=%#x", blockRoot)
 	if err := s.SaveBlock(ctx, wblk); err != nil {
 		return errors.Wrap(err, "could not save checkpoint block")
 	}
 
 	// save state
-	log.Infof("calling SaveState w/ blockRoot=%x, slot=%d, parent_root=%#x, block_root=%#x", blockRoot, state.Slot(), state.LatestBlockHeader().ParentRoot, state.LatestBlockHeader().BodyRoot)
+	log.Infof("calling SaveState w/ blockRoot=%x", blockRoot)
 	if err = s.SaveState(ctx, state, blockRoot); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}

beacon-chain/db/kv/wss_test.go

@@ -15,13 +15,13 @@ func TestSaveOrigin(t *testing.T) {
 	// Embedded Genesis works with Mainnet config
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig()
-	cfg.ConfigName = params.MainnetName
+	cfg.ConfigName = params.ConfigNames[params.Mainnet]
 	params.OverrideBeaconConfig(cfg)
 
 	ctx := context.Background()
 	db := setupDB(t)
 
-	st, err := genesis.State(params.MainnetName)
+	st, err := genesis.State(params.Mainnet.String())
 	require.NoError(t, err)
 
 	sb, err := st.MarshalSSZ()

beacon-chain/forkchoice/doubly-linked-tree/optimistic_sync.go

@@ -81,7 +81,7 @@ func (s *Store) removeNode(ctx context.Context, node *Node) ([][32]byte, error)
 				if i != len(children)-1 {
 					children[i] = children[len(children)-1]
 				}
-				node.parent.children = children[:len(children)-1]
+				node.parent.children = children[:len(children)-2]
 				break
 			}
 		}

beacon-chain/forkchoice/doubly-linked-tree/optimistic_sync_test.go

@@ -203,26 +203,3 @@ func TestSetOptimisticToInvalid_ProposerBoost(t *testing.T) {
 	require.DeepEqual(t, params.BeaconConfig().ZeroHash, f.store.previousProposerBoostRoot)
 	f.store.proposerBoostLock.RUnlock()
 }
-
-// This is a regression test (10565)
-//     ----- C
-//   /
-//  A <- B
-//   \
-//     ----------D
-// D is invalid
-
-func TestSetOptimisticToInvalid_CorrectChildren(t *testing.T) {
-	ctx := context.Background()
-	f := setup(1, 1)
-
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 102, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'D'}, 1, 1))
-
-	_, err := f.store.setOptimisticToInvalid(ctx, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'A'})
-	require.NoError(t, err)
-	require.Equal(t, 2, len(f.store.nodeByRoot[[32]byte{'a'}].children))
-
-}

beacon-chain/forkchoice/protoarray/optimistic_sync.go

@@ -24,7 +24,6 @@ func (f *ForkChoice) IsOptimistic(root [32]byte) (bool, error) {
 
 // SetOptimisticToValid is called with the root of a block that was returned as
 // VALID by the EL.
-//
 // WARNING: This method returns an error if the root is not found in forkchoice
 func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [32]byte) error {
 	f.store.nodesLock.Lock()

beacon-chain/node/config.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/cmd"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -118,18 +117,7 @@ func configureExecutionSetting(cliCtx *cli.Context) error {
 	if !common.IsHexAddress(ha) {
 		return fmt.Errorf("%s is not a valid fee recipient address", ha)
 	}
-	mixedcaseAddress, err := common.NewMixedcaseAddressFromString(ha)
-	if err != nil {
-		return errors.Wrapf(err, "could not decode fee recipient %s", ha)
-	}
-	checksumAddress := common.HexToAddress(ha)
-	if !mixedcaseAddress.ValidChecksum() {
-		log.Warnf("Fee recipient %s is not a checksum Ethereum address. "+
-			"The checksummed address is %s and will be used as the fee recipient. "+
-			"We recommend using a mixed-case address (checksum) "+
-			"to prevent spelling mistakes in your fee recipient Ethereum address", ha, checksumAddress.Hex())
-	}
-	c.DefaultFeeRecipient = checksumAddress
+	c.DefaultFeeRecipient = common.HexToAddress(ha)
 	params.OverrideBeaconConfig(c)
 	return nil
 }

beacon-chain/node/config_test.go

@@ -87,7 +87,6 @@ func TestConfigureProofOfWork(t *testing.T) {
 
 func TestConfigureExecutionSetting(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
-	hook := logTest.NewGlobal()
 
 	app := cli.App{}
 	set := flag.NewFlagSet("test", 0)
@@ -103,15 +102,11 @@ func TestConfigureExecutionSetting(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, common.HexToAddress("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"), params.BeaconConfig().DefaultFeeRecipient)
 
-	assert.LogsContain(t, hook,
-		"is not a checksum Ethereum address",
-	)
-	require.NoError(t, set.Set(flags.SuggestedFeeRecipient.Name, "0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa"))
+	require.NoError(t, set.Set(flags.SuggestedFeeRecipient.Name, "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"))
 	cliCtx = cli.NewContext(&app, set, nil)
 	err = configureExecutionSetting(cliCtx)
 	require.NoError(t, err)
-	assert.Equal(t, common.HexToAddress("0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa"), params.BeaconConfig().DefaultFeeRecipient)
-
+	assert.Equal(t, common.HexToAddress("0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"), params.BeaconConfig().DefaultFeeRecipient)
 }
 
 func TestConfigureNetwork(t *testing.T) {

beacon-chain/node/node.go

@@ -779,7 +779,6 @@ func (b *BeaconNode) registerRPCService() error {
 		PeerManager:             p2pService,
 		MetadataProvider:        p2pService,
 		ChainInfoFetcher:        chainService,
-		HeadUpdater:             chainService,
 		HeadFetcher:             chainService,
 		CanonicalFetcher:        chainService,
 		ForkFetcher:             chainService,
@@ -788,7 +787,6 @@ func (b *BeaconNode) registerRPCService() error {
 		AttestationReceiver:     chainService,
 		GenesisTimeFetcher:      chainService,
 		GenesisFetcher:          chainService,
-		OptimisticModeFetcher:   chainService,
 		AttestationsPool:        b.attestationPool,
 		ExitPool:                b.exitPool,
 		SlashingsPool:           b.slashingsPool,

beacon-chain/powchain/BUILD.bazel

@@ -34,7 +34,7 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/powchain/types:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
+        "//beacon-chain/state/state-native/v1:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//config/features:go_default_library",

beacon-chain/powchain/block_reader.go

@@ -22,7 +22,7 @@ const repeatedSearches = 2 * searchThreshold
 
 // BlockExists returns true if the block exists, its height and any possible error encountered.
 func (s *Service) BlockExists(ctx context.Context, hash common.Hash) (bool, *big.Int, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.BlockExists")
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.web3service.BlockExists")
 	defer span.End()
 
 	if exists, hdrInfo, err := s.headerCache.HeaderInfoByHash(hash); exists || err != nil {
@@ -45,9 +45,24 @@ func (s *Service) BlockExists(ctx context.Context, hash common.Hash) (bool, *big
 	return true, new(big.Int).Set(header.Number), nil
 }
 
+// BlockExistsWithCache returns true if the block exists in cache, its height and any possible error encountered.
+func (s *Service) BlockExistsWithCache(ctx context.Context, hash common.Hash) (bool, *big.Int, error) {
+	_, span := trace.StartSpan(ctx, "beacon-chain.web3service.BlockExistsWithCache")
+	defer span.End()
+	if exists, hdrInfo, err := s.headerCache.HeaderInfoByHash(hash); exists || err != nil {
+		if err != nil {
+			return false, nil, err
+		}
+		span.AddAttributes(trace.BoolAttribute("blockCacheHit", true))
+		return true, hdrInfo.Number, nil
+	}
+	span.AddAttributes(trace.BoolAttribute("blockCacheHit", false))
+	return false, nil, nil
+}
+
 // BlockHashByHeight returns the block hash of the block at the given height.
 func (s *Service) BlockHashByHeight(ctx context.Context, height *big.Int) (common.Hash, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.BlockHashByHeight")
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.web3service.BlockHashByHeight")
 	defer span.End()
 
 	if exists, hInfo, err := s.headerCache.HeaderInfoByHeight(height); exists || err != nil {
@@ -75,9 +90,9 @@ func (s *Service) BlockHashByHeight(ctx context.Context, height *big.Int) (commo
 	return header.Hash(), nil
 }
 
-// BlockTimeByHeight fetches an eth1 block timestamp by its height.
+// BlockTimeByHeight fetches an eth1.0 block timestamp by its height.
 func (s *Service) BlockTimeByHeight(ctx context.Context, height *big.Int) (uint64, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.BlockTimeByHeight")
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.web3service.BlockTimeByHeight")
 	defer span.End()
 	if s.eth1DataFetcher == nil {
 		err := errors.New("nil eth1DataFetcher")
@@ -96,7 +111,7 @@ func (s *Service) BlockTimeByHeight(ctx context.Context, height *big.Int) (uint6
 // This is an optimized version with the worst case being O(2*repeatedSearches) number of calls
 // while in best case search for the block is performed in O(1).
 func (s *Service) BlockByTimestamp(ctx context.Context, time uint64) (*types.HeaderInfo, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.BlockByTimestamp")
+	ctx, span := trace.StartSpan(ctx, "beacon-chain.web3service.BlockByTimestamp")
 	defer span.End()
 
 	s.latestEth1DataLock.RLock()
@@ -107,14 +122,15 @@ func (s *Service) BlockByTimestamp(ctx context.Context, time uint64) (*types.Hea
 	if time > latestBlkTime {
 		return nil, errors.Errorf("provided time is later than the current eth1 head. %d > %d", time, latestBlkTime)
 	}
-	// Initialize a pointer to eth1 chain's history to start our search from.
+	// Initialize a pointer to eth1 chain's history to start our search
+	// from.
 	cursorNum := big.NewInt(0).SetUint64(latestBlkHeight)
 	cursorTime := latestBlkTime
 
 	numOfBlocks := uint64(0)
 	estimatedBlk := cursorNum.Uint64()
 	maxTimeBuffer := searchThreshold * params.BeaconConfig().SecondsPerETH1Block
-	// Terminate if we can't find an acceptable block after
+	// Terminate if we cant find an acceptable block after
 	// repeated searches.
 	for i := 0; i < repeatedSearches; i++ {
 		if ctx.Err() != nil {
@@ -141,12 +157,12 @@ func (s *Service) BlockByTimestamp(ctx context.Context, time uint64) (*types.Hea
 			// time - buffer <= head.time <= time + buffer
 			break
 		}
-		hInfo, err := s.retrieveHeaderInfo(ctx, estimatedBlk)
+		hinfo, err := s.retrieveHeaderInfo(ctx, estimatedBlk)
 		if err != nil {
 			return nil, err
 		}
-		cursorNum = hInfo.Number
-		cursorTime = hInfo.Time
+		cursorNum = hinfo.Number
+		cursorTime = hinfo.Time
 	}
 
 	// Exit early if we get the desired block.
@@ -154,15 +170,15 @@ func (s *Service) BlockByTimestamp(ctx context.Context, time uint64) (*types.Hea
 		return s.retrieveHeaderInfo(ctx, cursorNum.Uint64())
 	}
 	if cursorTime > time {
-		return s.findMaxTargetEth1Block(ctx, big.NewInt(0).SetUint64(estimatedBlk), time)
+		return s.findLessTargetEth1Block(ctx, big.NewInt(0).SetUint64(estimatedBlk), time)
 	}
-	return s.findMinTargetEth1Block(ctx, big.NewInt(0).SetUint64(estimatedBlk), time)
+	return s.findMoreTargetEth1Block(ctx, big.NewInt(0).SetUint64(estimatedBlk), time)
 }
 
 // Performs a search to find a target eth1 block which is earlier than or equal to the
 // target time. This method is used when head.time > targetTime
-func (s *Service) findMaxTargetEth1Block(ctx context.Context, upperBoundBlk *big.Int, targetTime uint64) (*types.HeaderInfo, error) {
-	for bn := upperBoundBlk; ; bn = big.NewInt(0).Sub(bn, big.NewInt(1)) {
+func (s *Service) findLessTargetEth1Block(ctx context.Context, startBlk *big.Int, targetTime uint64) (*types.HeaderInfo, error) {
+	for bn := startBlk; ; bn = big.NewInt(0).Sub(bn, big.NewInt(1)) {
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
 		}
@@ -178,8 +194,8 @@ func (s *Service) findMaxTargetEth1Block(ctx context.Context, upperBoundBlk *big
 
 // Performs a search to find a target eth1 block which is just earlier than or equal to the
 // target time. This method is used when head.time < targetTime
-func (s *Service) findMinTargetEth1Block(ctx context.Context, lowerBoundBlk *big.Int, targetTime uint64) (*types.HeaderInfo, error) {
-	for bn := lowerBoundBlk; ; bn = big.NewInt(0).Add(bn, big.NewInt(1)) {
+func (s *Service) findMoreTargetEth1Block(ctx context.Context, startBlk *big.Int, targetTime uint64) (*types.HeaderInfo, error) {
+	for bn := startBlk; ; bn = big.NewInt(0).Add(bn, big.NewInt(1)) {
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
 		}
@@ -187,7 +203,8 @@ func (s *Service) findMinTargetEth1Block(ctx context.Context, lowerBoundBlk *big
 		if err != nil {
 			return nil, err
 		}
-		// Return the last block before we hit the threshold time.
+		// Return the last block before we hit the threshold
+		// time.
 		if info.Time > targetTime {
 			return s.retrieveHeaderInfo(ctx, info.Number.Uint64()-1)
 		}

beacon-chain/powchain/block_reader_test.go

@@ -61,7 +61,7 @@ func TestLatestMainchainInfo_OK(t *testing.T) {
 	require.NoError(t, err)
 
 	tickerChan := make(chan time.Time)
-	web3Service.eth1HeadTicker = &time.Ticker{C: tickerChan}
+	web3Service.headTicker = &time.Ticker{C: tickerChan}
 	tickerChan <- time.Now()
 	web3Service.cancel()
 	exitRoutine <- true
@@ -207,6 +207,51 @@ func TestBlockExists_UsesCachedBlockInfo(t *testing.T) {
 	require.Equal(t, 0, height.Cmp(header.Number))
 }
 
+func TestBlockExistsWithCache_UsesCachedHeaderInfo(t *testing.T) {
+	beaconDB := dbutil.SetupDB(t)
+	server, endpoint, err := mockPOW.SetupRPCServer()
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		server.Stop()
+	})
+	web3Service, err := NewService(context.Background(),
+		WithHttpEndpoints([]string{endpoint}),
+		WithDatabase(beaconDB),
+	)
+	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
+
+	header := &gethTypes.Header{
+		Number: big.NewInt(0),
+	}
+
+	err = web3Service.headerCache.AddHeader(header)
+	require.NoError(t, err)
+
+	exists, height, err := web3Service.BlockExistsWithCache(context.Background(), header.Hash())
+	require.NoError(t, err, "Could not get block hash with given height")
+	require.Equal(t, true, exists)
+	require.Equal(t, 0, height.Cmp(header.Number))
+}
+
+func TestBlockExistsWithCache_HeaderNotCached(t *testing.T) {
+	beaconDB := dbutil.SetupDB(t)
+	server, endpoint, err := mockPOW.SetupRPCServer()
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		server.Stop()
+	})
+	web3Service, err := NewService(context.Background(),
+		WithHttpEndpoints([]string{endpoint}),
+		WithDatabase(beaconDB),
+	)
+	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
+
+	exists, height, err := web3Service.BlockExistsWithCache(context.Background(), common.BytesToHash([]byte("hash")))
+	require.NoError(t, err, "Could not get block hash with given height")
+	require.Equal(t, false, exists)
+	require.Equal(t, (*big.Int)(nil), height)
+}
+
 func TestService_BlockNumberByTimestamp(t *testing.T) {
 	beaconDB := dbutil.SetupDB(t)
 	testAcc, err := mock.Setup()
@@ -268,11 +313,11 @@ func TestService_BlockNumberByTimestampLessTargetTime(t *testing.T) {
 	defer cancel()
 
 	// Provide an unattainable target time
-	_, err = web3Service.findMaxTargetEth1Block(ctx, hd.Number, hd.Time/2)
+	_, err = web3Service.findLessTargetEth1Block(ctx, hd.Number, hd.Time/2)
 	require.ErrorContains(t, context.DeadlineExceeded.Error(), err)
 
 	// Provide an attainable target time
-	blk, err := web3Service.findMaxTargetEth1Block(context.Background(), hd.Number, hd.Time-5)
+	blk, err := web3Service.findLessTargetEth1Block(context.Background(), hd.Number, hd.Time-5)
 	require.NoError(t, err)
 	require.NotEqual(t, hd.Number.Uint64(), blk.Number.Uint64(), "retrieved block is not less than the head")
 }
@@ -306,11 +351,11 @@ func TestService_BlockNumberByTimestampMoreTargetTime(t *testing.T) {
 	defer cancel()
 
 	// Provide an unattainable target time with respect to head
-	_, err = web3Service.findMinTargetEth1Block(ctx, big.NewInt(0).Div(hd.Number, big.NewInt(2)), hd.Time)
+	_, err = web3Service.findMoreTargetEth1Block(ctx, big.NewInt(0).Div(hd.Number, big.NewInt(2)), hd.Time)
 	require.ErrorContains(t, context.DeadlineExceeded.Error(), err)
 
 	// Provide an attainable target time with respect to head
-	blk, err := web3Service.findMinTargetEth1Block(context.Background(), big.NewInt(0).Sub(hd.Number, big.NewInt(5)), hd.Time)
+	blk, err := web3Service.findMoreTargetEth1Block(context.Background(), big.NewInt(0).Sub(hd.Number, big.NewInt(5)), hd.Time)
 	require.NoError(t, err)
 	require.Equal(t, hd.Number.Uint64(), blk.Number.Uint64(), "retrieved block is not equal to the head")
 }

beacon-chain/powchain/deposit_test.go

@@ -138,8 +138,7 @@ func TestProcessDeposit_InvalidPublicKey(t *testing.T) {
 	deposits[0].Proof, err = trie.MerkleProof(0)
 	require.NoError(t, err)
 
-	root, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	root := trie.HashTreeRoot()
 
 	eth1Data := &ethpb.Eth1Data{
 		DepositCount: 1,
@@ -179,8 +178,7 @@ func TestProcessDeposit_InvalidSignature(t *testing.T) {
 	trie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err)
 
-	root, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	root := trie.HashTreeRoot()
 
 	eth1Data := &ethpb.Eth1Data{
 		DepositCount: 1,
@@ -215,8 +213,7 @@ func TestProcessDeposit_UnableToVerify(t *testing.T) {
 
 	trie, _, err := util.DepositTrieFromDeposits(deposits)
 	require.NoError(t, err)
-	root, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	root := trie.HashTreeRoot()
 	eth1Data := &ethpb.Eth1Data{
 		DepositCount: 1,
 		DepositRoot:  root[:],
@@ -268,8 +265,7 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) {
 
 	trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
 	require.NoError(t, err)
-	root, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	root := trie.HashTreeRoot()
 	eth1Data := &ethpb.Eth1Data{
 		DepositCount: 1,
 		DepositRoot:  root[:],
@@ -285,8 +281,7 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) {
 	for i := 0; i < int(factor-1); i++ {
 		assert.NoError(t, trie.Insert(dataRoot[:], i))
 
-		trieRoot, err := trie.HashTreeRoot()
-		require.NoError(t, err)
+		trieRoot := trie.HashTreeRoot()
 		eth1Data.DepositRoot = trieRoot[:]
 		eth1Data.DepositCount = uint64(i + 1)
 

beacon-chain/powchain/engine_client.go

@@ -33,10 +33,6 @@ const (
 	ExecutionBlockByHashMethod = "eth_getBlockByHash"
 	// ExecutionBlockByNumberMethod request string for JSON-RPC.
 	ExecutionBlockByNumberMethod = "eth_getBlockByNumber"
-	// Defines the seconds to wait before timing out engine endpoints with block execution semantics (newPayload, forkchoiceUpdated).
-	payloadAndForkchoiceUpdatedTimeout = 8 * time.Second
-	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
-	defaultEngineTimeout = time.Second
 )
 
 // ForkchoiceUpdatedResponse is the response kind received by the
@@ -69,9 +65,7 @@ func (s *Service) NewPayload(ctx context.Context, payload *pb.ExecutionPayload)
 	defer func() {
 		newPayloadLatency.Observe(float64(time.Since(start).Milliseconds()))
 	}()
-	d := time.Now().Add(payloadAndForkchoiceUpdatedTimeout)
-	ctx, cancel := context.WithDeadline(ctx, d)
-	defer cancel()
+
 	result := &pb.PayloadStatus{}
 	err := s.rpcClient.CallContext(ctx, result, NewPayloadMethod, payload)
 	if err != nil {
@@ -105,9 +99,6 @@ func (s *Service) ForkchoiceUpdated(
 		forkchoiceUpdatedLatency.Observe(float64(time.Since(start).Milliseconds()))
 	}()
 
-	d := time.Now().Add(payloadAndForkchoiceUpdatedTimeout)
-	ctx, cancel := context.WithDeadline(ctx, d)
-	defer cancel()
 	result := &ForkchoiceUpdatedResponse{}
 	err := s.rpcClient.CallContext(ctx, result, ForkchoiceUpdatedMethod, state, attrs)
 	if err != nil {
@@ -141,9 +132,6 @@ func (s *Service) GetPayload(ctx context.Context, payloadId [8]byte) (*pb.Execut
 		getPayloadLatency.Observe(float64(time.Since(start).Milliseconds()))
 	}()
 
-	d := time.Now().Add(defaultEngineTimeout)
-	ctx, cancel := context.WithDeadline(ctx, d)
-	defer cancel()
 	result := &pb.ExecutionPayload{}
 	err := s.rpcClient.CallContext(ctx, result, GetPayloadMethod, pb.PayloadIDBytes(payloadId))
 	return result, handleRPCError(err)
@@ -159,14 +147,10 @@ func (s *Service) ExchangeTransitionConfiguration(
 	// We set terminal block number to 0 as the parameter is not set on the consensus layer.
 	zeroBigNum := big.NewInt(0)
 	cfg.TerminalBlockNumber = zeroBigNum.Bytes()
-	d := time.Now().Add(defaultEngineTimeout)
-	ctx, cancel := context.WithDeadline(ctx, d)
-	defer cancel()
 	result := &pb.TransitionConfiguration{}
 	if err := s.rpcClient.CallContext(ctx, result, ExchangeTransitionConfigurationMethod, cfg); err != nil {
 		return handleRPCError(err)
 	}
-
 	// We surface an error to the user if local configuration settings mismatch
 	// according to the response from the execution node.
 	cfgTerminalHash := params.BeaconConfig().TerminalBlockHash[:]

beacon-chain/powchain/errors.go

@@ -19,6 +19,8 @@ var (
 	ErrUnknownPayload = errors.New("payload does not exist or is not available")
 	// ErrUnknownPayloadStatus when the payload status is unknown.
 	ErrUnknownPayloadStatus = errors.New("unknown payload status")
+	// ErrUnsupportedScheme for unsupported URL schemes.
+	ErrUnsupportedScheme = errors.New("unsupported url scheme, only http(s) and ipc are supported")
 	// ErrConfigMismatch when the execution node's terminal total difficulty or
 	// terminal block hash received via the API mismatches Prysm's configuration value.
 	ErrConfigMismatch = errors.New("execution client configuration mismatch")

beacon-chain/powchain/log_processing.go

@@ -5,7 +5,6 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math/big"
-	"strings"
 	"time"
 
 	"github.com/ethereum/go-ethereum"
@@ -17,9 +16,7 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	coreState "github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
-	state_native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	contracts "github.com/prysmaticlabs/prysm/contracts/deposit"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
@@ -36,28 +33,22 @@ var (
 const eth1DataSavingInterval = 1000
 const maxTolerableDifference = 50
 const defaultEth1HeaderReqLimit = uint64(1000)
-const depositLogRequestLimit = 10000
+const depositlogRequestLimit = 10000
 const additiveFactorMultiplier = 0.10
 const multiplicativeDecreaseDivisor = 2
 
-var errTimedOut = errors.New("net/http: request canceled")
-
 func tooMuchDataRequestedError(err error) bool {
 	// this error is only infura specific (other providers might have different error messages)
 	return err.Error() == "query returned more than 10000 results"
 }
 
-func clientTimedOutError(err error) bool {
-	return strings.Contains(err.Error(), errTimedOut.Error())
-}
-
 // Eth2GenesisPowchainInfo retrieves the genesis time and eth1 block number of the beacon chain
 // from the deposit contract.
 func (s *Service) Eth2GenesisPowchainInfo() (uint64, *big.Int) {
 	return s.chainStartData.GenesisTime, big.NewInt(int64(s.chainStartData.GenesisBlock))
 }
 
-// ProcessETH1Block processes logs from the provided eth1 block.
+// ProcessETH1Block processes the logs from the provided eth1Block.
 func (s *Service) ProcessETH1Block(ctx context.Context, blkNum *big.Int) error {
 	query := ethereum.FilterQuery{
 		Addresses: []common.Address{
@@ -80,7 +71,7 @@ func (s *Service) ProcessETH1Block(ctx context.Context, blkNum *big.Int) error {
 		}
 	}
 	if !s.chainStartData.Chainstarted {
-		if err := s.processChainStartFromBlockNum(ctx, blkNum); err != nil {
+		if err := s.checkBlockNumberForChainStart(ctx, blkNum); err != nil {
 			return err
 		}
 	}
@@ -88,7 +79,7 @@ func (s *Service) ProcessETH1Block(ctx context.Context, blkNum *big.Int) error {
 }
 
 // ProcessLog is the main method which handles the processing of all
-// logs from the deposit contract on the eth1 chain.
+// logs from the deposit contract on the ETH1.0 chain.
 func (s *Service) ProcessLog(ctx context.Context, depositLog gethTypes.Log) error {
 	s.processingLock.RLock()
 	defer s.processingLock.RUnlock()
@@ -107,7 +98,7 @@ func (s *Service) ProcessLog(ctx context.Context, depositLog gethTypes.Log) erro
 }
 
 // ProcessDepositLog processes the log which had been received from
-// the eth1 chain by trying to ascertain which participant deposited
+// the ETH1.0 chain by trying to ascertain which participant deposited
 // in the contract.
 func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethTypes.Log) error {
 	pubkey, withdrawalCredentials, amount, signature, merkleTreeIndex, err := contracts.UnpackDepositLogData(depositLog.Data)
@@ -140,7 +131,7 @@ func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethTypes.Lo
 
 	depositHash, err := depositData.HashTreeRoot()
 	if err != nil {
-		return errors.Wrap(err, "unable to determine hashed value of deposit")
+		return errors.Wrap(err, "Unable to determine hashed value of deposit")
 	}
 
 	// Defensive check to validate incoming index.
@@ -158,27 +149,20 @@ func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethTypes.Lo
 	if !s.chainStartData.Chainstarted {
 		proof, err := s.depositTrie.MerkleProof(int(index))
 		if err != nil {
-			return errors.Wrap(err, "unable to generate merkle proof for deposit")
+			return errors.Wrap(err, "Unable to generate merkle proof for deposit")
 		}
 		deposit.Proof = proof
 	}
 
 	// We always store all historical deposits in the DB.
-	root, err := s.depositTrie.HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "unable to determine root of deposit trie")
-	}
-	err = s.cfg.depositCache.InsertDeposit(ctx, deposit, depositLog.BlockNumber, index, root)
+	err = s.cfg.depositCache.InsertDeposit(ctx, deposit, depositLog.BlockNumber, index, s.depositTrie.HashTreeRoot())
 	if err != nil {
 		return errors.Wrap(err, "unable to insert deposit into cache")
 	}
 	validData := true
 	if !s.chainStartData.Chainstarted {
 		s.chainStartData.ChainstartDeposits = append(s.chainStartData.ChainstartDeposits, deposit)
-		root, err := s.depositTrie.HashTreeRoot()
-		if err != nil {
-			return errors.Wrap(err, "unable to determine root of deposit trie")
-		}
+		root := s.depositTrie.HashTreeRoot()
 		eth1Data := &ethpb.Eth1Data{
 			DepositRoot:  root[:],
 			DepositCount: uint64(len(s.chainStartData.ChainstartDeposits)),
@@ -188,11 +172,7 @@ func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethTypes.Lo
 			validData = false
 		}
 	} else {
-		root, err := s.depositTrie.HashTreeRoot()
-		if err != nil {
-			return errors.Wrap(err, "unable to determine root of deposit trie")
-		}
-		s.cfg.depositCache.InsertPendingDeposit(ctx, deposit, depositLog.BlockNumber, index, root)
+		s.cfg.depositCache.InsertPendingDeposit(ctx, deposit, depositLog.BlockNumber, index, s.depositTrie.HashTreeRoot())
 	}
 	if validData {
 		log.WithFields(logrus.Fields{
@@ -226,7 +206,7 @@ func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethTypes.Lo
 }
 
 // ProcessChainStart processes the log which had been received from
-// the eth1 chain by trying to determine when to start the beacon chain.
+// the ETH1.0 chain by trying to determine when to start the beacon chain.
 func (s *Service) ProcessChainStart(genesisTime uint64, eth1BlockHash [32]byte, blockNumber *big.Int) {
 	s.chainStartData.Chainstarted = true
 	s.chainStartData.GenesisBlock = blockNumber.Uint64()
@@ -236,16 +216,12 @@ func (s *Service) ProcessChainStart(genesisTime uint64, eth1BlockHash [32]byte,
 	for i := range s.chainStartData.ChainstartDeposits {
 		proof, err := s.depositTrie.MerkleProof(i)
 		if err != nil {
-			log.Errorf("unable to generate deposit proof %v", err)
+			log.Errorf("Unable to generate deposit proof %v", err)
 		}
 		s.chainStartData.ChainstartDeposits[i].Proof = proof
 	}
 
-	root, err := s.depositTrie.HashTreeRoot()
-	if err != nil { // This should never happen.
-		log.WithError(err).Error("unable to determine root of deposit trie, aborting chain start")
-		return
-	}
+	root := s.depositTrie.HashTreeRoot()
 	s.chainStartData.Eth1Data = &ethpb.Eth1Data{
 		DepositCount: uint64(len(s.chainStartData.ChainstartDeposits)),
 		DepositRoot:  root[:],
@@ -262,15 +238,15 @@ func (s *Service) ProcessChainStart(genesisTime uint64, eth1BlockHash [32]byte,
 		},
 	})
 	if err := s.savePowchainData(s.ctx); err != nil {
-		// continue on if the save fails as this will get re-saved
+		// continue on, if the save fails as this will get re-saved
 		// in the next interval.
 		log.Error(err)
 	}
 }
 
-// createGenesisTime adds in the genesis delay to the eth1 block time
-// on which it was triggered.
 func createGenesisTime(timeStamp uint64) uint64 {
+	// adds in the genesis delay to the eth1 block time
+	// on which it was triggered.
 	return timeStamp + params.BeaconConfig().GenesisDelay
 }
 
@@ -307,7 +283,7 @@ func (s *Service) processPastLogs(ctx context.Context) error {
 		}
 		return nil
 	}
-	latestFollowHeight, err := s.followedBlockHeight(ctx)
+	latestFollowHeight, err := s.followBlockHeight(ctx)
 	if err != nil {
 		return err
 	}
@@ -333,7 +309,7 @@ func (s *Service) processPastLogs(ctx context.Context) error {
 		remainingLogs := logCount - uint64(s.lastReceivedMerkleIndex+1)
 		// only change the end block if the remaining logs are below the required log limit.
 		// reset our query and end block in this case.
-		withinLimit := remainingLogs < depositLogRequestLimit
+		withinLimit := remainingLogs < depositlogRequestLimit
 		aboveFollowHeight := end >= latestFollowHeight
 		if withinLimit && aboveFollowHeight {
 			query.ToBlock = big.NewInt(0).SetUint64(latestFollowHeight)
@@ -428,9 +404,9 @@ func (s *Service) processPastLogs(ctx context.Context) error {
 // logs from the period last polled to now.
 func (s *Service) requestBatchedHeadersAndLogs(ctx context.Context) error {
 	// We request for the nth block behind the current head, in order to have
-	// stabilized logs when we retrieve it from the eth1 chain.
+	// stabilized logs when we retrieve it from the 1.0 chain.
 
-	requestedBlock, err := s.followedBlockHeight(ctx)
+	requestedBlock, err := s.followBlockHeight(ctx)
 	if err != nil {
 		return err
 	}
@@ -472,17 +448,18 @@ func (s *Service) retrieveBlockHashAndTime(ctx context.Context, blkNum *big.Int)
 	return bHash, timeStamp, nil
 }
 
-func (s *Service) processChainStartFromBlockNum(ctx context.Context, blkNum *big.Int) error {
+// checkBlockNumberForChainStart checks the given block number for if chainstart has occurred.
+func (s *Service) checkBlockNumberForChainStart(ctx context.Context, blkNum *big.Int) error {
 	bHash, timeStamp, err := s.retrieveBlockHashAndTime(ctx, blkNum)
 	if err != nil {
 		return err
 	}
-	s.processChainStartIfReady(ctx, bHash, blkNum, timeStamp)
+	s.checkForChainstart(ctx, bHash, blkNum, timeStamp)
 	return nil
 }
 
-func (s *Service) processChainStartFromHeader(ctx context.Context, header *gethTypes.Header) {
-	s.processChainStartIfReady(ctx, header.Hash(), header.Number, header.Time)
+func (s *Service) checkHeaderForChainstart(ctx context.Context, header *gethTypes.Header) {
+	s.checkForChainstart(ctx, header.Hash(), header.Number, header.Time)
 }
 
 func (s *Service) checkHeaderRange(ctx context.Context, start, end uint64, headersMap map[uint64]*gethTypes.Header,
@@ -498,7 +475,7 @@ func (s *Service) checkHeaderRange(ctx context.Context, start, end uint64, heade
 				i--
 				continue
 			}
-			s.processChainStartFromHeader(ctx, h)
+			s.checkHeaderForChainstart(ctx, h)
 		}
 	}
 	return nil
@@ -518,7 +495,7 @@ func (s *Service) currentCountAndTime(ctx context.Context, blockTime uint64) (ui
 	return valCount, createGenesisTime(blockTime)
 }
 
-func (s *Service) processChainStartIfReady(ctx context.Context, blockHash [32]byte, blockNumber *big.Int, blockTime uint64) {
+func (s *Service) checkForChainstart(ctx context.Context, blockHash [32]byte, blockNumber *big.Int, blockTime uint64) {
 	valCount, genesisTime := s.currentCountAndTime(ctx, blockTime)
 	if valCount == 0 {
 		return
@@ -530,15 +507,9 @@ func (s *Service) processChainStartIfReady(ctx context.Context, blockHash [32]by
 	}
 }
 
-// savePowchainData saves all powchain related metadata to disk.
+// save all powchain related metadata to disk.
 func (s *Service) savePowchainData(ctx context.Context) error {
-	var pbState *ethpb.BeaconState
-	var err error
-	if features.Get().EnableNativeState {
-		pbState, err = state_native.ProtobufBeaconStatePhase0(s.preGenesisState.InnerStateUnsafe())
-	} else {
-		pbState, err = v1.ProtobufBeaconState(s.preGenesisState.InnerStateUnsafe())
-	}
+	pbState, err := v1.ProtobufBeaconState(s.preGenesisState.InnerStateUnsafe())
 	if err != nil {
 		return err
 	}

beacon-chain/powchain/log_processing_test.go

@@ -589,7 +589,7 @@ func TestCheckForChainstart_NoValidator(t *testing.T) {
 	require.NoError(t, err, "Unable to set up simulated backend")
 	beaconDB := testDB.SetupDB(t)
 	s := newPowchainService(t, testAcc, beaconDB)
-	s.processChainStartIfReady(context.Background(), [32]byte{}, nil, 0)
+	s.checkForChainstart(context.Background(), [32]byte{}, nil, 0)
 	require.LogsDoNotContain(t, hook, "Could not determine active validator count from pre genesis state")
 }
 

beacon-chain/powchain/service.go

@@ -13,6 +13,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -29,7 +30,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native"
+	nativev1 "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native/v1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/features"
@@ -97,6 +98,7 @@ type POWBlockFetcher interface {
 	BlockByTimestamp(ctx context.Context, time uint64) (*types.HeaderInfo, error)
 	BlockHashByHeight(ctx context.Context, height *big.Int) (common.Hash, error)
 	BlockExists(ctx context.Context, hash common.Hash) (bool, *big.Int, error)
+	BlockExistsWithCache(ctx context.Context, hash common.Hash) (bool, *big.Int, error)
 }
 
 // Chain defines a standard interface for the powchain service in Prysm.
@@ -112,6 +114,7 @@ type RPCDataFetcher interface {
 	Close()
 	HeaderByNumber(ctx context.Context, number *big.Int) (*gethTypes.Header, error)
 	HeaderByHash(ctx context.Context, hash common.Hash) (*gethTypes.Header, error)
+	SyncProgress(ctx context.Context) (*ethereum.SyncProgress, error)
 }
 
 // RPCClient defines the rpc methods required to interact with the eth1 node.
@@ -136,10 +139,10 @@ type config struct {
 }
 
 // Service fetches important information about the canonical
-// eth1 chain via a web3 endpoint using an ethclient.
-// The beacon chain requires synchronization with the eth1 chain's current
-// block hash, block number, and access to logs within the
-// Validator Registration Contract on the eth1 chain to kick off the beacon
+// Ethereum ETH1.0 chain via a web3 endpoint using an ethclient. The Random
+// Beacon Chain requires synchronization with the ETH1.0 chain's current
+// blockhash, block number, and access to logs within the
+// Validator Registration Contract on the ETH1.0 chain to kick off the beacon
 // chain's validator registration process.
 type Service struct {
 	connectedETH1           bool
@@ -149,7 +152,7 @@ type Service struct {
 	cfg                     *config
 	ctx                     context.Context
 	cancel                  context.CancelFunc
-	eth1HeadTicker          *time.Ticker
+	headTicker              *time.Ticker
 	httpLogger              bind.ContractFilterer
 	eth1DataFetcher         RPCDataFetcher
 	rpcClient               RPCClient
@@ -170,11 +173,11 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	depositTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
 	if err != nil {
 		cancel()
-		return nil, errors.Wrap(err, "could not set up deposit trie")
+		return nil, errors.Wrap(err, "could not setup deposit trie")
 	}
 	genState, err := transition.EmptyGenesisState()
 	if err != nil {
-		return nil, errors.Wrap(err, "could not set up genesis state")
+		return nil, errors.Wrap(err, "could not setup genesis state")
 	}
 
 	s := &Service{
@@ -198,7 +201,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		},
 		lastReceivedMerkleIndex: -1,
 		preGenesisState:         genState,
-		eth1HeadTicker:          time.NewTicker(time.Duration(params.BeaconConfig().SecondsPerETH1Block) * time.Second),
+		headTicker:              time.NewTicker(time.Duration(params.BeaconConfig().SecondsPerETH1Block) * time.Second),
 	}
 
 	for _, opt := range opts {
@@ -222,7 +225,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	return s, nil
 }
 
-// Start the powchain service's main event loop.
+// Start a web3 service's main event loop.
 func (s *Service) Start() {
 	if err := s.setupExecutionClientConnections(s.ctx, s.cfg.currHttpEndpoint); err != nil {
 		log.WithError(err).Error("Could not connect to execution endpoint")
@@ -270,7 +273,7 @@ func (s *Service) Stop() error {
 func (s *Service) ClearPreGenesisData() {
 	s.chainStartData.ChainstartDeposits = []*ethpb.Deposit{}
 	if features.Get().EnableNativeState {
-		s.preGenesisState = &native.BeaconState{}
+		s.preGenesisState = &nativev1.BeaconState{}
 	} else {
 		s.preGenesisState = &v1.BeaconState{}
 	}
@@ -369,7 +372,7 @@ func (s *Service) ETH1ConnectionErrors() []error {
 
 // refers to the latest eth1 block which follows the condition: eth1_timestamp +
 // SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE <= current_unix_time
-func (s *Service) followedBlockHeight(_ context.Context) (uint64, error) {
+func (s *Service) followBlockHeight(_ context.Context) (uint64, error) {
 	latestValidBlock := uint64(0)
 	if s.latestEth1Data.BlockHeight > params.BeaconConfig().Eth1FollowDistance {
 		latestValidBlock = s.latestEth1Data.BlockHeight - params.BeaconConfig().Eth1FollowDistance
@@ -383,7 +386,8 @@ func (s *Service) initDepositCaches(ctx context.Context, ctrs []*ethpb.DepositCo
 	}
 	s.cfg.depositCache.InsertDepositContainers(ctx, ctrs)
 	if !s.chainStartData.Chainstarted {
-		// Do not add to pending cache if no genesis state exists.
+		// do not add to pending cache
+		// if no genesis state exists.
 		validDepositsCount.Add(float64(s.preGenesisState.Eth1DepositIndex()))
 		return nil
 	}
@@ -391,7 +395,7 @@ func (s *Service) initDepositCaches(ctx context.Context, ctrs []*ethpb.DepositCo
 	if err != nil {
 		return err
 	}
-	// Default to all post-genesis deposits in
+	// Default to all deposits post-genesis deposits in
 	// the event we cannot find a finalized state.
 	currIndex := genesisState.Eth1DepositIndex()
 	chkPt, err := s.cfg.beaconDB.FinalizedCheckpoint(ctx)
@@ -407,17 +411,17 @@ func (s *Service) initDepositCaches(ctx context.Context, ctrs []*ethpb.DepositCo
 		// Set deposit index to the one in the current archived state.
 		currIndex = fState.Eth1DepositIndex()
 
-		// When a node pauses for some time and starts again, the deposits to finalize
-		// accumulates. We finalize them here before we are ready to receive a block.
+		// when a node pauses for some time and starts again, the deposits to finalize
+		// accumulates. we finalize them here before we are ready to receive a block.
 		// Otherwise, the first few blocks will be slower to compute as we will
 		// hold the lock and be busy finalizing the deposits.
 		// The deposit index in the state is always the index of the next deposit
-		// to be included (rather than the last one to be processed). This was most likely
+		// to be included(rather than the last one to be processed). This was most likely
 		// done as the state cannot represent signed integers.
 		actualIndex := int64(currIndex) - 1 // lint:ignore uintcast -- deposit index will not exceed int64 in your lifetime.
 		s.cfg.depositCache.InsertFinalizedDeposits(ctx, actualIndex)
-
 		// Deposit proofs are only used during state transition and can be safely removed to save space.
+
 		if err = s.cfg.depositCache.PruneProofs(ctx, actualIndex); err != nil {
 			return errors.Wrap(err, "could not prune deposit proofs")
 		}
@@ -494,7 +498,8 @@ func (s *Service) batchRequestHeaders(startBlock, endBlock uint64) ([]*gethTypes
 	return headers, nil
 }
 
-// safelyHandleHeader will recover and log any panic that occurs from the block
+// safelyHandleHeader will recover and log any panic that occurs from the
+// block
 func safelyHandlePanic() {
 	if r := recover(); r != nil {
 		log.WithFields(logrus.Fields{
@@ -517,7 +522,7 @@ func (s *Service) handleETH1FollowDistance() {
 		log.Warn("Execution client is not syncing")
 	}
 	if !s.chainStartData.Chainstarted {
-		if err := s.processChainStartFromBlockNum(ctx, big.NewInt(int64(s.latestEth1Data.LastRequestedBlock))); err != nil {
+		if err := s.checkBlockNumberForChainStart(ctx, big.NewInt(int64(s.latestEth1Data.LastRequestedBlock))); err != nil {
 			s.runError = err
 			log.Error(err)
 			return
@@ -525,8 +530,9 @@ func (s *Service) handleETH1FollowDistance() {
 	}
 	// If the last requested block has not changed,
 	// we do not request batched logs as this means there are no new
-	// logs for the powchain service to process. Also it is a potential
-	// failure condition as would mean we have not respected the protocol threshold.
+	// logs for the powchain service to process. Also is a potential
+	// failure condition as would mean we have not respected the protocol
+	// threshold.
 	if s.latestEth1Data.LastRequestedBlock == s.latestEth1Data.BlockHeight {
 		log.Error("Beacon node is not respecting the follow distance")
 		return
@@ -589,7 +595,7 @@ func (s *Service) initPOWService() {
 			if s.chainStartData.Chainstarted && s.chainStartData.GenesisBlock == 0 {
 				genHash := common.BytesToHash(s.chainStartData.Eth1Data.BlockHash)
 				genBlock := s.chainStartData.GenesisBlock
-				// In the event our provided chainstart data references a non-existent block hash,
+				// In the event our provided chainstart data references a non-existent blockhash
 				// we assume the genesis block to be 0.
 				if genHash != [32]byte{} {
 					genHeader, err := s.eth1DataFetcher.HeaderByHash(ctx, genHash)
@@ -612,7 +618,7 @@ func (s *Service) initPOWService() {
 	}
 }
 
-// run subscribes to all the services for the eth1 chain.
+// run subscribes to all the services for the ETH1.0 chain.
 func (s *Service) run(done <-chan struct{}) {
 	s.runError = nil
 
@@ -630,7 +636,7 @@ func (s *Service) run(done <-chan struct{}) {
 			s.updateConnectedETH1(false)
 			log.Debug("Context closed, exiting goroutine")
 			return
-		case <-s.eth1HeadTicker.C:
+		case <-s.headTicker.C:
 			head, err := s.eth1DataFetcher.HeaderByNumber(s.ctx, nil)
 			if err != nil {
 				s.pollConnectionStatus(s.ctx)
@@ -686,10 +692,10 @@ func (s *Service) logTillChainStart(ctx context.Context) {
 }
 
 // cacheHeadersForEth1DataVote makes sure that voting for eth1data after startup utilizes cached headers
-// instead of making multiple RPC requests to the eth1 endpoint.
+// instead of making multiple RPC requests to the ETH1 endpoint.
 func (s *Service) cacheHeadersForEth1DataVote(ctx context.Context) error {
 	// Find the end block to request from.
-	end, err := s.followedBlockHeight(ctx)
+	end, err := s.followBlockHeight(ctx)
 	if err != nil {
 		return err
 	}
@@ -697,48 +703,20 @@ func (s *Service) cacheHeadersForEth1DataVote(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	return s.cacheBlockHeaders(start, end)
-}
-
-// Caches block headers from the desired range.
-func (s *Service) cacheBlockHeaders(start, end uint64) error {
-	batchSize := s.cfg.eth1HeaderReqLimit
-	for i := start; i < end; i += batchSize {
-		startReq := i
-		endReq := i + batchSize
-		if endReq > end {
-			endReq = end
-		}
-		// We call batchRequestHeaders for its header caching side-effect, so we don't need the return value.
-		_, err := s.batchRequestHeaders(startReq, endReq)
-		if err != nil {
-			if clientTimedOutError(err) {
-				// Reduce batch size as eth1 node is
-				// unable to respond to the request in time.
-				batchSize /= 2
-				// Always have it greater than 0.
-				if batchSize == 0 {
-					batchSize += 1
-				}
-
-				// Reset request value
-				if i > batchSize {
-					i -= batchSize
-				}
-				continue
-			}
-			return err
-		}
+	// We call batchRequestHeaders for its header caching side-effect, so we don't need the return value.
+	_, err = s.batchRequestHeaders(start, end)
+	if err != nil {
+		return err
 	}
 	return nil
 }
 
-// Determines the earliest voting block from which to start caching all our previous headers from.
+// determines the earliest voting block from which to start caching all our previous headers from.
 func (s *Service) determineEarliestVotingBlock(ctx context.Context, followBlock uint64) (uint64, error) {
 	genesisTime := s.chainStartData.GenesisTime
 	currSlot := slots.CurrentSlot(genesisTime)
 
-	// In the event genesis has not occurred yet, we just request to go back follow_distance blocks.
+	// In the event genesis has not occurred yet, we just request go back follow_distance blocks.
 	if genesisTime == 0 || currSlot == 0 {
 		earliestBlk := uint64(0)
 		if followBlock > params.BeaconConfig().Eth1FollowDistance {
@@ -785,7 +763,7 @@ func (s *Service) initializeEth1Data(ctx context.Context, eth1DataInDB *ethpb.ET
 	return nil
 }
 
-// Validates that all deposit containers are valid and have their relevant indices
+// validates that all deposit containers are valid and have their relevant indices
 // in order.
 func validateDepositContainers(ctrs []*ethpb.DepositContainer) bool {
 	ctrLen := len(ctrs)
@@ -808,7 +786,7 @@ func validateDepositContainers(ctrs []*ethpb.DepositContainer) bool {
 	return true
 }
 
-// Validates the current powchain data is saved and makes sure that any
+// validates the current powchain data saved and makes sure that any
 // embedded genesis state is correctly accounted for.
 func (s *Service) ensureValidPowchainData(ctx context.Context) error {
 	genState, err := s.cfg.beaconDB.GenesisState(ctx)
@@ -824,13 +802,7 @@ func (s *Service) ensureValidPowchainData(ctx context.Context) error {
 		return errors.Wrap(err, "unable to retrieve eth1 data")
 	}
 	if eth1Data == nil || !eth1Data.ChainstartData.Chainstarted || !validateDepositContainers(eth1Data.DepositContainers) {
-		var pbState *ethpb.BeaconState
-		var err error
-		if features.Get().EnableNativeState {
-			pbState, err = native.ProtobufBeaconStatePhase0(s.preGenesisState.InnerStateUnsafe())
-		} else {
-			pbState, err = v1.ProtobufBeaconState(s.preGenesisState.InnerStateUnsafe())
-		}
+		pbState, err := v1.ProtobufBeaconState(s.preGenesisState.InnerStateUnsafe())
 		if err != nil {
 			return err
 		}

beacon-chain/powchain/service_test.go

@@ -12,9 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	gethTypes "github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
@@ -267,7 +265,7 @@ func TestFollowBlock_OK(t *testing.T) {
 	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
 	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
 
-	h, err := web3Service.followedBlockHeight(context.Background())
+	h, err := web3Service.followBlockHeight(context.Background())
 	require.NoError(t, err)
 	assert.Equal(t, baseHeight, h, "Unexpected block height")
 	numToForward := uint64(2)
@@ -280,7 +278,7 @@ func TestFollowBlock_OK(t *testing.T) {
 	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
 	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
 
-	h, err = web3Service.followedBlockHeight(context.Background())
+	h, err = web3Service.followBlockHeight(context.Background())
 	require.NoError(t, err)
 	assert.Equal(t, expectedHeight, h, "Unexpected block height")
 }
@@ -845,50 +843,3 @@ func TestETH1Endpoints(t *testing.T) {
 	// Check endpoints are all present.
 	assert.DeepSSZEqual(t, endpoints, s1.ETH1Endpoints(), "Unexpected http endpoint slice")
 }
-
-func TestService_CacheBlockHeaders(t *testing.T) {
-	rClient := &slowRPCClient{limit: 1000}
-	s := &Service{
-		cfg:         &config{eth1HeaderReqLimit: 1000},
-		rpcClient:   rClient,
-		headerCache: newHeaderCache(),
-	}
-	assert.NoError(t, s.cacheBlockHeaders(1, 1000))
-	assert.Equal(t, 1, rClient.numOfCalls)
-	// Reset Num of Calls
-	rClient.numOfCalls = 0
-
-	assert.NoError(t, s.cacheBlockHeaders(1000, 3000))
-	// 1000 - 2000 would be 1001 headers which is higher than our request limit, it
-	// is then reduced to 500 and tried again.
-	assert.Equal(t, 5, rClient.numOfCalls)
-}
-
-type slowRPCClient struct {
-	limit      int
-	numOfCalls int
-}
-
-func (s *slowRPCClient) Close() {
-	panic("implement me")
-}
-
-func (s *slowRPCClient) BatchCall(b []rpc.BatchElem) error {
-	s.numOfCalls++
-	if len(b) > s.limit {
-		return errTimedOut
-	}
-	for _, e := range b {
-		num, err := hexutil.DecodeBig(e.Args[0].(string))
-		if err != nil {
-			return err
-		}
-		h := &gethTypes.Header{Number: num}
-		*e.Result.(*gethTypes.Header) = *h
-	}
-	return nil
-}
-
-func (s *slowRPCClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
-	panic("implement me")
-}

beacon-chain/powchain/testing/mock_engine_client.go

@@ -28,7 +28,6 @@ type EngineClient struct {
 	BlockByHashMap          map[[32]byte]*pb.ExecutionBlock
 	TerminalBlockHash       []byte
 	TerminalBlockHashExists bool
-	OverrideValidHash       [32]byte
 }
 
 // NewPayload --
@@ -38,11 +37,8 @@ func (e *EngineClient) NewPayload(_ context.Context, _ *pb.ExecutionPayload) ([]
 
 // ForkchoiceUpdated --
 func (e *EngineClient) ForkchoiceUpdated(
-	_ context.Context, fcs *pb.ForkchoiceState, _ *pb.PayloadAttributes,
+	_ context.Context, _ *pb.ForkchoiceState, _ *pb.PayloadAttributes,
 ) (*pb.PayloadIDBytes, []byte, error) {
-	if e.OverrideValidHash != [32]byte{} && bytesutil.ToBytes32(fcs.HeadBlockHash) == e.OverrideValidHash {
-		return e.PayloadIDBytes, e.ForkChoiceUpdatedResp, nil
-	}
 	return e.PayloadIDBytes, e.ForkChoiceUpdatedResp, e.ErrForkchoiceUpdated
 }
 

beacon-chain/powchain/testing/mock_faulty_powchain.go

@@ -71,3 +71,8 @@ func (_ *FaultyMockPOWChain) ClearPreGenesisData() {
 func (_ *FaultyMockPOWChain) IsConnectedToETH1() bool {
 	return true
 }
+
+// BlockExistsWithCache --
+func (f *FaultyMockPOWChain) BlockExistsWithCache(ctx context.Context, hash common.Hash) (bool, *big.Int, error) {
+	return f.BlockExists(ctx, hash)
+}

beacon-chain/powchain/testing/mock_powchain.go

@@ -179,6 +179,11 @@ func (m *POWChain) InsertBlock(height int, time uint64, hash []byte) *POWChain {
 	return m
 }
 
+// BlockExistsWithCache --
+func (m *POWChain) BlockExistsWithCache(ctx context.Context, hash common.Hash) (bool, *big.Int, error) {
+	return m.BlockExists(ctx, hash)
+}
+
 func SetupRPCServer() (*rpc.Server, string, error) {
 	srv := rpc.NewServer()
 	if err := srv.RegisterName("eth", &testETHRPC{}); err != nil {

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

@@ -109,7 +109,7 @@ func (bs *Server) GetBlockHeader(ctx context.Context, req *ethpbv1.BlockRequest)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not determine if block root is canonical: %v", err)
 	}
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, blkRoot)
+	isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, blkRoot)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
 	}
@@ -175,7 +175,7 @@ func (bs *Server) ListBlockHeaders(ctx context.Context, req *ethpbv1.BlockHeader
 			return nil, status.Errorf(codes.Internal, "Could not determine if block root is canonical: %v", err)
 		}
 		if !isOptimistic {
-			isOptimistic, err = bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, blkRoots[i])
+			isOptimistic, err = bs.HeadFetcher.IsOptimisticForRoot(ctx, blkRoots[i])
 			if err != nil {
 				return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
 			}
@@ -371,7 +371,7 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get block root: %v", err)
 		}
-		isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+		isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, root)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
 		}
@@ -543,7 +543,7 @@ func (bs *Server) GetBlockRoot(ctx context.Context, req *ethpbv1.BlockRequest) (
 		}
 	}
 
-	isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, bytesutil.ToBytes32(root))
+	isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, bytesutil.ToBytes32(root))
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
 	}
@@ -616,7 +616,7 @@ func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockR
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get block root: %v", err)
 		}
-		isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+		isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, root)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
 		}

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

@@ -187,10 +187,9 @@ func TestServer_GetBlockHeader(t *testing.T) {
 		FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 	}
 	bs := &Server{
-		BeaconDB:              beaconDB,
-		ChainInfoFetcher:      mockChainService,
-		HeadFetcher:           mockChainService,
-		OptimisticModeFetcher: mockChainService,
+		BeaconDB:         beaconDB,
+		ChainInfoFetcher: mockChainService,
+		HeadFetcher:      mockChainService,
 	}
 
 	tests := []struct {
@@ -288,10 +287,9 @@ func TestServer_GetBlockHeader(t *testing.T) {
 			Optimistic:          true,
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 		header, err := bs.GetBlockHeader(ctx, &ethpbv1.BlockRequest{BlockId: []byte("head")})
 		require.NoError(t, err)
@@ -314,10 +312,9 @@ func TestServer_ListBlockHeaders(t *testing.T) {
 		FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 	}
 	bs := &Server{
-		BeaconDB:              beaconDB,
-		ChainInfoFetcher:      mockChainFetcher,
-		HeadFetcher:           mockChainFetcher,
-		OptimisticModeFetcher: mockChainFetcher,
+		BeaconDB:         beaconDB,
+		ChainInfoFetcher: mockChainFetcher,
+		HeadFetcher:      mockChainFetcher,
 	}
 
 	b2 := util.NewBeaconBlock()
@@ -419,10 +416,9 @@ func TestServer_ListBlockHeaders(t *testing.T) {
 			Optimistic:          true,
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainFetcher,
-			HeadFetcher:           mockChainFetcher,
-			OptimisticModeFetcher: mockChainFetcher,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainFetcher,
+			HeadFetcher:      mockChainFetcher,
 		}
 		slot := types.Slot(30)
 		headers, err := bs.ListBlockHeaders(ctx, &ethpbv1.BlockHeadersRequest{
@@ -840,10 +836,9 @@ func TestServer_GetBlockV2(t *testing.T) {
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
@@ -960,10 +955,9 @@ func TestServer_GetBlockV2(t *testing.T) {
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB)
@@ -1080,10 +1074,9 @@ func TestServer_GetBlockV2(t *testing.T) {
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
@@ -1201,10 +1194,9 @@ func TestServer_GetBlockV2(t *testing.T) {
 			Optimistic:          true,
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		blk, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{
@@ -1403,10 +1395,9 @@ func TestServer_GetBlockRoot(t *testing.T) {
 		FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 	}
 	bs := &Server{
-		BeaconDB:              beaconDB,
-		ChainInfoFetcher:      mockChainFetcher,
-		HeadFetcher:           mockChainFetcher,
-		OptimisticModeFetcher: mockChainFetcher,
+		BeaconDB:         beaconDB,
+		ChainInfoFetcher: mockChainFetcher,
+		HeadFetcher:      mockChainFetcher,
 	}
 
 	root, err := genBlk.Block.HashTreeRoot()
@@ -1494,10 +1485,9 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			Optimistic:          true,
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainFetcher,
-			HeadFetcher:           mockChainFetcher,
-			OptimisticModeFetcher: mockChainFetcher,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainFetcher,
+			HeadFetcher:      mockChainFetcher,
 		}
 		blockRootResp, err := bs.GetBlockRoot(ctx, &ethpbv1.BlockRequest{
 			BlockId: []byte("head"),
@@ -1523,10 +1513,9 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
@@ -1626,10 +1615,9 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB)
@@ -1729,10 +1717,9 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
@@ -1833,10 +1820,9 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 			Optimistic:          true,
 		}
 		bs := &Server{
-			BeaconDB:              beaconDB,
-			ChainInfoFetcher:      mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 		resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{
 			BlockId: []byte("head"),

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

@@ -34,9 +34,7 @@ type Server struct {
 	StateGenService         stategen.StateManager
 	StateFetcher            statefetcher.Fetcher
 	HeadFetcher             blockchain.HeadFetcher
-	OptimisticModeFetcher   blockchain.OptimisticModeFetcher
 	V1Alpha1ValidatorServer *v1alpha1validator.Server
 	SyncChecker             sync.Checker
 	CanonicalHistory        *stategen.CanonicalHistory
-	HeadUpdater             blockchain.HeadUpdater
 }

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

@@ -75,7 +75,7 @@ func (bs *Server) GetStateRoot(ctx context.Context, req *ethpb.StateRequest) (*e
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not get state: %v", err)
 	}
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -103,7 +103,7 @@ func (bs *Server) GetStateFork(ctx context.Context, req *ethpb.StateRequest) (*e
 		return nil, helpers.PrepareStateFetchGRPCError(err)
 	}
 	fork := st.Fork()
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -133,7 +133,7 @@ func (bs *Server) GetFinalityCheckpoints(ctx context.Context, req *ethpb.StateRe
 	if err != nil {
 		return nil, helpers.PrepareStateFetchGRPCError(err)
 	}
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}

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

@@ -80,15 +80,13 @@ func TestGetStateRoot(t *testing.T) {
 	require.NoError(t, err)
 	db := dbTest.SetupDB(t)
 
-	chainService := &chainMock.ChainService{}
 	server := &Server{
 		StateFetcher: &testutil.MockFetcher{
 			BeaconStateRoot: stateRoot[:],
 			BeaconState:     fakeState,
 		},
-		HeadFetcher:           chainService,
-		OptimisticModeFetcher: chainService,
-		BeaconDB:              db,
+		HeadFetcher: &chainMock.ChainService{},
+		BeaconDB:    db,
 	}
 
 	resp, err := server.GetStateRoot(context.Background(), &eth.StateRequest{
@@ -109,15 +107,13 @@ func TestGetStateRoot(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &chainMock.ChainService{Optimistic: true}
 		server := &Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconStateRoot: stateRoot[:],
 				BeaconState:     fakeState,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetStateRoot(context.Background(), &eth.StateRequest{
 			StateId: make([]byte, 0),
@@ -142,14 +138,12 @@ func TestGetStateFork(t *testing.T) {
 	require.NoError(t, err)
 	db := dbTest.SetupDB(t)
 
-	chainService := &chainMock.ChainService{}
 	server := &Server{
 		StateFetcher: &testutil.MockFetcher{
 			BeaconState: fakeState,
 		},
-		HeadFetcher:           chainService,
-		OptimisticModeFetcher: chainService,
-		BeaconDB:              db,
+		HeadFetcher: &chainMock.ChainService{},
+		BeaconDB:    db,
 	}
 
 	resp, err := server.GetStateFork(ctx, &eth.StateRequest{
@@ -173,14 +167,12 @@ func TestGetStateFork(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &chainMock.ChainService{Optimistic: true}
 		server := &Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetStateFork(context.Background(), &eth.StateRequest{
 			StateId: make([]byte, 0),
@@ -212,14 +204,12 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 	require.NoError(t, err)
 	db := dbTest.SetupDB(t)
 
-	chainService := &chainMock.ChainService{}
 	server := &Server{
 		StateFetcher: &testutil.MockFetcher{
 			BeaconState: fakeState,
 		},
-		HeadFetcher:           chainService,
-		OptimisticModeFetcher: chainService,
-		BeaconDB:              db,
+		HeadFetcher: &chainMock.ChainService{},
+		BeaconDB:    db,
 	}
 
 	resp, err := server.GetFinalityCheckpoints(ctx, &eth.StateRequest{
@@ -245,14 +235,12 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &chainMock.ChainService{Optimistic: true}
 		server := &Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetFinalityCheckpoints(context.Background(), &eth.StateRequest{
 			StateId: make([]byte, 0),

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

@@ -91,7 +91,7 @@ func (bs *Server) ListSyncCommittees(ctx context.Context, req *ethpbv2.StateSync
 		return nil, status.Errorf(codes.Internal, "Could not extract sync subcommittees: %v", err)
 	}
 
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}

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

@@ -162,7 +162,6 @@ func TestListSyncCommittees(t *testing.T) {
 	require.NoError(t, err)
 	db := dbTest.SetupDB(t)
 
-	chainService := &mock.ChainService{}
 	s := &Server{
 		GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 			Genesis: time.Now(),
@@ -170,9 +169,8 @@ func TestListSyncCommittees(t *testing.T) {
 		StateFetcher: &testutil.MockFetcher{
 			BeaconState: st,
 		},
-		HeadFetcher:           chainService,
-		OptimisticModeFetcher: chainService,
-		BeaconDB:              db,
+		HeadFetcher: &mock.ChainService{},
+		BeaconDB:    db,
 	}
 	req := &ethpbv2.StateSyncCommitteesRequest{StateId: stRoot[:]}
 	resp, err := s.ListSyncCommittees(ctx, req)
@@ -207,7 +205,6 @@ func TestListSyncCommittees(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &mock.ChainService{Optimistic: true}
 		s := &Server{
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
@@ -215,9 +212,8 @@ func TestListSyncCommittees(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &mock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 		resp, err := s.ListSyncCommittees(ctx, req)
 		require.NoError(t, err)
@@ -265,7 +261,6 @@ func TestListSyncCommitteesFuture(t *testing.T) {
 	}))
 	db := dbTest.SetupDB(t)
 
-	chainService := &mock.ChainService{}
 	s := &Server{
 		GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 			Genesis: time.Now(),
@@ -273,9 +268,8 @@ func TestListSyncCommitteesFuture(t *testing.T) {
 		StateFetcher: &futureSyncMockFetcher{
 			BeaconState: st,
 		},
-		HeadFetcher:           chainService,
-		OptimisticModeFetcher: chainService,
-		BeaconDB:              db,
+		HeadFetcher: &mock.ChainService{},
+		BeaconDB:    db,
 	}
 	req := &ethpbv2.StateSyncCommitteesRequest{}
 	epoch := 2 * params.BeaconConfig().EpochsPerSyncCommitteePeriod

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

@@ -57,7 +57,7 @@ func (bs *Server) GetValidator(ctx context.Context, req *ethpb.StateValidatorReq
 		return nil, status.Error(codes.NotFound, "Could not find validator")
 	}
 
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -80,7 +80,7 @@ func (bs *Server) ListValidators(ctx context.Context, req *ethpb.StateValidators
 		return nil, handleValContainerErr(err)
 	}
 
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -143,7 +143,7 @@ func (bs *Server) ListValidatorBalances(ctx context.Context, req *ethpb.Validato
 		}
 	}
 
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -202,7 +202,7 @@ func (bs *Server) ListCommittees(ctx context.Context, req *ethpb.StateCommittees
 		}
 	}
 
-	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}

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

@@ -33,14 +33,12 @@ func TestGetValidator(t *testing.T) {
 	st, _ = util.DeterministicGenesisState(t, 8192)
 
 	t.Run("Head Get Validator by index", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.GetValidator(ctx, &ethpb.StateValidatorRequest{
@@ -52,14 +50,12 @@ func TestGetValidator(t *testing.T) {
 	})
 
 	t.Run("Head Get Validator by pubkey", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		pubKey := st.PubkeyAtIndex(types.ValidatorIndex(20))
@@ -97,14 +93,12 @@ func TestGetValidator(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &chainMock.ChainService{Optimistic: true}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 		resp, err := s.GetValidator(ctx, &ethpb.StateValidatorRequest{
 			StateId:     []byte("head"),
@@ -123,14 +117,12 @@ func TestListValidators(t *testing.T) {
 	st, _ = util.DeterministicGenesisState(t, 8192)
 
 	t.Run("Head List All Validators", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -144,14 +136,12 @@ func TestListValidators(t *testing.T) {
 	})
 
 	t.Run("Head List Validators by index", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		ids := [][]byte{[]byte("15"), []byte("26"), []byte("400")}
@@ -168,14 +158,12 @@ func TestListValidators(t *testing.T) {
 	})
 
 	t.Run("Head List Validators by pubkey", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 		idNums := []types.ValidatorIndex{20, 66, 90, 100}
 		pubkey1 := st.PubkeyAtIndex(types.ValidatorIndex(20))
@@ -196,14 +184,12 @@ func TestListValidators(t *testing.T) {
 	})
 
 	t.Run("Head List Validators by both index and pubkey", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		idNums := []types.ValidatorIndex{20, 90, 170, 129}
@@ -226,14 +212,12 @@ func TestListValidators(t *testing.T) {
 	})
 
 	t.Run("Unknown public key is ignored", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		existingKey := st.PubkeyAtIndex(types.ValidatorIndex(1))
@@ -248,14 +232,12 @@ func TestListValidators(t *testing.T) {
 	})
 
 	t.Run("Unknown index is ignored", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		ids := [][]byte{[]byte("1"), []byte("99999")}
@@ -279,14 +261,12 @@ func TestListValidators(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &chainMock.ChainService{Optimistic: true}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
 			StateId: []byte("head"),
@@ -369,14 +349,12 @@ func TestListValidators_Status(t *testing.T) {
 	}
 
 	t.Run("Head List All ACTIVE Validators", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -406,14 +384,12 @@ func TestListValidators_Status(t *testing.T) {
 	})
 
 	t.Run("Head List All ACTIVE_ONGOING Validators", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -442,14 +418,12 @@ func TestListValidators_Status(t *testing.T) {
 
 	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*35))
 	t.Run("Head List All EXITED Validators", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -477,14 +451,12 @@ func TestListValidators_Status(t *testing.T) {
 	})
 
 	t.Run("Head List All PENDING_INITIALIZED and EXITED_UNSLASHED Validators", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -512,14 +484,12 @@ func TestListValidators_Status(t *testing.T) {
 	})
 
 	t.Run("Head List All PENDING and EXITED Validators", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -562,14 +532,12 @@ func TestListValidatorBalances(t *testing.T) {
 	require.NoError(t, st.SetBalances(balances))
 
 	t.Run("Head List Validators Balance by index", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		ids := [][]byte{[]byte("15"), []byte("26"), []byte("400")}
@@ -586,14 +554,12 @@ func TestListValidatorBalances(t *testing.T) {
 	})
 
 	t.Run("Head List Validators Balance by pubkey", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 		idNums := []types.ValidatorIndex{20, 66, 90, 100}
 		pubkey1 := st.PubkeyAtIndex(types.ValidatorIndex(20))
@@ -613,14 +579,12 @@ func TestListValidatorBalances(t *testing.T) {
 	})
 
 	t.Run("Head List Validators Balance by both index and pubkey", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		idNums := []types.ValidatorIndex{20, 90, 170, 129}
@@ -649,14 +613,12 @@ func TestListValidatorBalances(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &chainMock.ChainService{Optimistic: true}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 
 		ids := [][]byte{[]byte("15"), []byte("26"), []byte("400")}
@@ -678,14 +640,12 @@ func TestListCommittees(t *testing.T) {
 	epoch := slots.ToEpoch(st.Slot())
 
 	t.Run("Head All Committees", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListCommittees(ctx, &ethpb.StateCommitteesRequest{
@@ -700,14 +660,12 @@ func TestListCommittees(t *testing.T) {
 	})
 
 	t.Run("Head All Committees of Epoch 10", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 		epoch := types.Epoch(10)
 		resp, err := s.ListCommittees(ctx, &ethpb.StateCommitteesRequest{
@@ -721,14 +679,12 @@ func TestListCommittees(t *testing.T) {
 	})
 
 	t.Run("Head All Committees of Slot 4", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		slot := types.Slot(4)
@@ -748,14 +704,12 @@ func TestListCommittees(t *testing.T) {
 	})
 
 	t.Run("Head All Committees of Index 1", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		index := types.CommitteeIndex(1)
@@ -775,14 +729,12 @@ func TestListCommittees(t *testing.T) {
 	})
 
 	t.Run("Head All Committees of Slot 2, Index 1", func(t *testing.T) {
-		chainService := &chainMock.ChainService{}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		index := types.CommitteeIndex(1)
@@ -812,14 +764,12 @@ func TestListCommittees(t *testing.T) {
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
-		chainService := &chainMock.ChainService{Optimistic: true}
 		s := Server{
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			BeaconDB:              db,
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListCommittees(ctx, &ethpb.StateCommitteesRequest{

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

@@ -65,7 +65,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 	if err != nil {
 		return nil, helpers.PrepareStateFetchGRPCError(err)
 	}
-	isOptimistic, err := helpers.IsOptimistic(ctx, beaconSt, ds.OptimisticModeFetcher)
+	isOptimistic, err := helpers.IsOptimistic(ctx, beaconSt, ds.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -167,7 +167,7 @@ func (ds *Server) ListForkChoiceHeadsV2(ctx context.Context, _ *emptypb.Empty) (
 		Data: make([]*ethpbv2.ForkChoiceHead, len(headRoots)),
 	}
 	for i := range headRoots {
-		isOptimistic, err := ds.OptimisticModeFetcher.IsOptimisticForRoot(ctx, headRoots[i])
+		isOptimistic, err := ds.HeadFetcher.IsOptimisticForRoot(ctx, headRoots[i])
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not check if head is optimistic: %v", err)
 		}

beacon-chain/rpc/eth/debug/debug_test.go

@@ -44,9 +44,8 @@ func TestGetBeaconStateV2(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
-			HeadFetcher:           &blockchainmock.ChainService{},
-			OptimisticModeFetcher: &blockchainmock.ChainService{},
-			BeaconDB:              db,
+			HeadFetcher: &blockchainmock.ChainService{},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
 			StateId: make([]byte, 0),
@@ -61,9 +60,8 @@ func TestGetBeaconStateV2(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
-			HeadFetcher:           &blockchainmock.ChainService{},
-			OptimisticModeFetcher: &blockchainmock.ChainService{},
-			BeaconDB:              db,
+			HeadFetcher: &blockchainmock.ChainService{},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
 			StateId: make([]byte, 0),
@@ -78,9 +76,8 @@ func TestGetBeaconStateV2(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
-			HeadFetcher:           &blockchainmock.ChainService{},
-			OptimisticModeFetcher: &blockchainmock.ChainService{},
-			BeaconDB:              db,
+			HeadFetcher: &blockchainmock.ChainService{},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
 			StateId: make([]byte, 0),
@@ -105,9 +102,8 @@ func TestGetBeaconStateV2(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
-			HeadFetcher:           &blockchainmock.ChainService{},
-			OptimisticModeFetcher: &blockchainmock.ChainService{Optimistic: true},
-			BeaconDB:              db,
+			HeadFetcher: &blockchainmock.ChainService{Optimistic: true},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
 			StateId: make([]byte, 0),
@@ -242,10 +238,8 @@ func TestListForkChoiceHeadsV2(t *testing.T) {
 		Root: bytesutil.ToBytes32(bytesutil.PadTo([]byte("bar"), 32)),
 	}}
 
-	chainService := &blockchainmock.ChainService{}
 	server := &Server{
-		HeadFetcher:           chainService,
-		OptimisticModeFetcher: chainService,
+		HeadFetcher: &blockchainmock.ChainService{},
 	}
 	resp, err := server.ListForkChoiceHeadsV2(ctx, &emptypb.Empty{})
 	require.NoError(t, err)
@@ -263,10 +257,8 @@ func TestListForkChoiceHeadsV2(t *testing.T) {
 	}
 
 	t.Run("optimistic head", func(t *testing.T) {
-		chainService := &blockchainmock.ChainService{Optimistic: true}
 		server := &Server{
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
+			HeadFetcher: &blockchainmock.ChainService{Optimistic: true},
 		}
 		resp, err := server.ListForkChoiceHeadsV2(ctx, &emptypb.Empty{})
 		require.NoError(t, err)

beacon-chain/rpc/eth/debug/server.go

@@ -12,8 +12,7 @@ import (
 // Server defines a server implementation of the gRPC Beacon Chain service,
 // providing RPC endpoints to access data relevant to the Ethereum Beacon Chain.
 type Server struct {
-	BeaconDB              db.ReadOnlyDatabase
-	HeadFetcher           blockchain.HeadFetcher
-	StateFetcher          statefetcher.Fetcher
-	OptimisticModeFetcher blockchain.OptimisticModeFetcher
+	BeaconDB     db.ReadOnlyDatabase
+	HeadFetcher  blockchain.HeadFetcher
+	StateFetcher statefetcher.Fetcher
 }

beacon-chain/rpc/eth/helpers/sync.go

@@ -39,7 +39,7 @@ func ValidateSync(ctx context.Context, syncChecker sync.Checker, headFetcher blo
 }
 
 // IsOptimistic checks whether the latest block header of the passed in beacon state is the header of an optimistic block.
-func IsOptimistic(ctx context.Context, st state.BeaconState, optimisticSyncFetcher blockchain.OptimisticModeFetcher) (bool, error) {
+func IsOptimistic(ctx context.Context, st state.BeaconState, headFetcher blockchain.HeadFetcher) (bool, error) {
 	root, err := st.HashTreeRoot(ctx)
 	if err != nil {
 		return false, errors.Wrap(err, "could not get state root")
@@ -50,7 +50,7 @@ func IsOptimistic(ctx context.Context, st state.BeaconState, optimisticSyncFetch
 	if err != nil {
 		return false, errors.Wrap(err, "could not get header root")
 	}
-	isOptimistic, err := optimisticSyncFetcher.IsOptimisticForRoot(ctx, headRoot)
+	isOptimistic, err := headFetcher.IsOptimisticForRoot(ctx, headRoot)
 	if err != nil {
 		return false, errors.Wrap(err, "could not check if block is optimistic")
 	}

beacon-chain/rpc/eth/helpers/sync_test.go

@@ -58,14 +58,14 @@ func TestIsOptimistic(t *testing.T) {
 	require.NoError(t, err)
 
 	t.Run("optimistic", func(t *testing.T) {
-		mockOptSyncFetcher := &chainmock.ChainService{Optimistic: true}
-		o, err := IsOptimistic(ctx, st, mockOptSyncFetcher)
+		mockHeadFetcher := &chainmock.ChainService{Optimistic: true}
+		o, err := IsOptimistic(ctx, st, mockHeadFetcher)
 		require.NoError(t, err)
 		assert.Equal(t, true, o)
 	})
 	t.Run("not optimistic", func(t *testing.T) {
-		mockOptSyncFetcher := &chainmock.ChainService{Optimistic: false}
-		o, err := IsOptimistic(ctx, st, mockOptSyncFetcher)
+		mockHeadFetcher := &chainmock.ChainService{Optimistic: false}
+		o, err := IsOptimistic(ctx, st, mockHeadFetcher)
 		require.NoError(t, err)
 		assert.Equal(t, false, o)
 	})

beacon-chain/rpc/eth/validator/server.go

@@ -13,15 +13,13 @@ import (
 // Server defines a server implementation of the gRPC Validator service,
 // providing RPC endpoints intended for validator clients.
 type Server struct {
-	HeadFetcher           blockchain.HeadFetcher
-	HeadUpdater           blockchain.HeadUpdater
-	TimeFetcher           blockchain.TimeFetcher
-	SyncChecker           sync.Checker
-	AttestationsPool      attestations.Pool
-	PeerManager           p2p.PeerManager
-	Broadcaster           p2p.Broadcaster
-	StateFetcher          statefetcher.Fetcher
-	OptimisticModeFetcher blockchain.OptimisticModeFetcher
-	SyncCommitteePool     synccommittee.Pool
-	V1Alpha1Server        *v1alpha1validator.Server
+	HeadFetcher       blockchain.HeadFetcher
+	TimeFetcher       blockchain.TimeFetcher
+	SyncChecker       sync.Checker
+	AttestationsPool  attestations.Pool
+	PeerManager       p2p.PeerManager
+	Broadcaster       p2p.Broadcaster
+	StateFetcher      statefetcher.Fetcher
+	SyncCommitteePool synccommittee.Pool
+	V1Alpha1Server    *v1alpha1validator.Server
 }

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

@@ -58,7 +58,7 @@ func (vs *Server) GetAttesterDuties(ctx context.Context, req *ethpbv1.AttesterDu
 		return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
 	}
 
-	isOptimistic, err := rpchelpers.IsOptimistic(ctx, s, vs.OptimisticModeFetcher)
+	isOptimistic, err := rpchelpers.IsOptimistic(ctx, s, vs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -142,7 +142,7 @@ func (vs *Server) GetProposerDuties(ctx context.Context, req *ethpbv1.ProposerDu
 		return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
 	}
 
-	isOptimistic, err := rpchelpers.IsOptimistic(ctx, s, vs.OptimisticModeFetcher)
+	isOptimistic, err := rpchelpers.IsOptimistic(ctx, s, vs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
@@ -258,7 +258,7 @@ func (vs *Server) GetSyncCommitteeDuties(ctx context.Context, req *ethpbv2.SyncC
 		return nil, status.Errorf(codes.Internal, "Could not get duties: %v", err)
 	}
 
-	isOptimistic, err := rpchelpers.IsOptimistic(ctx, st, vs.OptimisticModeFetcher)
+	isOptimistic, err := rpchelpers.IsOptimistic(ctx, st, vs.HeadFetcher)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}

beacon-chain/rpc/eth/validator/validator_test.go

@@ -82,10 +82,9 @@ func TestGetAttesterDuties(t *testing.T) {
 		State: bs, Root: genesisRoot[:], Slot: &chainSlot,
 	}
 	vs := &Server{
-		HeadFetcher:           chain,
-		TimeFetcher:           chain,
-		SyncChecker:           &mockSync.Sync{IsSyncing: false},
-		OptimisticModeFetcher: chain,
+		HeadFetcher: chain,
+		TimeFetcher: chain,
+		SyncChecker: &mockSync.Sync{IsSyncing: false},
 	}
 
 	t.Run("Single validator", func(t *testing.T) {
@@ -161,10 +160,9 @@ func TestGetAttesterDuties(t *testing.T) {
 			State: bs, Root: genesisRoot[:], Slot: &chainSlot,
 		}
 		vs := &Server{
-			HeadFetcher:           chain,
-			TimeFetcher:           chain,
-			OptimisticModeFetcher: chain,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
+			HeadFetcher: chain,
+			TimeFetcher: chain,
+			SyncChecker: &mockSync.Sync{IsSyncing: false},
 		}
 
 		req := &ethpbv1.AttesterDutiesRequest{
@@ -233,10 +231,9 @@ func TestGetAttesterDuties(t *testing.T) {
 			State: bs, Root: genesisRoot[:], Slot: &chainSlot, Optimistic: true,
 		}
 		vs := &Server{
-			HeadFetcher:           chain,
-			TimeFetcher:           chain,
-			OptimisticModeFetcher: chain,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
+			HeadFetcher: chain,
+			TimeFetcher: chain,
+			SyncChecker: &mockSync.Sync{IsSyncing: false},
 		}
 		req := &ethpbv1.AttesterDutiesRequest{
 			Epoch: 0,
@@ -288,10 +285,9 @@ func TestGetProposerDuties(t *testing.T) {
 		State: bs, Root: genesisRoot[:], Slot: &chainSlot,
 	}
 	vs := &Server{
-		HeadFetcher:           chain,
-		TimeFetcher:           chain,
-		OptimisticModeFetcher: chain,
-		SyncChecker:           &mockSync.Sync{IsSyncing: false},
+		HeadFetcher: chain,
+		TimeFetcher: chain,
+		SyncChecker: &mockSync.Sync{IsSyncing: false},
 	}
 
 	t.Run("Ok", func(t *testing.T) {
@@ -339,10 +335,9 @@ func TestGetProposerDuties(t *testing.T) {
 			State: bs, Root: genesisRoot[:], Slot: &chainSlot,
 		}
 		vs := &Server{
-			HeadFetcher:           chain,
-			TimeFetcher:           chain,
-			OptimisticModeFetcher: chain,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
+			HeadFetcher: chain,
+			TimeFetcher: chain,
+			SyncChecker: &mockSync.Sync{IsSyncing: false},
 		}
 
 		req := &ethpbv1.ProposerDutiesRequest{
@@ -391,10 +386,9 @@ func TestGetProposerDuties(t *testing.T) {
 			State: bs, Root: genesisRoot[:], Slot: &chainSlot, Optimistic: true,
 		}
 		vs := &Server{
-			HeadFetcher:           chain,
-			TimeFetcher:           chain,
-			OptimisticModeFetcher: chain,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
+			HeadFetcher: chain,
+			TimeFetcher: chain,
+			SyncChecker: &mockSync.Sync{IsSyncing: false},
 		}
 		req := &ethpbv1.ProposerDutiesRequest{
 			Epoch: 0,
@@ -439,11 +433,10 @@ func TestGetSyncCommitteeDuties(t *testing.T) {
 
 	mockChainService := &mockChain.ChainService{Genesis: genesisTime}
 	vs := &Server{
-		StateFetcher:          &testutil.MockFetcher{BeaconState: st},
-		SyncChecker:           &mockSync.Sync{IsSyncing: false},
-		TimeFetcher:           mockChainService,
-		HeadFetcher:           mockChainService,
-		OptimisticModeFetcher: mockChainService,
+		StateFetcher: &testutil.MockFetcher{BeaconState: st},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+		TimeFetcher:  mockChainService,
+		HeadFetcher:  mockChainService,
 	}
 
 	t.Run("Single validator", func(t *testing.T) {
@@ -578,11 +571,10 @@ func TestGetSyncCommitteeDuties(t *testing.T) {
 		}
 		mockChainService := &mockChain.ChainService{Genesis: genesisTime, Slot: &newSyncPeriodStartSlot}
 		vs := &Server{
-			StateFetcher:          &testutil.MockFetcher{BeaconState: stateFetchFn(newSyncPeriodStartSlot)},
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-			TimeFetcher:           mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			StateFetcher: &testutil.MockFetcher{BeaconState: stateFetchFn(newSyncPeriodStartSlot)},
+			SyncChecker:  &mockSync.Sync{IsSyncing: false},
+			TimeFetcher:  mockChainService,
+			HeadFetcher:  mockChainService,
 		}
 
 		req := &ethpbv2.SyncCommitteeDutiesRequest{
@@ -614,11 +606,10 @@ func TestGetSyncCommitteeDuties(t *testing.T) {
 
 		mockChainService := &mockChain.ChainService{Genesis: genesisTime, Optimistic: true}
 		vs := &Server{
-			StateFetcher:          &testutil.MockFetcher{BeaconState: st},
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-			TimeFetcher:           mockChainService,
-			HeadFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			StateFetcher: &testutil.MockFetcher{BeaconState: st},
+			SyncChecker:  &mockSync.Sync{IsSyncing: false},
+			TimeFetcher:  mockChainService,
+			HeadFetcher:  mockChainService,
 		}
 		req := &ethpbv2.SyncCommitteeDutiesRequest{
 			Epoch: 0,
@@ -633,10 +624,9 @@ func TestGetSyncCommitteeDuties(t *testing.T) {
 func TestGetSyncCommitteeDuties_SyncNotReady(t *testing.T) {
 	chainService := &mockChain.ChainService{}
 	vs := &Server{
-		SyncChecker:           &mockSync.Sync{IsSyncing: true},
-		HeadFetcher:           chainService,
-		TimeFetcher:           chainService,
-		OptimisticModeFetcher: chainService,
+		SyncChecker: &mockSync.Sync{IsSyncing: true},
+		HeadFetcher: chainService,
+		TimeFetcher: chainService,
 	}
 	_, err := vs.GetSyncCommitteeDuties(context.Background(), &ethpbv2.SyncCommitteeDutiesRequest{})
 	assert.ErrorContains(t, "Syncing to latest head, not ready to respond", err)
@@ -680,7 +670,6 @@ func TestProduceBlock(t *testing.T) {
 		HeadFetcher:       &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
 		SyncChecker:       &mockSync.Sync{IsSyncing: false},
 		BlockReceiver:     &mockChain.ChainService{},
-		HeadUpdater:       &mockChain.ChainService{},
 		ChainStartFetcher: &mockPOW.POWChain{},
 		Eth1InfoFetcher:   &mockPOW.POWChain{},
 		Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -785,7 +774,6 @@ func TestProduceBlockV2(t *testing.T) {
 			HeadFetcher:       &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
 			ChainStartFetcher: &mockPOW.POWChain{},
 			Eth1InfoFetcher:   &mockPOW.POWChain{},
 			Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -891,7 +879,6 @@ func TestProduceBlockV2(t *testing.T) {
 			HeadFetcher:       &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
 			ChainStartFetcher: &mockPOW.POWChain{},
 			Eth1InfoFetcher:   &mockPOW.POWChain{},
 			Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -1039,10 +1026,8 @@ func TestProduceBlockV2(t *testing.T) {
 			},
 			TimeFetcher:            &mockChain.ChainService{},
 			HeadFetcher:            &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
-			OptimisticModeFetcher:  &mockChain.ChainService{},
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
 			ChainStartFetcher:      &mockPOW.POWChain{},
 			Eth1InfoFetcher:        &mockPOW.POWChain{},
 			Eth1BlockFetcher:       &mockPOW.POWChain{},
@@ -1189,7 +1174,6 @@ func TestProduceBlindedBlock(t *testing.T) {
 			HeadFetcher:       &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
 			ChainStartFetcher: &mockPOW.POWChain{},
 			Eth1InfoFetcher:   &mockPOW.POWChain{},
 			Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -1296,7 +1280,6 @@ func TestProduceBlindedBlock(t *testing.T) {
 			HeadFetcher:       &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
 			ChainStartFetcher: &mockPOW.POWChain{},
 			Eth1InfoFetcher:   &mockPOW.POWChain{},
 			Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -1444,10 +1427,8 @@ func TestProduceBlindedBlock(t *testing.T) {
 			},
 			TimeFetcher:            &mockChain.ChainService{},
 			HeadFetcher:            &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
-			OptimisticModeFetcher:  &mockChain.ChainService{},
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
 			ChainStartFetcher:      &mockPOW.POWChain{},
 			Eth1InfoFetcher:        &mockPOW.POWChain{},
 			Eth1BlockFetcher:       &mockPOW.POWChain{},

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

@@ -46,5 +46,4 @@ type Server struct {
 	StateGen                    stategen.StateManager
 	SyncChecker                 sync.Checker
 	ReplayerBuilder             stategen.ReplayerBuilder
-	HeadUpdater                 blockchain.HeadUpdater
 }

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

@@ -499,7 +499,7 @@ func (bs *Server) GetValidatorParticipation(
 	}
 	// Use the last slot of requested epoch to obtain current and previous epoch attestations.
 	// This ensures that we don't miss previous attestations when input requested epochs.
-	endSlot, err := slots.EpochEnd(requestedEpoch)
+	startSlot, err := slots.EpochEnd(requestedEpoch)
 	if err != nil {
 		return nil, err
 	}
@@ -507,14 +507,14 @@ func (bs *Server) GetValidatorParticipation(
 	// The above check ensures a future *epoch* isn't requested, but the end slot of the requested epoch could still
 	// be past the current slot. In that case, use the current slot as the best approximation of the requested epoch.
 	// Replayer will make sure the slot ultimately used is canonical.
-	if endSlot > currentSlot {
-		endSlot = currentSlot
+	if startSlot > currentSlot {
+		startSlot = currentSlot
 	}
 
 	// ReplayerBuilder ensures that a canonical chain is followed to the slot
-	beaconState, err := bs.ReplayerBuilder.ReplayerForSlot(endSlot).ReplayBlocks(ctx)
+	beaconState, err := bs.ReplayerBuilder.ReplayerForSlot(startSlot).ReplayBlocks(ctx)
 	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", endSlot, err))
+		return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", startSlot, err))
 	}
 	var v []*precompute.Validator
 	var b *precompute.Balance

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

@@ -178,10 +178,9 @@ func TestGetAttestationData_Optimistic(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 
 	as := &Server{
-		SyncChecker:           &mockSync.Sync{},
-		TimeFetcher:           &mock.ChainService{Genesis: time.Now()},
-		HeadFetcher:           &mock.ChainService{},
-		OptimisticModeFetcher: &mock.ChainService{Optimistic: true},
+		SyncChecker: &mockSync.Sync{},
+		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
+		HeadFetcher: &mock.ChainService{Optimistic: true},
 	}
 	_, err := as.GetAttestationData(context.Background(), &ethpb.AttestationDataRequest{})
 	s, ok := status.FromError(err)
@@ -192,11 +191,10 @@ func TestGetAttestationData_Optimistic(t *testing.T) {
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	as = &Server{
-		SyncChecker:           &mockSync.Sync{},
-		TimeFetcher:           &mock.ChainService{Genesis: time.Now()},
-		HeadFetcher:           &mock.ChainService{Optimistic: false, State: beaconState},
-		OptimisticModeFetcher: &mock.ChainService{Optimistic: false},
-		AttestationCache:      cache.NewAttestationCache(),
+		SyncChecker:      &mockSync.Sync{},
+		TimeFetcher:      &mock.ChainService{Genesis: time.Now()},
+		HeadFetcher:      &mock.ChainService{Optimistic: false, State: beaconState},
+		AttestationCache: cache.NewAttestationCache(),
 	}
 	_, err = as.GetAttestationData(context.Background(), &ethpb.AttestationDataRequest{})
 	require.NoError(t, err)

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

@@ -197,16 +197,10 @@ func (vs *Server) rebuildDepositTrie(ctx context.Context, canonicalEth1Data *eth
 
 // validate that the provided deposit trie matches up with the canonical eth1 data provided.
 func validateDepositTrie(trie *trie.SparseMerkleTrie, canonicalEth1Data *ethpb.Eth1Data) (bool, error) {
-	if trie == nil || canonicalEth1Data == nil {
-		return false, errors.New("nil trie or eth1data provided")
-	}
 	if trie.NumOfItems() != int(canonicalEth1Data.DepositCount) {
 		return false, errors.Errorf("wanted the canonical count of %d but received %d", canonicalEth1Data.DepositCount, trie.NumOfItems())
 	}
-	rt, err := trie.HashTreeRoot()
-	if err != nil {
-		return false, err
-	}
+	rt := trie.HashTreeRoot()
 	if !bytes.Equal(rt[:], canonicalEth1Data.DepositRoot) {
 		return false, errors.Errorf("wanted the canonical deposit root of %#x but received %#x", canonicalEth1Data.DepositRoot, rt)
 	}

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

@@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -131,7 +130,7 @@ func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot, vIdx
 		if bytes.Equal(feeRecipient.Bytes(), burnAddr) {
 			logrus.WithFields(logrus.Fields{
 				"validatorIndex": vIdx,
-				"burnAddress":    common.BytesToAddress(burnAddr).Hex(),
+				"burnAddress":    burnAddr,
 			}).Error("Fee recipient not set. Using burn address")
 		}
 	default:

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

@@ -82,10 +82,6 @@ func (vs *Server) buildPhase0BlockData(ctx context.Context, req *ethpb.BlockRequ
 		return nil, fmt.Errorf("syncing to latest head, not ready to respond")
 	}
 
-	if err := vs.HeadUpdater.UpdateHead(ctx); err != nil {
-		log.WithError(err).Error("Could not process attestations and update head")
-	}
-
 	// Retrieve the parent block as the current head of the canonical chain.
 	parentRoot, err := vs.HeadFetcher.HeadRoot(ctx)
 	if err != nil {

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

@@ -72,7 +72,6 @@ func TestProposer_GetBlock_OK(t *testing.T) {
 		HeadFetcher:       &mock.ChainService{State: beaconState, Root: parentRoot[:]},
 		SyncChecker:       &mockSync.Sync{IsSyncing: false},
 		BlockReceiver:     &mock.ChainService{},
-		HeadUpdater:       &mock.ChainService{},
 		ChainStartFetcher: &mockPOW.POWChain{},
 		Eth1InfoFetcher:   &mockPOW.POWChain{},
 		Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -159,7 +158,6 @@ func TestProposer_GetBlock_AddsUnaggregatedAtts(t *testing.T) {
 		ChainStartFetcher: &mockPOW.POWChain{},
 		Eth1InfoFetcher:   &mockPOW.POWChain{},
 		Eth1BlockFetcher:  &mockPOW.POWChain{},
-		HeadUpdater:       &mock.ChainService{},
 		MockEth1Votes:     true,
 		SlashingsPool:     slashings.NewPool(),
 		AttPool:           attestations.NewPool(),
@@ -505,14 +503,10 @@ func TestProposer_PendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot())
 	}
 
 	blk := util.NewBeaconBlock()
@@ -644,14 +638,10 @@ func TestProposer_PendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot())
 	}
 
 	bs := &Server{
@@ -747,14 +737,10 @@ func TestProposer_PendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testin
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, depositTrie.HashTreeRoot())
 	}
 
 	bs := &Server{
@@ -847,14 +833,10 @@ func TestProposer_PendingDeposits_CantReturnMoreThanMax(t *testing.T) {
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, height.Uint64(), dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, height.Uint64(), dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, height.Uint64(), dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, height.Uint64(), dp.Index, depositTrie.HashTreeRoot())
 	}
 
 	bs := &Server{
@@ -945,14 +927,10 @@ func TestProposer_PendingDeposits_CantReturnMoreThanDepositCount(t *testing.T) {
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, depositTrie.HashTreeRoot())
 	}
 
 	bs := &Server{
@@ -1058,14 +1036,10 @@ func TestProposer_DepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot())
 	}
 
 	bs := &Server{
@@ -1081,10 +1055,8 @@ func TestProposer_DepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
 	trie, err := bs.depositTrie(ctx, &ethpb.Eth1Data{}, big.NewInt(int64(params.BeaconConfig().Eth1FollowDistance)))
 	require.NoError(t, err)
 
-	actualRoot, err := trie.HashTreeRoot()
-	require.NoError(t, err)
-	expectedRoot, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
+	actualRoot := trie.HashTreeRoot()
+	expectedRoot := depositTrie.HashTreeRoot()
 	assert.Equal(t, expectedRoot, actualRoot, "Incorrect deposit trie root")
 }
 
@@ -1174,14 +1146,10 @@ func TestProposer_DepositTrie_RebuildTrie(t *testing.T) {
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.HashTreeRoot())
 	}
 	d := depositCache.AllDepositContainers(ctx)
 	origDeposit, ok := proto.Clone(d[0].Deposit).(*ethpb.Deposit)
@@ -1209,10 +1177,8 @@ func TestProposer_DepositTrie_RebuildTrie(t *testing.T) {
 	trie, err := bs.depositTrie(ctx, &ethpb.Eth1Data{}, big.NewInt(int64(params.BeaconConfig().Eth1FollowDistance)))
 	require.NoError(t, err)
 
-	expectedRoot, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	actualRoot, err := trie.HashTreeRoot()
-	require.NoError(t, err)
+	expectedRoot := depositTrie.HashTreeRoot()
+	actualRoot := trie.HashTreeRoot()
 	assert.Equal(t, expectedRoot, actualRoot, "Incorrect deposit trie root")
 
 }
@@ -1264,8 +1230,7 @@ func TestProposer_ValidateDepositTrie(t *testing.T) {
 				assert.NoError(t, trie.Insert([]byte{'a'}, 0))
 				assert.NoError(t, trie.Insert([]byte{'b'}, 1))
 				assert.NoError(t, trie.Insert([]byte{'c'}, 2))
-				rt, err := trie.HashTreeRoot()
-				require.NoError(t, err)
+				rt := trie.HashTreeRoot()
 				return &ethpb.Eth1Data{DepositRoot: rt[:], DepositCount: 3, BlockHash: []byte{}}
 			},
 			trieCreator: func() *trie.SparseMerkleTrie {
@@ -1309,9 +1274,7 @@ func TestProposer_Eth1Data_MajorityVote(t *testing.T) {
 	require.NoError(t, err)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(context.Background(), dc.Deposit, dc.Eth1BlockHeight, dc.Index, root))
+	assert.NoError(t, depositCache.InsertDeposit(context.Background(), dc.Deposit, dc.Eth1BlockHeight, dc.Index, depositTrie.HashTreeRoot()))
 
 	t.Run("choose highest count", func(t *testing.T) {
 		t.Skip()
@@ -2013,14 +1976,10 @@ func TestProposer_Deposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t
 		require.NoError(t, err, "Unable to determine hashed value of deposit")
 
 		assert.NoError(t, depositTrie.Insert(depositHash[:], int(dp.Index)))
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, depositTrie.HashTreeRoot()))
 	}
 	for _, dp := range recentDeposits {
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		depositCache.InsertPendingDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, root)
+		depositCache.InsertPendingDeposit(ctx, dp.Deposit, uint64(dp.Index), dp.Index, depositTrie.HashTreeRoot())
 	}
 
 	bs := &Server{
@@ -2107,7 +2066,6 @@ func TestProposer_GetBeaconBlock_PreForkEpoch(t *testing.T) {
 		HeadFetcher:       &mock.ChainService{State: beaconState, Root: parentRoot[:]},
 		SyncChecker:       &mockSync.Sync{IsSyncing: false},
 		BlockReceiver:     &mock.ChainService{},
-		HeadUpdater:       &mock.ChainService{},
 		ChainStartFetcher: &mockPOW.POWChain{},
 		Eth1InfoFetcher:   &mockPOW.POWChain{},
 		Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -2220,7 +2178,6 @@ func TestProposer_GetBeaconBlock_PostForkEpoch(t *testing.T) {
 		HeadFetcher:       &mock.ChainService{State: beaconState, Root: parentRoot[:]},
 		SyncChecker:       &mockSync.Sync{IsSyncing: false},
 		BlockReceiver:     &mock.ChainService{},
-		HeadUpdater:       &mock.ChainService{},
 		ChainStartFetcher: &mockPOW.POWChain{},
 		Eth1InfoFetcher:   &mockPOW.POWChain{},
 		Eth1BlockFetcher:  &mockPOW.POWChain{},
@@ -2374,7 +2331,6 @@ func TestProposer_GetBeaconBlock_BellatrixEpoch(t *testing.T) {
 		TimeFetcher:       &mock.ChainService{Genesis: time.Now()},
 		SyncChecker:       &mockSync.Sync{IsSyncing: false},
 		BlockReceiver:     &mock.ChainService{},
-		HeadUpdater:       &mock.ChainService{},
 		ChainStartFetcher: &mockPOW.POWChain{},
 		Eth1InfoFetcher:   &mockPOW.POWChain{},
 		Eth1BlockFetcher:  c,
@@ -2437,7 +2393,7 @@ func TestProposer_GetBeaconBlock_Optimistic(t *testing.T) {
 	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
 	require.NoError(t, err)
 
-	proposerServer := &Server{OptimisticModeFetcher: &mock.ChainService{Optimistic: true}, TimeFetcher: &mock.ChainService{}}
+	proposerServer := &Server{HeadFetcher: &mock.ChainService{Optimistic: true}, TimeFetcher: &mock.ChainService{}}
 	req := &ethpb.BlockRequest{
 		Slot: bellatrixSlot + 1,
 	}

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

@@ -43,7 +43,6 @@ type Server struct {
 	AttestationCache       *cache.AttestationCache
 	ProposerSlotIndexCache *cache.ProposerPayloadIDsCache
 	HeadFetcher            blockchain.HeadFetcher
-	HeadUpdater            blockchain.HeadUpdater
 	ForkFetcher            blockchain.ForkFetcher
 	FinalizationFetcher    blockchain.FinalizationFetcher
 	TimeFetcher            blockchain.TimeFetcher
@@ -51,7 +50,6 @@ type Server struct {
 	DepositFetcher         depositcache.DepositFetcher
 	ChainStartFetcher      powchain.ChainStartFetcher
 	Eth1InfoFetcher        powchain.ChainInfoFetcher
-	OptimisticModeFetcher  blockchain.OptimisticModeFetcher
 	SyncChecker            sync.Checker
 	StateNotifier          statefeed.Notifier
 	BlockNotifier          blockfeed.Notifier

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

@@ -137,9 +137,7 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 10 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 10 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	trie, err := v1.InitializeFromProtoUnsafe(beaconState)
 	require.NoError(t, err)
 	vs := &Server{

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

@@ -255,7 +255,7 @@ func (vs *Server) optimisticStatus(ctx context.Context) error {
 	if slots.ToEpoch(vs.TimeFetcher.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {
 		return nil
 	}
-	optimistic, err := vs.OptimisticModeFetcher.IsOptimistic(ctx)
+	optimistic, err := vs.HeadFetcher.IsOptimistic(ctx)
 	if err != nil {
 		return status.Errorf(codes.Internal, "Could not determine if the node is a optimistic node: %v", err)
 	}

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

@@ -41,9 +41,7 @@ func TestValidatorStatus_DepositedEth1(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
 		TimesByHeight: map[int]uint64{
@@ -86,9 +84,7 @@ func TestValidatorStatus_Deposited(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
 		TimesByHeight: map[int]uint64{
@@ -138,9 +134,7 @@ func TestValidatorStatus_PartiallyDeposited(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
 		TimesByHeight: map[int]uint64{
@@ -208,9 +202,7 @@ func TestValidatorStatus_Pending(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
@@ -255,9 +247,7 @@ func TestValidatorStatus_Active(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 
 	// Active because activation epoch <= current epoch < exit epoch.
 	activeEpoch := helpers.ActivationExitEpoch(0)
@@ -344,9 +334,7 @@ func TestValidatorStatus_Exiting(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
 		TimesByHeight: map[int]uint64{
@@ -403,9 +391,7 @@ func TestValidatorStatus_Slashing(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
 		TimesByHeight: map[int]uint64{
@@ -463,9 +449,7 @@ func TestValidatorStatus_Exited(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
 		TimesByHeight: map[int]uint64{
@@ -548,15 +532,11 @@ func TestActivationStatus_OK(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, dep, 10 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, dep, 10 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 
 	dep = deposits[2]
 	assert.NoError(t, depositTrie.Insert(dep.Data.Signature, 15))
-	root, err = depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(context.Background(), dep, 0, 1, root))
+	assert.NoError(t, depositCache.InsertDeposit(context.Background(), dep, 0, 1, depositTrie.HashTreeRoot()))
 
 	vs := &Server{
 		Ctx:               context.Background(),
@@ -603,7 +583,7 @@ func TestActivationStatus_OK(t *testing.T) {
 }
 
 func TestOptimisticStatus(t *testing.T) {
-	server := &Server{OptimisticModeFetcher: &mockChain.ChainService{}, TimeFetcher: &mockChain.ChainService{}}
+	server := &Server{HeadFetcher: &mockChain.ChainService{}, TimeFetcher: &mockChain.ChainService{}}
 	err := server.optimisticStatus(context.Background())
 	require.NoError(t, err)
 
@@ -612,14 +592,14 @@ func TestOptimisticStatus(t *testing.T) {
 	cfg.BellatrixForkEpoch = 2
 	params.OverrideBeaconConfig(cfg)
 
-	server = &Server{OptimisticModeFetcher: &mockChain.ChainService{Optimistic: true}, TimeFetcher: &mockChain.ChainService{}}
+	server = &Server{HeadFetcher: &mockChain.ChainService{Optimistic: true}, TimeFetcher: &mockChain.ChainService{}}
 	err = server.optimisticStatus(context.Background())
 	s, ok := status.FromError(err)
 	require.Equal(t, true, ok)
 	require.DeepEqual(t, codes.Unavailable, s.Code())
 	require.ErrorContains(t, errOptimisticMode.Error(), err)
 
-	server = &Server{OptimisticModeFetcher: &mockChain.ChainService{Optimistic: false}, TimeFetcher: &mockChain.ChainService{}}
+	server = &Server{HeadFetcher: &mockChain.ChainService{Optimistic: false}, TimeFetcher: &mockChain.ChainService{}}
 	err = server.optimisticStatus(context.Background())
 	require.NoError(t, err)
 }
@@ -697,9 +677,7 @@ func TestValidatorStatus_CorrectActivationQueue(t *testing.T) {
 		deposit := &ethpb.Deposit{
 			Data: depData,
 		}
-		root, err := depositTrie.HashTreeRoot()
-		require.NoError(t, err)
-		assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, int64(i), root))
+		assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, int64(i), depositTrie.HashTreeRoot()))
 
 	}
 
@@ -780,14 +758,10 @@ func TestMultipleValidatorStatus_Pubkeys(t *testing.T) {
 	require.NoError(t, err)
 
 	dep := deposits[0]
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, dep, 10 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, dep, 10 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	dep = deposits[2]
 	assert.NoError(t, depositTrie.Insert(dep.Data.Signature, 15))
-	root, err = depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(context.Background(), dep, 0, 1, root))
+	assert.NoError(t, depositCache.InsertDeposit(context.Background(), dep, 0, 1, depositTrie.HashTreeRoot()))
 
 	vs := &Server{
 		Ctx:               context.Background(),
@@ -944,9 +918,7 @@ func TestValidatorStatus_Invalid(t *testing.T) {
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, root))
+	assert.NoError(t, depositCache.InsertDeposit(ctx, deposit, 0 /*blockNum*/, 0, depositTrie.HashTreeRoot()))
 	height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
 	p := &mockPOW.POWChain{
 		TimesByHeight: map[int]uint64{

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

@@ -42,9 +42,8 @@ func TestGetSyncMessageBlockRoot_Optimistic(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 
 	server := &Server{
-		HeadFetcher:           &mock.ChainService{},
-		TimeFetcher:           &mock.ChainService{Genesis: time.Now()},
-		OptimisticModeFetcher: &mock.ChainService{Optimistic: true},
+		HeadFetcher: &mock.ChainService{Optimistic: true},
+		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 	_, err := server.GetSyncMessageBlockRoot(context.Background(), &emptypb.Empty{})
 	s, ok := status.FromError(err)
@@ -53,9 +52,8 @@ func TestGetSyncMessageBlockRoot_Optimistic(t *testing.T) {
 	require.ErrorContains(t, errOptimisticMode.Error(), err)
 
 	server = &Server{
-		HeadFetcher:           &mock.ChainService{},
-		TimeFetcher:           &mock.ChainService{Genesis: time.Now()},
-		OptimisticModeFetcher: &mock.ChainService{Optimistic: false},
+		HeadFetcher: &mock.ChainService{Optimistic: false},
+		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 	_, err = server.GetSyncMessageBlockRoot(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)

beacon-chain/rpc/service.go

@@ -78,7 +78,6 @@ type Config struct {
 	BeaconMonitoringPort    int
 	BeaconDB                db.HeadAccessDatabase
 	ChainInfoFetcher        blockchain.ChainInfoFetcher
-	HeadUpdater             blockchain.HeadUpdater
 	HeadFetcher             blockchain.HeadFetcher
 	CanonicalFetcher        blockchain.CanonicalFetcher
 	ForkFetcher             blockchain.ForkFetcher
@@ -111,7 +110,6 @@ type Config struct {
 	MaxMsgSize              int
 	ExecutionEngineCaller   powchain.EngineCaller
 	ProposerIdsCache        *cache.ProposerPayloadIDsCache
-	OptimisticModeFetcher   blockchain.OptimisticModeFetcher
 }
 
 // NewService instantiates a new RPC service instance that will
@@ -191,7 +189,6 @@ func (s *Service) Start() {
 		AttPool:                s.cfg.AttestationsPool,
 		ExitPool:               s.cfg.ExitPool,
 		HeadFetcher:            s.cfg.HeadFetcher,
-		HeadUpdater:            s.cfg.HeadUpdater,
 		ForkFetcher:            s.cfg.ForkFetcher,
 		FinalizationFetcher:    s.cfg.FinalizationFetcher,
 		TimeFetcher:            s.cfg.GenesisTimeFetcher,
@@ -199,7 +196,6 @@ func (s *Service) Start() {
 		DepositFetcher:         s.cfg.DepositFetcher,
 		ChainStartFetcher:      s.cfg.ChainStartFetcher,
 		Eth1InfoFetcher:        s.cfg.POWChainService,
-		OptimisticModeFetcher:  s.cfg.OptimisticModeFetcher,
 		SyncChecker:            s.cfg.SyncService,
 		StateNotifier:          s.cfg.StateNotifier,
 		BlockNotifier:          s.cfg.BlockNotifier,
@@ -219,7 +215,6 @@ func (s *Service) Start() {
 	}
 	validatorServerV1 := &validator.Server{
 		HeadFetcher:      s.cfg.HeadFetcher,
-		HeadUpdater:      s.cfg.HeadUpdater,
 		TimeFetcher:      s.cfg.GenesisTimeFetcher,
 		SyncChecker:      s.cfg.SyncService,
 		AttestationsPool: s.cfg.AttestationsPool,
@@ -233,8 +228,7 @@ func (s *Service) Start() {
 			StateGenService:    s.cfg.StateGen,
 			ReplayerBuilder:    ch,
 		},
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
-		SyncCommitteePool:     s.cfg.SyncCommitteeObjectPool,
+		SyncCommitteePool: s.cfg.SyncCommitteeObjectPool,
 	}
 
 	nodeServer := &nodev1alpha1.Server{
@@ -267,7 +261,6 @@ func (s *Service) Start() {
 		BeaconDB:                    s.cfg.BeaconDB,
 		AttestationsPool:            s.cfg.AttestationsPool,
 		SlashingsPool:               s.cfg.SlashingsPool,
-		HeadUpdater:                 s.cfg.HeadUpdater,
 		HeadFetcher:                 s.cfg.HeadFetcher,
 		FinalizationFetcher:         s.cfg.FinalizationFetcher,
 		CanonicalFetcher:            s.cfg.CanonicalFetcher,
@@ -304,7 +297,6 @@ func (s *Service) Start() {
 			StateGenService:    s.cfg.StateGen,
 			ReplayerBuilder:    ch,
 		},
-		OptimisticModeFetcher:   s.cfg.OptimisticModeFetcher,
 		HeadFetcher:             s.cfg.HeadFetcher,
 		VoluntaryExitsPool:      s.cfg.ExitPool,
 		V1Alpha1ValidatorServer: validatorServer,
@@ -343,7 +335,6 @@ func (s *Service) Start() {
 				StateGenService:    s.cfg.StateGen,
 				ReplayerBuilder:    ch,
 			},
-			OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
 		}
 		ethpbv1alpha1.RegisterDebugServer(s.grpcServer, debugServer)
 		ethpbservice.RegisterBeaconDebugServer(s.grpcServer, debugServerV1)

beacon-chain/state/fieldtrie/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
         "//beacon-chain/state/state-native/custom-types:go_default_library",
-        "//beacon-chain/state/state-native/types:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/types:go_default_library",
         "//crypto/hash:go_default_library",

beacon-chain/state/fieldtrie/field_trie.go

@@ -16,7 +16,7 @@ type FieldTrie struct {
 	*sync.RWMutex
 	reference   *stateutil.Reference
 	fieldLayers [][]*[32]byte
-	field       types.BeaconStateField
+	field       types.FieldIndex
 	dataType    types.DataType
 	length      uint64
 	numOfElems  int
@@ -25,7 +25,7 @@ type FieldTrie struct {
 // NewFieldTrie is the constructor for the field trie data structure. It creates the corresponding
 // trie according to the given parameters. Depending on whether the field is a basic/composite array
 // which is either fixed/variable length, it will appropriately determine the trie.
-func NewFieldTrie(field types.BeaconStateField, dataType types.DataType, elements interface{}, length uint64) (*FieldTrie, error) {
+func NewFieldTrie(field types.FieldIndex, dataType types.DataType, elements interface{}, length uint64) (*FieldTrie, error) {
 	if elements == nil {
 		return &FieldTrie{
 			field:      field,
@@ -36,19 +36,10 @@ func NewFieldTrie(field types.BeaconStateField, dataType types.DataType, element
 			numOfElems: 0,
 		}, nil
 	}
-
-	var fieldRoots [][32]byte
-	var err error
-	if field.Native() {
-		fieldRoots, err = fieldConvertersNative(field, []uint64{}, elements, true)
-	} else {
-		fieldRoots, err = fieldConverters(field, []uint64{}, elements, true)
-	}
-
+	fieldRoots, err := fieldConverters(field, []uint64{}, elements, true)
 	if err != nil {
 		return nil, err
 	}
-
 	if err := validateElements(field, dataType, elements, length); err != nil {
 		return nil, err
 	}
@@ -93,18 +84,10 @@ func (f *FieldTrie) RecomputeTrie(indices []uint64, elements interface{}) ([32]b
 	if len(indices) == 0 {
 		return f.TrieRoot()
 	}
-
-	var fieldRoots [][32]byte
-	var err error
-	if f.field.Native() {
-		fieldRoots, err = fieldConvertersNative(f.field, indices, elements, false)
-	} else {
-		fieldRoots, err = fieldConverters(f.field, indices, elements, false)
-	}
+	fieldRoots, err := fieldConverters(f.field, indices, elements, false)
 	if err != nil {
 		return [32]byte{}, err
 	}
-
 	if err := f.validateIndices(indices); err != nil {
 		return [32]byte{}, err
 	}

beacon-chain/state/fieldtrie/field_trie_helpers.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/pkg/errors"
 	customtypes "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native/custom-types"
-	nativetypes "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/types"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
@@ -19,7 +18,7 @@ import (
 )
 
 // ProofFromMerkleLayers creates a proof starting at the leaf index of the state Merkle layers.
-func ProofFromMerkleLayers(layers [][][]byte, startingLeafIndex int) [][]byte {
+func ProofFromMerkleLayers(layers [][][]byte, startingLeafIndex types.FieldIndex) [][]byte {
 	// The merkle tree structure looks as follows:
 	// [[r1, r2, r3, r4], [parent1, parent2], [root]]
 	proof := make([][]byte, 0)
@@ -50,7 +49,7 @@ func (f *FieldTrie) validateIndices(idxs []uint64) error {
 	return nil
 }
 
-func validateElements(field types.BeaconStateField, dataType types.DataType, 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 {
@@ -66,118 +65,68 @@ func validateElements(field types.BeaconStateField, dataType types.DataType, ele
 }
 
 // fieldConverters converts the corresponding field and the provided elements to the appropriate roots.
-func fieldConverters(field types.BeaconStateField, indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
+func fieldConverters(field types.FieldIndex, indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
 	switch field {
 	case types.BlockRoots:
-		return convertBlockRoots(indices, elements, convertAll)
+		switch val := elements.(type) {
+		case [][]byte:
+			return handleByteArrays(val, indices, convertAll)
+		case *customtypes.BlockRoots:
+			return handle32ByteArrays(val[:], indices, convertAll)
+		default:
+			return nil, errors.Errorf("Incorrect type used for block roots")
+		}
 	case types.StateRoots:
-		return convertStateRoots(indices, elements, convertAll)
+		switch val := elements.(type) {
+		case [][]byte:
+			return handleByteArrays(val, indices, convertAll)
+		case *customtypes.StateRoots:
+			return handle32ByteArrays(val[:], indices, convertAll)
+		default:
+			return nil, errors.Errorf("Incorrect type used for state roots")
+		}
 	case types.RandaoMixes:
-		return convertRandaoMixes(indices, elements, convertAll)
+		switch val := elements.(type) {
+		case [][]byte:
+			return handleByteArrays(val, indices, convertAll)
+		case *customtypes.RandaoMixes:
+			return handle32ByteArrays(val[:], indices, convertAll)
+		default:
+			return nil, errors.Errorf("Incorrect type used for randao mixes")
+		}
 	case types.Eth1DataVotes:
-		return convertEth1DataVotes(indices, elements, convertAll)
+		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)
 	case types.Validators:
-		return convertValidators(indices, elements, convertAll)
+		val, ok := elements.([]*ethpb.Validator)
+		if !ok {
+			return nil, errors.Errorf("Wanted type of %v but got %v",
+				reflect.TypeOf([]*ethpb.Validator{}).Name(), reflect.TypeOf(elements).Name())
+		}
+		return handleValidatorSlice(val, indices, convertAll)
 	case types.PreviousEpochAttestations, types.CurrentEpochAttestations:
-		return convertAttestations(indices, elements, convertAll)
+		val, ok := elements.([]*ethpb.PendingAttestation)
+		if !ok {
+			return nil, errors.Errorf("Wanted type of %v but got %v",
+				reflect.TypeOf([]*ethpb.PendingAttestation{}).Name(), reflect.TypeOf(elements).Name())
+		}
+		return handlePendingAttestationSlice(val, indices, convertAll)
 	case types.Balances:
-		return convertBalances(indices, elements, convertAll)
+		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())
 	}
 }
 
-// fieldConvertersNative converts the corresponding field and the provided elements to the appropriate roots.
-func fieldConvertersNative(field types.BeaconStateField, indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	switch field {
-	case nativetypes.BlockRoots:
-		return convertBlockRoots(indices, elements, convertAll)
-	case nativetypes.StateRoots:
-		return convertStateRoots(indices, elements, convertAll)
-	case nativetypes.RandaoMixes:
-		return convertRandaoMixes(indices, elements, convertAll)
-	case nativetypes.Eth1DataVotes:
-		return convertEth1DataVotes(indices, elements, convertAll)
-	case nativetypes.Validators:
-		return convertValidators(indices, elements, convertAll)
-	case nativetypes.PreviousEpochAttestations, nativetypes.CurrentEpochAttestations:
-		return convertAttestations(indices, elements, convertAll)
-	case nativetypes.Balances:
-		return convertBalances(indices, elements, convertAll)
-	default:
-		return [][32]byte{}, errors.Errorf("got unsupported type of %v", reflect.TypeOf(elements).Name())
-	}
-}
-
-func convertBlockRoots(indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	switch val := elements.(type) {
-	case [][]byte:
-		return handleByteArrays(val, indices, convertAll)
-	case *customtypes.BlockRoots:
-		return handle32ByteArrays(val[:], indices, convertAll)
-	default:
-		return nil, errors.Errorf("Incorrect type used for block roots")
-	}
-}
-
-func convertStateRoots(indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	switch val := elements.(type) {
-	case [][]byte:
-		return handleByteArrays(val, indices, convertAll)
-	case *customtypes.StateRoots:
-		return handle32ByteArrays(val[:], indices, convertAll)
-	default:
-		return nil, errors.Errorf("Incorrect type used for state roots")
-	}
-}
-
-func convertRandaoMixes(indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	switch val := elements.(type) {
-	case [][]byte:
-		return handleByteArrays(val, indices, convertAll)
-	case *customtypes.RandaoMixes:
-		return handle32ByteArrays(val[:], indices, convertAll)
-	default:
-		return nil, errors.Errorf("Incorrect type used for randao mixes")
-	}
-}
-
-func convertEth1DataVotes(indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	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)
-}
-
-func convertValidators(indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	val, ok := elements.([]*ethpb.Validator)
-	if !ok {
-		return nil, errors.Errorf("Wanted type of %v but got %v",
-			reflect.TypeOf([]*ethpb.Validator{}).Name(), reflect.TypeOf(elements).Name())
-	}
-	return handleValidatorSlice(val, indices, convertAll)
-}
-
-func convertAttestations(indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	val, ok := elements.([]*ethpb.PendingAttestation)
-	if !ok {
-		return nil, errors.Errorf("Wanted type of %v but got %v",
-			reflect.TypeOf([]*ethpb.PendingAttestation{}).Name(), reflect.TypeOf(elements).Name())
-	}
-	return handlePendingAttestationSlice(val, indices, convertAll)
-}
-
-func convertBalances(indices []uint64, elements interface{}, convertAll bool) ([][32]byte, error) {
-	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)
-}
-
 // 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)

beacon-chain/state/fieldtrie/field_trie_test.go

@@ -18,7 +18,7 @@ func TestFieldTrie_NewTrie(t *testing.T) {
 	newState, _ := util.DeterministicGenesisState(t, 40)
 
 	// 5 represents the enum value of state roots
-	trie, err := fieldtrie.NewFieldTrie(stateTypes.FieldIndex(5), stateTypes.BasicArray, newState.StateRoots(), uint64(params.BeaconConfig().SlotsPerHistoricalRoot))
+	trie, err := fieldtrie.NewFieldTrie(5, stateTypes.BasicArray, newState.StateRoots(), uint64(params.BeaconConfig().SlotsPerHistoricalRoot))
 	require.NoError(t, err)
 	root, err := stateutil.RootsArrayHashTreeRoot(newState.StateRoots(), uint64(params.BeaconConfig().SlotsPerHistoricalRoot))
 	require.NoError(t, err)
@@ -30,7 +30,7 @@ func TestFieldTrie_NewTrie(t *testing.T) {
 func TestFieldTrie_RecomputeTrie(t *testing.T) {
 	newState, _ := util.DeterministicGenesisState(t, 32)
 	// 10 represents the enum value of validators
-	trie, err := fieldtrie.NewFieldTrie(stateTypes.FieldIndex(11), stateTypes.CompositeArray, newState.Validators(), params.BeaconConfig().ValidatorRegistryLimit)
+	trie, err := fieldtrie.NewFieldTrie(11, stateTypes.CompositeArray, newState.Validators(), params.BeaconConfig().ValidatorRegistryLimit)
 	require.NoError(t, err)
 
 	changedIdx := []uint64{2, 29}
@@ -58,7 +58,7 @@ func TestFieldTrie_RecomputeTrie(t *testing.T) {
 func TestFieldTrie_CopyTrieImmutable(t *testing.T) {
 	newState, _ := util.DeterministicGenesisState(t, 32)
 	// 12 represents the enum value of randao mixes.
-	trie, err := fieldtrie.NewFieldTrie(stateTypes.FieldIndex(13), stateTypes.BasicArray, newState.RandaoMixes(), uint64(params.BeaconConfig().EpochsPerHistoricalVector))
+	trie, err := fieldtrie.NewFieldTrie(13, stateTypes.BasicArray, newState.RandaoMixes(), uint64(params.BeaconConfig().EpochsPerHistoricalVector))
 	require.NoError(t, err)
 
 	newTrie := trie.CopyTrie()

beacon-chain/state/genesis/genesis.go

@@ -18,7 +18,7 @@ var (
 // State returns a copy of the genesis state from a hardcoded value.
 func State(name string) (state.BeaconState, error) {
 	switch name {
-	case params.MainnetName:
+	case params.ConfigNames[params.Mainnet]:
 		return load(mainnetRawSSZCompressed)
 	default:
 		// No state found.

beacon-chain/state/genesis/genesis_test.go

@@ -9,15 +9,15 @@ import (
 
 func TestGenesisState(t *testing.T) {
 	tests := []struct {
-		name string
+		name params.ConfigName
 	}{
 		{
-			name: params.MainnetName,
+			name: params.Mainnet,
 		},
 	}
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			st, err := genesis.State(tt.name)
+		t.Run(params.ConfigNames[tt.name], func(t *testing.T) {
+			st, err := genesis.State(params.ConfigNames[tt.name])
 			if err != nil {
 				t.Fatal(err)
 			}

beacon-chain/state/state-native/getters_block_test.go

@@ -1,117 +0,0 @@
-package state_native
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	testtmpl "github.com/prysmaticlabs/prysm/beacon-chain/state/testing"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-func TestBeaconState_LatestBlockHeader_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateLatestBlockHeader(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{})
-		},
-		func(BH *ethpb.BeaconBlockHeader) (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{LatestBlockHeader: BH})
-		},
-	)
-}
-
-func TestBeaconState_LatestBlockHeader_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateLatestBlockHeader(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{})
-		},
-		func(BH *ethpb.BeaconBlockHeader) (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{LatestBlockHeader: BH})
-		},
-	)
-}
-
-func TestBeaconState_LatestBlockHeader_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateLatestBlockHeader(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{})
-		},
-		func(BH *ethpb.BeaconBlockHeader) (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{LatestBlockHeader: BH})
-		},
-	)
-}
-
-func TestBeaconState_BlockRoots_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateBlockRootsNative(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{})
-		},
-		func(BR [][]byte) (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{BlockRoots: BR})
-		},
-	)
-}
-
-func TestBeaconState_BlockRoots_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateBlockRootsNative(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{})
-		},
-		func(BR [][]byte) (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{BlockRoots: BR})
-		},
-	)
-}
-
-func TestBeaconState_BlockRoots_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateBlockRootsNative(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{})
-		},
-		func(BR [][]byte) (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{BlockRoots: BR})
-		},
-	)
-}
-
-func TestBeaconState_BlockRootAtIndex_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateBlockRootAtIndexNative(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{})
-		},
-		func(BR [][]byte) (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{BlockRoots: BR})
-		},
-	)
-}
-
-func TestBeaconState_BlockRootAtIndex_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateBlockRootAtIndexNative(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{})
-		},
-		func(BR [][]byte) (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{BlockRoots: BR})
-		},
-	)
-}
-
-func TestBeaconState_BlockRootAtIndex_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateBlockRootAtIndexNative(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{})
-		},
-		func(BR [][]byte) (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{BlockRoots: BR})
-		},
-	)
-}

beacon-chain/state/state-native/getters_checkpoint_test.go

@@ -1,202 +0,0 @@
-package state_native
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	testtmpl "github.com/prysmaticlabs/prysm/beacon-chain/state/testing"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-func TestBeaconState_PreviousJustifiedCheckpointNil_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStatePreviousJustifiedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
-		})
-}
-
-func TestBeaconState_PreviousJustifiedCheckpointNil_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStatePreviousJustifiedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{})
-		})
-}
-
-func TestBeaconState_PreviousJustifiedCheckpointNil_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStatePreviousJustifiedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{})
-		})
-}
-
-func TestBeaconState_PreviousJustifiedCheckpoint_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStatePreviousJustifiedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{PreviousJustifiedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_PreviousJustifiedCheckpoint_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStatePreviousJustifiedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{PreviousJustifiedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_PreviousJustifiedCheckpoint_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStatePreviousJustifiedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{PreviousJustifiedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_CurrentJustifiedCheckpointNil_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateCurrentJustifiedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
-		})
-}
-
-func TestBeaconState_CurrentJustifiedCheckpointNil_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateCurrentJustifiedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{})
-		})
-}
-
-func TestBeaconState_CurrentJustifiedCheckpointNil_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateCurrentJustifiedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{})
-		})
-}
-
-func TestBeaconState_CurrentJustifiedCheckpoint_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateCurrentJustifiedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{CurrentJustifiedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_CurrentJustifiedCheckpoint_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateCurrentJustifiedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{CurrentJustifiedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_CurrentJustifiedCheckpoint_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateCurrentJustifiedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{CurrentJustifiedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_FinalizedCheckpointNil_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateFinalizedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
-		})
-}
-
-func TestBeaconState_FinalizedCheckpointNil_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateFinalizedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{})
-		})
-}
-
-func TestBeaconState_FinalizedCheckpointNil_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateFinalizedCheckpointNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{})
-		})
-}
-
-func TestBeaconState_FinalizedCheckpoint_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateFinalizedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{FinalizedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_FinalizedCheckpoint_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateFinalizedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{FinalizedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_FinalizedCheckpoint_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateFinalizedCheckpoint(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{FinalizedCheckpoint: cp})
-		})
-}
-
-func TestBeaconState_JustificationBitsNil_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateJustificationBitsNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
-		})
-}
-
-func TestBeaconState_JustificationBitsNil_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateJustificationBitsNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{})
-		})
-}
-
-func TestBeaconState_JustificationBitsNil_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateJustificationBitsNil(
-		t,
-		func() (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{})
-		})
-}
-
-func TestBeaconState_JustificationBits_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateJustificationBits(
-		t,
-		func(bits bitfield.Bitvector4) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{JustificationBits: bits})
-		})
-}
-
-func TestBeaconState_JustificationBits_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateJustificationBits(
-		t,
-		func(bits bitfield.Bitvector4) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{JustificationBits: bits})
-		})
-}
-
-func TestBeaconState_JustificationBits_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateJustificationBits(
-		t,
-		func(bits bitfield.Bitvector4) (state.BeaconState, error) {
-			return InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{JustificationBits: bits})
-		})
-}

beacon-chain/state/state-native/getters_state.go

@@ -1,279 +0,0 @@
-package state_native
-
-import (
-	"fmt"
-
-	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-)
-
-// ToProtoUnsafe returns the pointer value of the underlying
-// beacon state proto object, bypassing immutability. Use with care.
-func (b *BeaconState) ToProtoUnsafe() interface{} {
-	if b == nil {
-		return nil
-	}
-
-	gvrCopy := b.genesisValidatorsRoot
-
-	switch b.version {
-	case version.Phase0:
-		return &ethpb.BeaconState{
-			GenesisTime:                 b.genesisTime,
-			GenesisValidatorsRoot:       gvrCopy[:],
-			Slot:                        b.slot,
-			Fork:                        b.fork,
-			LatestBlockHeader:           b.latestBlockHeader,
-			BlockRoots:                  b.blockRoots.Slice(),
-			StateRoots:                  b.stateRoots.Slice(),
-			HistoricalRoots:             b.historicalRoots.Slice(),
-			Eth1Data:                    b.eth1Data,
-			Eth1DataVotes:               b.eth1DataVotes,
-			Eth1DepositIndex:            b.eth1DepositIndex,
-			Validators:                  b.validators,
-			Balances:                    b.balances,
-			RandaoMixes:                 b.randaoMixes.Slice(),
-			Slashings:                   b.slashings,
-			PreviousEpochAttestations:   b.previousEpochAttestations,
-			CurrentEpochAttestations:    b.currentEpochAttestations,
-			JustificationBits:           b.justificationBits,
-			PreviousJustifiedCheckpoint: b.previousJustifiedCheckpoint,
-			CurrentJustifiedCheckpoint:  b.currentJustifiedCheckpoint,
-			FinalizedCheckpoint:         b.finalizedCheckpoint,
-		}
-	case version.Altair:
-		return &ethpb.BeaconStateAltair{
-			GenesisTime:                 b.genesisTime,
-			GenesisValidatorsRoot:       gvrCopy[:],
-			Slot:                        b.slot,
-			Fork:                        b.fork,
-			LatestBlockHeader:           b.latestBlockHeader,
-			BlockRoots:                  b.blockRoots.Slice(),
-			StateRoots:                  b.stateRoots.Slice(),
-			HistoricalRoots:             b.historicalRoots.Slice(),
-			Eth1Data:                    b.eth1Data,
-			Eth1DataVotes:               b.eth1DataVotes,
-			Eth1DepositIndex:            b.eth1DepositIndex,
-			Validators:                  b.validators,
-			Balances:                    b.balances,
-			RandaoMixes:                 b.randaoMixes.Slice(),
-			Slashings:                   b.slashings,
-			PreviousEpochParticipation:  b.previousEpochParticipation,
-			CurrentEpochParticipation:   b.currentEpochParticipation,
-			JustificationBits:           b.justificationBits,
-			PreviousJustifiedCheckpoint: b.previousJustifiedCheckpoint,
-			CurrentJustifiedCheckpoint:  b.currentJustifiedCheckpoint,
-			FinalizedCheckpoint:         b.finalizedCheckpoint,
-			InactivityScores:            b.inactivityScores,
-			CurrentSyncCommittee:        b.currentSyncCommittee,
-			NextSyncCommittee:           b.nextSyncCommittee,
-		}
-	case version.Bellatrix:
-		return &ethpb.BeaconStateBellatrix{
-			GenesisTime:                  b.genesisTime,
-			GenesisValidatorsRoot:        gvrCopy[:],
-			Slot:                         b.slot,
-			Fork:                         b.fork,
-			LatestBlockHeader:            b.latestBlockHeader,
-			BlockRoots:                   b.blockRoots.Slice(),
-			StateRoots:                   b.stateRoots.Slice(),
-			HistoricalRoots:              b.historicalRoots.Slice(),
-			Eth1Data:                     b.eth1Data,
-			Eth1DataVotes:                b.eth1DataVotes,
-			Eth1DepositIndex:             b.eth1DepositIndex,
-			Validators:                   b.validators,
-			Balances:                     b.balances,
-			RandaoMixes:                  b.randaoMixes.Slice(),
-			Slashings:                    b.slashings,
-			PreviousEpochParticipation:   b.previousEpochParticipation,
-			CurrentEpochParticipation:    b.currentEpochParticipation,
-			JustificationBits:            b.justificationBits,
-			PreviousJustifiedCheckpoint:  b.previousJustifiedCheckpoint,
-			CurrentJustifiedCheckpoint:   b.currentJustifiedCheckpoint,
-			FinalizedCheckpoint:          b.finalizedCheckpoint,
-			InactivityScores:             b.inactivityScores,
-			CurrentSyncCommittee:         b.currentSyncCommittee,
-			NextSyncCommittee:            b.nextSyncCommittee,
-			LatestExecutionPayloadHeader: b.latestExecutionPayloadHeader,
-		}
-	default:
-		return nil
-	}
-}
-
-// ToProto the beacon state into a protobuf for usage.
-func (b *BeaconState) ToProto() interface{} {
-	if b == nil {
-		return nil
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	gvrCopy := b.genesisValidatorsRoot
-
-	switch b.version {
-	case version.Phase0:
-		return &ethpb.BeaconState{
-			GenesisTime:                 b.genesisTime,
-			GenesisValidatorsRoot:       gvrCopy[:],
-			Slot:                        b.slot,
-			Fork:                        b.forkVal(),
-			LatestBlockHeader:           b.latestBlockHeaderVal(),
-			BlockRoots:                  b.blockRoots.Slice(),
-			StateRoots:                  b.stateRoots.Slice(),
-			HistoricalRoots:             b.historicalRoots.Slice(),
-			Eth1Data:                    b.eth1DataVal(),
-			Eth1DataVotes:               b.eth1DataVotesVal(),
-			Eth1DepositIndex:            b.eth1DepositIndex,
-			Validators:                  b.validatorsVal(),
-			Balances:                    b.balancesVal(),
-			RandaoMixes:                 b.randaoMixes.Slice(),
-			Slashings:                   b.slashingsVal(),
-			PreviousEpochAttestations:   b.previousEpochAttestationsVal(),
-			CurrentEpochAttestations:    b.currentEpochAttestationsVal(),
-			JustificationBits:           b.justificationBitsVal(),
-			PreviousJustifiedCheckpoint: b.previousJustifiedCheckpointVal(),
-			CurrentJustifiedCheckpoint:  b.currentJustifiedCheckpointVal(),
-			FinalizedCheckpoint:         b.finalizedCheckpointVal(),
-		}
-	case version.Altair:
-		return &ethpb.BeaconStateAltair{
-			GenesisTime:                 b.genesisTime,
-			GenesisValidatorsRoot:       gvrCopy[:],
-			Slot:                        b.slot,
-			Fork:                        b.forkVal(),
-			LatestBlockHeader:           b.latestBlockHeaderVal(),
-			BlockRoots:                  b.blockRoots.Slice(),
-			StateRoots:                  b.stateRoots.Slice(),
-			HistoricalRoots:             b.historicalRoots.Slice(),
-			Eth1Data:                    b.eth1DataVal(),
-			Eth1DataVotes:               b.eth1DataVotesVal(),
-			Eth1DepositIndex:            b.eth1DepositIndex,
-			Validators:                  b.validatorsVal(),
-			Balances:                    b.balancesVal(),
-			RandaoMixes:                 b.randaoMixes.Slice(),
-			Slashings:                   b.slashingsVal(),
-			PreviousEpochParticipation:  b.previousEpochParticipationVal(),
-			CurrentEpochParticipation:   b.currentEpochParticipationVal(),
-			JustificationBits:           b.justificationBitsVal(),
-			PreviousJustifiedCheckpoint: b.previousJustifiedCheckpointVal(),
-			CurrentJustifiedCheckpoint:  b.currentJustifiedCheckpointVal(),
-			FinalizedCheckpoint:         b.finalizedCheckpointVal(),
-			InactivityScores:            b.inactivityScoresVal(),
-			CurrentSyncCommittee:        b.currentSyncCommitteeVal(),
-			NextSyncCommittee:           b.nextSyncCommitteeVal(),
-		}
-	case version.Bellatrix:
-		return &ethpb.BeaconStateBellatrix{
-			GenesisTime:                  b.genesisTime,
-			GenesisValidatorsRoot:        gvrCopy[:],
-			Slot:                         b.slot,
-			Fork:                         b.forkVal(),
-			LatestBlockHeader:            b.latestBlockHeaderVal(),
-			BlockRoots:                   b.blockRoots.Slice(),
-			StateRoots:                   b.stateRoots.Slice(),
-			HistoricalRoots:              b.historicalRoots.Slice(),
-			Eth1Data:                     b.eth1DataVal(),
-			Eth1DataVotes:                b.eth1DataVotesVal(),
-			Eth1DepositIndex:             b.eth1DepositIndex,
-			Validators:                   b.validatorsVal(),
-			Balances:                     b.balancesVal(),
-			RandaoMixes:                  b.randaoMixes.Slice(),
-			Slashings:                    b.slashingsVal(),
-			PreviousEpochParticipation:   b.previousEpochParticipationVal(),
-			CurrentEpochParticipation:    b.currentEpochParticipationVal(),
-			JustificationBits:            b.justificationBitsVal(),
-			PreviousJustifiedCheckpoint:  b.previousJustifiedCheckpointVal(),
-			CurrentJustifiedCheckpoint:   b.currentJustifiedCheckpointVal(),
-			FinalizedCheckpoint:          b.finalizedCheckpointVal(),
-			InactivityScores:             b.inactivityScoresVal(),
-			CurrentSyncCommittee:         b.currentSyncCommitteeVal(),
-			NextSyncCommittee:            b.nextSyncCommitteeVal(),
-			LatestExecutionPayloadHeader: b.latestExecutionPayloadHeaderVal(),
-		}
-	default:
-		return nil
-	}
-}
-
-// StateRoots kept track of in the beacon state.
-func (b *BeaconState) StateRoots() [][]byte {
-	if b.stateRoots == nil {
-		return nil
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.stateRoots.Slice()
-}
-
-// StateRootAtIndex retrieves a specific state root based on an
-// input index value.
-func (b *BeaconState) StateRootAtIndex(idx uint64) ([]byte, error) {
-	if b.stateRoots == nil {
-		return nil, nil
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	r, err := b.stateRootAtIndex(idx)
-	if err != nil {
-		return nil, err
-	}
-	return r[:], nil
-}
-
-// stateRootAtIndex retrieves a specific state root based on an
-// input index value.
-// This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) stateRootAtIndex(idx uint64) ([32]byte, error) {
-	if uint64(len(b.stateRoots)) <= idx {
-		return [32]byte{}, fmt.Errorf("index %d out of range", idx)
-	}
-	return b.stateRoots[idx], nil
-}
-
-// ProtobufBeaconStatePhase0 transforms an input into beacon state in the form of protobuf.
-// Error is returned if the input is not type protobuf beacon state.
-func ProtobufBeaconStatePhase0(s interface{}) (*ethpb.BeaconState, error) {
-	pbState, ok := s.(*ethpb.BeaconState)
-	if !ok {
-		return nil, errors.New("input is not type ethpb.BeaconState")
-	}
-	return pbState, nil
-}
-
-// ProtobufBeaconStateAltair transforms an input into beacon state Altair in the form of protobuf.
-// Error is returned if the input is not type protobuf beacon state.
-func ProtobufBeaconStateAltair(s interface{}) (*ethpb.BeaconStateAltair, error) {
-	pbState, ok := s.(*ethpb.BeaconStateAltair)
-	if !ok {
-		return nil, errors.New("input is not type pb.BeaconStateAltair")
-	}
-	return pbState, nil
-}
-
-// ProtobufBeaconStateBellatrix transforms an input into beacon state Bellatrix in the form of protobuf.
-// Error is returned if the input is not type protobuf beacon state.
-func ProtobufBeaconStateBellatrix(s interface{}) (*ethpb.BeaconStateBellatrix, error) {
-	pbState, ok := s.(*ethpb.BeaconStateBellatrix)
-	if !ok {
-		return nil, errors.New("input is not type pb.BeaconStateBellatrix")
-	}
-	return pbState, nil
-}
-
-// InnerStateUnsafe returns the pointer value of the underlying
-// beacon state proto object, bypassing immutability. Use with care.
-func (b *BeaconState) InnerStateUnsafe() interface{} {
-	return b.ToProtoUnsafe()
-}
-
-// CloneInnerState the beacon state into a protobuf for usage.
-func (b *BeaconState) CloneInnerState() interface{} {
-	return b.ToProto()
-}

beacon-chain/state/state-native/getters_test.go

@@ -1,99 +0,0 @@
-package state_native
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	testtmpl "github.com/prysmaticlabs/prysm/beacon-chain/state/testing"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-func TestBeaconState_SlotDataRace_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateSlotDataRace(t, func() (state.BeaconState, error) {
-		return InitializeFromProtoPhase0(&ethpb.BeaconState{Slot: 1})
-	})
-}
-
-func TestBeaconState_SlotDataRace_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateSlotDataRace(t, func() (state.BeaconState, error) {
-		return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{Slot: 1})
-	})
-}
-
-func TestBeaconState_SlotDataRace_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateSlotDataRace(t, func() (state.BeaconState, error) {
-		return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{Slot: 1})
-	})
-}
-
-func TestBeaconState_MatchCurrentJustifiedCheckpt_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateMatchCurrentJustifiedCheckptNative(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{CurrentJustifiedCheckpoint: cp})
-		},
-	)
-}
-
-func TestBeaconState_MatchCurrentJustifiedCheckpt_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateMatchCurrentJustifiedCheckptNative(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{CurrentJustifiedCheckpoint: cp})
-		},
-	)
-}
-
-func TestBeaconState_MatchCurrentJustifiedCheckpt_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateMatchCurrentJustifiedCheckptNative(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{CurrentJustifiedCheckpoint: cp})
-		},
-	)
-}
-
-func TestBeaconState_MatchPreviousJustifiedCheckpt_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateMatchPreviousJustifiedCheckptNative(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoPhase0(&ethpb.BeaconState{PreviousJustifiedCheckpoint: cp})
-		},
-	)
-}
-
-func TestBeaconState_MatchPreviousJustifiedCheckpt_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateMatchPreviousJustifiedCheckptNative(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{PreviousJustifiedCheckpoint: cp})
-		},
-	)
-}
-
-func TestBeaconState_MatchPreviousJustifiedCheckpt_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateMatchPreviousJustifiedCheckptNative(
-		t,
-		func(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-			return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{PreviousJustifiedCheckpoint: cp})
-		},
-	)
-}
-
-func TestBeaconState_ValidatorByPubkey_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateValidatorByPubkey(t, func() (state.BeaconState, error) {
-		return InitializeFromProtoPhase0(&ethpb.BeaconState{})
-	})
-}
-
-func TestBeaconState_ValidatorByPubkey_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateValidatorByPubkey(t, func() (state.BeaconState, error) {
-		return InitializeFromProtoAltair(&ethpb.BeaconStateAltair{})
-	})
-}
-
-func TestBeaconState_ValidatorByPubkey_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateValidatorByPubkey(t, func() (state.BeaconState, error) {
-		return InitializeFromProtoBellatrix(&ethpb.BeaconStateBellatrix{})
-	})
-}

beacon-chain/state/state-native/getters_validator_test.go

@@ -1,34 +0,0 @@
-package state_native_test
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	statenative "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native"
-	testtmpl "github.com/prysmaticlabs/prysm/beacon-chain/state/testing"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-func TestBeaconState_ValidatorAtIndexReadOnly_HandlesNilSlice_Phase0(t *testing.T) {
-	testtmpl.VerifyBeaconStateValidatorAtIndexReadOnlyHandlesNilSlice(t, func() (state.BeaconState, error) {
-		return statenative.InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{
-			Validators: nil,
-		})
-	})
-}
-
-func TestBeaconState_ValidatorAtIndexReadOnly_HandlesNilSlice_Altair(t *testing.T) {
-	testtmpl.VerifyBeaconStateValidatorAtIndexReadOnlyHandlesNilSlice(t, func() (state.BeaconState, error) {
-		return statenative.InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{
-			Validators: nil,
-		})
-	})
-}
-
-func TestBeaconState_ValidatorAtIndexReadOnly_HandlesNilSlice_Bellatrix(t *testing.T) {
-	testtmpl.VerifyBeaconStateValidatorAtIndexReadOnlyHandlesNilSlice(t, func() (state.BeaconState, error) {
-		return statenative.InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{
-			Validators: nil,
-		})
-	})
-}

beacon-chain/state/state-native/hasher.go

@@ -1,240 +0,0 @@
-package state_native
-
-import (
-	"context"
-	"encoding/binary"
-
-	"github.com/pkg/errors"
-	nativetypes "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native/types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/hash"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/encoding/ssz"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"go.opencensus.io/trace"
-)
-
-// ComputeFieldRootsWithHasher hashes the provided state and returns its respective field roots.
-func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]byte, error) {
-	_, span := trace.StartSpan(ctx, "ComputeFieldRootsWithHasher")
-	defer span.End()
-
-	if state == nil {
-		return nil, errors.New("nil state")
-	}
-	hasher := hash.CustomSHA256Hasher()
-	var fieldRoots [][]byte
-	switch state.version {
-	case version.Phase0:
-		fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateFieldCount)
-	case version.Altair:
-		fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateAltairFieldCount)
-	case version.Bellatrix:
-		fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateBellatrixFieldCount)
-	}
-
-	// Genesis time root.
-	genesisRoot := ssz.Uint64Root(state.genesisTime)
-	fieldRoots[nativetypes.GenesisTime.RealPosition()] = genesisRoot[:]
-
-	// Genesis validators root.
-	r := [32]byte{}
-	copy(r[:], state.genesisValidatorsRoot[:])
-	fieldRoots[nativetypes.GenesisValidatorsRoot.RealPosition()] = r[:]
-
-	// Slot root.
-	slotRoot := ssz.Uint64Root(uint64(state.slot))
-	fieldRoots[nativetypes.Slot.RealPosition()] = 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[nativetypes.Fork.RealPosition()] = 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[nativetypes.LatestBlockHeader.RealPosition()] = headerHashTreeRoot[:]
-
-	// BlockRoots array root.
-	bRoots := make([][]byte, len(state.blockRoots))
-	for i := range bRoots {
-		bRoots[i] = state.blockRoots[i][:]
-	}
-	blockRootsRoot, err := stateutil.ArraysRoot(bRoots, fieldparams.BlockRootsLength)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute block roots merkleization")
-	}
-	fieldRoots[nativetypes.BlockRoots.RealPosition()] = blockRootsRoot[:]
-
-	// StateRoots array root.
-	sRoots := make([][]byte, len(state.stateRoots))
-	for i := range sRoots {
-		sRoots[i] = state.stateRoots[i][:]
-	}
-	stateRootsRoot, err := stateutil.ArraysRoot(sRoots, fieldparams.StateRootsLength)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute state roots merkleization")
-	}
-	fieldRoots[nativetypes.StateRoots.RealPosition()] = stateRootsRoot[:]
-
-	// HistoricalRoots slice root.
-	hRoots := make([][]byte, len(state.historicalRoots))
-	for i := range hRoots {
-		hRoots[i] = state.historicalRoots[i][:]
-	}
-	historicalRootsRt, err := ssz.ByteArrayRootWithLimit(hRoots, fieldparams.HistoricalRootsLength)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute historical roots merkleization")
-	}
-	fieldRoots[nativetypes.HistoricalRoots.RealPosition()] = historicalRootsRt[:]
-
-	// Eth1Data data structure root.
-	eth1HashTreeRoot, err := stateutil.Eth1Root(hasher, state.eth1Data)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute eth1data merkleization")
-	}
-	fieldRoots[nativetypes.Eth1Data.RealPosition()] = eth1HashTreeRoot[:]
-
-	// Eth1DataVotes slice root.
-	eth1VotesRoot, err := stateutil.Eth1DataVotesRoot(state.eth1DataVotes)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute eth1data votes merkleization")
-	}
-	fieldRoots[nativetypes.Eth1DataVotes.RealPosition()] = eth1VotesRoot[:]
-
-	// Eth1DepositIndex root.
-	eth1DepositIndexBuf := make([]byte, 8)
-	binary.LittleEndian.PutUint64(eth1DepositIndexBuf, state.eth1DepositIndex)
-	eth1DepositBuf := bytesutil.ToBytes32(eth1DepositIndexBuf)
-	fieldRoots[nativetypes.Eth1DepositIndex.RealPosition()] = eth1DepositBuf[:]
-
-	// Validators slice root.
-	validatorsRoot, err := stateutil.ValidatorRegistryRoot(state.validators)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute validator registry merkleization")
-	}
-	fieldRoots[nativetypes.Validators.RealPosition()] = 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[nativetypes.Balances.RealPosition()] = balancesRoot[:]
-
-	// RandaoMixes array root.
-	mixes := make([][]byte, len(state.randaoMixes))
-	for i := range mixes {
-		mixes[i] = state.randaoMixes[i][:]
-	}
-	randaoRootsRoot, err := stateutil.ArraysRoot(mixes, fieldparams.RandaoMixesLength)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute randao roots merkleization")
-	}
-	fieldRoots[nativetypes.RandaoMixes.RealPosition()] = randaoRootsRoot[:]
-
-	// Slashings array root.
-	slashingsRootsRoot, err := ssz.SlashingsRoot(state.slashings)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute slashings merkleization")
-	}
-	fieldRoots[nativetypes.Slashings.RealPosition()] = slashingsRootsRoot[:]
-
-	if state.version == version.Phase0 {
-		// PreviousEpochAttestations slice root.
-		prevAttsRoot, err := stateutil.EpochAttestationsRoot(state.previousEpochAttestations)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute previous epoch attestations merkleization")
-		}
-		fieldRoots[nativetypes.PreviousEpochAttestations.RealPosition()] = prevAttsRoot[:]
-
-		// CurrentEpochAttestations slice root.
-		currAttsRoot, err := stateutil.EpochAttestationsRoot(state.currentEpochAttestations)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute current epoch attestations merkleization")
-		}
-		fieldRoots[nativetypes.CurrentEpochAttestations.RealPosition()] = currAttsRoot[:]
-	}
-
-	if state.version == version.Altair || state.version == version.Bellatrix {
-		// 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[nativetypes.PreviousEpochParticipationBits.RealPosition()] = 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[nativetypes.CurrentEpochParticipationBits.RealPosition()] = currParticipationRoot[:]
-	}
-
-	// JustificationBits root.
-	justifiedBitsRoot := bytesutil.ToBytes32(state.justificationBits)
-	fieldRoots[nativetypes.JustificationBits.RealPosition()] = 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[nativetypes.PreviousJustifiedCheckpoint.RealPosition()] = 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[nativetypes.CurrentJustifiedCheckpoint.RealPosition()] = 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[nativetypes.FinalizedCheckpoint.RealPosition()] = finalRoot[:]
-
-	if state.version == version.Altair || state.version == version.Bellatrix {
-		// Inactivity scores root.
-		inactivityScoresRoot, err := stateutil.Uint64ListRootWithRegistryLimit(state.inactivityScores)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute inactivityScoreRoot")
-		}
-		fieldRoots[nativetypes.InactivityScores.RealPosition()] = 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[nativetypes.CurrentSyncCommittee.RealPosition()] = 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[nativetypes.NextSyncCommittee.RealPosition()] = nextSyncCommitteeRoot[:]
-	}
-
-	if state.version == version.Bellatrix {
-		// Execution payload root.
-		executionPayloadRoot, err := state.latestExecutionPayloadHeader.HashTreeRoot()
-		if err != nil {
-			return nil, err
-		}
-		fieldRoots[nativetypes.LatestExecutionPayloadHeader.RealPosition()] = executionPayloadRoot[:]
-	}
-
-	return fieldRoots, nil
-}

beacon-chain/state/state-native/hasher_test.go

@@ -1,355 +0,0 @@
-package state_native_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	state_native "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	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"
-)
-
-func TestComputeFieldRootsWithHasher_Phase0(t *testing.T) {
-	beaconState, err := util.NewBeaconState(util.FillRootsNaturalOpt)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetGenesisTime(123))
-	require.NoError(t, beaconState.SetGenesisValidatorsRoot(genesisValidatorsRoot()))
-	require.NoError(t, beaconState.SetSlot(123))
-	require.NoError(t, beaconState.SetFork(fork()))
-	require.NoError(t, beaconState.SetLatestBlockHeader(latestBlockHeader()))
-	historicalRoots, err := util.PrepareRoots(int(params.BeaconConfig().SlotsPerHistoricalRoot))
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetHistoricalRoots(historicalRoots))
-	require.NoError(t, beaconState.SetEth1Data(eth1Data()))
-	require.NoError(t, beaconState.SetEth1DataVotes([]*ethpb.Eth1Data{eth1Data()}))
-	require.NoError(t, beaconState.SetEth1DepositIndex(123))
-	require.NoError(t, beaconState.SetValidators([]*ethpb.Validator{validator()}))
-	require.NoError(t, beaconState.SetBalances([]uint64{1, 2, 3}))
-	randaoMixes, err := util.PrepareRoots(int(params.BeaconConfig().EpochsPerHistoricalVector))
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetRandaoMixes(randaoMixes))
-	require.NoError(t, beaconState.SetSlashings([]uint64{1, 2, 3}))
-	require.NoError(t, beaconState.AppendPreviousEpochAttestations(pendingAttestation("previous")))
-	require.NoError(t, beaconState.AppendCurrentEpochAttestations(pendingAttestation("current")))
-	require.NoError(t, beaconState.SetJustificationBits(justificationBits()))
-	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(checkpoint("previous")))
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(checkpoint("current")))
-	require.NoError(t, beaconState.SetFinalizedCheckpoint(checkpoint("finalized")))
-
-	v1State, ok := beaconState.(*v1.BeaconState)
-	require.Equal(t, true, ok)
-	protoState, ok := v1State.InnerStateUnsafe().(*ethpb.BeaconState)
-	require.Equal(t, true, ok)
-	initState, err := state_native.InitializeFromProtoPhase0(protoState)
-	require.NoError(t, err)
-	s, ok := initState.(*state_native.BeaconState)
-	require.Equal(t, true, ok)
-	root, err := state_native.ComputeFieldRootsWithHasher(context.Background(), s)
-	require.NoError(t, err)
-	expected := [][]byte{
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x67, 0x76, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x58, 0xba, 0xf, 0x9b, 0x4f, 0x63, 0x1c, 0xa6, 0x19, 0xb1, 0xa2, 0x1f, 0xd1, 0x29, 0xc7, 0x67, 0x9c, 0x32, 0x4, 0x1f, 0xcf, 0x4e, 0x64, 0x9b, 0x8f, 0x21, 0xb4, 0xe6, 0xa5, 0xc9, 0xc, 0x38},
-		{0x8b, 0x5, 0x59, 0x78, 0xed, 0xbe, 0x2c, 0xde, 0xa6, 0xf, 0x52, 0xdc, 0x16, 0x83, 0xa0, 0x5d, 0x8, 0xc3, 0x37, 0x91, 0x3a, 0xf6, 0xfa, 0x6, 0x62, 0xc9, 0x6, 0xb1, 0x41, 0x48, 0xaf, 0xec},
-		{0xcc, 0xa1, 0x69, 0xa8, 0x8b, 0x1e, 0x49, 0x5, 0x1f, 0xe4, 0xd8, 0xff, 0x82, 0xa2, 0x2e, 0xf0, 0x54, 0xd1, 0x13, 0xc9, 0x8e, 0xb9, 0x82, 0xa6, 0x9e, 0x42, 0x2, 0xec, 0x97, 0x6f, 0x33, 0x88},
-		{0xcc, 0xa1, 0x69, 0xa8, 0x8b, 0x1e, 0x49, 0x5, 0x1f, 0xe4, 0xd8, 0xff, 0x82, 0xa2, 0x2e, 0xf0, 0x54, 0xd1, 0x13, 0xc9, 0x8e, 0xb9, 0x82, 0xa6, 0x9e, 0x42, 0x2, 0xec, 0x97, 0x6f, 0x33, 0x88},
-		{0xf, 0xad, 0xd3, 0x92, 0x4b, 0xda, 0xfa, 0xc6, 0x61, 0x50, 0xb7, 0xdf, 0x5f, 0x2c, 0xd0, 0x94, 0xc3, 0xaf, 0x41, 0x9d, 0xa, 0xea, 0x50, 0x96, 0x82, 0x62, 0x1c, 0x72, 0x26, 0x20, 0x6b, 0xac},
-		{0xc9, 0x4e, 0x2c, 0xb0, 0x20, 0xe3, 0xe7, 0x8c, 0x5c, 0xbd, 0xeb, 0x9b, 0xa5, 0x7b, 0x53, 0x50, 0xca, 0xfe, 0xe9, 0x48, 0x9e, 0x8d, 0xf8, 0x4a, 0xe6, 0x8d, 0x9c, 0x97, 0x81, 0x74, 0xb, 0x5e},
-		{0x71, 0x52, 0xd2, 0x9b, 0x87, 0x3c, 0x8a, 0xd9, 0x51, 0x55, 0xc0, 0x42, 0xb, 0xc4, 0x12, 0xa4, 0x79, 0xf5, 0x7d, 0x37, 0x16, 0xf4, 0x90, 0x72, 0x5d, 0xe0, 0x34, 0xb4, 0x2, 0x8c, 0x39, 0xe4},
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0xf, 0xf7, 0x4f, 0xe1, 0xa9, 0x72, 0x9c, 0x95, 0xf0, 0xe1, 0xde, 0xa4, 0x32, 0xc, 0x67, 0x52, 0x23, 0x13, 0x9e, 0xe2, 0x40, 0x8d, 0xf6, 0x18, 0x57, 0xf0, 0x1a, 0x4a, 0xad, 0x46, 0xce, 0x42},
-		{0xf9, 0x11, 0x2c, 0xc2, 0x71, 0x70, 0xde, 0x47, 0x26, 0xeb, 0x26, 0xd4, 0xa4, 0xe8, 0x68, 0xb, 0x16, 0xa2, 0x6e, 0x52, 0x54, 0xe, 0x5c, 0x83, 0x17, 0x3, 0xea, 0xdd, 0xd5, 0xa7, 0xb2, 0x3f},
-		{0x64, 0xbd, 0x40, 0xa7, 0x10, 0x44, 0x84, 0xed, 0xf3, 0x5f, 0xc3, 0x5d, 0x7b, 0xbe, 0xe8, 0x75, 0xbf, 0x66, 0xcb, 0xce, 0x77, 0xfa, 0x0, 0x3, 0xdd, 0xfb, 0x80, 0xd2, 0x77, 0x1b, 0xc2, 0x8},
-		{0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x54, 0xd3, 0xce, 0x8a, 0x3f, 0xfd, 0x21, 0x3a, 0xb4, 0xa6, 0xd, 0xb, 0x9f, 0xf2, 0x88, 0xf0, 0xb1, 0x44, 0x9d, 0xb1, 0x2, 0x95, 0x67, 0xdf, 0x6f, 0x28, 0xa9, 0x68, 0xcd, 0xaa, 0x8c, 0x54},
-		{0xeb, 0x8, 0xb4, 0x1b, 0x76, 0xa2, 0x23, 0xbb, 0x4a, 0xd3, 0x78, 0xca, 0x2e, 0xe8, 0x2c, 0xa1, 0xbf, 0x45, 0xf2, 0x58, 0xdf, 0x39, 0xdf, 0x43, 0x40, 0xb, 0x96, 0xcf, 0xfd, 0x9a, 0x87, 0x85},
-		{0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x76, 0x88, 0xa0, 0x68, 0x45, 0x25, 0x8f, 0xd5, 0xf9, 0xb2, 0xb0, 0x42, 0x68, 0x6b, 0x51, 0xcc, 0x29, 0x94, 0x63, 0x85, 0xec, 0xf5, 0x47, 0xf0, 0x9c, 0x46, 0x86, 0xa9, 0x99, 0x7d, 0x29, 0x6c},
-		{0x41, 0x44, 0x52, 0xff, 0x8c, 0xa6, 0xb3, 0x2e, 0xcc, 0x5e, 0x63, 0x8f, 0x8e, 0x7d, 0xe7, 0x52, 0x42, 0x94, 0x55, 0x2f, 0x89, 0xdd, 0x1e, 0x3c, 0xb0, 0xf4, 0x51, 0x51, 0x36, 0x81, 0x72, 0x1},
-		{0xa9, 0xbb, 0x6a, 0x1f, 0x5d, 0x86, 0x7d, 0xa7, 0x5a, 0x7d, 0x9d, 0x8d, 0xc0, 0x15, 0xb7, 0x0, 0xee, 0xa9, 0x68, 0x51, 0x88, 0x57, 0x5a, 0xd9, 0x4e, 0x1d, 0x8e, 0x44, 0xbf, 0xdc, 0x73, 0xff},
-	}
-	assert.DeepEqual(t, expected, root)
-}
-
-func TestComputeFieldRootsWithHasher_Altair(t *testing.T) {
-	beaconState, err := util.NewBeaconStateAltair(util.FillRootsNaturalOptAltair)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetGenesisTime(123))
-	require.NoError(t, beaconState.SetGenesisValidatorsRoot(genesisValidatorsRoot()))
-	require.NoError(t, beaconState.SetSlot(123))
-	require.NoError(t, beaconState.SetFork(fork()))
-	require.NoError(t, beaconState.SetLatestBlockHeader(latestBlockHeader()))
-	historicalRoots, err := util.PrepareRoots(int(params.BeaconConfig().SlotsPerHistoricalRoot))
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetHistoricalRoots(historicalRoots))
-	require.NoError(t, beaconState.SetEth1Data(eth1Data()))
-	require.NoError(t, beaconState.SetEth1DataVotes([]*ethpb.Eth1Data{eth1Data()}))
-	require.NoError(t, beaconState.SetEth1DepositIndex(123))
-	require.NoError(t, beaconState.SetValidators([]*ethpb.Validator{validator()}))
-	require.NoError(t, beaconState.SetBalances([]uint64{1, 2, 3}))
-	randaoMixes, err := util.PrepareRoots(int(params.BeaconConfig().EpochsPerHistoricalVector))
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetRandaoMixes(randaoMixes))
-	require.NoError(t, beaconState.SetSlashings([]uint64{1, 2, 3}))
-	require.NoError(t, beaconState.SetPreviousParticipationBits([]byte{1, 2, 3}))
-	require.NoError(t, beaconState.SetCurrentParticipationBits([]byte{1, 2, 3}))
-	require.NoError(t, beaconState.SetJustificationBits(justificationBits()))
-	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(checkpoint("previous")))
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(checkpoint("current")))
-	require.NoError(t, beaconState.SetFinalizedCheckpoint(checkpoint("finalized")))
-	require.NoError(t, beaconState.SetInactivityScores([]uint64{1, 2, 3}))
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee("current")))
-	require.NoError(t, beaconState.SetNextSyncCommittee(syncCommittee("next")))
-
-	v1State, ok := beaconState.(*v2.BeaconState)
-	require.Equal(t, true, ok)
-	protoState, ok := v1State.InnerStateUnsafe().(*ethpb.BeaconStateAltair)
-	require.Equal(t, true, ok)
-	initState, err := state_native.InitializeFromProtoAltair(protoState)
-	require.NoError(t, err)
-	s, ok := initState.(*state_native.BeaconState)
-	require.Equal(t, true, ok)
-
-	root, err := state_native.ComputeFieldRootsWithHasher(context.Background(), s)
-	require.NoError(t, err)
-	expected := [][]byte{
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x67, 0x76, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x58, 0xba, 0xf, 0x9b, 0x4f, 0x63, 0x1c, 0xa6, 0x19, 0xb1, 0xa2, 0x1f, 0xd1, 0x29, 0xc7, 0x67, 0x9c, 0x32, 0x4, 0x1f, 0xcf, 0x4e, 0x64, 0x9b, 0x8f, 0x21, 0xb4, 0xe6, 0xa5, 0xc9, 0xc, 0x38},
-		{0x8b, 0x5, 0x59, 0x78, 0xed, 0xbe, 0x2c, 0xde, 0xa6, 0xf, 0x52, 0xdc, 0x16, 0x83, 0xa0, 0x5d, 0x8, 0xc3, 0x37, 0x91, 0x3a, 0xf6, 0xfa, 0x6, 0x62, 0xc9, 0x6, 0xb1, 0x41, 0x48, 0xaf, 0xec},
-		{0xcc, 0xa1, 0x69, 0xa8, 0x8b, 0x1e, 0x49, 0x5, 0x1f, 0xe4, 0xd8, 0xff, 0x82, 0xa2, 0x2e, 0xf0, 0x54, 0xd1, 0x13, 0xc9, 0x8e, 0xb9, 0x82, 0xa6, 0x9e, 0x42, 0x2, 0xec, 0x97, 0x6f, 0x33, 0x88},
-		{0xcc, 0xa1, 0x69, 0xa8, 0x8b, 0x1e, 0x49, 0x5, 0x1f, 0xe4, 0xd8, 0xff, 0x82, 0xa2, 0x2e, 0xf0, 0x54, 0xd1, 0x13, 0xc9, 0x8e, 0xb9, 0x82, 0xa6, 0x9e, 0x42, 0x2, 0xec, 0x97, 0x6f, 0x33, 0x88},
-		{0xf, 0xad, 0xd3, 0x92, 0x4b, 0xda, 0xfa, 0xc6, 0x61, 0x50, 0xb7, 0xdf, 0x5f, 0x2c, 0xd0, 0x94, 0xc3, 0xaf, 0x41, 0x9d, 0xa, 0xea, 0x50, 0x96, 0x82, 0x62, 0x1c, 0x72, 0x26, 0x20, 0x6b, 0xac},
-		{0xc9, 0x4e, 0x2c, 0xb0, 0x20, 0xe3, 0xe7, 0x8c, 0x5c, 0xbd, 0xeb, 0x9b, 0xa5, 0x7b, 0x53, 0x50, 0xca, 0xfe, 0xe9, 0x48, 0x9e, 0x8d, 0xf8, 0x4a, 0xe6, 0x8d, 0x9c, 0x97, 0x81, 0x74, 0xb, 0x5e},
-		{0x71, 0x52, 0xd2, 0x9b, 0x87, 0x3c, 0x8a, 0xd9, 0x51, 0x55, 0xc0, 0x42, 0xb, 0xc4, 0x12, 0xa4, 0x79, 0xf5, 0x7d, 0x37, 0x16, 0xf4, 0x90, 0x72, 0x5d, 0xe0, 0x34, 0xb4, 0x2, 0x8c, 0x39, 0xe4},
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0xf, 0xf7, 0x4f, 0xe1, 0xa9, 0x72, 0x9c, 0x95, 0xf0, 0xe1, 0xde, 0xa4, 0x32, 0xc, 0x67, 0x52, 0x23, 0x13, 0x9e, 0xe2, 0x40, 0x8d, 0xf6, 0x18, 0x57, 0xf0, 0x1a, 0x4a, 0xad, 0x46, 0xce, 0x42},
-		{0xf9, 0x11, 0x2c, 0xc2, 0x71, 0x70, 0xde, 0x47, 0x26, 0xeb, 0x26, 0xd4, 0xa4, 0xe8, 0x68, 0xb, 0x16, 0xa2, 0x6e, 0x52, 0x54, 0xe, 0x5c, 0x83, 0x17, 0x3, 0xea, 0xdd, 0xd5, 0xa7, 0xb2, 0x3f},
-		{0x64, 0xbd, 0x40, 0xa7, 0x10, 0x44, 0x84, 0xed, 0xf3, 0x5f, 0xc3, 0x5d, 0x7b, 0xbe, 0xe8, 0x75, 0xbf, 0x66, 0xcb, 0xce, 0x77, 0xfa, 0x0, 0x3, 0xdd, 0xfb, 0x80, 0xd2, 0x77, 0x1b, 0xc2, 0x8},
-		{0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x75, 0xb2, 0xae, 0x1d, 0xd8, 0xca, 0xe6, 0x4d, 0xa8, 0xc5, 0xc9, 0x19, 0x8, 0x96, 0xaf, 0x9b, 0xe6, 0xf6, 0x99, 0xb9, 0x58, 0x56, 0x5b, 0x25, 0xea, 0x9c, 0x86, 0x5e, 0x96, 0x6a, 0x48, 0xb},
-		{0x75, 0xb2, 0xae, 0x1d, 0xd8, 0xca, 0xe6, 0x4d, 0xa8, 0xc5, 0xc9, 0x19, 0x8, 0x96, 0xaf, 0x9b, 0xe6, 0xf6, 0x99, 0xb9, 0x58, 0x56, 0x5b, 0x25, 0xea, 0x9c, 0x86, 0x5e, 0x96, 0x6a, 0x48, 0xb},
-		{0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x76, 0x88, 0xa0, 0x68, 0x45, 0x25, 0x8f, 0xd5, 0xf9, 0xb2, 0xb0, 0x42, 0x68, 0x6b, 0x51, 0xcc, 0x29, 0x94, 0x63, 0x85, 0xec, 0xf5, 0x47, 0xf0, 0x9c, 0x46, 0x86, 0xa9, 0x99, 0x7d, 0x29, 0x6c},
-		{0x41, 0x44, 0x52, 0xff, 0x8c, 0xa6, 0xb3, 0x2e, 0xcc, 0x5e, 0x63, 0x8f, 0x8e, 0x7d, 0xe7, 0x52, 0x42, 0x94, 0x55, 0x2f, 0x89, 0xdd, 0x1e, 0x3c, 0xb0, 0xf4, 0x51, 0x51, 0x36, 0x81, 0x72, 0x1},
-		{0xa9, 0xbb, 0x6a, 0x1f, 0x5d, 0x86, 0x7d, 0xa7, 0x5a, 0x7d, 0x9d, 0x8d, 0xc0, 0x15, 0xb7, 0x0, 0xee, 0xa9, 0x68, 0x51, 0x88, 0x57, 0x5a, 0xd9, 0x4e, 0x1d, 0x8e, 0x44, 0xbf, 0xdc, 0x73, 0xff},
-		{0xf9, 0x11, 0x2c, 0xc2, 0x71, 0x70, 0xde, 0x47, 0x26, 0xeb, 0x26, 0xd4, 0xa4, 0xe8, 0x68, 0xb, 0x16, 0xa2, 0x6e, 0x52, 0x54, 0xe, 0x5c, 0x83, 0x17, 0x3, 0xea, 0xdd, 0xd5, 0xa7, 0xb2, 0x3f},
-		{0x3d, 0xf3, 0x66, 0xd4, 0x12, 0x40, 0x3f, 0x28, 0xeb, 0xe4, 0x19, 0x59, 0xae, 0xab, 0x4d, 0xf3, 0x98, 0x88, 0x7f, 0x1e, 0x58, 0xa, 0x5d, 0xd4, 0xeb, 0xe5, 0x5d, 0x3d, 0x11, 0x70, 0x24, 0x76},
-		{0xd6, 0x4c, 0xb1, 0xac, 0x61, 0x7, 0x26, 0xbb, 0xd3, 0x27, 0x2a, 0xcd, 0xdd, 0x55, 0xf, 0x2b, 0x6a, 0xe8, 0x1, 0x31, 0x48, 0x66, 0x2f, 0x98, 0x7b, 0x6d, 0x27, 0x69, 0xd9, 0x40, 0xcc, 0x37},
-	}
-	assert.DeepEqual(t, expected, root)
-}
-
-func TestComputeFieldRootsWithHasher_Bellatrix(t *testing.T) {
-	beaconState, err := util.NewBeaconStateBellatrix(util.FillRootsNaturalOptBellatrix)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetGenesisTime(123))
-	require.NoError(t, beaconState.SetGenesisValidatorsRoot(genesisValidatorsRoot()))
-	require.NoError(t, beaconState.SetSlot(123))
-	require.NoError(t, beaconState.SetFork(fork()))
-	require.NoError(t, beaconState.SetLatestBlockHeader(latestBlockHeader()))
-	historicalRoots, err := util.PrepareRoots(int(params.BeaconConfig().SlotsPerHistoricalRoot))
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetHistoricalRoots(historicalRoots))
-	require.NoError(t, beaconState.SetEth1Data(eth1Data()))
-	require.NoError(t, beaconState.SetEth1DataVotes([]*ethpb.Eth1Data{eth1Data()}))
-	require.NoError(t, beaconState.SetEth1DepositIndex(123))
-	require.NoError(t, beaconState.SetValidators([]*ethpb.Validator{validator()}))
-	require.NoError(t, beaconState.SetBalances([]uint64{1, 2, 3}))
-	randaoMixes, err := util.PrepareRoots(int(params.BeaconConfig().EpochsPerHistoricalVector))
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetRandaoMixes(randaoMixes))
-	require.NoError(t, beaconState.SetSlashings([]uint64{1, 2, 3}))
-	require.NoError(t, beaconState.SetPreviousParticipationBits([]byte{1, 2, 3}))
-	require.NoError(t, beaconState.SetCurrentParticipationBits([]byte{1, 2, 3}))
-	require.NoError(t, beaconState.SetJustificationBits(justificationBits()))
-	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(checkpoint("previous")))
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(checkpoint("current")))
-	require.NoError(t, beaconState.SetFinalizedCheckpoint(checkpoint("finalized")))
-	require.NoError(t, beaconState.SetInactivityScores([]uint64{1, 2, 3}))
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee("current")))
-	require.NoError(t, beaconState.SetNextSyncCommittee(syncCommittee("next")))
-	require.NoError(t, beaconState.SetLatestExecutionPayloadHeader(executionPayloadHeader()))
-
-	v1State, ok := beaconState.(*v3.BeaconState)
-	require.Equal(t, true, ok)
-	protoState, ok := v1State.InnerStateUnsafe().(*ethpb.BeaconStateBellatrix)
-	require.Equal(t, true, ok)
-	initState, err := state_native.InitializeFromProtoBellatrix(protoState)
-	require.NoError(t, err)
-	s, ok := initState.(*state_native.BeaconState)
-	require.Equal(t, true, ok)
-
-	root, err := state_native.ComputeFieldRootsWithHasher(context.Background(), s)
-	require.NoError(t, err)
-	expected := [][]byte{
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x67, 0x76, 0x72, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x58, 0xba, 0xf, 0x9b, 0x4f, 0x63, 0x1c, 0xa6, 0x19, 0xb1, 0xa2, 0x1f, 0xd1, 0x29, 0xc7, 0x67, 0x9c, 0x32, 0x4, 0x1f, 0xcf, 0x4e, 0x64, 0x9b, 0x8f, 0x21, 0xb4, 0xe6, 0xa5, 0xc9, 0xc, 0x38},
-		{0x8b, 0x5, 0x59, 0x78, 0xed, 0xbe, 0x2c, 0xde, 0xa6, 0xf, 0x52, 0xdc, 0x16, 0x83, 0xa0, 0x5d, 0x8, 0xc3, 0x37, 0x91, 0x3a, 0xf6, 0xfa, 0x6, 0x62, 0xc9, 0x6, 0xb1, 0x41, 0x48, 0xaf, 0xec},
-		{0xcc, 0xa1, 0x69, 0xa8, 0x8b, 0x1e, 0x49, 0x5, 0x1f, 0xe4, 0xd8, 0xff, 0x82, 0xa2, 0x2e, 0xf0, 0x54, 0xd1, 0x13, 0xc9, 0x8e, 0xb9, 0x82, 0xa6, 0x9e, 0x42, 0x2, 0xec, 0x97, 0x6f, 0x33, 0x88},
-		{0xcc, 0xa1, 0x69, 0xa8, 0x8b, 0x1e, 0x49, 0x5, 0x1f, 0xe4, 0xd8, 0xff, 0x82, 0xa2, 0x2e, 0xf0, 0x54, 0xd1, 0x13, 0xc9, 0x8e, 0xb9, 0x82, 0xa6, 0x9e, 0x42, 0x2, 0xec, 0x97, 0x6f, 0x33, 0x88},
-		{0xf, 0xad, 0xd3, 0x92, 0x4b, 0xda, 0xfa, 0xc6, 0x61, 0x50, 0xb7, 0xdf, 0x5f, 0x2c, 0xd0, 0x94, 0xc3, 0xaf, 0x41, 0x9d, 0xa, 0xea, 0x50, 0x96, 0x82, 0x62, 0x1c, 0x72, 0x26, 0x20, 0x6b, 0xac},
-		{0xc9, 0x4e, 0x2c, 0xb0, 0x20, 0xe3, 0xe7, 0x8c, 0x5c, 0xbd, 0xeb, 0x9b, 0xa5, 0x7b, 0x53, 0x50, 0xca, 0xfe, 0xe9, 0x48, 0x9e, 0x8d, 0xf8, 0x4a, 0xe6, 0x8d, 0x9c, 0x97, 0x81, 0x74, 0xb, 0x5e},
-		{0x71, 0x52, 0xd2, 0x9b, 0x87, 0x3c, 0x8a, 0xd9, 0x51, 0x55, 0xc0, 0x42, 0xb, 0xc4, 0x12, 0xa4, 0x79, 0xf5, 0x7d, 0x37, 0x16, 0xf4, 0x90, 0x72, 0x5d, 0xe0, 0x34, 0xb4, 0x2, 0x8c, 0x39, 0xe4},
-		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0xf, 0xf7, 0x4f, 0xe1, 0xa9, 0x72, 0x9c, 0x95, 0xf0, 0xe1, 0xde, 0xa4, 0x32, 0xc, 0x67, 0x52, 0x23, 0x13, 0x9e, 0xe2, 0x40, 0x8d, 0xf6, 0x18, 0x57, 0xf0, 0x1a, 0x4a, 0xad, 0x46, 0xce, 0x42},
-		{0xf9, 0x11, 0x2c, 0xc2, 0x71, 0x70, 0xde, 0x47, 0x26, 0xeb, 0x26, 0xd4, 0xa4, 0xe8, 0x68, 0xb, 0x16, 0xa2, 0x6e, 0x52, 0x54, 0xe, 0x5c, 0x83, 0x17, 0x3, 0xea, 0xdd, 0xd5, 0xa7, 0xb2, 0x3f},
-		{0x64, 0xbd, 0x40, 0xa7, 0x10, 0x44, 0x84, 0xed, 0xf3, 0x5f, 0xc3, 0x5d, 0x7b, 0xbe, 0xe8, 0x75, 0xbf, 0x66, 0xcb, 0xce, 0x77, 0xfa, 0x0, 0x3, 0xdd, 0xfb, 0x80, 0xd2, 0x77, 0x1b, 0xc2, 0x8},
-		{0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x75, 0xb2, 0xae, 0x1d, 0xd8, 0xca, 0xe6, 0x4d, 0xa8, 0xc5, 0xc9, 0x19, 0x8, 0x96, 0xaf, 0x9b, 0xe6, 0xf6, 0x99, 0xb9, 0x58, 0x56, 0x5b, 0x25, 0xea, 0x9c, 0x86, 0x5e, 0x96, 0x6a, 0x48, 0xb},
-		{0x75, 0xb2, 0xae, 0x1d, 0xd8, 0xca, 0xe6, 0x4d, 0xa8, 0xc5, 0xc9, 0x19, 0x8, 0x96, 0xaf, 0x9b, 0xe6, 0xf6, 0x99, 0xb9, 0x58, 0x56, 0x5b, 0x25, 0xea, 0x9c, 0x86, 0x5e, 0x96, 0x6a, 0x48, 0xb},
-		{0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0x76, 0x88, 0xa0, 0x68, 0x45, 0x25, 0x8f, 0xd5, 0xf9, 0xb2, 0xb0, 0x42, 0x68, 0x6b, 0x51, 0xcc, 0x29, 0x94, 0x63, 0x85, 0xec, 0xf5, 0x47, 0xf0, 0x9c, 0x46, 0x86, 0xa9, 0x99, 0x7d, 0x29, 0x6c},
-		{0x41, 0x44, 0x52, 0xff, 0x8c, 0xa6, 0xb3, 0x2e, 0xcc, 0x5e, 0x63, 0x8f, 0x8e, 0x7d, 0xe7, 0x52, 0x42, 0x94, 0x55, 0x2f, 0x89, 0xdd, 0x1e, 0x3c, 0xb0, 0xf4, 0x51, 0x51, 0x36, 0x81, 0x72, 0x1},
-		{0xa9, 0xbb, 0x6a, 0x1f, 0x5d, 0x86, 0x7d, 0xa7, 0x5a, 0x7d, 0x9d, 0x8d, 0xc0, 0x15, 0xb7, 0x0, 0xee, 0xa9, 0x68, 0x51, 0x88, 0x57, 0x5a, 0xd9, 0x4e, 0x1d, 0x8e, 0x44, 0xbf, 0xdc, 0x73, 0xff},
-		{0xf9, 0x11, 0x2c, 0xc2, 0x71, 0x70, 0xde, 0x47, 0x26, 0xeb, 0x26, 0xd4, 0xa4, 0xe8, 0x68, 0xb, 0x16, 0xa2, 0x6e, 0x52, 0x54, 0xe, 0x5c, 0x83, 0x17, 0x3, 0xea, 0xdd, 0xd5, 0xa7, 0xb2, 0x3f},
-		{0x3d, 0xf3, 0x66, 0xd4, 0x12, 0x40, 0x3f, 0x28, 0xeb, 0xe4, 0x19, 0x59, 0xae, 0xab, 0x4d, 0xf3, 0x98, 0x88, 0x7f, 0x1e, 0x58, 0xa, 0x5d, 0xd4, 0xeb, 0xe5, 0x5d, 0x3d, 0x11, 0x70, 0x24, 0x76},
-		{0xd6, 0x4c, 0xb1, 0xac, 0x61, 0x7, 0x26, 0xbb, 0xd3, 0x27, 0x2a, 0xcd, 0xdd, 0x55, 0xf, 0x2b, 0x6a, 0xe8, 0x1, 0x31, 0x48, 0x66, 0x2f, 0x98, 0x7b, 0x6d, 0x27, 0x69, 0xd9, 0x40, 0xcc, 0x37},
-		{0xbc, 0xbb, 0x39, 0x57, 0x61, 0x1d, 0x54, 0xd6, 0x1b, 0xfe, 0x7a, 0xbd, 0x29, 0x52, 0x57, 0xdd, 0x19, 0x1, 0x89, 0x22, 0x7d, 0xdf, 0x7b, 0x53, 0x9f, 0xb, 0x46, 0x5, 0x9f, 0x80, 0xcc, 0x8e},
-	}
-	assert.DeepEqual(t, expected, root)
-}
-
-func genesisValidatorsRoot() []byte {
-	gvr := bytesutil.ToBytes32([]byte("gvr"))
-	return gvr[:]
-}
-
-func fork() *ethpb.Fork {
-	prev := bytesutil.ToBytes4([]byte("prev"))
-	curr := bytesutil.ToBytes4([]byte("curr"))
-	return &ethpb.Fork{
-		PreviousVersion: prev[:],
-		CurrentVersion:  curr[:],
-		Epoch:           123,
-	}
-}
-
-func latestBlockHeader() *ethpb.BeaconBlockHeader {
-	pr := bytesutil.ToBytes32([]byte("parent"))
-	sr := bytesutil.ToBytes32([]byte("state"))
-	br := bytesutil.ToBytes32([]byte("body"))
-	return &ethpb.BeaconBlockHeader{
-		Slot:          123,
-		ProposerIndex: 123,
-		ParentRoot:    pr[:],
-		StateRoot:     sr[:],
-		BodyRoot:      br[:],
-	}
-}
-
-func eth1Data() *ethpb.Eth1Data {
-	dr := bytesutil.ToBytes32([]byte("deposit"))
-	bh := bytesutil.ToBytes32([]byte("block"))
-	return &ethpb.Eth1Data{
-		DepositRoot:  dr[:],
-		DepositCount: 123,
-		BlockHash:    bh[:],
-	}
-}
-
-func validator() *ethpb.Validator {
-	pk := bytesutil.ToBytes48([]byte("public"))
-	wc := bytesutil.ToBytes32([]byte("withdrawal"))
-	return &ethpb.Validator{
-		PublicKey:                  pk[:],
-		WithdrawalCredentials:      wc[:],
-		EffectiveBalance:           123,
-		Slashed:                    true,
-		ActivationEligibilityEpoch: 123,
-		ActivationEpoch:            123,
-		ExitEpoch:                  123,
-		WithdrawableEpoch:          123,
-	}
-}
-
-func pendingAttestation(prefix string) *ethpb.PendingAttestation {
-	bbr := bytesutil.ToBytes32([]byte(prefix + "beacon"))
-	r := bytesutil.ToBytes32([]byte(prefix + "root"))
-	return &ethpb.PendingAttestation{
-		AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
-		Data: &ethpb.AttestationData{
-			Slot:            123,
-			CommitteeIndex:  123,
-			BeaconBlockRoot: bbr[:],
-			Source: &ethpb.Checkpoint{
-				Epoch: 123,
-				Root:  r[:],
-			},
-			Target: &ethpb.Checkpoint{
-				Epoch: 123,
-				Root:  r[:],
-			},
-		},
-		InclusionDelay: 123,
-		ProposerIndex:  123,
-	}
-}
-
-func justificationBits() bitfield.Bitvector4 {
-	v := bitfield.NewBitvector4()
-	v.SetBitAt(1, true)
-	return v
-}
-
-func checkpoint(prefix string) *ethpb.Checkpoint {
-	r := bytesutil.ToBytes32([]byte(prefix + "root"))
-	return &ethpb.Checkpoint{
-		Epoch: 123,
-		Root:  r[:],
-	}
-}
-
-func syncCommittee(prefix string) *ethpb.SyncCommittee {
-	pubkeys := make([][]byte, params.BeaconConfig().SyncCommitteeSize)
-	for i := range pubkeys {
-		key := bytesutil.ToBytes48([]byte(prefix + "pubkey"))
-		pubkeys[i] = key[:]
-	}
-	agg := bytesutil.ToBytes48([]byte(prefix + "aggregate"))
-	return &ethpb.SyncCommittee{
-		Pubkeys:         pubkeys,
-		AggregatePubkey: agg[:],
-	}
-}
-
-func executionPayloadHeader() *ethpb.ExecutionPayloadHeader {
-	ph := bytesutil.ToBytes32([]byte("parent"))
-	fr := bytesutil.PadTo([]byte("fee"), 20)
-	sr := bytesutil.ToBytes32([]byte("state"))
-	rr := bytesutil.ToBytes32([]byte("receipts"))
-	lb := bytesutil.PadTo([]byte("logs"), 256)
-	pr := bytesutil.ToBytes32([]byte("prev"))
-	ed := bytesutil.ToBytes32([]byte("extra"))
-	bf := bytesutil.ToBytes32([]byte("base"))
-	bh := bytesutil.ToBytes32([]byte("block"))
-	tr := bytesutil.ToBytes32([]byte("transactions"))
-	return &ethpb.ExecutionPayloadHeader{
-		ParentHash:       ph[:],
-		FeeRecipient:     fr,
-		StateRoot:        sr[:],
-		ReceiptsRoot:     rr[:],
-		LogsBloom:        lb,
-		PrevRandao:       pr[:],
-		BlockNumber:      0,
-		GasLimit:         0,
-		GasUsed:          0,
-		Timestamp:        0,
-		ExtraData:        ed[:],
-		BaseFeePerGas:    bf[:],
-		BlockHash:        bh[:],
-		TransactionsRoot: tr[:],
-	}
-}

beacon-chain/state/state-native/references_test.go

@@ -1,715 +0,0 @@
-package state_native
-
-import (
-	"reflect"
-	"runtime"
-	"runtime/debug"
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	nativetypes "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native/types"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestStateReferenceSharing_Finalizer_Phase0(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
-
-	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{RandaoMixes: [][]byte{[]byte("foo")}})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
-
-	func() {
-		// Create object in a different scope for GC
-		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
-		_ = b
-	}()
-
-	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
-
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, []byte("bar")))
-	if b.sharedFieldReferences[nativetypes.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[nativetypes.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
-	}
-}
-
-func TestStateReferenceSharing_Finalizer_Altair(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
-
-	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{RandaoMixes: [][]byte{[]byte("foo")}})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
-
-	func() {
-		// Create object in a different scope for GC
-		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
-		_ = b
-	}()
-
-	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
-
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, []byte("bar")))
-	if b.sharedFieldReferences[nativetypes.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[nativetypes.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
-	}
-}
-
-func TestStateReferenceSharing_Finalizer_Bellatrix(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
-
-	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{RandaoMixes: [][]byte{[]byte("foo")}})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
-
-	func() {
-		// Create object in a different scope for GC
-		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
-		_ = b
-	}()
-
-	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
-
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[nativetypes.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, []byte("bar")))
-	if b.sharedFieldReferences[nativetypes.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[nativetypes.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
-	}
-}
-
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Phase0(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, nativetypes.BlockRoots, 1)
-	assertRefCount(t, a, nativetypes.StateRoots, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.BlockRoots, 2)
-	assertRefCount(t, a, nativetypes.StateRoots, 2)
-	assertRefCount(t, b, nativetypes.BlockRoots, 2)
-	assertRefCount(t, b, nativetypes.StateRoots, 2)
-
-	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, nativetypes.BlockRoots, 1)
-	assertRefCount(t, a, nativetypes.StateRoots, 1)
-	assertRefCount(t, b, nativetypes.BlockRoots, 1)
-	assertRefCount(t, b, nativetypes.StateRoots, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Altair(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, nativetypes.BlockRoots, 1)
-	assertRefCount(t, a, nativetypes.StateRoots, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.BlockRoots, 2)
-	assertRefCount(t, a, nativetypes.StateRoots, 2)
-	assertRefCount(t, b, nativetypes.BlockRoots, 2)
-	assertRefCount(t, b, nativetypes.StateRoots, 2)
-
-	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, nativetypes.BlockRoots, 1)
-	assertRefCount(t, a, nativetypes.StateRoots, 1)
-	assertRefCount(t, b, nativetypes.BlockRoots, 1)
-	assertRefCount(t, b, nativetypes.StateRoots, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Bellatrix(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, nativetypes.BlockRoots, 1)
-	assertRefCount(t, a, nativetypes.StateRoots, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.BlockRoots, 2)
-	assertRefCount(t, a, nativetypes.StateRoots, 2)
-	assertRefCount(t, b, nativetypes.BlockRoots, 2)
-	assertRefCount(t, b, nativetypes.StateRoots, 2)
-
-	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, nativetypes.BlockRoots, 1)
-	assertRefCount(t, a, nativetypes.StateRoots, 1)
-	assertRefCount(t, b, nativetypes.BlockRoots, 1)
-	assertRefCount(t, b, nativetypes.StateRoots, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Phase0(t *testing.T) {
-
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, nativetypes.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.RandaoMixes, 2)
-	assertRefCount(t, b, nativetypes.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2[:]))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, nativetypes.RandaoMixes, 1)
-	assertRefCount(t, b, nativetypes.RandaoMixes, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Altair(t *testing.T) {
-
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, nativetypes.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.RandaoMixes, 2)
-	assertRefCount(t, b, nativetypes.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2[:]))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, nativetypes.RandaoMixes, 1)
-	assertRefCount(t, b, nativetypes.RandaoMixes, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Bellatrix(t *testing.T) {
-
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, nativetypes.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.RandaoMixes, 2)
-	assertRefCount(t, b, nativetypes.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2[:]))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, nativetypes.RandaoMixes, 1)
-	assertRefCount(t, b, nativetypes.RandaoMixes, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedAttestationsMutation(t *testing.T) {
-	assertAttFound := func(vals []*ethpb.PendingAttestation, val uint64) {
-		for i := range vals {
-			if reflect.DeepEqual(vals[i].AggregationBits, bitfield.NewBitlist(val)) {
-				return
-			}
-		}
-		t.Log(string(debug.Stack()))
-		t.Fatalf("Expected attestation not found (%v), want: %v", vals, val)
-	}
-	assertAttNotFound := func(vals []*ethpb.PendingAttestation, val uint64) {
-		for i := range vals {
-			if reflect.DeepEqual(vals[i].AggregationBits, bitfield.NewBitlist(val)) {
-				t.Log(string(debug.Stack()))
-				t.Fatalf("Unexpected attestation found (%v): %v", vals, val)
-				return
-			}
-		}
-	}
-
-	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.PreviousEpochAttestations, 1)
-	assertRefCount(t, a, nativetypes.CurrentEpochAttestations, 1)
-
-	// Update initial state.
-	atts := []*ethpb.PendingAttestation{
-		{AggregationBits: bitfield.NewBitlist(1)},
-		{AggregationBits: bitfield.NewBitlist(2)},
-	}
-	a.setPreviousEpochAttestations(atts[:1])
-	a.setCurrentEpochAttestations(atts[:1])
-	curAtt, err := a.CurrentEpochAttestations()
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(curAtt), "Unexpected number of attestations")
-	preAtt, err := a.PreviousEpochAttestations()
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(preAtt), "Unexpected number of attestations")
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, nativetypes.PreviousEpochAttestations, 2)
-	assertRefCount(t, a, nativetypes.CurrentEpochAttestations, 2)
-	assertRefCount(t, b, nativetypes.PreviousEpochAttestations, 2)
-	assertRefCount(t, b, nativetypes.CurrentEpochAttestations, 2)
-	prevAtts, err := b.PreviousEpochAttestations()
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(prevAtts), "Unexpected number of attestations")
-	currAtts, err := b.CurrentEpochAttestations()
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(currAtts), "Unexpected number of attestations")
-
-	// Assert shared state.
-	currAttsA, err := a.CurrentEpochAttestations()
-	require.NoError(t, err)
-	prevAttsA, err := a.PreviousEpochAttestations()
-	require.NoError(t, err)
-	currAttsB, err := b.CurrentEpochAttestations()
-	require.NoError(t, err)
-	prevAttsB, err := b.PreviousEpochAttestations()
-	require.NoError(t, err)
-	if len(currAttsA) != len(currAttsB) || len(currAttsA) < 1 {
-		t.Errorf("Unexpected number of attestations, want: %v", 1)
-	}
-	if len(prevAttsA) != len(prevAttsB) || len(prevAttsA) < 1 {
-		t.Errorf("Unexpected number of attestations, want: %v", 1)
-	}
-	assertAttFound(currAttsA, 1)
-	assertAttFound(prevAttsA, 1)
-	assertAttFound(currAttsB, 1)
-	assertAttFound(prevAttsB, 1)
-
-	// Extend state attestations.
-	require.NoError(t, a.AppendCurrentEpochAttestations(atts[1]))
-	require.NoError(t, a.AppendPreviousEpochAttestations(atts[1]))
-	curAtt, err = a.CurrentEpochAttestations()
-	require.NoError(t, err)
-	assert.Equal(t, 2, len(curAtt), "Unexpected number of attestations")
-	preAtt, err = a.PreviousEpochAttestations()
-	require.NoError(t, err)
-	assert.Equal(t, 2, len(preAtt), "Unexpected number of attestations")
-	currAttsA, err = a.CurrentEpochAttestations()
-	require.NoError(t, err)
-	prevAttsA, err = a.PreviousEpochAttestations()
-	require.NoError(t, err)
-	currAttsB, err = b.CurrentEpochAttestations()
-	require.NoError(t, err)
-	prevAttsB, err = b.PreviousEpochAttestations()
-	require.NoError(t, err)
-	assertAttFound(currAttsA, 1)
-	assertAttFound(prevAttsA, 1)
-	assertAttFound(currAttsA, 2)
-	assertAttFound(prevAttsA, 2)
-	assertAttFound(currAttsB, 1)
-	assertAttFound(prevAttsB, 1)
-	assertAttNotFound(currAttsB, 2)
-	assertAttNotFound(prevAttsB, 2)
-
-	// Mutator should only affect calling state: a.
-	applyToEveryAttestation := func(state *BeaconState) {
-		// One MUST copy on write.
-		currEpochAtts, err := state.CurrentEpochAttestations()
-		require.NoError(t, err)
-		atts = make([]*ethpb.PendingAttestation, len(currEpochAtts))
-		copy(atts, currEpochAtts)
-		state.setCurrentEpochAttestations(atts)
-		currEpochAtts, err = state.CurrentEpochAttestations()
-		require.NoError(t, err)
-		for i := range currEpochAtts {
-			att := ethpb.CopyPendingAttestation(currEpochAtts[i])
-			att.AggregationBits = bitfield.NewBitlist(3)
-			currEpochAtts[i] = att
-		}
-		state.setCurrentEpochAttestations(currEpochAtts)
-
-		prevEpochAtts, err := state.PreviousEpochAttestations()
-		require.NoError(t, err)
-		atts = make([]*ethpb.PendingAttestation, len(prevEpochAtts))
-		copy(atts, prevEpochAtts)
-		state.setPreviousEpochAttestations(atts)
-		prevEpochAtts, err = state.PreviousEpochAttestations()
-		require.NoError(t, err)
-		for i := range prevEpochAtts {
-			att := ethpb.CopyPendingAttestation(prevEpochAtts[i])
-			att.AggregationBits = bitfield.NewBitlist(3)
-			prevEpochAtts[i] = att
-		}
-		state.setPreviousEpochAttestations(prevEpochAtts)
-	}
-	applyToEveryAttestation(a)
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	currAttsA, err = a.CurrentEpochAttestations()
-	require.NoError(t, err)
-	prevAttsA, err = a.PreviousEpochAttestations()
-	require.NoError(t, err)
-	assertAttFound(currAttsA, 3)
-	assertAttFound(prevAttsA, 3)
-	assertAttNotFound(currAttsA, 1)
-	assertAttNotFound(prevAttsA, 1)
-	assertAttNotFound(currAttsA, 2)
-	assertAttNotFound(prevAttsA, 2)
-	// State b must be unaffected.
-	currAttsB, err = b.CurrentEpochAttestations()
-	require.NoError(t, err)
-	prevAttsB, err = b.PreviousEpochAttestations()
-	require.NoError(t, err)
-	assertAttNotFound(currAttsB, 3)
-	assertAttNotFound(prevAttsB, 3)
-	assertAttFound(currAttsB, 1)
-	assertAttFound(prevAttsB, 1)
-	assertAttNotFound(currAttsB, 2)
-	assertAttNotFound(prevAttsB, 2)
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, nativetypes.CurrentEpochAttestations, 1)
-	assertRefCount(t, b, nativetypes.CurrentEpochAttestations, 1)
-	assertRefCount(t, a, nativetypes.PreviousEpochAttestations, 1)
-	assertRefCount(t, b, nativetypes.PreviousEpochAttestations, 1)
-}
-
-func TestValidatorReferences_RemainsConsistent_Phase0(t *testing.T) {
-	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{
-		Validators: []*ethpb.Validator{
-			{PublicKey: []byte{'A'}},
-			{PublicKey: []byte{'B'}},
-			{PublicKey: []byte{'C'}},
-			{PublicKey: []byte{'D'}},
-			{PublicKey: []byte{'E'}},
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	// Create a second state.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	// Update First Validator.
-	assert.NoError(t, a.UpdateValidatorAtIndex(0, &ethpb.Validator{PublicKey: []byte{'Z'}}))
-
-	assert.DeepNotEqual(t, a.Validators()[0], b.Validators()[0], "validators are equal when they are supposed to be different")
-	// Modify all validators from copied state.
-	assert.NoError(t, b.ApplyToEveryValidator(func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
-		return true, &ethpb.Validator{PublicKey: []byte{'V'}}, nil
-	}))
-
-	// Ensure reference is properly accounted for.
-	assert.NoError(t, a.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
-		assert.NotEqual(t, bytesutil.ToBytes48([]byte{'V'}), val.PublicKey())
-		return nil
-	}))
-}
-
-func TestValidatorReferences_RemainsConsistent_Altair(t *testing.T) {
-	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{
-		Validators: []*ethpb.Validator{
-			{PublicKey: []byte{'A'}},
-			{PublicKey: []byte{'B'}},
-			{PublicKey: []byte{'C'}},
-			{PublicKey: []byte{'D'}},
-			{PublicKey: []byte{'E'}},
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	// Create a second state.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	// Update First Validator.
-	assert.NoError(t, a.UpdateValidatorAtIndex(0, &ethpb.Validator{PublicKey: []byte{'Z'}}))
-
-	assert.DeepNotEqual(t, a.Validators()[0], b.Validators()[0], "validators are equal when they are supposed to be different")
-	// Modify all validators from copied state.
-	assert.NoError(t, b.ApplyToEveryValidator(func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
-		return true, &ethpb.Validator{PublicKey: []byte{'V'}}, nil
-	}))
-
-	// Ensure reference is properly accounted for.
-	assert.NoError(t, a.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
-		assert.NotEqual(t, bytesutil.ToBytes48([]byte{'V'}), val.PublicKey())
-		return nil
-	}))
-}
-
-func TestValidatorReferences_RemainsConsistent_Bellatrix(t *testing.T) {
-	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{
-		Validators: []*ethpb.Validator{
-			{PublicKey: []byte{'A'}},
-			{PublicKey: []byte{'B'}},
-			{PublicKey: []byte{'C'}},
-			{PublicKey: []byte{'D'}},
-			{PublicKey: []byte{'E'}},
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	// Create a second state.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	// Update First Validator.
-	assert.NoError(t, a.UpdateValidatorAtIndex(0, &ethpb.Validator{PublicKey: []byte{'Z'}}))
-
-	assert.DeepNotEqual(t, a.Validators()[0], b.Validators()[0], "validators are equal when they are supposed to be different")
-	// Modify all validators from copied state.
-	assert.NoError(t, b.ApplyToEveryValidator(func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
-		return true, &ethpb.Validator{PublicKey: []byte{'V'}}, nil
-	}))
-
-	// Ensure reference is properly accounted for.
-	assert.NoError(t, a.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
-		assert.NotEqual(t, bytesutil.ToBytes48([]byte{'V'}), val.PublicKey())
-		return nil
-	}))
-}
-
-// assertRefCount checks whether reference count for a given state
-// at a given index is equal to expected amount.
-func assertRefCount(t *testing.T, b *BeaconState, idx nativetypes.FieldIndex, want uint) {
-	if cnt := b.sharedFieldReferences[idx].Refs(); cnt != want {
-		t.Errorf("Unexpected count of references for index %d, want: %v, got: %v", idx, want, cnt)
-	}
-}
-
-// assertValFound checks whether item with a given value exists in list.
-func assertValFound(t *testing.T, vals [][]byte, val []byte) {
-	for i := range vals {
-		if reflect.DeepEqual(vals[i], val) {
-			return
-		}
-	}
-	t.Log(string(debug.Stack()))
-	t.Fatalf("Expected value not found (%v), want: %v", vals, val)
-}
-
-// assertValNotFound checks whether item with a given value doesn't exist in list.
-func assertValNotFound(t *testing.T, vals [][]byte, val []byte) {
-	for i := range vals {
-		if reflect.DeepEqual(vals[i], val) {
-			t.Log(string(debug.Stack()))
-			t.Errorf("Unexpected value found (%v),: %v", vals, val)
-			return
-		}
-	}
-}

beacon-chain/state/state-native/setters_participation.go

@@ -1,165 +0,0 @@
-package state_native
-
-import (
-	nativetypes "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native/types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-)
-
-// SetPreviousParticipationBits for the beacon state. Updates the entire
-// list to a new value by overwriting the previous one.
-func (b *BeaconState) SetPreviousParticipationBits(val []byte) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.version == version.Phase0 {
-		return errNotSupported("SetPreviousParticipationBits", b.version)
-	}
-
-	b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits].MinusRef()
-	b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits] = stateutil.NewRef(1)
-
-	b.previousEpochParticipation = val
-	b.markFieldAsDirty(nativetypes.PreviousEpochParticipationBits)
-	b.rebuildTrie[nativetypes.PreviousEpochParticipationBits] = true
-	return nil
-}
-
-// SetCurrentParticipationBits for the beacon state. Updates the entire
-// list to a new value by overwriting the previous one.
-func (b *BeaconState) SetCurrentParticipationBits(val []byte) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.version == version.Phase0 {
-		return errNotSupported("SetCurrentParticipationBits", b.version)
-	}
-
-	b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits].MinusRef()
-	b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits] = stateutil.NewRef(1)
-
-	b.currentEpochParticipation = val
-	b.markFieldAsDirty(nativetypes.CurrentEpochParticipationBits)
-	b.rebuildTrie[nativetypes.CurrentEpochParticipationBits] = true
-	return nil
-}
-
-// AppendCurrentParticipationBits for the beacon state. Appends the new value
-// to the the end of list.
-func (b *BeaconState) AppendCurrentParticipationBits(val byte) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.version == version.Phase0 {
-		return errNotSupported("AppendCurrentParticipationBits", b.version)
-	}
-
-	participation := b.currentEpochParticipation
-	if b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits].Refs() > 1 {
-		// Copy elements in underlying array by reference.
-		participation = make([]byte, len(b.currentEpochParticipation))
-		copy(participation, b.currentEpochParticipation)
-		b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits].MinusRef()
-		b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits] = stateutil.NewRef(1)
-	}
-
-	b.currentEpochParticipation = append(participation, val)
-	b.markFieldAsDirty(nativetypes.CurrentEpochParticipationBits)
-	b.addDirtyIndices(nativetypes.CurrentEpochParticipationBits, []uint64{uint64(len(b.currentEpochParticipation) - 1)})
-	return nil
-}
-
-// AppendPreviousParticipationBits for the beacon state. Appends the new value
-// to the the end of list.
-func (b *BeaconState) AppendPreviousParticipationBits(val byte) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.version == version.Phase0 {
-		return errNotSupported("AppendPreviousParticipationBits", b.version)
-	}
-
-	bits := b.previousEpochParticipation
-	if b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits].Refs() > 1 {
-		bits = make([]byte, len(b.previousEpochParticipation))
-		copy(bits, b.previousEpochParticipation)
-		b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits].MinusRef()
-		b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits] = stateutil.NewRef(1)
-	}
-
-	b.previousEpochParticipation = append(bits, val)
-	b.markFieldAsDirty(nativetypes.PreviousEpochParticipationBits)
-	b.addDirtyIndices(nativetypes.PreviousEpochParticipationBits, []uint64{uint64(len(b.previousEpochParticipation) - 1)})
-
-	return nil
-}
-
-// ModifyPreviousParticipationBits modifies the previous participation bitfield via
-// the provided mutator function.
-func (b *BeaconState) ModifyPreviousParticipationBits(mutator func(val []byte) ([]byte, error)) error {
-	b.lock.Lock()
-
-	if b.version == version.Phase0 {
-		b.lock.Unlock()
-		return errNotSupported("ModifyPreviousParticipationBits", b.version)
-	}
-
-	participation := b.previousEpochParticipation
-	if b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits].Refs() > 1 {
-		// Copy elements in underlying array by reference.
-		participation = make([]byte, len(b.previousEpochParticipation))
-		copy(participation, b.previousEpochParticipation)
-		b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits].MinusRef()
-		b.sharedFieldReferences[nativetypes.PreviousEpochParticipationBits] = stateutil.NewRef(1)
-	}
-	// Lock is released so that mutator can
-	// acquire it.
-	b.lock.Unlock()
-
-	var err error
-	participation, err = mutator(participation)
-	if err != nil {
-		return err
-	}
-	b.lock.Lock()
-	defer b.lock.Unlock()
-	b.previousEpochParticipation = participation
-	b.markFieldAsDirty(nativetypes.PreviousEpochParticipationBits)
-	b.rebuildTrie[nativetypes.PreviousEpochParticipationBits] = true
-	return nil
-}
-
-// ModifyCurrentParticipationBits modifies the current participation bitfield via
-// the provided mutator function.
-func (b *BeaconState) ModifyCurrentParticipationBits(mutator func(val []byte) ([]byte, error)) error {
-	b.lock.Lock()
-
-	if b.version == version.Phase0 {
-		b.lock.Unlock()
-		return errNotSupported("ModifyCurrentParticipationBits", b.version)
-	}
-
-	participation := b.currentEpochParticipation
-	if b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits].Refs() > 1 {
-		// Copy elements in underlying array by reference.
-		participation = make([]byte, len(b.currentEpochParticipation))
-		copy(participation, b.currentEpochParticipation)
-		b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits].MinusRef()
-		b.sharedFieldReferences[nativetypes.CurrentEpochParticipationBits] = stateutil.NewRef(1)
-	}
-	// Lock is released so that mutator can
-	// acquire it.
-	b.lock.Unlock()
-
-	var err error
-	participation, err = mutator(participation)
-	if err != nil {
-		return err
-	}
-	b.lock.Lock()
-	defer b.lock.Unlock()
-	b.currentEpochParticipation = participation
-	b.markFieldAsDirty(nativetypes.CurrentEpochParticipationBits)
-	b.rebuildTrie[nativetypes.CurrentEpochParticipationBits] = true
-	return nil
-}