Refactor Exported Names to Follow Golang Best Practices (#13075)

* Fix exported names that start with a package name

* A few more renames

* Fix exported names that start with a package name

* A few more renames

* Radek's feedback

* Fix conflict

* fix keymanager test

* Fix comments

---------

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>

beacon-chain/cache/checkpoint_state.go

@@ -42,7 +42,7 @@ func NewCheckpointStateCache() *CheckpointStateCache {
 // StateByCheckpoint fetches state by checkpoint. Returns true with a
 // reference to the CheckpointState info, if exists. Otherwise returns false, nil.
 func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.BeaconState, error) {
-	h, err := hash.HashProto(cp)
+	h, err := hash.Proto(cp)
 	if err != nil {
 		return nil, err
 	}
@@ -62,7 +62,7 @@ func (c *CheckpointStateCache) StateByCheckpoint(cp *ethpb.Checkpoint) (state.Be
 // AddCheckpointState adds CheckpointState object to the cache. This method also trims the least
 // recently added CheckpointState object if the cache size has ready the max cache size limit.
 func (c *CheckpointStateCache) AddCheckpointState(cp *ethpb.Checkpoint, s state.ReadOnlyBeaconState) error {
-	h, err := hash.HashProto(cp)
+	h, err := hash.Proto(cp)
 	if err != nil {
 		return err
 	}

beacon-chain/cache/depositcache/pending_deposits.go

@@ -98,7 +98,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 		return
 	}
 
-	depRoot, err := hash.HashProto(d)
+	depRoot, err := hash.Proto(d)
 	if err != nil {
 		log.WithError(err).Error("Could not remove deposit")
 		return
@@ -109,7 +109,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 
 	idx := -1
 	for i, ctnr := range dc.pendingDeposits {
-		h, err := hash.HashProto(ctnr.Deposit)
+		h, err := hash.Proto(ctnr.Deposit)
 		if err != nil {
 			log.WithError(err).Error("Could not hash deposit")
 			continue

beacon-chain/core/blocks/exit.go

@@ -55,7 +55,7 @@ func ProcessVoluntaryExits(
 	if len(exits) == 0 {
 		return beaconState, nil
 	}
-	maxExitEpoch, churn := v.ValidatorsMaxExitEpochAndChurn(beaconState)
+	maxExitEpoch, churn := v.MaxExitEpochAndChurn(beaconState)
 	var exitEpoch primitives.Epoch
 	for idx, exit := range exits {
 		if exit == nil || exit.Exit == nil {

beacon-chain/core/blocks/withdrawals.go

@@ -235,7 +235,7 @@ func BLSChangesSignatureBatch(
 			return nil, errors.Wrap(err, "could not convert bytes to public key")
 		}
 		batch.PublicKeys[i] = publicKey
-		htr, err := signing.SigningData(change.Message.HashTreeRoot, domain)
+		htr, err := signing.Data(change.Message.HashTreeRoot, domain)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not compute BLSToExecutionChange signing data")
 		}

beacon-chain/core/epoch/epoch_processing.go

@@ -112,7 +112,7 @@ func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state
 		if isActive && belowEjectionBalance {
 			// Here is fine to do a quadratic loop since this should
 			// barely happen
-			maxExitEpoch, churn := validators.ValidatorsMaxExitEpochAndChurn(state)
+			maxExitEpoch, churn := validators.MaxExitEpochAndChurn(state)
 			state, _, err = validators.InitiateValidatorExit(ctx, state, primitives.ValidatorIndex(idx), maxExitEpoch, churn)
 			if err != nil && !errors.Is(err, validators.ValidatorAlreadyExitedErr) {
 				return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)

beacon-chain/core/signing/signing_root.go

@@ -92,12 +92,12 @@ func ComputeDomainAndSign(st state.ReadOnlyBeaconState, epoch primitives.Epoch,
 //	       domain=domain,
 //	   ))
 func ComputeSigningRoot(object fssz.HashRoot, domain []byte) ([32]byte, error) {
-	return SigningData(object.HashTreeRoot, domain)
+	return Data(object.HashTreeRoot, domain)
 }
 
-// SigningData computes the signing data by utilising the provided root function and then
+// Data computes the signing data by utilising the provided root function and then
 // returning the signing data of the container object.
-func SigningData(rootFunc func() ([32]byte, error), domain []byte) ([32]byte, error) {
+func Data(rootFunc func() ([32]byte, error), domain []byte) ([32]byte, error) {
 	objRoot, err := rootFunc()
 	if err != nil {
 		return [32]byte{}, err
@@ -152,7 +152,7 @@ func VerifyBlockHeaderSigningRoot(blkHdr *ethpb.BeaconBlockHeader, pub, signatur
 	if err != nil {
 		return errors.Wrap(err, "could not convert bytes to signature")
 	}
-	root, err := SigningData(blkHdr.HashTreeRoot, domain)
+	root, err := Data(blkHdr.HashTreeRoot, domain)
 	if err != nil {
 		return errors.Wrap(err, "could not compute signing root")
 	}
@@ -191,7 +191,7 @@ func BlockSignatureBatch(pub, signature, domain []byte, rootFunc func() ([32]byt
 		return nil, errors.Wrap(err, "could not convert bytes to public key")
 	}
 	// utilize custom block hashing function
-	root, err := SigningData(rootFunc, domain)
+	root, err := Data(rootFunc, domain)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not compute signing root")
 	}

beacon-chain/core/transition/state_test.go

@@ -103,8 +103,8 @@ func TestGenesisState_HashEquality(t *testing.T) {
 	pbstate, err := state_native.ProtobufBeaconStatePhase0(state.ToProto())
 	require.NoError(t, err)
 
-	root1, err1 := hash.HashProto(pbState1)
+	root1, err1 := hash.Proto(pbState1)
-	root2, err2 := hash.HashProto(pbstate)
+	root2, err2 := hash.Proto(pbstate)
 
 	if err1 != nil || err2 != nil {
 		t.Fatalf("Failed to marshal state to bytes: %v %v", err1, err2)

beacon-chain/core/validators/validator.go

@@ -21,9 +21,9 @@ import (
 // an already exited validator
 var ValidatorAlreadyExitedErr = errors.New("validator already exited")
 
-// ValidatorsMaxExitEpochAndChurn returns the maximum non-FAR_FUTURE_EPOCH exit
+// MaxExitEpochAndChurn returns the maximum non-FAR_FUTURE_EPOCH exit
 // epoch and the number of them
-func ValidatorsMaxExitEpochAndChurn(s state.BeaconState) (maxExitEpoch primitives.Epoch, churn uint64) {
+func MaxExitEpochAndChurn(s state.BeaconState) (maxExitEpoch primitives.Epoch, churn uint64) {
 	farFutureEpoch := params.BeaconConfig().FarFutureEpoch
 	err := s.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		e := val.ExitEpoch()
@@ -134,7 +134,7 @@ func SlashValidator(
 	slashedIdx primitives.ValidatorIndex,
 	penaltyQuotient uint64,
 	proposerRewardQuotient uint64) (state.BeaconState, error) {
-	maxExitEpoch, churn := ValidatorsMaxExitEpochAndChurn(s)
+	maxExitEpoch, churn := MaxExitEpochAndChurn(s)
 	s, _, err := InitiateValidatorExit(ctx, s, slashedIdx, maxExitEpoch, churn)
 	if err != nil && !errors.Is(err, ValidatorAlreadyExitedErr) {
 		return nil, errors.Wrapf(err, "could not initiate validator %d exit", slashedIdx)

beacon-chain/core/validators/validator_test.go

@@ -410,7 +410,7 @@ func TestValidatorMaxExitEpochAndChurn(t *testing.T) {
 	for _, tt := range tests {
 		s, err := state_native.InitializeFromProtoPhase0(tt.state)
 		require.NoError(t, err)
-		epoch, churn := ValidatorsMaxExitEpochAndChurn(s)
+		epoch, churn := MaxExitEpochAndChurn(s)
 		require.Equal(t, tt.wantedEpoch, epoch)
 		require.Equal(t, tt.wantedChurn, churn)
 	}

beacon-chain/db/db.go

@@ -13,9 +13,9 @@ func NewDB(ctx context.Context, dirPath string) (Database, error) {
 	return kv.NewKVStore(ctx, dirPath)
 }
 
-// NewDBFilename uses the KVStoreDatafilePath so that if this layer of
+// NewFileName uses the KVStoreDatafilePath so that if this layer of
 // indirection between db.NewDB->kv.NewKVStore ever changes, it will be easy to remember
 // to also change this filename indirection at the same time.
-func NewDBFilename(dirPath string) string {
+func NewFileName(dirPath string) string {
-	return kv.KVStoreDatafilePath(dirPath)
+	return kv.StoreDatafilePath(dirPath)
 }

beacon-chain/db/iface/interface.go

@@ -170,7 +170,7 @@ type SlasherDatabase interface {
 // Database interface with full access.
 type Database interface {
 	io.Closer
-	backup.BackupExporter
+	backup.Exporter
 	HeadAccessDatabase
 
 	DatabasePath() string

beacon-chain/db/kv/blob.go

@@ -260,7 +260,7 @@ func (s *Store) BlobSidecarsBySlot(ctx context.Context, slot types.Slot, indices
 	return filterForIndices(sc, indices...)
 }
 
-// DeleteBlobSidecar returns true if the blobs are in the db.
+// DeleteBlobSidecars returns true if the blobs are in the db.
 func (s *Store) DeleteBlobSidecars(ctx context.Context, beaconBlockRoot [32]byte) error {
 	_, span := trace.StartSpan(ctx, "BeaconDB.DeleteBlobSidecar")
 	defer span.End()

beacon-chain/db/kv/kv.go

@@ -92,10 +92,10 @@ type Store struct {
 	ctx                 context.Context
 }
 
-// KVStoreDatafilePath is the canonical construction of a full
+// StoreDatafilePath is the canonical construction of a full
 // database file path from the directory path, so that code outside
 // this package can find the full path in a consistent way.
-func KVStoreDatafilePath(dirPath string) string {
+func StoreDatafilePath(dirPath string) string {
 	return path.Join(dirPath, DatabaseFileName)
 }
 
@@ -146,7 +146,7 @@ func NewKVStore(ctx context.Context, dirPath string) (*Store, error) {
 			return nil, err
 		}
 	}
-	datafile := KVStoreDatafilePath(dirPath)
+	datafile := StoreDatafilePath(dirPath)
 	log.Infof("Opening Bolt DB at %s", datafile)
 	boltDB, err := bolt.Open(
 		datafile,

beacon-chain/db/restore.go

@@ -22,7 +22,7 @@ func Restore(cliCtx *cli.Context) error {
 	targetDir := cliCtx.String(cmd.RestoreTargetDirFlag.Name)
 
 	restoreDir := path.Join(targetDir, kv.BeaconNodeDbDirName)
-	if file.FileExists(path.Join(restoreDir, kv.DatabaseFileName)) {
+	if file.Exists(path.Join(restoreDir, kv.DatabaseFileName)) {
 		resp, err := prompt.ValidatePrompt(
 			os.Stdin, dbExistsYesNoPrompt, prompt.ValidateYesOrNo,
 		)

beacon-chain/execution/engine_client.go

@@ -64,10 +64,10 @@ const (
 	GetPayloadMethodV3 = "engine_getPayloadV3"
 	// ExchangeTransitionConfigurationMethod v1 request string for JSON-RPC.
 	ExchangeTransitionConfigurationMethod = "engine_exchangeTransitionConfigurationV1"
-	// ExecutionBlockByHashMethod request string for JSON-RPC.
+	// BlockByHashMethod request string for JSON-RPC.
-	ExecutionBlockByHashMethod = "eth_getBlockByHash"
+	BlockByHashMethod = "eth_getBlockByHash"
-	// ExecutionBlockByNumberMethod request string for JSON-RPC.
+	// BlockByNumberMethod request string for JSON-RPC.
-	ExecutionBlockByNumberMethod = "eth_getBlockByNumber"
+	BlockByNumberMethod = "eth_getBlockByNumber"
 	// GetPayloadBodiesByHashV1 v1 request string for JSON-RPC.
 	GetPayloadBodiesByHashV1 = "engine_getPayloadBodiesByHashV1"
 	// GetPayloadBodiesByRangeV1 v1 request string for JSON-RPC.
@@ -89,7 +89,7 @@ type ForkchoiceUpdatedResponse struct {
 // ExecutionPayloadReconstructor defines a service that can reconstruct a full beacon
 // block with an execution payload from a signed beacon block and a connection
 // to an execution client's engine API.
-type ExecutionPayloadReconstructor interface {
+type PayloadReconstructor interface {
 	ReconstructFullBlock(
 		ctx context.Context, blindedBlock interfaces.ReadOnlySignedBeaconBlock,
 	) (interfaces.SignedBeaconBlock, error)
@@ -463,7 +463,7 @@ func (s *Service) LatestExecutionBlock(ctx context.Context) (*pb.ExecutionBlock,
 	err := s.rpcClient.CallContext(
 		ctx,
 		result,
-		ExecutionBlockByNumberMethod,
+		BlockByNumberMethod,
 		"latest",
 		false, /* no full transaction objects */
 	)
@@ -476,7 +476,7 @@ func (s *Service) ExecutionBlockByHash(ctx context.Context, hash common.Hash, wi
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ExecutionBlockByHash")
 	defer span.End()
 	result := &pb.ExecutionBlock{}
-	err := s.rpcClient.CallContext(ctx, result, ExecutionBlockByHashMethod, hash, withTxs)
+	err := s.rpcClient.CallContext(ctx, result, BlockByHashMethod, hash, withTxs)
 	return result, handleRPCError(err)
 }
 
@@ -495,7 +495,7 @@ func (s *Service) ExecutionBlocksByHashes(ctx context.Context, hashes []common.H
 		blk := &pb.ExecutionBlock{}
 		newH := h
 		elems = append(elems, gethRPC.BatchElem{
-			Method: ExecutionBlockByHashMethod,
+			Method: BlockByHashMethod,
 			Args:   []interface{}{newH, withTxs},
 			Result: blk,
 			Error:  error(nil),
@@ -517,7 +517,7 @@ func (s *Service) ExecutionBlocksByHashes(ctx context.Context, hashes []common.H
 // HeaderByHash returns the relevant header details for the provided block hash.
 func (s *Service) HeaderByHash(ctx context.Context, hash common.Hash) (*types.HeaderInfo, error) {
 	var hdr *types.HeaderInfo
-	err := s.rpcClient.CallContext(ctx, &hdr, ExecutionBlockByHashMethod, hash, false /* no transactions */)
+	err := s.rpcClient.CallContext(ctx, &hdr, BlockByHashMethod, hash, false /* no transactions */)
 	if err == nil && hdr == nil {
 		err = ethereum.NotFound
 	}
@@ -527,7 +527,7 @@ func (s *Service) HeaderByHash(ctx context.Context, hash common.Hash) (*types.He
 // HeaderByNumber returns the relevant header details for the provided block number.
 func (s *Service) HeaderByNumber(ctx context.Context, number *big.Int) (*types.HeaderInfo, error) {
 	var hdr *types.HeaderInfo
-	err := s.rpcClient.CallContext(ctx, &hdr, ExecutionBlockByNumberMethod, toBlockNumArg(number), false /* no transactions */)
+	err := s.rpcClient.CallContext(ctx, &hdr, BlockByNumberMethod, toBlockNumArg(number), false /* no transactions */)
 	if err == nil && hdr == nil {
 		err = ethereum.NotFound
 	}

beacon-chain/execution/engine_client_test.go

@@ -37,9 +37,9 @@ import (
 )
 
 var (
-	_ = ExecutionPayloadReconstructor(&Service{})
+	_ = PayloadReconstructor(&Service{})
 	_ = EngineCaller(&Service{})
-	_ = ExecutionPayloadReconstructor(&Service{})
+	_ = PayloadReconstructor(&Service{})
 	_ = EngineCaller(&mocks.EngineClient{})
 )
 
@@ -141,14 +141,14 @@ func TestClient_IPC(t *testing.T) {
 		err := srv.ExchangeTransitionConfiguration(ctx, want)
 		require.NoError(t, err)
 	})
-	t.Run(ExecutionBlockByNumberMethod, func(t *testing.T) {
+	t.Run(BlockByNumberMethod, func(t *testing.T) {
 		want, ok := fix["ExecutionBlock"].(*pb.ExecutionBlock)
 		require.Equal(t, true, ok)
 		resp, err := srv.LatestExecutionBlock(ctx)
 		require.NoError(t, err)
 		require.DeepEqual(t, want, resp)
 	})
-	t.Run(ExecutionBlockByHashMethod, func(t *testing.T) {
+	t.Run(BlockByHashMethod, func(t *testing.T) {
 		want, ok := fix["ExecutionBlock"].(*pb.ExecutionBlock)
 		require.Equal(t, true, ok)
 		arg := common.BytesToHash([]byte("foo"))
@@ -644,7 +644,7 @@ func TestClient_HTTP(t *testing.T) {
 		require.ErrorIs(t, ErrUnknownPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
-	t.Run(ExecutionBlockByNumberMethod, func(t *testing.T) {
+	t.Run(BlockByNumberMethod, func(t *testing.T) {
 		want, ok := fix["ExecutionBlock"].(*pb.ExecutionBlock)
 		require.Equal(t, true, ok)
 		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -712,7 +712,7 @@ func TestClient_HTTP(t *testing.T) {
 		err = client.ExchangeTransitionConfiguration(ctx, want)
 		require.NoError(t, err)
 	})
-	t.Run(ExecutionBlockByHashMethod, func(t *testing.T) {
+	t.Run(BlockByHashMethod, func(t *testing.T) {
 		arg := common.BytesToHash([]byte("foo"))
 		want, ok := fix["ExecutionBlock"].(*pb.ExecutionBlock)
 		require.Equal(t, true, ok)

beacon-chain/execution/log_processing.go

@@ -32,7 +32,7 @@ import (
 )
 
 var (
-	depositEventSignature = hash.HashKeccak256([]byte("DepositEvent(bytes,bytes,bytes,bytes,bytes)"))
+	depositEventSignature = hash.Keccak256([]byte("DepositEvent(bytes,bytes,bytes,bytes,bytes)"))
 )
 
 const eth1DataSavingInterval = 1000

beacon-chain/node/node.go

@@ -295,9 +295,9 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 	}
 
 	// db.DatabasePath is the path to the containing directory
-	// db.NewDBFilename expands that to the canonical full path using
+	// db.NewFileName expands that to the canonical full path using
 	// the same construction as NewDB()
-	c, err := newBeaconNodePromCollector(db.NewDBFilename(beacon.db.DatabasePath()))
+	c, err := newBeaconNodePromCollector(db.NewFileName(beacon.db.DatabasePath()))
 	if err != nil {
 		return nil, err
 	}
@@ -514,7 +514,7 @@ func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context) error {
 }
 
 func (b *BeaconNode) startStateGen(ctx context.Context, bfs *backfill.Status, fc forkchoice.ForkChoicer) error {
-	opts := []stategen.StateGenOption{stategen.WithBackfillStatus(bfs)}
+	opts := []stategen.Option{stategen.WithBackfillStatus(bfs)}
 	sg := stategen.New(b.db, fc, opts...)
 
 	cp, err := b.db.FinalizedCheckpoint(ctx)
@@ -713,7 +713,7 @@ func (b *BeaconNode) registerSyncService(initialSyncComplete chan struct{}) erro
 		regularsync.WithStateGen(b.stateGen),
 		regularsync.WithSlasherAttestationsFeed(b.slasherAttestationsFeed),
 		regularsync.WithSlasherBlockHeadersFeed(b.slasherBlockHeadersFeed),
-		regularsync.WithExecutionPayloadReconstructor(web3Service),
+		regularsync.WithPayloadReconstructor(web3Service),
 		regularsync.WithClockWaiter(b.clockWaiter),
 		regularsync.WithInitialSyncComplete(initialSyncComplete),
 		regularsync.WithStateNotifier(b),

beacon-chain/operations/attestations/kv/kv.go

@@ -13,7 +13,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
-var hashFn = hash.HashProto
+var hashFn = hash.Proto
 
 // AttCaches defines the caches used to satisfy attestation pool interface.
 // These caches are KV store for various attestations

beacon-chain/operations/attestations/prepare_forkchoice.go

@@ -119,7 +119,7 @@ func (s *Service) aggregateAndSaveForkChoiceAtts(atts []*ethpb.Attestation) erro
 // This checks if the attestation has previously been aggregated for fork choice
 // return true if yes, false if no.
 func (s *Service) seen(att *ethpb.Attestation) (bool, error) {
-	attRoot, err := hash.HashProto(att.Data)
+	attRoot, err := hash.Proto(att.Data)
 	if err != nil {
 		return false, err
 	}

beacon-chain/rpc/core/validator.go

@@ -312,7 +312,7 @@ func (s *Service) AggregatedSigAndAggregationBits(
 
 // AssignValidatorToSubnet checks the status and pubkey of a particular validator
 // to discern whether persistent subnets need to be registered for them.
-func AssignValidatorToSubnet(pubkey []byte, status validator.ValidatorStatus) {
+func AssignValidatorToSubnet(pubkey []byte, status validator.Status) {
 	if status != validator.Active {
 		return
 	}
@@ -489,7 +489,7 @@ func (s *Service) SubmitSyncMessage(ctx context.Context, msg *ethpb.SyncCommitte
 }
 
 // RegisterSyncSubnetCurrentPeriod registers a persistent subnet for the current sync committee period.
-func RegisterSyncSubnetCurrentPeriod(s beaconState.BeaconState, epoch primitives.Epoch, pubKey []byte, status validator.ValidatorStatus) error {
+func RegisterSyncSubnetCurrentPeriod(s beaconState.BeaconState, epoch primitives.Epoch, pubKey []byte, status validator.Status) error {
 	committee, err := s.CurrentSyncCommittee()
 	if err != nil {
 		return err
@@ -511,7 +511,7 @@ func RegisterSyncSubnetCurrentPeriodProto(s beaconState.BeaconState, epoch primi
 }
 
 // RegisterSyncSubnetNextPeriod registers a persistent subnet for the next sync committee period.
-func RegisterSyncSubnetNextPeriod(s beaconState.BeaconState, epoch primitives.Epoch, pubKey []byte, status validator.ValidatorStatus) error {
+func RegisterSyncSubnetNextPeriod(s beaconState.BeaconState, epoch primitives.Epoch, pubKey []byte, status validator.Status) error {
 	committee, err := s.NextSyncCommittee()
 	if err != nil {
 		return err
@@ -539,7 +539,7 @@ func registerSyncSubnet(
 	syncPeriod uint64,
 	pubkey []byte,
 	syncCommittee *ethpb.SyncCommittee,
-	status validator.ValidatorStatus,
+	status validator.Status,
 ) {
 	if status != validator.Active && status != validator.ActiveExiting {
 		return

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

@@ -101,9 +101,9 @@ func (s *Server) GetValidators(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	filteredStatuses := make(map[validator.ValidatorStatus]bool, len(statuses))
+	filteredStatuses := make(map[validator.Status]bool, len(statuses))
 	for _, ss := range statuses {
-		ok, vs := validator.ValidatorStatusFromString(ss)
+		ok, vs := validator.StatusFromString(ss)
 		if !ok {
 			http2.HandleError(w, "Invalid status "+ss, http.StatusBadRequest)
 			return
@@ -358,7 +358,7 @@ func valContainerFromReadOnlyVal(
 	val state.ReadOnlyValidator,
 	id primitives.ValidatorIndex,
 	bal uint64,
-	valStatus validator.ValidatorStatus,
+	valStatus validator.Status,
 ) *ValidatorContainer {
 	pubkey := val.PublicKey()
 	return &ValidatorContainer{

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

@@ -43,7 +43,7 @@ type Server struct {
 	V1Alpha1ValidatorServer       eth.BeaconNodeValidatorServer
 	SyncChecker                   sync.Checker
 	CanonicalHistory              *stategen.CanonicalHistory
-	ExecutionPayloadReconstructor execution.ExecutionPayloadReconstructor
+	ExecutionPayloadReconstructor execution.PayloadReconstructor
 	FinalizationFetcher           blockchain.FinalizationFetcher
 	BLSChangesPool                blstoexec.PoolManager
 	ForkchoiceFetcher             blockchain.ForkchoiceFetcher

beacon-chain/rpc/eth/events/events_test.go

@@ -694,7 +694,7 @@ func TestStreamEvents_CommaSeparatedTopics(t *testing.T) {
 	})
 }
 
-func setupServer(ctx context.Context, t testing.TB) (*Server, *gomock.Controller, *mock.MockEvents_StreamEventsServer) {
+func setupServer(ctx context.Context, t testing.TB) (*Server, *gomock.Controller, *mock.Events_StreamEventsServer) {
 	srv := &Server{
 		StateNotifier:     &mockChain.MockStateNotifier{},
 		OperationNotifier: &mockChain.MockOperationNotifier{},
@@ -709,7 +709,7 @@ type assertFeedArgs struct {
 	t             *testing.T
 	topics        []string
 	srv           *Server
-	stream        *mock.MockEvents_StreamEventsServer
+	stream        *mock.Events_StreamEventsServer
 	shouldReceive interface{}
 	itemToSend    *feed.Event
 	feed          *event.Feed

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

@@ -9,7 +9,7 @@ import (
 )
 
 // ValidatorStatus returns a validator's status at the given epoch.
-func ValidatorStatus(val state.ReadOnlyValidator, epoch primitives.Epoch) (validator.ValidatorStatus, error) {
+func ValidatorStatus(val state.ReadOnlyValidator, epoch primitives.Epoch) (validator.Status, error) {
 	valStatus, err := ValidatorSubStatus(val, epoch)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get validator sub status")
@@ -28,7 +28,7 @@ func ValidatorStatus(val state.ReadOnlyValidator, epoch primitives.Epoch) (valid
 }
 
 // ValidatorSubStatus returns a validator's sub-status at the given epoch.
-func ValidatorSubStatus(val state.ReadOnlyValidator, epoch primitives.Epoch) (validator.ValidatorStatus, error) {
+func ValidatorSubStatus(val state.ReadOnlyValidator, epoch primitives.Epoch) (validator.Status, error) {
 	farFutureEpoch := params.BeaconConfig().FarFutureEpoch
 
 	// Pending.

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

@@ -24,7 +24,7 @@ func Test_ValidatorStatus(t *testing.T) {
 	tests := []struct {
 		name    string
 		args    args
-		want    validator.ValidatorStatus
+		want    validator.Status
 		wantErr bool
 	}{
 		{
@@ -162,7 +162,7 @@ func Test_ValidatorSubStatus(t *testing.T) {
 	tests := []struct {
 		name    string
 		args    args
-		want    validator.ValidatorStatus
+		want    validator.Status
 		wantErr bool
 	}{
 		{

beacon-chain/rpc/eth/rewards/handlers_test.go

@@ -226,7 +226,7 @@ func TestBlockRewards(t *testing.T) {
 			}},
 			OptimisticModeFetcher: mockChainService,
 			FinalizationFetcher:   mockChainService,
-			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st))},
+			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(st))},
 		}
 
 		url := "http://only.the.slot.number.at.the.end.is.important/2"
@@ -259,7 +259,7 @@ func TestBlockRewards(t *testing.T) {
 			}},
 			OptimisticModeFetcher: mockChainService,
 			FinalizationFetcher:   mockChainService,
-			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st))},
+			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(st))},
 		}
 
 		url := "http://only.the.slot.number.at.the.end.is.important/2"
@@ -292,7 +292,7 @@ func TestBlockRewards(t *testing.T) {
 			}},
 			OptimisticModeFetcher: mockChainService,
 			FinalizationFetcher:   mockChainService,
-			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st))},
+			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(st))},
 		}
 
 		url := "http://only.the.slot.number.at.the.end.is.important/2"
@@ -325,7 +325,7 @@ func TestBlockRewards(t *testing.T) {
 			}},
 			OptimisticModeFetcher: mockChainService,
 			FinalizationFetcher:   mockChainService,
-			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st))},
+			BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(st))},
 		}
 
 		url := "http://only.the.slot.number.at.the.end.is.important/2"
@@ -704,7 +704,7 @@ func TestSyncCommiteeRewards(t *testing.T) {
 		}},
 		OptimisticModeFetcher: mockChainService,
 		FinalizationFetcher:   mockChainService,
-		BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st))},
+		BlockRewardFetcher:    &BlockRewardService{Replayer: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(st))},
 	}
 
 	t.Run("ok - filtered vals", func(t *testing.T) {

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

@@ -969,7 +969,7 @@ func (s *Server) GetSyncCommitteeDuties(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	var registerSyncSubnet func(state.BeaconState, primitives.Epoch, []byte, validator2.ValidatorStatus) error
+	var registerSyncSubnet func(state.BeaconState, primitives.Epoch, []byte, validator2.Status) error
 	if isCurrentCommitteeRequested {
 		registerSyncSubnet = core.RegisterSyncSubnetCurrentPeriod
 	} else {
@@ -1091,14 +1091,14 @@ func (s *Server) GetLiveness(w http.ResponseWriter, r *http.Request) {
 	}
 
 	resp := &GetLivenessResponse{
-		Data: make([]*ValidatorLiveness, len(requestedValIndices)),
+		Data: make([]*Liveness, len(requestedValIndices)),
 	}
 	for i, vi := range requestedValIndices {
 		if vi >= primitives.ValidatorIndex(len(participation)) {
 			http2.HandleError(w, fmt.Sprintf("Validator index %d is invalid", vi), http.StatusBadRequest)
 			return
 		}
-		resp.Data[i] = &ValidatorLiveness{
+		resp.Data[i] = &Liveness{
 			Index:  strconv.FormatUint(uint64(vi), 10),
 			IsLive: participation[vi] != 0,
 		}

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

@@ -83,10 +83,10 @@ type ProduceBlockV3Response struct {
 }
 
 type GetLivenessResponse struct {
-	Data []*ValidatorLiveness `json:"data"`
+	Data []*Liveness `json:"data"`
 }
 
-type ValidatorLiveness struct {
+type Liveness struct {
 	Index  string `json:"index"`
 	IsLive bool   `json:"is_live"`
 }

beacon-chain/rpc/lookup/stater_test.go

@@ -74,8 +74,8 @@ func TestGetState(t *testing.T) {
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, r))
 		require.NoError(t, db.SaveState(ctx, bs, r))
 
-		cc := &mockstategen.MockCanonicalChecker{Is: true}
+		cc := &mockstategen.CanonicalChecker{Is: true}
-		cs := &mockstategen.MockCurrentSlotter{Slot: bs.Slot() + 1}
+		cs := &mockstategen.CurrentSlotter{Slot: bs.Slot() + 1}
 		ch := stategen.NewCanonicalHistory(db, cc, cs)
 		currentSlot := primitives.Slot(0)
 		p := BeaconDbStater{
@@ -93,8 +93,8 @@ func TestGetState(t *testing.T) {
 	})
 
 	t.Run("finalized", func(t *testing.T) {
-		stateGen := mockstategen.NewMockService()
+		stateGen := mockstategen.NewService()
-		replayer := mockstategen.NewMockReplayerBuilder()
+		replayer := mockstategen.NewReplayerBuilder()
 		replayer.SetMockStateForSlot(newBeaconState, params.BeaconConfig().SlotsPerEpoch*10)
 		stateGen.StatesByRoot[stateRoot] = newBeaconState
 
@@ -117,8 +117,8 @@ func TestGetState(t *testing.T) {
 	})
 
 	t.Run("justified", func(t *testing.T) {
-		stateGen := mockstategen.NewMockService()
+		stateGen := mockstategen.NewService()
-		replayer := mockstategen.NewMockReplayerBuilder()
+		replayer := mockstategen.NewReplayerBuilder()
 		replayer.SetMockStateForSlot(newBeaconState, params.BeaconConfig().SlotsPerEpoch*10)
 		stateGen.StatesByRoot[stateRoot] = newBeaconState
 
@@ -144,7 +144,7 @@ func TestGetState(t *testing.T) {
 		hex := "0x" + strings.Repeat("0", 63) + "1"
 		root, err := hexutil.Decode(hex)
 		require.NoError(t, err)
-		stateGen := mockstategen.NewMockService()
+		stateGen := mockstategen.NewService()
 		stateGen.StatesByRoot[bytesutil.ToBytes32(root)] = newBeaconState
 
 		p := BeaconDbStater{
@@ -162,7 +162,7 @@ func TestGetState(t *testing.T) {
 	t.Run("root", func(t *testing.T) {
 		stateId, err := hexutil.Decode("0x" + strings.Repeat("0", 63) + "1")
 		require.NoError(t, err)
-		stateGen := mockstategen.NewMockService()
+		stateGen := mockstategen.NewService()
 		stateGen.StatesByRoot[bytesutil.ToBytes32(stateId)] = newBeaconState
 
 		p := BeaconDbStater{
@@ -196,7 +196,7 @@ func TestGetState(t *testing.T) {
 				},
 				State: newBeaconState,
 			},
-			ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(newBeaconState)),
+			ReplayerBuilder: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(newBeaconState)),
 		}
 
 		s, err := p.State(ctx, []byte(strconv.FormatUint(uint64(headSlot), 10)))
@@ -420,7 +420,7 @@ func TestStateBySlot_AfterHeadSlot(t *testing.T) {
 	require.NoError(t, err)
 	currentSlot := primitives.Slot(102)
 	mock := &chainMock.ChainService{State: headSt, Slot: &currentSlot}
-	mockReplayer := mockstategen.NewMockReplayerBuilder()
+	mockReplayer := mockstategen.NewReplayerBuilder()
 	mockReplayer.SetMockStateForSlot(slotSt, 101)
 	p := BeaconDbStater{ChainInfoFetcher: mock, GenesisTimeFetcher: mock, ReplayerBuilder: mockReplayer}
 	st, err := p.StateBySlot(context.Background(), 101)

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

@@ -62,7 +62,7 @@ func TestServer_ListAssignments_NoResults(t *testing.T) {
 		BeaconDB:           db,
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db, doublylinkedtree.New()),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st)),
+		ReplayerBuilder:    mockstategen.NewReplayerBuilder(mockstategen.WithMockState(st)),
 	}
 	wanted := &ethpb.ValidatorAssignments{
 		Assignments:   make([]*ethpb.ValidatorAssignments_CommitteeAssignment, 0),
@@ -124,7 +124,7 @@ func TestServer_ListAssignments_Pagination_InputOutOfRange(t *testing.T) {
 		},
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db, doublylinkedtree.New()),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(s)),
+		ReplayerBuilder:    mockstategen.NewReplayerBuilder(mockstategen.WithMockState(s)),
 	}
 
 	wanted := fmt.Sprintf("page start %d >= list %d", 500, count)
@@ -200,7 +200,7 @@ func TestServer_ListAssignments_Pagination_DefaultPageSize_NoArchive(t *testing.
 		},
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db, doublylinkedtree.New()),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(s)),
+		ReplayerBuilder:    mockstategen.NewReplayerBuilder(mockstategen.WithMockState(s)),
 	}
 
 	res, err := bs.ListValidatorAssignments(context.Background(), &ethpb.ListValidatorAssignmentsRequest{
@@ -267,7 +267,7 @@ func TestServer_ListAssignments_FilterPubkeysIndices_NoPagination(t *testing.T)
 		},
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db, doublylinkedtree.New()),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(s)),
+		ReplayerBuilder:    mockstategen.NewReplayerBuilder(mockstategen.WithMockState(s)),
 	}
 
 	pubKey1 := make([]byte, params.BeaconConfig().BLSPubkeyLength)

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

@@ -52,7 +52,7 @@ func TestServer_ListBeaconCommittees_CurrentEpoch(t *testing.T) {
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
 	require.NoError(t, db.SaveState(ctx, headState, gRoot))
 
-	bs.ReplayerBuilder = mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState))
+	bs.ReplayerBuilder = mockstategen.NewReplayerBuilder(mockstategen.WithMockState(headState))
 
 	activeIndices, err := helpers.ActiveValidatorIndices(ctx, headState, 0)
 	require.NoError(t, err)
@@ -76,8 +76,8 @@ func TestServer_ListBeaconCommittees_CurrentEpoch(t *testing.T) {
 }
 
 func addDefaultReplayerBuilder(s *Server, h stategen.HistoryAccessor) {
-	cc := &mockstategen.MockCanonicalChecker{Is: true, Err: nil}
+	cc := &mockstategen.CanonicalChecker{Is: true, Err: nil}
-	cs := &mockstategen.MockCurrentSlotter{Slot: math.MaxUint64 - 1}
+	cs := &mockstategen.CurrentSlotter{Slot: math.MaxUint64 - 1}
 	s.ReplayerBuilder = stategen.NewCanonicalHistory(h, cc, cs)
 }
 

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

@@ -121,7 +121,7 @@ func TestServer_ListValidatorBalances_NoResults(t *testing.T) {
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
 
-	bs.ReplayerBuilder = mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState))
+	bs.ReplayerBuilder = mockstategen.NewReplayerBuilder(mockstategen.WithMockState(headState))
 
 	wanted := &ethpb.ValidatorBalances{
 		Balances:      make([]*ethpb.ValidatorBalances_Balance, 0),
@@ -180,7 +180,7 @@ func TestServer_ListValidatorBalances_DefaultResponse_NoArchive(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: st,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st)),
+		ReplayerBuilder: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(st)),
 	}
 	res, err := bs.ListValidatorBalances(
 		ctx,
@@ -209,7 +209,7 @@ func TestServer_ListValidatorBalances_PaginationOutOfRange(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
+		ReplayerBuilder: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	wanted := fmt.Sprintf("page start %d >= list %d", 200, len(headState.Balances()))
@@ -258,7 +258,7 @@ func TestServer_ListValidatorBalances_Pagination_Default(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
+		ReplayerBuilder: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	tests := []struct {
@@ -342,7 +342,7 @@ func TestServer_ListValidatorBalances_Pagination_CustomPageSizes(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
+		ReplayerBuilder: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	tests := []struct {
@@ -410,7 +410,7 @@ func TestServer_ListValidatorBalances_OutOfRange(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
+		ReplayerBuilder: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	req := &ethpb.ListValidatorBalancesRequest{Indices: []primitives.ValidatorIndex{primitives.ValidatorIndex(1)}, QueryFilter: &ethpb.ListValidatorBalancesRequest_Epoch{Epoch: 0}}
@@ -461,7 +461,7 @@ func TestServer_ListValidators_reqStateIsNil(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: nil,
 		},
-		StateGen: &mockstategen.MockStateManager{
+		StateGen: &mockstategen.StateManager{
 			StatesBySlot: map[primitives.Slot]state.BeaconState{
 				0: nil,
 			},
@@ -673,7 +673,7 @@ func TestServer_ListValidatorBalances_UnknownValidatorInResponse(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
+		ReplayerBuilder: mockstategen.NewReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	nonExistentPubKey := [32]byte{8}

beacon-chain/rpc/prysm/v1alpha1/debug/state_test.go

@@ -18,8 +18,8 @@ import (
 )
 
 func addDefaultReplayerBuilder(s *Server, h stategen.HistoryAccessor) {
-	cc := &mockstategen.MockCanonicalChecker{Is: true}
+	cc := &mockstategen.CanonicalChecker{Is: true}
-	cs := &mockstategen.MockCurrentSlotter{Slot: math.MaxUint64 - 1}
+	cs := &mockstategen.CurrentSlotter{Slot: math.MaxUint64 - 1}
 	s.ReplayerBuilder = stategen.NewCanonicalHistory(h, cc, cs)
 }
 

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

@@ -963,7 +963,7 @@ func TestServer_CheckDoppelGanger(t *testing.T) {
 			wantErr: false,
 			svSetup: func(t *testing.T) (*Server, *ethpb.DoppelGangerRequest, *ethpb.DoppelGangerResponse) {
 				hs, ps, keys := createStateSetupAltair(t, 3)
-				rb := mockstategen.NewMockReplayerBuilder()
+				rb := mockstategen.NewReplayerBuilder()
 				rb.SetMockStateForSlot(ps, 23)
 				vs := &Server{
 					HeadFetcher: &mockChain.ChainService{
@@ -995,7 +995,7 @@ func TestServer_CheckDoppelGanger(t *testing.T) {
 			wantErr: false,
 			svSetup: func(t *testing.T) (*Server, *ethpb.DoppelGangerRequest, *ethpb.DoppelGangerResponse) {
 				hs, ps, keys := createStateSetupAltair(t, 3)
-				rb := mockstategen.NewMockReplayerBuilder()
+				rb := mockstategen.NewReplayerBuilder()
 				rb.SetMockStateForSlot(ps, 23)
 				currentIndices := make([]byte, 64)
 				currentIndices[2] = 1
@@ -1045,7 +1045,7 @@ func TestServer_CheckDoppelGanger(t *testing.T) {
 				prevIndices := make([]byte, 64)
 				prevIndices[2] = 1
 				require.NoError(t, ps.SetPreviousParticipationBits(prevIndices))
-				rb := mockstategen.NewMockReplayerBuilder()
+				rb := mockstategen.NewReplayerBuilder()
 				rb.SetMockStateForSlot(ps, 23)
 
 				vs := &Server{
@@ -1093,7 +1093,7 @@ func TestServer_CheckDoppelGanger(t *testing.T) {
 				currentIndices[10] = 1
 				currentIndices[11] = 2
 				require.NoError(t, hs.SetPreviousParticipationBits(currentIndices))
-				rb := mockstategen.NewMockReplayerBuilder()
+				rb := mockstategen.NewReplayerBuilder()
 				rb.SetMockStateForSlot(ps, 23)
 
 				prevIndices := make([]byte, 64)
@@ -1145,7 +1145,7 @@ func TestServer_CheckDoppelGanger(t *testing.T) {
 			wantErr: false,
 			svSetup: func(t *testing.T) (*Server, *ethpb.DoppelGangerRequest, *ethpb.DoppelGangerResponse) {
 				hs, ps, keys := createStateSetupAltair(t, 3)
-				rb := mockstategen.NewMockReplayerBuilder()
+				rb := mockstategen.NewReplayerBuilder()
 				rb.SetMockStateForSlot(ps, 23)
 				currentIndices := make([]byte, 64)
 				currentIndices[0] = 1
@@ -1182,7 +1182,7 @@ func TestServer_CheckDoppelGanger(t *testing.T) {
 			wantErr: false,
 			svSetup: func(t *testing.T) (*Server, *ethpb.DoppelGangerRequest, *ethpb.DoppelGangerResponse) {
 				hs, ps, keys := createStateSetupAltair(t, 3)
-				rb := mockstategen.NewMockReplayerBuilder()
+				rb := mockstategen.NewReplayerBuilder()
 				rb.SetMockStateForSlot(ps, 23)
 				currentIndices := make([]byte, 64)
 				currentIndices[0] = 1

beacon-chain/rpc/prysm/validator/validator_count.go

@@ -20,13 +20,13 @@ import (
 	"go.opencensus.io/trace"
 )
 
-type ValidatorCountResponse struct {
+type CountResponse struct {
-	ExecutionOptimistic string            `json:"execution_optimistic"`
+	ExecutionOptimistic string   `json:"execution_optimistic"`
-	Finalized           string            `json:"finalized"`
+	Finalized           string   `json:"finalized"`
-	Data                []*ValidatorCount `json:"data"`
+	Data                []*Count `json:"data"`
 }
 
-type ValidatorCount struct {
+type Count struct {
 	Status string `json:"status"`
 	Count  string `json:"count"`
 }
@@ -93,7 +93,7 @@ func (vs *Server) GetValidatorCount(w http.ResponseWriter, r *http.Request) {
 
 	isFinalized := vs.FinalizationFetcher.IsFinalized(ctx, blockRoot)
 
-	var statusVals []validator.ValidatorStatus
+	var statusVals []validator.Status
 	for _, status := range r.URL.Query()["status"] {
 		statusVal, ok := ethpb.ValidatorStatus_value[strings.ToUpper(status)]
 		if !ok {
@@ -105,13 +105,13 @@ func (vs *Server) GetValidatorCount(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		statusVals = append(statusVals, validator.ValidatorStatus(statusVal))
+		statusVals = append(statusVals, validator.Status(statusVal))
 	}
 
 	// If no status was provided then consider all the statuses to return validator count for each status.
 	if len(statusVals) == 0 {
 		for _, val := range ethpb.ValidatorStatus_value {
-			statusVals = append(statusVals, validator.ValidatorStatus(val))
+			statusVals = append(statusVals, validator.Status(val))
 		}
 	}
 
@@ -126,7 +126,7 @@ func (vs *Server) GetValidatorCount(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	valCountResponse := &ValidatorCountResponse{
+	valCountResponse := &CountResponse{
 		ExecutionOptimistic: strconv.FormatBool(isOptimistic),
 		Finalized:           strconv.FormatBool(isFinalized),
 		Data:                valCount,
@@ -136,8 +136,8 @@ func (vs *Server) GetValidatorCount(w http.ResponseWriter, r *http.Request) {
 }
 
 // validatorCountByStatus returns a slice of validator count for each status in the given epoch.
-func validatorCountByStatus(validators []*eth.Validator, statuses []validator.ValidatorStatus, epoch primitives.Epoch) ([]*ValidatorCount, error) {
+func validatorCountByStatus(validators []*eth.Validator, statuses []validator.Status, epoch primitives.Epoch) ([]*Count, error) {
-	countByStatus := make(map[validator.ValidatorStatus]uint64)
+	countByStatus := make(map[validator.Status]uint64)
 	for _, val := range validators {
 		readOnlyVal, err := statenative.NewValidator(val)
 		if err != nil {
@@ -159,9 +159,9 @@ func validatorCountByStatus(validators []*eth.Validator, statuses []validator.Va
 		}
 	}
 
-	var resp []*ValidatorCount
+	var resp []*Count
 	for status, count := range countByStatus {
-		resp = append(resp, &ValidatorCount{
+		resp = append(resp, &Count{
 			Status: status.String(),
 			Count:  strconv.FormatUint(count, 10),
 		})

beacon-chain/rpc/prysm/validator/validator_count_test.go

@@ -188,16 +188,16 @@ func TestGetValidatorCount(t *testing.T) {
 		stateID          string
 		statuses         []string
 		currentEpoch     int
-		expectedResponse ValidatorCountResponse
+		expectedResponse CountResponse
 	}{
 		{
 			name:     "Head count active validators",
 			stateID:  "head",
 			statuses: []string{"active"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "active",
 						Count:  "13",
@@ -209,10 +209,10 @@ func TestGetValidatorCount(t *testing.T) {
 			name:     "Head count active ongoing validators",
 			stateID:  "head",
 			statuses: []string{"active_ongoing"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "active_ongoing",
 						Count:  "11",
@@ -224,10 +224,10 @@ func TestGetValidatorCount(t *testing.T) {
 			name:     "Head count active exiting validators",
 			stateID:  "head",
 			statuses: []string{"active_exiting"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "active_exiting",
 						Count:  "1",
@@ -239,10 +239,10 @@ func TestGetValidatorCount(t *testing.T) {
 			name:     "Head count active slashed validators",
 			stateID:  "head",
 			statuses: []string{"active_slashed"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "active_slashed",
 						Count:  "1",
@@ -254,10 +254,10 @@ func TestGetValidatorCount(t *testing.T) {
 			name:     "Head count pending validators",
 			stateID:  "head",
 			statuses: []string{"pending"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "pending",
 						Count:  "6",
@@ -269,10 +269,10 @@ func TestGetValidatorCount(t *testing.T) {
 			name:     "Head count pending initialized validators",
 			stateID:  "head",
 			statuses: []string{"pending_initialized"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "pending_initialized",
 						Count:  "1",
@@ -284,10 +284,10 @@ func TestGetValidatorCount(t *testing.T) {
 			name:     "Head count pending queued validators",
 			stateID:  "head",
 			statuses: []string{"pending_queued"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "pending_queued",
 						Count:  "5",
@@ -300,10 +300,10 @@ func TestGetValidatorCount(t *testing.T) {
 			stateID:      "head",
 			statuses:     []string{"exited"},
 			currentEpoch: 35,
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "exited",
 						Count:  "6",
@@ -316,10 +316,10 @@ func TestGetValidatorCount(t *testing.T) {
 			stateID:      "head",
 			statuses:     []string{"exited_slashed"},
 			currentEpoch: 35,
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "exited_slashed",
 						Count:  "2",
@@ -332,10 +332,10 @@ func TestGetValidatorCount(t *testing.T) {
 			stateID:      "head",
 			statuses:     []string{"exited_unslashed"},
 			currentEpoch: 35,
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "exited_unslashed",
 						Count:  "4",
@@ -348,10 +348,10 @@ func TestGetValidatorCount(t *testing.T) {
 			stateID:      "head",
 			statuses:     []string{"withdrawal"},
 			currentEpoch: 45,
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "withdrawal",
 						Count:  "2",
@@ -364,10 +364,10 @@ func TestGetValidatorCount(t *testing.T) {
 			stateID:      "head",
 			statuses:     []string{"withdrawal_possible"},
 			currentEpoch: 45,
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "withdrawal_possible",
 						Count:  "1",
@@ -380,10 +380,10 @@ func TestGetValidatorCount(t *testing.T) {
 			stateID:      "head",
 			statuses:     []string{"withdrawal_done"},
 			currentEpoch: 45,
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "withdrawal_done",
 						Count:  "1",
@@ -395,10 +395,10 @@ func TestGetValidatorCount(t *testing.T) {
 			name:     "Head count active and pending validators",
 			stateID:  "head",
 			statuses: []string{"active", "pending"},
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "active",
 						Count:  "13",
@@ -413,10 +413,10 @@ func TestGetValidatorCount(t *testing.T) {
 		{
 			name:    "Head count of ALL validators",
 			stateID: "head",
-			expectedResponse: ValidatorCountResponse{
+			expectedResponse: CountResponse{
 				ExecutionOptimistic: "false",
 				Finalized:           "true",
-				Data: []*ValidatorCount{
+				Data: []*Count{
 					{
 						Status: "active",
 						Count:  "13",
@@ -482,7 +482,7 @@ func TestGetValidatorCount(t *testing.T) {
 			body, err := io.ReadAll(resp.Body)
 			require.NoError(t, err)
 
-			var count ValidatorCountResponse
+			var count CountResponse
 			err = json.Unmarshal(body, &count)
 			require.NoError(t, err)
 			require.DeepEqual(t, test.expectedResponse, count)

beacon-chain/rpc/prysm/validator/validator_performance.go

@@ -10,12 +10,12 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
-type ValidatorPerformanceRequest struct {
+type PerformanceRequest struct {
 	PublicKeys [][]byte                    `json:"public_keys,omitempty"`
 	Indices    []primitives.ValidatorIndex `json:"indices,omitempty"`
 }
 
-type ValidatorPerformanceResponse struct {
+type PerformanceResponse struct {
 	PublicKeys                    [][]byte `json:"public_keys,omitempty"`
 	CorrectlyVotedSource          []bool   `json:"correctly_voted_source,omitempty"`
 	CorrectlyVotedTarget          []bool   `json:"correctly_voted_target,omitempty"`
@@ -29,7 +29,7 @@ type ValidatorPerformanceResponse struct {
 
 // GetValidatorPerformance is an HTTP handler for GetValidatorPerformance.
 func (vs *Server) GetValidatorPerformance(w http.ResponseWriter, r *http.Request) {
-	var req ValidatorPerformanceRequest
+	var req PerformanceRequest
 	if r.Body != http.NoBody {
 		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 			handleHTTPError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
@@ -47,7 +47,7 @@ func (vs *Server) GetValidatorPerformance(w http.ResponseWriter, r *http.Request
 		handleHTTPError(w, "Could not compute validator performance: "+err.Err.Error(), core.ErrorReasonToHTTP(err.Reason))
 		return
 	}
-	response := &ValidatorPerformanceResponse{
+	response := &PerformanceResponse{
 		PublicKeys:                    computed.PublicKeys,
 		CorrectlyVotedSource:          computed.CorrectlyVotedSource,
 		CorrectlyVotedTarget:          computed.CorrectlyVotedTarget, // In altair, when this is true then the attestation was definitely included.

beacon-chain/rpc/prysm/validator/validator_performance_test.go

@@ -67,7 +67,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 				SyncChecker:        &mockSync.Sync{IsSyncing: false},
 			},
 		}
-		want := &ValidatorPerformanceResponse{
+		want := &PerformanceResponse{
 			PublicKeys:                    [][]byte{publicKeys[1][:], publicKeys[2][:]},
 			CurrentEffectiveBalances:      []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
 			CorrectlyVotedSource:          []bool{false, false},
@@ -78,7 +78,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 			MissingValidators:             [][]byte{publicKeys[0][:]},
 		}
 
-		request := &ValidatorPerformanceRequest{
+		request := &PerformanceRequest{
 			PublicKeys: [][]byte{publicKeys[0][:], publicKeys[2][:], publicKeys[1][:]},
 		}
 		var buf bytes.Buffer
@@ -98,7 +98,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		body, err := io.ReadAll(rawResp.Body)
 		require.NoError(t, err)
 
-		response := &ValidatorPerformanceResponse{}
+		response := &PerformanceResponse{}
 		require.NoError(t, json.Unmarshal(body, response))
 		require.DeepEqual(t, want, response)
 	})
@@ -133,7 +133,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		require.NoError(t, err)
 		extraBal := params.BeaconConfig().MaxEffectiveBalance + params.BeaconConfig().GweiPerEth
 
-		want := &ValidatorPerformanceResponse{
+		want := &PerformanceResponse{
 			PublicKeys:                    [][]byte{publicKeys[1][:], publicKeys[2][:]},
 			CurrentEffectiveBalances:      []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
 			CorrectlyVotedSource:          []bool{false, false},
@@ -143,7 +143,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 			BalancesAfterEpochTransition:  []uint64{vp[1].AfterEpochTransitionBalance, vp[2].AfterEpochTransitionBalance},
 			MissingValidators:             [][]byte{publicKeys[0][:]},
 		}
-		request := &ValidatorPerformanceRequest{
+		request := &PerformanceRequest{
 			Indices: []primitives.ValidatorIndex{2, 1, 0},
 		}
 		var buf bytes.Buffer
@@ -163,7 +163,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		body, err := io.ReadAll(rawResp.Body)
 		require.NoError(t, err)
 
-		response := &ValidatorPerformanceResponse{}
+		response := &PerformanceResponse{}
 		require.NoError(t, json.Unmarshal(body, response))
 		require.DeepEqual(t, want, response)
 	})
@@ -198,7 +198,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		require.NoError(t, err)
 		extraBal := params.BeaconConfig().MaxEffectiveBalance + params.BeaconConfig().GweiPerEth
 
-		want := &ValidatorPerformanceResponse{
+		want := &PerformanceResponse{
 			PublicKeys:                    [][]byte{publicKeys[1][:], publicKeys[2][:]},
 			CurrentEffectiveBalances:      []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
 			CorrectlyVotedSource:          []bool{false, false},
@@ -208,7 +208,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 			BalancesAfterEpochTransition:  []uint64{vp[1].AfterEpochTransitionBalance, vp[2].AfterEpochTransitionBalance},
 			MissingValidators:             [][]byte{publicKeys[0][:]},
 		}
-		request := &ValidatorPerformanceRequest{
+		request := &PerformanceRequest{
 			PublicKeys: [][]byte{publicKeys[0][:], publicKeys[2][:]}, Indices: []primitives.ValidatorIndex{1, 2},
 		}
 		var buf bytes.Buffer
@@ -228,7 +228,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		body, err := io.ReadAll(rawResp.Body)
 		require.NoError(t, err)
 
-		response := &ValidatorPerformanceResponse{}
+		response := &PerformanceResponse{}
 		require.NoError(t, json.Unmarshal(body, response))
 		require.DeepEqual(t, want, response)
 	})
@@ -259,7 +259,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 				SyncChecker:        &mockSync.Sync{IsSyncing: false},
 			},
 		}
-		want := &ValidatorPerformanceResponse{
+		want := &PerformanceResponse{
 			PublicKeys:                    [][]byte{publicKeys[1][:], publicKeys[2][:]},
 			CurrentEffectiveBalances:      []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
 			CorrectlyVotedSource:          []bool{false, false},
@@ -270,7 +270,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 			MissingValidators:             [][]byte{publicKeys[0][:]},
 			InactivityScores:              []uint64{0, 0},
 		}
-		request := &ValidatorPerformanceRequest{
+		request := &PerformanceRequest{
 			PublicKeys: [][]byte{publicKeys[0][:], publicKeys[2][:], publicKeys[1][:]},
 		}
 		var buf bytes.Buffer
@@ -290,7 +290,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		body, err := io.ReadAll(rawResp.Body)
 		require.NoError(t, err)
 
-		response := &ValidatorPerformanceResponse{}
+		response := &PerformanceResponse{}
 		require.NoError(t, json.Unmarshal(body, response))
 		require.DeepEqual(t, want, response)
 	})
@@ -321,7 +321,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 				SyncChecker:        &mockSync.Sync{IsSyncing: false},
 			},
 		}
-		want := &ValidatorPerformanceResponse{
+		want := &PerformanceResponse{
 			PublicKeys:                    [][]byte{publicKeys[1][:], publicKeys[2][:]},
 			CurrentEffectiveBalances:      []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
 			CorrectlyVotedSource:          []bool{false, false},
@@ -332,7 +332,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 			MissingValidators:             [][]byte{publicKeys[0][:]},
 			InactivityScores:              []uint64{0, 0},
 		}
-		request := &ValidatorPerformanceRequest{
+		request := &PerformanceRequest{
 			PublicKeys: [][]byte{publicKeys[0][:], publicKeys[2][:], publicKeys[1][:]},
 		}
 		var buf bytes.Buffer
@@ -352,7 +352,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		body, err := io.ReadAll(rawResp.Body)
 		require.NoError(t, err)
 
-		response := &ValidatorPerformanceResponse{}
+		response := &PerformanceResponse{}
 		require.NoError(t, json.Unmarshal(body, response))
 		require.DeepEqual(t, want, response)
 	})
@@ -383,7 +383,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 				SyncChecker:        &mockSync.Sync{IsSyncing: false},
 			},
 		}
-		want := &ValidatorPerformanceResponse{
+		want := &PerformanceResponse{
 			PublicKeys:                    [][]byte{publicKeys[1][:], publicKeys[2][:]},
 			CurrentEffectiveBalances:      []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
 			CorrectlyVotedSource:          []bool{false, false},
@@ -394,7 +394,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 			MissingValidators:             [][]byte{publicKeys[0][:]},
 			InactivityScores:              []uint64{0, 0},
 		}
-		request := &ValidatorPerformanceRequest{
+		request := &PerformanceRequest{
 			PublicKeys: [][]byte{publicKeys[0][:], publicKeys[2][:], publicKeys[1][:]},
 		}
 		var buf bytes.Buffer
@@ -414,7 +414,7 @@ func TestServer_GetValidatorPerformance(t *testing.T) {
 		body, err := io.ReadAll(rawResp.Body)
 		require.NoError(t, err)
 
-		response := &ValidatorPerformanceResponse{}
+		response := &PerformanceResponse{}
 		require.NoError(t, json.Unmarshal(body, response))
 		require.DeepEqual(t, want, response)
 	})

beacon-chain/rpc/service.go

@@ -81,7 +81,7 @@ type Service struct {
 
 // Config options for the beacon node RPC server.
 type Config struct {
-	ExecutionPayloadReconstructor execution.ExecutionPayloadReconstructor
+	ExecutionPayloadReconstructor execution.PayloadReconstructor
 	Host                          string
 	Port                          string
 	CertFlag                      string

beacon-chain/state/interfaces.go

@@ -23,7 +23,7 @@ type BeaconState interface {
 	Copy() BeaconState
 	CopyAllTries()
 	HashTreeRoot(ctx context.Context) ([32]byte, error)
-	StateProver
+	Prover
 	json.Marshaler
 }
 
@@ -35,7 +35,7 @@ type SpecParametersProvider interface {
 }
 
 // StateProver defines the ability to create Merkle proofs for beacon state fields.
-type StateProver interface {
+type Prover interface {
 	FinalizedRootProof(ctx context.Context) ([][]byte, error)
 	CurrentSyncCommitteeProof(ctx context.Context) ([][]byte, error)
 	NextSyncCommitteeProof(ctx context.Context) ([][]byte, error)

beacon-chain/state/prometheus.go

@@ -6,7 +6,7 @@ import (
 )
 
 var (
-	StateCount = promauto.NewGauge(prometheus.GaugeOpts{
+	Count = promauto.NewGauge(prometheus.GaugeOpts{
 		Name: "beacon_state_count",
 		Help: "Count the number of active beacon state objects.",
 	})

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

@@ -228,7 +228,7 @@ func InitializeFromProtoUnsafePhase0(st *ethpb.BeaconState) (state.BeaconState,
 		b.sharedFieldReferences[types.Validators] = stateutil.NewRef(1)
 	}
 
-	state.StateCount.Inc()
+	state.Count.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
 	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
@@ -337,7 +337,7 @@ func InitializeFromProtoUnsafeAltair(st *ethpb.BeaconStateAltair) (state.BeaconS
 		b.sharedFieldReferences[types.InactivityScores] = stateutil.NewRef(1)
 	}
 
-	state.StateCount.Inc()
+	state.Count.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
 	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
@@ -448,7 +448,7 @@ func InitializeFromProtoUnsafeBellatrix(st *ethpb.BeaconStateBellatrix) (state.B
 		b.sharedFieldReferences[types.InactivityScores] = stateutil.NewRef(1)
 	}
 
-	state.StateCount.Inc()
+	state.Count.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
 	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
@@ -563,7 +563,7 @@ func InitializeFromProtoUnsafeCapella(st *ethpb.BeaconStateCapella) (state.Beaco
 		b.sharedFieldReferences[types.InactivityScores] = stateutil.NewRef(1)
 	}
 
-	state.StateCount.Inc()
+	state.Count.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
 	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
@@ -676,7 +676,7 @@ func InitializeFromProtoUnsafeDeneb(st *ethpb.BeaconStateDeneb) (state.BeaconSta
 		b.sharedFieldReferences[types.InactivityScores] = stateutil.NewRef(1)
 	}
 
-	state.StateCount.Inc()
+	state.Count.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
 	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
@@ -842,7 +842,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 		}
 	}
 
-	state.StateCount.Inc()
+	state.Count.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
 	runtime.SetFinalizer(dst, finalizerCleanup)
 	return dst
@@ -1172,7 +1172,7 @@ func finalizerCleanup(b *BeaconState) {
 		}
 	}
 
-	state.StateCount.Sub(1)
+	state.Count.Sub(1)
 }
 
 func (b *BeaconState) blockRootsRootSelector(field types.FieldIndex) ([32]byte, error) {

beacon-chain/state/stategen/mock/mock.go

@@ -7,96 +7,96 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 )
 
-// MockStateManager is a fake implementation of StateManager.
+// StateManager is a fake implementation of StateManager.
-type MockStateManager struct {
+type StateManager struct {
 	StatesByRoot map[[32]byte]state.BeaconState
 	StatesBySlot map[primitives.Slot]state.BeaconState
 }
 
-// NewMockService --
+// NewService --
-func NewMockService() *MockStateManager {
+func NewService() *StateManager {
-	return &MockStateManager{
+	return &StateManager{
 		StatesByRoot: make(map[[32]byte]state.BeaconState),
 		StatesBySlot: make(map[primitives.Slot]state.BeaconState),
 	}
 }
 
 // StateByRootIfCachedNoCopy --
-func (_ *MockStateManager) StateByRootIfCachedNoCopy(_ [32]byte) state.BeaconState {
+func (_ *StateManager) StateByRootIfCachedNoCopy(_ [32]byte) state.BeaconState {
 	panic("implement me")
 }
 
 // Resume --
-func (_ *MockStateManager) Resume(_ context.Context, _ state.BeaconState) (state.BeaconState, error) {
+func (_ *StateManager) Resume(_ context.Context, _ state.BeaconState) (state.BeaconState, error) {
 	panic("implement me")
 }
 
 // SaveFinalizedState --
-func (_ *MockStateManager) SaveFinalizedState(_ primitives.Slot, _ [32]byte, _ state.BeaconState) {
+func (_ *StateManager) SaveFinalizedState(_ primitives.Slot, _ [32]byte, _ state.BeaconState) {
 	panic("implement me")
 }
 
 // MigrateToCold --
-func (_ *MockStateManager) MigrateToCold(_ context.Context, _ [32]byte) error {
+func (_ *StateManager) MigrateToCold(_ context.Context, _ [32]byte) error {
 	panic("implement me")
 }
 
 // HasState --
-func (_ *MockStateManager) HasState(_ context.Context, _ [32]byte) (bool, error) {
+func (_ *StateManager) HasState(_ context.Context, _ [32]byte) (bool, error) {
 	panic("implement me")
 }
 
 // StateByRoot --
-func (m *MockStateManager) StateByRoot(_ context.Context, blockRoot [32]byte) (state.BeaconState, error) {
+func (m *StateManager) StateByRoot(_ context.Context, blockRoot [32]byte) (state.BeaconState, error) {
 	return m.StatesByRoot[blockRoot], nil
 }
 
-// BalancesByRoot --
+// ActiveNonSlashedBalancesByRoot --
-func (*MockStateManager) ActiveNonSlashedBalancesByRoot(_ context.Context, _ [32]byte) ([]uint64, error) {
+func (*StateManager) ActiveNonSlashedBalancesByRoot(_ context.Context, _ [32]byte) ([]uint64, error) {
 	return []uint64{}, nil
 }
 
 // StateByRootInitialSync --
-func (_ *MockStateManager) StateByRootInitialSync(_ context.Context, _ [32]byte) (state.BeaconState, error) {
+func (_ *StateManager) StateByRootInitialSync(_ context.Context, _ [32]byte) (state.BeaconState, error) {
 	panic("implement me")
 }
 
 // StateBySlot --
-func (m *MockStateManager) StateBySlot(_ context.Context, slot primitives.Slot) (state.BeaconState, error) {
+func (m *StateManager) StateBySlot(_ context.Context, slot primitives.Slot) (state.BeaconState, error) {
 	return m.StatesBySlot[slot], nil
 }
 
 // SaveState --
-func (_ *MockStateManager) SaveState(_ context.Context, _ [32]byte, _ state.BeaconState) error {
+func (_ *StateManager) SaveState(_ context.Context, _ [32]byte, _ state.BeaconState) error {
 	panic("implement me")
 }
 
 // ForceCheckpoint --
-func (_ *MockStateManager) ForceCheckpoint(_ context.Context, _ []byte) error {
+func (_ *StateManager) ForceCheckpoint(_ context.Context, _ []byte) error {
 	panic("implement me")
 }
 
 // EnableSaveHotStateToDB --
-func (_ *MockStateManager) EnableSaveHotStateToDB(_ context.Context) {
+func (_ *StateManager) EnableSaveHotStateToDB(_ context.Context) {
 	panic("implement me")
 }
 
 // DisableSaveHotStateToDB --
-func (_ *MockStateManager) DisableSaveHotStateToDB(_ context.Context) error {
+func (_ *StateManager) DisableSaveHotStateToDB(_ context.Context) error {
 	panic("implement me")
 }
 
 // AddStateForRoot --
-func (m *MockStateManager) AddStateForRoot(state state.BeaconState, blockRoot [32]byte) {
+func (m *StateManager) AddStateForRoot(state state.BeaconState, blockRoot [32]byte) {
 	m.StatesByRoot[blockRoot] = state
 }
 
 // AddStateForSlot --
-func (m *MockStateManager) AddStateForSlot(state state.BeaconState, slot primitives.Slot) {
+func (m *StateManager) AddStateForSlot(state state.BeaconState, slot primitives.Slot) {
 	m.StatesBySlot[slot] = state
 }
 
 // DeleteStateFromCaches --
-func (m *MockStateManager) DeleteStateFromCaches(context.Context, [32]byte) error {
+func (m *StateManager) DeleteStateFromCaches(context.Context, [32]byte) error {
 	return nil
 }

beacon-chain/state/stategen/mock/replayer.go

@@ -8,85 +8,85 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 )
 
-func NewMockReplayerBuilder(opt ...MockReplayerBuilderOption) *MockReplayerBuilder {
+func NewReplayerBuilder(opt ...ReplayerBuilderOption) *ReplayerBuilder {
-	b := &MockReplayerBuilder{}
+	b := &ReplayerBuilder{}
 	for _, o := range opt {
 		o(b)
 	}
 	return b
 }
 
-type MockReplayerBuilderOption func(*MockReplayerBuilder)
+type ReplayerBuilderOption func(*ReplayerBuilder)
 
-func WithMockState(s state.BeaconState) MockReplayerBuilderOption {
+func WithMockState(s state.BeaconState) ReplayerBuilderOption {
-	return func(b *MockReplayerBuilder) {
+	return func(b *ReplayerBuilder) {
 		b.SetMockState(s)
 	}
 }
 
-type MockReplayerBuilder struct {
+type ReplayerBuilder struct {
-	forSlot map[primitives.Slot]*MockReplayer
+	forSlot map[primitives.Slot]*Replayer
 }
 
-func (b *MockReplayerBuilder) SetMockState(s state.BeaconState) {
+func (b *ReplayerBuilder) SetMockState(s state.BeaconState) {
 	if b.forSlot == nil {
-		b.forSlot = make(map[primitives.Slot]*MockReplayer)
+		b.forSlot = make(map[primitives.Slot]*Replayer)
 	}
-	b.forSlot[s.Slot()] = &MockReplayer{State: s}
+	b.forSlot[s.Slot()] = &Replayer{State: s}
 }
 
-func (b *MockReplayerBuilder) SetMockStateForSlot(s state.BeaconState, slot primitives.Slot) {
+func (b *ReplayerBuilder) SetMockStateForSlot(s state.BeaconState, slot primitives.Slot) {
 	if b.forSlot == nil {
-		b.forSlot = make(map[primitives.Slot]*MockReplayer)
+		b.forSlot = make(map[primitives.Slot]*Replayer)
 	}
-	b.forSlot[slot] = &MockReplayer{State: s}
+	b.forSlot[slot] = &Replayer{State: s}
 }
 
-func (b *MockReplayerBuilder) SetMockSlotError(s primitives.Slot, e error) {
+func (b *ReplayerBuilder) SetMockSlotError(s primitives.Slot, e error) {
 	if b.forSlot == nil {
-		b.forSlot = make(map[primitives.Slot]*MockReplayer)
+		b.forSlot = make(map[primitives.Slot]*Replayer)
 	}
-	b.forSlot[s] = &MockReplayer{Err: e}
+	b.forSlot[s] = &Replayer{Err: e}
 }
 
-func (b *MockReplayerBuilder) ReplayerForSlot(target primitives.Slot) stategen.Replayer {
+func (b *ReplayerBuilder) ReplayerForSlot(target primitives.Slot) stategen.Replayer {
 	return b.forSlot[target]
 }
 
-var _ stategen.ReplayerBuilder = &MockReplayerBuilder{}
+var _ stategen.ReplayerBuilder = &ReplayerBuilder{}
 
-type MockReplayer struct {
+type Replayer struct {
 	State state.BeaconState
 	Err   error
 }
 
-func (m *MockReplayer) ReplayBlocks(_ context.Context) (state.BeaconState, error) {
+func (m *Replayer) ReplayBlocks(_ context.Context) (state.BeaconState, error) {
 	return m.State, m.Err
 }
 
-func (m *MockReplayer) ReplayToSlot(_ context.Context, _ primitives.Slot) (state.BeaconState, error) {
+func (m *Replayer) ReplayToSlot(_ context.Context, _ primitives.Slot) (state.BeaconState, error) {
 	return m.State, m.Err
 }
 
-var _ stategen.Replayer = &MockReplayer{}
+var _ stategen.Replayer = &Replayer{}
 
-type MockCanonicalChecker struct {
+type CanonicalChecker struct {
 	Is  bool
 	Err error
 }
 
-func (m *MockCanonicalChecker) IsCanonical(_ context.Context, _ [32]byte) (bool, error) {
+func (m *CanonicalChecker) IsCanonical(_ context.Context, _ [32]byte) (bool, error) {
 	return m.Is, m.Err
 }
 
-var _ stategen.CanonicalChecker = &MockCanonicalChecker{}
+var _ stategen.CanonicalChecker = &CanonicalChecker{}
 
-type MockCurrentSlotter struct {
+type CurrentSlotter struct {
 	Slot primitives.Slot
 }
 
-func (c *MockCurrentSlotter) CurrentSlot() primitives.Slot {
+func (c *CurrentSlotter) CurrentSlot() primitives.Slot {
 	return c.Slot
 }
 
-var _ stategen.CurrentSlotter = &MockCurrentSlotter{}
+var _ stategen.CurrentSlotter = &CurrentSlotter{}

beacon-chain/state/stategen/service.go

@@ -75,17 +75,17 @@ type finalizedInfo struct {
 	lock  sync.RWMutex
 }
 
-// StateGenOption is a functional option for controlling the initialization of a *State value
+// Option is a functional option for controlling the initialization of a *State value
-type StateGenOption func(*State)
+type Option func(*State)
 
-func WithBackfillStatus(bfs *backfill.Status) StateGenOption {
+func WithBackfillStatus(bfs *backfill.Status) Option {
 	return func(sg *State) {
 		sg.backfillStatus = bfs
 	}
 }
 
 // New returns a new state management object.
-func New(beaconDB db.NoHeadAccessDatabase, fc forkchoice.ForkChoicer, opts ...StateGenOption) *State {
+func New(beaconDB db.NoHeadAccessDatabase, fc forkchoice.ForkChoicer, opts ...Option) *State {
 	s := &State{
 		beaconDB:                beaconDB,
 		hotStateCache:           newHotStateCache(),

beacon-chain/sync/backfill/status.go

@@ -11,7 +11,7 @@ import (
 )
 
 // NewStatus correctly initializes a Status value with the required database value.
-func NewStatus(store BackfillDB) *Status {
+func NewStatus(store DB) *Status {
 	return &Status{
 		store: store,
 	}
@@ -25,7 +25,7 @@ func NewStatus(store BackfillDB) *Status {
 type Status struct {
 	start       primitives.Slot
 	end         primitives.Slot
-	store       BackfillDB
+	store       DB
 	genesisSync bool
 }
 
@@ -112,8 +112,8 @@ func (s *Status) Reload(ctx context.Context) error {
 	return nil
 }
 
-// BackfillDB describes the set of DB methods that the Status type needs to function.
+// DB describes the set of DB methods that the Status type needs to function.
-type BackfillDB interface {
+type DB interface {
 	SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) error
 	GenesisBlockRoot(ctx context.Context) ([32]byte, error)
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)

beacon-chain/sync/backfill/status_test.go

@@ -25,7 +25,7 @@ type mockBackfillDB struct {
 	block                     func(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error)
 }
 
-var _ BackfillDB = &mockBackfillDB{}
+var _ DB = &mockBackfillDB{}
 
 func (db *mockBackfillDB) SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) error {
 	if db.saveBackfillBlockRoot != nil {
@@ -168,9 +168,9 @@ func TestReload(t *testing.T) {
 	require.NoError(t, err)
 
 	cases := []struct {
-		name     string
+		name string
-		db       BackfillDB
+		db   DB
-		err      error
+		err  error
 		expected *Status
 	}{
 		/*{

beacon-chain/sync/broadcast_bls_changes_test.go

@@ -93,7 +93,7 @@ func TestRateBLSChanges(t *testing.T) {
 		epoch := params.BeaconConfig().CapellaForkEpoch + 1
 		domain, err := signing.Domain(st.Fork(), epoch, params.BeaconConfig().DomainBLSToExecutionChange, st.GenesisValidatorsRoot())
 		assert.NoError(t, err)
-		htr, err := signing.SigningData(message.HashTreeRoot, domain)
+		htr, err := signing.Data(message.HashTreeRoot, domain)
 		assert.NoError(t, err)
 		signed := &ethpb.SignedBLSToExecutionChange{
 			Message:   message,

beacon-chain/sync/options.go

@@ -124,7 +124,7 @@ func WithSlasherBlockHeadersFeed(slasherBlockHeadersFeed *event.Feed) Option {
 	}
 }
 
-func WithExecutionPayloadReconstructor(r execution.ExecutionPayloadReconstructor) Option {
+func WithPayloadReconstructor(r execution.PayloadReconstructor) Option {
 	return func(s *Service) error {
 		s.cfg.executionPayloadReconstructor = r
 		return nil

beacon-chain/sync/service.go

@@ -83,7 +83,7 @@ type config struct {
 	initialSync                   Checker
 	blockNotifier                 blockfeed.Notifier
 	operationNotifier             operation.Notifier
-	executionPayloadReconstructor execution.ExecutionPayloadReconstructor
+	executionPayloadReconstructor execution.PayloadReconstructor
 	stateGen                      *stategen.State
 	slasherAttestationsFeed       *event.Feed
 	slasherBlockHeadersFeed       *event.Feed

beacon-chain/sync/validate_bls_to_execution_change_test.go

@@ -178,7 +178,7 @@ func TestService_ValidateBlsToExecutionChange(t *testing.T) {
 				epoch := slots.ToEpoch(st.Slot())
 				domain, err := signing.Domain(st.Fork(), epoch, params.BeaconConfig().DomainBLSToExecutionChange, st.GenesisValidatorsRoot())
 				assert.NoError(t, err)
-				htr, err := signing.SigningData(msg.Message.HashTreeRoot, domain)
+				htr, err := signing.Data(msg.Message.HashTreeRoot, domain)
 				assert.NoError(t, err)
 				msg.Signature = keys[51].Sign(htr[:]).Marshal()
 				return s, topic
@@ -396,7 +396,7 @@ func TestService_ValidateBlsToExecutionChange(t *testing.T) {
 				epoch := slots.ToEpoch(st.Slot())
 				domain, err := signing.Domain(st.Fork(), epoch, params.BeaconConfig().DomainBLSToExecutionChange, st.GenesisValidatorsRoot())
 				assert.NoError(t, err)
-				htr, err := signing.SigningData(msg.Message.HashTreeRoot, domain)
+				htr, err := signing.Data(msg.Message.HashTreeRoot, domain)
 				assert.NoError(t, err)
 				msg.Signature = keys[51].Sign(htr[:]).Marshal()
 				return s, topic

cmd/flags/enum.go

@@ -39,7 +39,7 @@ func (e *EnumValue) String() string {
 	return *e.Destination
 }
 
-// Wraps the EnumValue in a GenericFlag value so that it satisfies the cli.Flag interface.
+// GenericFlag wraps the EnumValue in a GenericFlag value so that it satisfies the cli.Flag interface.
 func (e EnumValue) GenericFlag() *cli.GenericFlag {
 	*e.Destination = e.Value
 	var i cli.Generic = &e

cmd/helpers_test.go

@@ -66,7 +66,7 @@ func TestEnterPassword(t *testing.T) {
 	for _, tc := range tt {
 		t.Run(tc.name, func(t *testing.T) {
 			ctrl := gomock.NewController(t)
-			m := mock.NewMockPasswordReader(ctrl)
+			m := mock.NewPasswordReader(ctrl)
 			for _, ret := range tc.rets {
 				m.EXPECT().ReadPassword().Return(ret.pw, ret.err)
 			}

cmd/mock/password_reader_mock.go

@@ -10,31 +10,31 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockPasswordReader is a mock of PasswordReader interface
+// PasswordReader is a mock of PasswordReader interface
-type MockPasswordReader struct {
+type PasswordReader struct {
 	ctrl     *gomock.Controller
-	recorder *MockPasswordReaderMockRecorder
+	recorder *PasswordReaderMockRecorder
 }
 
-// MockPasswordReaderMockRecorder is the mock recorder for MockPasswordReader
+// PasswordReaderMockRecorder is the mock recorder for MockPasswordReader
-type MockPasswordReaderMockRecorder struct {
+type PasswordReaderMockRecorder struct {
-	mock *MockPasswordReader
+	mock *PasswordReader
 }
 
-// NewMockPasswordReader creates a new mock instance
+// NewPasswordReader creates a new mock instance
-func NewMockPasswordReader(ctrl *gomock.Controller) *MockPasswordReader {
+func NewPasswordReader(ctrl *gomock.Controller) *PasswordReader {
-	mock := &MockPasswordReader{ctrl: ctrl}
+	mock := &PasswordReader{ctrl: ctrl}
-	mock.recorder = &MockPasswordReaderMockRecorder{mock}
+	mock.recorder = &PasswordReaderMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockPasswordReader) EXPECT() *MockPasswordReaderMockRecorder {
+func (m *PasswordReader) EXPECT() *PasswordReaderMockRecorder {
 	return m.recorder
 }
 
 // ReadPassword mocks base method
-func (m *MockPasswordReader) ReadPassword() (string, error) {
+func (m *PasswordReader) ReadPassword() (string, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReadPassword")
 	ret0, _ := ret[0].(string)
@@ -43,7 +43,7 @@ func (m *MockPasswordReader) ReadPassword() (string, error) {
 }
 
 // ReadPassword indicates an expected call of ReadPassword
-func (mr *MockPasswordReaderMockRecorder) ReadPassword() *gomock.Call {
+func (mr *PasswordReaderMockRecorder) ReadPassword() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPassword", reflect.TypeOf((*MockPasswordReader)(nil).ReadPassword))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPassword", reflect.TypeOf((*PasswordReader)(nil).ReadPassword))
 }

cmd/prysmctl/validator/cmd.go

@@ -40,7 +40,7 @@ var (
 		Usage:   "overrides withdrawal command to only verify whether requests are in the pool and does not submit withdrawal requests",
 	}
 
-	ValidatorHostFlag = &cli.StringFlag{
+	HostFlag = &cli.StringFlag{
 		Name:    "validator-host",
 		Aliases: []string{"vch"},
 		Usage:   "host:port for validator client.",
@@ -131,7 +131,7 @@ var Commands = []*cli.Command{
 					cmd.ConfigFileFlag,
 					DefaultFeeRecipientFlag,
 					TokenFlag,
-					ValidatorHostFlag,
+					HostFlag,
 					ProposerSettingsOutputFlag,
 				},
 				Before: func(cliCtx *cli.Context) error {
@@ -182,7 +182,7 @@ var Commands = []*cli.Command{
 					return features.ConfigureValidator(cliCtx)
 				},
 				Action: func(cliCtx *cli.Context) error {
-					if err := accounts.AccountsExit(cliCtx, os.Stdin); err != nil {
+					if err := accounts.Exit(cliCtx, os.Stdin); err != nil {
 						log.WithError(err).Fatal("Could not perform voluntary exit")
 					}
 					return nil

cmd/prysmctl/validator/proposer_settings.go

@@ -23,8 +23,8 @@ import (
 func getProposerSettings(c *cli.Context, r io.Reader) error {
 	ctx, span := trace.StartSpan(c.Context, "prysmctl.getProposerSettings")
 	defer span.End()
-	if !c.IsSet(ValidatorHostFlag.Name) {
+	if !c.IsSet(HostFlag.Name) {
-		return errNoFlag(ValidatorHostFlag.Name)
+		return errNoFlag(HostFlag.Name)
 	}
 	if !c.IsSet(TokenFlag.Name) {
 		return errNoFlag(TokenFlag.Name)
@@ -47,7 +47,7 @@ func getProposerSettings(c *cli.Context, r io.Reader) error {
 		}
 	}
 
-	cl, err := validator.NewClient(c.String(ValidatorHostFlag.Name), client.WithAuthenticationToken(c.String(TokenFlag.Name)))
+	cl, err := validator.NewClient(c.String(HostFlag.Name), client.WithAuthenticationToken(c.String(TokenFlag.Name)))
 	if err != nil {
 		return err
 	}

cmd/validator/accounts/accounts.go

@@ -188,7 +188,7 @@ var Commands = &cli.Command{
 			},
 			Action: func(cliCtx *cli.Context) error {
 				log.Info("This command will be deprecated in the future in favor of `prysmctl validator exit`")
-				if err := AccountsExit(cliCtx, os.Stdin); err != nil {
+				if err := Exit(cliCtx, os.Stdin); err != nil {
 					log.WithError(err).Fatal("Could not perform voluntary exit")
 				}
 				return nil

cmd/validator/accounts/backup_test.go

@@ -98,7 +98,7 @@ func TestBackupAccounts_Noninteractive_Derived(t *testing.T) {
 
 	// We check a backup.zip file was created at the output path.
 	zipFilePath := filepath.Join(backupDir, accounts.ArchiveFilename)
-	assert.DeepEqual(t, true, file.FileExists(zipFilePath))
+	assert.DeepEqual(t, true, file.Exists(zipFilePath))
 
 	// We attempt to unzip the file and verify the keystores do match our accounts.
 	f, err := os.Open(zipFilePath)
@@ -189,7 +189,7 @@ func TestBackupAccounts_Noninteractive_Imported(t *testing.T) {
 
 	// We check a backup.zip file was created at the output path.
 	zipFilePath := filepath.Join(backupDir, accounts.ArchiveFilename)
-	assert.DeepEqual(t, true, file.FileExists(zipFilePath))
+	assert.DeepEqual(t, true, file.Exists(zipFilePath))
 
 	// We attempt to unzip the file and verify the keystores do match our accounts.
 	f, err := os.Open(zipFilePath)

cmd/validator/accounts/exit.go

@@ -20,7 +20,7 @@ import (
 	"google.golang.org/grpc"
 )
 
-func AccountsExit(c *cli.Context, r io.Reader) error {
+func Exit(c *cli.Context, r io.Reader) error {
 	var w *wallet.Wallet
 	var km keymanager.IKeymanager
 	var err error

cmd/validator/accounts/exit_test.go

@@ -395,5 +395,5 @@ func TestExitAccountsCli_WriteJSON_NoBroadcast(t *testing.T) {
 	require.Equal(t, 1, len(formattedExitedKeys))
 	assert.Equal(t, "0x"+keystore.Pubkey[:12], formattedExitedKeys[0])
 
-	require.Equal(t, true, file.FileExists(path.Join(out, "validator-exit-1.json")), "Expected file to exist")
+	require.Equal(t, true, file.Exists(path.Join(out, "validator-exit-1.json")), "Expected file to exist")
 }

consensus-types/blocks/execution.go

@@ -343,7 +343,7 @@ func (e executionPayloadHeader) ExcessBlobGas() (uint64, error) {
 	return 0, consensus_types.ErrUnsupportedField
 }
 
-// PbV2 --
+// PbCapella --
 func (executionPayloadHeader) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
 	return nil, consensus_types.ErrUnsupportedField
 }
@@ -543,7 +543,7 @@ func (e executionPayloadCapella) ExcessBlobGas() (uint64, error) {
 	return 0, consensus_types.ErrUnsupportedField
 }
 
-// PbV2 --
+// PbCapella --
 func (e executionPayloadCapella) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
 	return e.p, nil
 }
@@ -715,7 +715,7 @@ func (e executionPayloadHeaderCapella) ExcessBlobGas() (uint64, error) {
 	return 0, consensus_types.ErrUnsupportedField
 }
 
-// PbV2 --
+// PbCapella --
 func (executionPayloadHeaderCapella) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
 	return nil, consensus_types.ErrUnsupportedField
 }

consensus-types/validator/types.go

@@ -4,10 +4,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 )
 
-type ValidatorStatus int8
+type Status int8
 
 const (
-	PendingInitialized ValidatorStatus = iota
+	PendingInitialized Status = iota
 	PendingQueued
 	ActiveOngoing
 	ActiveExiting
@@ -22,7 +22,7 @@ const (
 	Withdrawal
 )
 
-func (s ValidatorStatus) String() string {
+func (s Status) String() string {
 	switch s {
 	case PendingInitialized:
 		return "pending_initialized"
@@ -55,7 +55,7 @@ func (s ValidatorStatus) String() string {
 	}
 }
 
-func ValidatorStatusFromString(s string) (bool, ValidatorStatus) {
+func StatusFromString(s string) (bool, Status) {
 	switch s {
 	case "pending_initialized":
 		return true, PendingInitialized

crypto/bls/bls.go

@@ -11,7 +11,7 @@ import (
 
 // Initialize herumi temporarily while we transition to blst for ethdo.
 func init() {
-	herumi.HerumiInit()
+	herumi.Init()
 }
 
 // SecretKeyFromBytes creates a BLS private key from a BigEndian byte slice.

crypto/bls/common/mock/interface_mock.go

@@ -12,30 +12,30 @@ import (
 )
 
 // MockSecretKey is a mock of SecretKey interface.
-type MockSecretKey struct {
+type SecretKey struct {
 	ctrl     *gomock.Controller
-	recorder *MockSecretKeyMockRecorder
+	recorder *SecretKeyMockRecorder
 }
 
 // MockSecretKeyMockRecorder is the mock recorder for MockSecretKey.
-type MockSecretKeyMockRecorder struct {
+type SecretKeyMockRecorder struct {
-	mock *MockSecretKey
+	mock *SecretKey
 }
 
-// NewMockSecretKey creates a new mock instance.
+// NewSecretKey creates a new mock instance.
-func NewMockSecretKey(ctrl *gomock.Controller) *MockSecretKey {
+func NewSecretKey(ctrl *gomock.Controller) *SecretKey {
-	mock := &MockSecretKey{ctrl: ctrl}
+	mock := &SecretKey{ctrl: ctrl}
-	mock.recorder = &MockSecretKeyMockRecorder{mock}
+	mock.recorder = &SecretKeyMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockSecretKey) EXPECT() *MockSecretKeyMockRecorder {
+func (m *SecretKey) EXPECT() *SecretKeyMockRecorder {
 	return m.recorder
 }
 
 // Marshal mocks base method.
-func (m *MockSecretKey) Marshal() []byte {
+func (m *SecretKey) Marshal() []byte {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Marshal")
 	ret0, _ := ret[0].([]byte)
@@ -43,13 +43,13 @@ func (m *MockSecretKey) Marshal() []byte {
 }
 
 // Marshal indicates an expected call of Marshal.
-func (mr *MockSecretKeyMockRecorder) Marshal() *gomock.Call {
+func (mr *SecretKeyMockRecorder) Marshal() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*MockSecretKey)(nil).Marshal))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*SecretKey)(nil).Marshal))
 }
 
 // PublicKey mocks base method.
-func (m *MockSecretKey) PublicKey() common.PublicKey {
+func (m *SecretKey) PublicKey() common.PublicKey {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PublicKey")
 	ret0, _ := ret[0].(common.PublicKey)
@@ -57,13 +57,13 @@ func (m *MockSecretKey) PublicKey() common.PublicKey {
 }
 
 // PublicKey indicates an expected call of PublicKey.
-func (mr *MockSecretKeyMockRecorder) PublicKey() *gomock.Call {
+func (mr *SecretKeyMockRecorder) PublicKey() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicKey", reflect.TypeOf((*MockSecretKey)(nil).PublicKey))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicKey", reflect.TypeOf((*SecretKey)(nil).PublicKey))
 }
 
 // Sign mocks base method.
-func (m *MockSecretKey) Sign(msg []byte) common.Signature {
+func (m *SecretKey) Sign(msg []byte) common.Signature {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Sign", msg)
 	ret0, _ := ret[0].(common.Signature)
@@ -71,36 +71,36 @@ func (m *MockSecretKey) Sign(msg []byte) common.Signature {
 }
 
 // Sign indicates an expected call of Sign.
-func (mr *MockSecretKeyMockRecorder) Sign(msg interface{}) *gomock.Call {
+func (mr *SecretKeyMockRecorder) Sign(msg interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sign", reflect.TypeOf((*MockSecretKey)(nil).Sign), msg)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sign", reflect.TypeOf((*SecretKey)(nil).Sign), msg)
 }
 
 // MockPublicKey is a mock of PublicKey interface.
-type MockPublicKey struct {
+type PublicKey struct {
 	ctrl     *gomock.Controller
-	recorder *MockPublicKeyMockRecorder
+	recorder *PublicKeyMockRecorder
 }
 
 // MockPublicKeyMockRecorder is the mock recorder for MockPublicKey.
-type MockPublicKeyMockRecorder struct {
+type PublicKeyMockRecorder struct {
-	mock *MockPublicKey
+	mock *PublicKey
 }
 
-// NewMockPublicKey creates a new mock instance.
+// NewPublicKey creates a new mock instance.
-func NewMockPublicKey(ctrl *gomock.Controller) *MockPublicKey {
+func NewPublicKey(ctrl *gomock.Controller) *PublicKey {
-	mock := &MockPublicKey{ctrl: ctrl}
+	mock := &PublicKey{ctrl: ctrl}
-	mock.recorder = &MockPublicKeyMockRecorder{mock}
+	mock.recorder = &PublicKeyMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockPublicKey) EXPECT() *MockPublicKeyMockRecorder {
+func (m *PublicKey) EXPECT() *PublicKeyMockRecorder {
 	return m.recorder
 }
 
 // Aggregate mocks base method.
-func (m *MockPublicKey) Aggregate(p2 common.PublicKey) common.PublicKey {
+func (m *PublicKey) Aggregate(p2 common.PublicKey) common.PublicKey {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Aggregate", p2)
 	ret0, _ := ret[0].(common.PublicKey)
@@ -108,13 +108,13 @@ func (m *MockPublicKey) Aggregate(p2 common.PublicKey) common.PublicKey {
 }
 
 // Aggregate indicates an expected call of Aggregate.
-func (mr *MockPublicKeyMockRecorder) Aggregate(p2 interface{}) *gomock.Call {
+func (mr *PublicKeyMockRecorder) Aggregate(p2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockPublicKey)(nil).Aggregate), p2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*PublicKey)(nil).Aggregate), p2)
 }
 
 // Copy mocks base method.
-func (m *MockPublicKey) Copy() common.PublicKey {
+func (m *PublicKey) Copy() common.PublicKey {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Copy")
 	ret0, _ := ret[0].(common.PublicKey)
@@ -122,13 +122,13 @@ func (m *MockPublicKey) Copy() common.PublicKey {
 }
 
 // Copy indicates an expected call of Copy.
-func (mr *MockPublicKeyMockRecorder) Copy() *gomock.Call {
+func (mr *PublicKeyMockRecorder) Copy() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockPublicKey)(nil).Copy))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*PublicKey)(nil).Copy))
 }
 
 // Equals mocks base method.
-func (m *MockPublicKey) Equals(p2 common.PublicKey) bool {
+func (m *PublicKey) Equals(p2 common.PublicKey) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Equals", p2)
 	ret0, _ := ret[0].(bool)
@@ -136,13 +136,13 @@ func (m *MockPublicKey) Equals(p2 common.PublicKey) bool {
 }
 
 // Equals indicates an expected call of Equals.
-func (mr *MockPublicKeyMockRecorder) Equals(p2 interface{}) *gomock.Call {
+func (mr *PublicKeyMockRecorder) Equals(p2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equals", reflect.TypeOf((*MockPublicKey)(nil).Equals), p2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equals", reflect.TypeOf((*PublicKey)(nil).Equals), p2)
 }
 
 // IsInfinite mocks base method.
-func (m *MockPublicKey) IsInfinite() bool {
+func (m *PublicKey) IsInfinite() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IsInfinite")
 	ret0, _ := ret[0].(bool)
@@ -150,13 +150,13 @@ func (m *MockPublicKey) IsInfinite() bool {
 }
 
 // IsInfinite indicates an expected call of IsInfinite.
-func (mr *MockPublicKeyMockRecorder) IsInfinite() *gomock.Call {
+func (mr *PublicKeyMockRecorder) IsInfinite() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInfinite", reflect.TypeOf((*MockPublicKey)(nil).IsInfinite))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInfinite", reflect.TypeOf((*PublicKey)(nil).IsInfinite))
 }
 
 // Marshal mocks base method.
-func (m *MockPublicKey) Marshal() []byte {
+func (m *PublicKey) Marshal() []byte {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Marshal")
 	ret0, _ := ret[0].([]byte)
@@ -164,36 +164,36 @@ func (m *MockPublicKey) Marshal() []byte {
 }
 
 // Marshal indicates an expected call of Marshal.
-func (mr *MockPublicKeyMockRecorder) Marshal() *gomock.Call {
+func (mr *PublicKeyMockRecorder) Marshal() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*MockPublicKey)(nil).Marshal))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*PublicKey)(nil).Marshal))
 }
 
 // MockSignature is a mock of Signature interface.
-type MockSignature struct {
+type Signature struct {
 	ctrl     *gomock.Controller
-	recorder *MockSignatureMockRecorder
+	recorder *SignatureMockRecorder
 }
 
 // MockSignatureMockRecorder is the mock recorder for MockSignature.
-type MockSignatureMockRecorder struct {
+type SignatureMockRecorder struct {
-	mock *MockSignature
+	mock *Signature
 }
 
-// NewMockSignature creates a new mock instance.
+// NewSignature creates a new mock instance.
-func NewMockSignature(ctrl *gomock.Controller) *MockSignature {
+func NewSignature(ctrl *gomock.Controller) *Signature {
-	mock := &MockSignature{ctrl: ctrl}
+	mock := &Signature{ctrl: ctrl}
-	mock.recorder = &MockSignatureMockRecorder{mock}
+	mock.recorder = &SignatureMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockSignature) EXPECT() *MockSignatureMockRecorder {
+func (m *Signature) EXPECT() *SignatureMockRecorder {
 	return m.recorder
 }
 
 // AggregateVerify mocks base method.
-func (m *MockSignature) AggregateVerify(pubKeys []common.PublicKey, msgs [][32]byte) bool {
+func (m *Signature) AggregateVerify(pubKeys []common.PublicKey, msgs [][32]byte) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AggregateVerify", pubKeys, msgs)
 	ret0, _ := ret[0].(bool)
@@ -201,13 +201,13 @@ func (m *MockSignature) AggregateVerify(pubKeys []common.PublicKey, msgs [][32]b
 }
 
 // AggregateVerify indicates an expected call of AggregateVerify.
-func (mr *MockSignatureMockRecorder) AggregateVerify(pubKeys, msgs interface{}) *gomock.Call {
+func (mr *SignatureMockRecorder) AggregateVerify(pubKeys, msgs interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateVerify", reflect.TypeOf((*MockSignature)(nil).AggregateVerify), pubKeys, msgs)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateVerify", reflect.TypeOf((*Signature)(nil).AggregateVerify), pubKeys, msgs)
 }
 
 // Copy mocks base method.
-func (m *MockSignature) Copy() common.Signature {
+func (m *Signature) Copy() common.Signature {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Copy")
 	ret0, _ := ret[0].(common.Signature)
@@ -215,13 +215,13 @@ func (m *MockSignature) Copy() common.Signature {
 }
 
 // Copy indicates an expected call of Copy.
-func (mr *MockSignatureMockRecorder) Copy() *gomock.Call {
+func (mr *SignatureMockRecorder) Copy() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockSignature)(nil).Copy))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*Signature)(nil).Copy))
 }
 
 // Eth2FastAggregateVerify mocks base method.
-func (m *MockSignature) Eth2FastAggregateVerify(pubKeys []common.PublicKey, msg [32]byte) bool {
+func (m *Signature) Eth2FastAggregateVerify(pubKeys []common.PublicKey, msg [32]byte) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Eth2FastAggregateVerify", pubKeys, msg)
 	ret0, _ := ret[0].(bool)
@@ -229,13 +229,13 @@ func (m *MockSignature) Eth2FastAggregateVerify(pubKeys []common.PublicKey, msg
 }
 
 // Eth2FastAggregateVerify indicates an expected call of Eth2FastAggregateVerify.
-func (mr *MockSignatureMockRecorder) Eth2FastAggregateVerify(pubKeys, msg interface{}) *gomock.Call {
+func (mr *SignatureMockRecorder) Eth2FastAggregateVerify(pubKeys, msg interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eth2FastAggregateVerify", reflect.TypeOf((*MockSignature)(nil).Eth2FastAggregateVerify), pubKeys, msg)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eth2FastAggregateVerify", reflect.TypeOf((*Signature)(nil).Eth2FastAggregateVerify), pubKeys, msg)
 }
 
 // FastAggregateVerify mocks base method.
-func (m *MockSignature) FastAggregateVerify(pubKeys []common.PublicKey, msg [32]byte) bool {
+func (m *Signature) FastAggregateVerify(pubKeys []common.PublicKey, msg [32]byte) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FastAggregateVerify", pubKeys, msg)
 	ret0, _ := ret[0].(bool)
@@ -243,13 +243,13 @@ func (m *MockSignature) FastAggregateVerify(pubKeys []common.PublicKey, msg [32]
 }
 
 // FastAggregateVerify indicates an expected call of FastAggregateVerify.
-func (mr *MockSignatureMockRecorder) FastAggregateVerify(pubKeys, msg interface{}) *gomock.Call {
+func (mr *SignatureMockRecorder) FastAggregateVerify(pubKeys, msg interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FastAggregateVerify", reflect.TypeOf((*MockSignature)(nil).FastAggregateVerify), pubKeys, msg)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FastAggregateVerify", reflect.TypeOf((*Signature)(nil).FastAggregateVerify), pubKeys, msg)
 }
 
 // Marshal mocks base method.
-func (m *MockSignature) Marshal() []byte {
+func (m *Signature) Marshal() []byte {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Marshal")
 	ret0, _ := ret[0].([]byte)
@@ -257,13 +257,13 @@ func (m *MockSignature) Marshal() []byte {
 }
 
 // Marshal indicates an expected call of Marshal.
-func (mr *MockSignatureMockRecorder) Marshal() *gomock.Call {
+func (mr *SignatureMockRecorder) Marshal() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*MockSignature)(nil).Marshal))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*Signature)(nil).Marshal))
 }
 
 // Verify mocks base method.
-func (m *MockSignature) Verify(pubKey common.PublicKey, msg []byte) bool {
+func (m *Signature) Verify(pubKey common.PublicKey, msg []byte) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Verify", pubKey, msg)
 	ret0, _ := ret[0].(bool)
@@ -271,7 +271,7 @@ func (m *MockSignature) Verify(pubKey common.PublicKey, msg []byte) bool {
 }
 
 // Verify indicates an expected call of Verify.
-func (mr *MockSignatureMockRecorder) Verify(pubKey, msg interface{}) *gomock.Call {
+func (mr *SignatureMockRecorder) Verify(pubKey, msg interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Verify", reflect.TypeOf((*MockSignature)(nil).Verify), pubKey, msg)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Verify", reflect.TypeOf((*Signature)(nil).Verify), pubKey, msg)
 }

crypto/bls/herumi/init.go

@@ -2,8 +2,8 @@ package herumi
 
 import "github.com/herumi/bls-eth-go-binary/bls"
 
-// HerumiInit allows the required curve orders and appropriate sub-groups to be initialized.
+// Init allows the required curve orders and appropriate sub-groups to be initialized.
-func HerumiInit() {
+func Init() {
 	if err := bls.Init(bls.BLS12_381); err != nil {
 		panic(err)
 	}

crypto/hash/hash.go

@@ -79,9 +79,9 @@ var keccak256Pool = sync.Pool{New: func() interface{} {
 	return sha3.NewLegacyKeccak256()
 }}
 
-// HashKeccak256 defines a function which returns the Keccak-256/SHA3
+// Keccak256 defines a function which returns the Keccak-256/SHA3
 // hash of the data passed in.
-func HashKeccak256(data []byte) [32]byte {
+func Keccak256(data []byte) [32]byte {
 	var b [32]byte
 
 	h, ok := keccak256Pool.Get().(hash.Hash)
@@ -102,8 +102,8 @@ func HashKeccak256(data []byte) [32]byte {
 	return b
 }
 
-// HashProto hashes a protocol buffer message using sha256.
+// Proto hashes a protocol buffer message using sha256.
-func HashProto(msg proto.Message) (result [32]byte, err error) {
+func Proto(msg proto.Message) (result [32]byte, err error) {
 	if msg == nil || reflect.ValueOf(msg).IsNil() {
 		return [32]byte{}, ErrNilProto
 	}

crypto/hash/hash_test.go

@@ -33,25 +33,25 @@ func BenchmarkHash(b *testing.B) {
 
 func TestHashKeccak256(t *testing.T) {
 	hashOf0 := [32]byte{188, 54, 120, 158, 122, 30, 40, 20, 54, 70, 66, 41, 130, 143, 129, 125, 102, 18, 247, 180, 119, 214, 101, 145, 255, 150, 169, 224, 100, 188, 201, 138}
-	h := hash.HashKeccak256([]byte{0})
+	h := hash.Keccak256([]byte{0})
 	assert.Equal(t, hashOf0, h)
 
 	hashOf1 := [32]byte{95, 231, 249, 119, 231, 29, 186, 46, 161, 166, 142, 33, 5, 123, 238, 187, 155, 226, 172, 48, 198, 65, 10, 163, 141, 79, 63, 190, 65, 220, 255, 210}
-	h = hash.HashKeccak256([]byte{1})
+	h = hash.Keccak256([]byte{1})
 	assert.Equal(t, hashOf1, h)
 	assert.Equal(t, false, hashOf0 == hashOf1)
 
 	// Same hashing test from go-ethereum for keccak256
 	hashOfabc, err := hex.DecodeString("4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45")
 	require.NoError(t, err)
-	h = hash.HashKeccak256([]byte("abc"))
+	h = hash.Keccak256([]byte("abc"))
 	h32 := bytesutil.ToBytes32(hashOfabc)
 	assert.Equal(t, h32, h)
 }
 
 func BenchmarkHashKeccak256(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		hash.HashKeccak256([]byte("abc"))
+		hash.Keccak256([]byte("abc"))
 	}
 }
 
@@ -62,9 +62,9 @@ func TestHashProto(t *testing.T) {
 	msg2 := &pb.Puzzle{
 		Challenge: "hello",
 	}
-	h1, err := hash.HashProto(msg1)
+	h1, err := hash.Proto(msg1)
 	require.NoError(t, err)
-	h2, err := hash.HashProto(msg2)
+	h2, err := hash.Proto(msg2)
 	require.NoError(t, err)
 	assert.Equal(t, h1, h2)
 }
@@ -80,7 +80,7 @@ func TestHashProtoFuzz(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		msg := &pb.AddressBook{}
 		f.Fuzz(msg)
-		_, err := hash.HashProto(msg)
+		_, err := hash.Proto(msg)
 		_ = err
 	}
 }
@@ -99,7 +99,7 @@ func BenchmarkHashProto(b *testing.B) {
 	}
 
 	for i := 0; i < b.N; i++ {
-		if _, err := hash.HashProto(att); err != nil {
+		if _, err := hash.Proto(att); err != nil {
 			b.Log(err)
 		}
 	}

io/file/fileutil.go

@@ -92,7 +92,7 @@ func WriteFile(file string, data []byte) error {
 	if err != nil {
 		return err
 	}
-	if FileExists(expanded) {
+	if Exists(expanded) {
 		info, err := os.Stat(expanded)
 		if err != nil {
 			return err
@@ -141,9 +141,9 @@ func HasReadWritePermissions(itemPath string) (bool, error) {
 	return info.Mode() == params.BeaconIoConfig().ReadWritePermissions, nil
 }
 
-// FileExists returns true if a file is not a directory and exists
+// Exists returns true if a file is not a directory and exists
 // at the specified path.
-func FileExists(filename string) bool {
+func Exists(filename string) bool {
 	filePath, err := ExpandPath(filename)
 	if err != nil {
 		return false
@@ -201,7 +201,7 @@ func ReadFileAsBytes(filename string) ([]byte, error) {
 
 // CopyFile copy a file from source to destination path.
 func CopyFile(src, dst string) error {
-	if !FileExists(src) {
+	if !Exists(src) {
 		return errors.New("source file does not exist at provided path")
 	}
 	f, err := os.Open(src) // #nosec G304

io/file/fileutil_test.go

@@ -131,7 +131,7 @@ func TestWriteFile_OK(t *testing.T) {
 	require.NoError(t, err)
 	someFileName := filepath.Join(dirName, "somefile.txt")
 	require.NoError(t, file.WriteFile(someFileName, []byte("hi")))
-	exists := file.FileExists(someFileName)
+	exists := file.Exists(someFileName)
 	assert.Equal(t, true, exists)
 }
 
@@ -182,8 +182,8 @@ func TestCopyDir(t *testing.T) {
 	require.NoError(t, os.MkdirAll(filepath.Join(tmpDir1, "subfolder2"), 0777))
 	for _, fd := range fds {
 		require.NoError(t, file.WriteFile(filepath.Join(tmpDir1, fd.path), fd.content))
-		assert.Equal(t, true, file.FileExists(filepath.Join(tmpDir1, fd.path)))
+		assert.Equal(t, true, file.Exists(filepath.Join(tmpDir1, fd.path)))
-		assert.Equal(t, false, file.FileExists(filepath.Join(tmpDir2, fd.path)))
+		assert.Equal(t, false, file.Exists(filepath.Join(tmpDir2, fd.path)))
 	}
 
 	// Make sure that files are copied into non-existent directory only. If directory exists function exits.
@@ -192,7 +192,7 @@ func TestCopyDir(t *testing.T) {
 
 	// Now, all files should have been copied.
 	for _, fd := range fds {
-		assert.Equal(t, true, file.FileExists(filepath.Join(tmpDir2, fd.path)))
+		assert.Equal(t, true, file.Exists(filepath.Join(tmpDir2, fd.path)))
 		assert.Equal(t, true, deepCompare(t, filepath.Join(tmpDir1, fd.path), filepath.Join(tmpDir2, fd.path)))
 	}
 	assert.Equal(t, true, file.DirsEqual(tmpDir1, tmpDir2))

monitoring/backup/http_backup_handler.go

@@ -8,13 +8,13 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// BackupExporter defines a backup exporter methods.
+// Exporter defines a backup exporter methods.
-type BackupExporter interface {
+type Exporter interface {
 	Backup(ctx context.Context, outputPath string, permissionOverride bool) error
 }
 
-// BackupHandler for accepting requests to initiate a new database backup.
+// Handler for accepting requests to initiate a new database backup.
-func BackupHandler(bk BackupExporter, outputDir string) func(http.ResponseWriter, *http.Request) {
+func Handler(bk Exporter, outputDir string) func(http.ResponseWriter, *http.Request) {
 	log := logrus.WithField("prefix", "db")
 
 	return func(w http.ResponseWriter, r *http.Request) {

network/authorization/authorization_method.go

@@ -1,11 +1,11 @@
 package authorization
 
-// AuthorizationMethod is an authorization method such as 'Basic' or 'Bearer'.
+// Method is an authorization method such as 'Basic' or 'Bearer'.
-type AuthorizationMethod uint8
+type Method uint8
 
 const (
 	// None represents no authorization method.
-	None AuthorizationMethod = iota
+	None Method = iota
 	// Basic represents Basic Authentication.
 	Basic
 	// Bearer represents Bearer Authentication (token authentication).

network/endpoint.go

@@ -22,7 +22,7 @@ type Endpoint struct {
 
 // AuthorizationData holds all information necessary to authorize with HTTP.
 type AuthorizationData struct {
-	Method authorization.AuthorizationMethod
+	Method authorization.Method
 	Value  string
 }
 
@@ -100,7 +100,7 @@ func HttpEndpoint(eth1Provider string) Endpoint {
 }
 
 // Method returns the authorizationmethod.AuthorizationMethod corresponding with the parameter value.
-func Method(auth string) authorization.AuthorizationMethod {
+func Method(auth string) authorization.Method {
 	if strings.HasPrefix(strings.ToLower(auth), "basic") {
 		return authorization.Basic
 	}

runtime/interop/genesis.go

@@ -92,7 +92,7 @@ func GethShanghaiTime(genesisTime uint64, cfg *clparams.BeaconChainConfig) *uint
 	return shanghaiTime
 }
 
-// GethShanghaiTime calculates the absolute time of the shanghai (aka capella) fork block
+// GethCancunTime calculates the absolute time of the shanghai (aka capella) fork block
 // by adding the relative time of the capella the fork epoch to the given genesis timestamp.
 func GethCancunTime(genesisTime uint64, cfg *clparams.BeaconChainConfig) *uint64 {
 	var cancunTime *uint64

runtime/tos/tos.go

@@ -37,7 +37,7 @@ var (
 
 // VerifyTosAcceptedOrPrompt check if Tos was accepted before or asks to accept.
 func VerifyTosAcceptedOrPrompt(ctx *cli.Context) error {
-	if file.FileExists(filepath.Join(ctx.String(cmd.DataDirFlag.Name), acceptTosFilename)) {
+	if file.Exists(filepath.Join(ctx.String(cmd.DataDirFlag.Name), acceptTosFilename)) {
 		return nil
 	}
 	if ctx.Bool(cmd.AcceptTosFlag.Name) {

testing/assert/assertions.go

@@ -46,7 +46,7 @@ func StringContains(tb assertions.AssertionTestingTB, expected, actual string, m
 	assertions.StringContains(tb.Errorf, expected, actual, true, msg...)
 }
 
-// StringContains asserts a string does not contain specified substring.
+// StringNotContains asserts a string does not contain specified substring.
 func StringNotContains(tb assertions.AssertionTestingTB, expected, actual string, msg ...interface{}) {
 	assertions.StringContains(tb.Errorf, expected, actual, false, msg...)
 }

testing/endtoend/slasher_simulator_e2e_test.go

@@ -85,7 +85,7 @@ func TestEndToEnd_SlasherSimulator(t *testing.T) {
 	require.NoError(t, err)
 
 	mockChain := &mock.ChainService{State: beaconState}
-	gen := mockstategen.NewMockService()
+	gen := mockstategen.NewService()
 	gen.AddStateForRoot(beaconState, [32]byte{})
 
 	gs := startup.NewClockSynchronizer()

testing/mock/beacon_altair_validator_client_mock.go

@@ -13,31 +13,31 @@ import (
 	metadata "google.golang.org/grpc/metadata"
 )
 
-// MockBeaconNodeValidatorAltair_StreamBlocksClient is a mock of BeaconNodeValidatorAltair_StreamBlocksClient interface
+// BeaconNodeValidatorAltair_StreamBlocksClient is a mock of BeaconNodeValidatorAltair_StreamBlocksClient interface
-type MockBeaconNodeValidatorAltair_StreamBlocksClient struct {
+type BeaconNodeValidatorAltair_StreamBlocksClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder
+	recorder *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder
 }
 
-// MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder is the mock recorder for MockBeaconNodeValidatorAltair_StreamBlocksClient
+// BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder is the mock recorder for MockBeaconNodeValidatorAltair_StreamBlocksClient
-type MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder struct {
+type BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder struct {
-	mock *MockBeaconNodeValidatorAltair_StreamBlocksClient
+	mock *BeaconNodeValidatorAltair_StreamBlocksClient
 }
 
 // NewMockBeaconNodeValidatorAltair_StreamBlocksClient creates a new mock instance
-func NewMockBeaconNodeValidatorAltair_StreamBlocksClient(ctrl *gomock.Controller) *MockBeaconNodeValidatorAltair_StreamBlocksClient {
+func NewMockBeaconNodeValidatorAltair_StreamBlocksClient(ctrl *gomock.Controller) *BeaconNodeValidatorAltair_StreamBlocksClient {
-	mock := &MockBeaconNodeValidatorAltair_StreamBlocksClient{ctrl: ctrl}
+	mock := &BeaconNodeValidatorAltair_StreamBlocksClient{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) EXPECT() *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) EXPECT() *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder {
 	return m.recorder
 }
 
 // CloseSend mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) CloseSend() error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) CloseSend() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseSend")
 	ret0, _ := ret[0].(error)
@@ -45,13 +45,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) CloseSend() error {
 }
 
 // CloseSend indicates an expected call of CloseSend
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) CloseSend() *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) CloseSend() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksClient)(nil).CloseSend))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksClient)(nil).CloseSend))
 }
 
 // Context mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Context() context.Context {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -59,13 +59,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Context() context.Con
 }
 
 // Context indicates an expected call of Context
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksClient)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksClient)(nil).Context))
 }
 
 // Header mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Header() (metadata.MD, error) {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) Header() (metadata.MD, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Header")
 	ret0, _ := ret[0].(metadata.MD)
@@ -74,13 +74,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Header() (metadata.MD
 }
 
 // Header indicates an expected call of Header
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Header() *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Header() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksClient)(nil).Header))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksClient)(nil).Header))
 }
 
 // Recv mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Recv() (*v2.StreamBlocksResponse, error) {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) Recv() (*v2.StreamBlocksResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Recv")
 	ret0, _ := ret[0].(*v2.StreamBlocksResponse)
@@ -89,13 +89,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Recv() (*v2.StreamBlo
 }
 
 // Recv indicates an expected call of Recv
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Recv() *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Recv() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksClient)(nil).Recv))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksClient)(nil).Recv))
 }
 
 // RecvMsg mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -103,13 +103,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) RecvMsg(arg0 interfac
 }
 
 // RecvMsg indicates an expected call of RecvMsg
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksClient)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksClient)(nil).RecvMsg), arg0)
 }
 
 // SendMsg mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -117,13 +117,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) SendMsg(arg0 interfac
 }
 
 // SendMsg indicates an expected call of SendMsg
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksClient)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksClient)(nil).SendMsg), arg0)
 }
 
 // Trailer mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Trailer() metadata.MD {
+func (m *BeaconNodeValidatorAltair_StreamBlocksClient) Trailer() metadata.MD {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Trailer")
 	ret0, _ := ret[0].(metadata.MD)
@@ -131,7 +131,7 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksClient) Trailer() metadata.MD
 }
 
 // Trailer indicates an expected call of Trailer
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Trailer() *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksClientMockRecorder) Trailer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksClient)(nil).Trailer))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksClient)(nil).Trailer))
 }

testing/mock/beacon_altair_validator_server_mock.go

@@ -13,31 +13,31 @@ import (
 	metadata "google.golang.org/grpc/metadata"
 )
 
-// MockBeaconNodeValidatorAltair_StreamBlocksServer is a mock of BeaconNodeValidatorAltair_StreamBlocksServer interface
+// BeaconNodeValidatorAltair_StreamBlocksServer is a mock of BeaconNodeValidatorAltair_StreamBlocksServer interface
-type MockBeaconNodeValidatorAltair_StreamBlocksServer struct {
+type BeaconNodeValidatorAltair_StreamBlocksServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder
+	recorder *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder
 }
 
-// MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder is the mock recorder for MockBeaconNodeValidatorAltair_StreamBlocksServer
+// BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder is the mock recorder for MockBeaconNodeValidatorAltair_StreamBlocksServer
-type MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder struct {
+type BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder struct {
-	mock *MockBeaconNodeValidatorAltair_StreamBlocksServer
+	mock *BeaconNodeValidatorAltair_StreamBlocksServer
 }
 
 // NewMockBeaconNodeValidatorAltair_StreamBlocksServer creates a new mock instance
-func NewMockBeaconNodeValidatorAltair_StreamBlocksServer(ctrl *gomock.Controller) *MockBeaconNodeValidatorAltair_StreamBlocksServer {
+func NewMockBeaconNodeValidatorAltair_StreamBlocksServer(ctrl *gomock.Controller) *BeaconNodeValidatorAltair_StreamBlocksServer {
-	mock := &MockBeaconNodeValidatorAltair_StreamBlocksServer{ctrl: ctrl}
+	mock := &BeaconNodeValidatorAltair_StreamBlocksServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) EXPECT() *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) EXPECT() *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) Context() context.Context {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -45,13 +45,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) Context() context.Con
 }
 
 // Context indicates an expected call of Context
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksServer)(nil).Context))
 }
 
 // RecvMsg mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -59,13 +59,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) RecvMsg(arg0 interfac
 }
 
 // RecvMsg indicates an expected call of RecvMsg
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) Send(arg0 *v2.StreamBlocksResponse) error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) Send(arg0 *v2.StreamBlocksResponse) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -73,13 +73,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) Send(arg0 *v2.StreamB
 }
 
 // Send indicates an expected call of Send
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -87,13 +87,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) SendHeader(arg0 metad
 }
 
 // SendHeader indicates an expected call of SendHeader
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -101,13 +101,13 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) SendMsg(arg0 interfac
 }
 
 // SendMsg indicates an expected call of SendMsg
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -115,19 +115,19 @@ func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) SetHeader(arg0 metada
 }
 
 // SetHeader indicates an expected call of SetHeader
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method
-func (m *MockBeaconNodeValidatorAltair_StreamBlocksServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconNodeValidatorAltair_StreamBlocksServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer
-func (mr *MockBeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorAltair_StreamBlocksServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconNodeValidatorAltair_StreamBlocksServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconNodeValidatorAltair_StreamBlocksServer)(nil).SetTrailer), arg0)
 }

testing/mock/beacon_chain_service_mock.go

@@ -13,31 +13,31 @@ import (
 	metadata "google.golang.org/grpc/metadata"
 )
 
-// MockBeaconChain_StreamChainHeadServer is a mock of BeaconChain_StreamChainHeadServer interface.
+// BeaconChain_StreamChainHeadServer is a mock of BeaconChain_StreamChainHeadServer interface.
-type MockBeaconChain_StreamChainHeadServer struct {
+type BeaconChain_StreamChainHeadServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconChain_StreamChainHeadServerMockRecorder
+	recorder *BeaconChain_StreamChainHeadServerMockRecorder
 }
 
-// MockBeaconChain_StreamChainHeadServerMockRecorder is the mock recorder for MockBeaconChain_StreamChainHeadServer.
+// BeaconChain_StreamChainHeadServerMockRecorder is the mock recorder for MockBeaconChain_StreamChainHeadServer.
-type MockBeaconChain_StreamChainHeadServerMockRecorder struct {
+type BeaconChain_StreamChainHeadServerMockRecorder struct {
-	mock *MockBeaconChain_StreamChainHeadServer
+	mock *BeaconChain_StreamChainHeadServer
 }
 
 // NewMockBeaconChain_StreamChainHeadServer creates a new mock instance.
-func NewMockBeaconChain_StreamChainHeadServer(ctrl *gomock.Controller) *MockBeaconChain_StreamChainHeadServer {
+func NewMockBeaconChain_StreamChainHeadServer(ctrl *gomock.Controller) *BeaconChain_StreamChainHeadServer {
-	mock := &MockBeaconChain_StreamChainHeadServer{ctrl: ctrl}
+	mock := &BeaconChain_StreamChainHeadServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconChain_StreamChainHeadServerMockRecorder{mock}
+	mock.recorder = &BeaconChain_StreamChainHeadServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconChain_StreamChainHeadServer) EXPECT() *MockBeaconChain_StreamChainHeadServerMockRecorder {
+func (m *BeaconChain_StreamChainHeadServer) EXPECT() *BeaconChain_StreamChainHeadServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconChain_StreamChainHeadServer) Context() context.Context {
+func (m *BeaconChain_StreamChainHeadServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -45,13 +45,13 @@ func (m *MockBeaconChain_StreamChainHeadServer) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconChain_StreamChainHeadServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconChain_StreamChainHeadServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconChain_StreamChainHeadServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconChain_StreamChainHeadServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconChain_StreamChainHeadServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamChainHeadServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -59,13 +59,13 @@ func (m *MockBeaconChain_StreamChainHeadServer) RecvMsg(arg0 interface{}) error
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconChain_StreamChainHeadServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamChainHeadServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconChain_StreamChainHeadServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconChain_StreamChainHeadServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconChain_StreamChainHeadServer) Send(arg0 *eth.ChainHead) error {
+func (m *BeaconChain_StreamChainHeadServer) Send(arg0 *eth.ChainHead) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -73,13 +73,13 @@ func (m *MockBeaconChain_StreamChainHeadServer) Send(arg0 *eth.ChainHead) error
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconChain_StreamChainHeadServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamChainHeadServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconChain_StreamChainHeadServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconChain_StreamChainHeadServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconChain_StreamChainHeadServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamChainHeadServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -87,13 +87,13 @@ func (m *MockBeaconChain_StreamChainHeadServer) SendHeader(arg0 metadata.MD) err
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconChain_StreamChainHeadServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamChainHeadServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconChain_StreamChainHeadServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconChain_StreamChainHeadServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconChain_StreamChainHeadServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamChainHeadServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -101,13 +101,13 @@ func (m *MockBeaconChain_StreamChainHeadServer) SendMsg(arg0 interface{}) error
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconChain_StreamChainHeadServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamChainHeadServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconChain_StreamChainHeadServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconChain_StreamChainHeadServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconChain_StreamChainHeadServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamChainHeadServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -115,48 +115,48 @@ func (m *MockBeaconChain_StreamChainHeadServer) SetHeader(arg0 metadata.MD) erro
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconChain_StreamChainHeadServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamChainHeadServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconChain_StreamChainHeadServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconChain_StreamChainHeadServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconChain_StreamChainHeadServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconChain_StreamChainHeadServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconChain_StreamChainHeadServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamChainHeadServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconChain_StreamChainHeadServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconChain_StreamChainHeadServer)(nil).SetTrailer), arg0)
 }
 
-// MockBeaconChain_StreamAttestationsServer is a mock of BeaconChain_StreamAttestationsServer interface.
+// BeaconChain_StreamAttestationsServer is a mock of BeaconChain_StreamAttestationsServer interface.
-type MockBeaconChain_StreamAttestationsServer struct {
+type BeaconChain_StreamAttestationsServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconChain_StreamAttestationsServerMockRecorder
+	recorder *BeaconChain_StreamAttestationsServerMockRecorder
 }
 
-// MockBeaconChain_StreamAttestationsServerMockRecorder is the mock recorder for MockBeaconChain_StreamAttestationsServer.
+// BeaconChain_StreamAttestationsServerMockRecorder is the mock recorder for MockBeaconChain_StreamAttestationsServer.
-type MockBeaconChain_StreamAttestationsServerMockRecorder struct {
+type BeaconChain_StreamAttestationsServerMockRecorder struct {
-	mock *MockBeaconChain_StreamAttestationsServer
+	mock *BeaconChain_StreamAttestationsServer
 }
 
 // NewMockBeaconChain_StreamAttestationsServer creates a new mock instance.
-func NewMockBeaconChain_StreamAttestationsServer(ctrl *gomock.Controller) *MockBeaconChain_StreamAttestationsServer {
+func NewMockBeaconChain_StreamAttestationsServer(ctrl *gomock.Controller) *BeaconChain_StreamAttestationsServer {
-	mock := &MockBeaconChain_StreamAttestationsServer{ctrl: ctrl}
+	mock := &BeaconChain_StreamAttestationsServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconChain_StreamAttestationsServerMockRecorder{mock}
+	mock.recorder = &BeaconChain_StreamAttestationsServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconChain_StreamAttestationsServer) EXPECT() *MockBeaconChain_StreamAttestationsServerMockRecorder {
+func (m *BeaconChain_StreamAttestationsServer) EXPECT() *BeaconChain_StreamAttestationsServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconChain_StreamAttestationsServer) Context() context.Context {
+func (m *BeaconChain_StreamAttestationsServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -164,13 +164,13 @@ func (m *MockBeaconChain_StreamAttestationsServer) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconChain_StreamAttestationsServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconChain_StreamAttestationsServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconChain_StreamAttestationsServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconChain_StreamAttestationsServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconChain_StreamAttestationsServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamAttestationsServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -178,13 +178,13 @@ func (m *MockBeaconChain_StreamAttestationsServer) RecvMsg(arg0 interface{}) err
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconChain_StreamAttestationsServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamAttestationsServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconChain_StreamAttestationsServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconChain_StreamAttestationsServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconChain_StreamAttestationsServer) Send(arg0 *eth.Attestation) error {
+func (m *BeaconChain_StreamAttestationsServer) Send(arg0 *eth.Attestation) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -192,13 +192,13 @@ func (m *MockBeaconChain_StreamAttestationsServer) Send(arg0 *eth.Attestation) e
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconChain_StreamAttestationsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamAttestationsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconChain_StreamAttestationsServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconChain_StreamAttestationsServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconChain_StreamAttestationsServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamAttestationsServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -206,13 +206,13 @@ func (m *MockBeaconChain_StreamAttestationsServer) SendHeader(arg0 metadata.MD)
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconChain_StreamAttestationsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamAttestationsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconChain_StreamAttestationsServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconChain_StreamAttestationsServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconChain_StreamAttestationsServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamAttestationsServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -220,13 +220,13 @@ func (m *MockBeaconChain_StreamAttestationsServer) SendMsg(arg0 interface{}) err
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconChain_StreamAttestationsServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamAttestationsServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconChain_StreamAttestationsServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconChain_StreamAttestationsServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconChain_StreamAttestationsServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamAttestationsServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -234,48 +234,48 @@ func (m *MockBeaconChain_StreamAttestationsServer) SetHeader(arg0 metadata.MD) e
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconChain_StreamAttestationsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamAttestationsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconChain_StreamAttestationsServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconChain_StreamAttestationsServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconChain_StreamAttestationsServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconChain_StreamAttestationsServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconChain_StreamAttestationsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamAttestationsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconChain_StreamAttestationsServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconChain_StreamAttestationsServer)(nil).SetTrailer), arg0)
 }
 
-// MockBeaconChain_StreamBlocksServer is a mock of BeaconChain_StreamBlocksServer interface.
+// BeaconChain_StreamBlocksServer is a mock of BeaconChain_StreamBlocksServer interface.
-type MockBeaconChain_StreamBlocksServer struct {
+type BeaconChain_StreamBlocksServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconChain_StreamBlocksServerMockRecorder
+	recorder *BeaconChain_StreamBlocksServerMockRecorder
 }
 
-// MockBeaconChain_StreamBlocksServerMockRecorder is the mock recorder for MockBeaconChain_StreamBlocksServer.
+// BeaconChain_StreamBlocksServerMockRecorder is the mock recorder for MockBeaconChain_StreamBlocksServer.
-type MockBeaconChain_StreamBlocksServerMockRecorder struct {
+type BeaconChain_StreamBlocksServerMockRecorder struct {
-	mock *MockBeaconChain_StreamBlocksServer
+	mock *BeaconChain_StreamBlocksServer
 }
 
 // NewMockBeaconChain_StreamBlocksServer creates a new mock instance.
-func NewMockBeaconChain_StreamBlocksServer(ctrl *gomock.Controller) *MockBeaconChain_StreamBlocksServer {
+func NewMockBeaconChain_StreamBlocksServer(ctrl *gomock.Controller) *BeaconChain_StreamBlocksServer {
-	mock := &MockBeaconChain_StreamBlocksServer{ctrl: ctrl}
+	mock := &BeaconChain_StreamBlocksServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconChain_StreamBlocksServerMockRecorder{mock}
+	mock.recorder = &BeaconChain_StreamBlocksServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconChain_StreamBlocksServer) EXPECT() *MockBeaconChain_StreamBlocksServerMockRecorder {
+func (m *BeaconChain_StreamBlocksServer) EXPECT() *BeaconChain_StreamBlocksServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconChain_StreamBlocksServer) Context() context.Context {
+func (m *BeaconChain_StreamBlocksServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -283,13 +283,13 @@ func (m *MockBeaconChain_StreamBlocksServer) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconChain_StreamBlocksServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconChain_StreamBlocksServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconChain_StreamBlocksServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconChain_StreamBlocksServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconChain_StreamBlocksServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamBlocksServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -297,13 +297,13 @@ func (m *MockBeaconChain_StreamBlocksServer) RecvMsg(arg0 interface{}) error {
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconChain_StreamBlocksServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamBlocksServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconChain_StreamBlocksServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconChain_StreamBlocksServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconChain_StreamBlocksServer) Send(arg0 *eth.SignedBeaconBlock) error {
+func (m *BeaconChain_StreamBlocksServer) Send(arg0 *eth.SignedBeaconBlock) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -311,13 +311,13 @@ func (m *MockBeaconChain_StreamBlocksServer) Send(arg0 *eth.SignedBeaconBlock) e
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconChain_StreamBlocksServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamBlocksServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconChain_StreamBlocksServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconChain_StreamBlocksServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconChain_StreamBlocksServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamBlocksServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -325,13 +325,13 @@ func (m *MockBeaconChain_StreamBlocksServer) SendHeader(arg0 metadata.MD) error
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconChain_StreamBlocksServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamBlocksServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconChain_StreamBlocksServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconChain_StreamBlocksServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconChain_StreamBlocksServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamBlocksServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -339,13 +339,13 @@ func (m *MockBeaconChain_StreamBlocksServer) SendMsg(arg0 interface{}) error {
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconChain_StreamBlocksServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamBlocksServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconChain_StreamBlocksServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconChain_StreamBlocksServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconChain_StreamBlocksServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamBlocksServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -353,48 +353,48 @@ func (m *MockBeaconChain_StreamBlocksServer) SetHeader(arg0 metadata.MD) error {
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconChain_StreamBlocksServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamBlocksServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconChain_StreamBlocksServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconChain_StreamBlocksServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconChain_StreamBlocksServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconChain_StreamBlocksServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconChain_StreamBlocksServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamBlocksServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconChain_StreamBlocksServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconChain_StreamBlocksServer)(nil).SetTrailer), arg0)
 }
 
-// MockBeaconChain_StreamValidatorsInfoServer is a mock of BeaconChain_StreamValidatorsInfoServer interface.
+// BeaconChain_StreamValidatorsInfoServer is a mock of BeaconChain_StreamValidatorsInfoServer interface.
-type MockBeaconChain_StreamValidatorsInfoServer struct {
+type BeaconChain_StreamValidatorsInfoServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconChain_StreamValidatorsInfoServerMockRecorder
+	recorder *BeaconChain_StreamValidatorsInfoServerMockRecorder
 }
 
-// MockBeaconChain_StreamValidatorsInfoServerMockRecorder is the mock recorder for MockBeaconChain_StreamValidatorsInfoServer.
+// BeaconChain_StreamValidatorsInfoServerMockRecorder is the mock recorder for MockBeaconChain_StreamValidatorsInfoServer.
-type MockBeaconChain_StreamValidatorsInfoServerMockRecorder struct {
+type BeaconChain_StreamValidatorsInfoServerMockRecorder struct {
-	mock *MockBeaconChain_StreamValidatorsInfoServer
+	mock *BeaconChain_StreamValidatorsInfoServer
 }
 
 // NewMockBeaconChain_StreamValidatorsInfoServer creates a new mock instance.
-func NewMockBeaconChain_StreamValidatorsInfoServer(ctrl *gomock.Controller) *MockBeaconChain_StreamValidatorsInfoServer {
+func NewMockBeaconChain_StreamValidatorsInfoServer(ctrl *gomock.Controller) *BeaconChain_StreamValidatorsInfoServer {
-	mock := &MockBeaconChain_StreamValidatorsInfoServer{ctrl: ctrl}
+	mock := &BeaconChain_StreamValidatorsInfoServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconChain_StreamValidatorsInfoServerMockRecorder{mock}
+	mock.recorder = &BeaconChain_StreamValidatorsInfoServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) EXPECT() *MockBeaconChain_StreamValidatorsInfoServerMockRecorder {
+func (m *BeaconChain_StreamValidatorsInfoServer) EXPECT() *BeaconChain_StreamValidatorsInfoServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) Context() context.Context {
+func (m *BeaconChain_StreamValidatorsInfoServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -402,13 +402,13 @@ func (m *MockBeaconChain_StreamValidatorsInfoServer) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).Context))
 }
 
 // Recv mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) Recv() (*eth.ValidatorChangeSet, error) {
+func (m *BeaconChain_StreamValidatorsInfoServer) Recv() (*eth.ValidatorChangeSet, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Recv")
 	ret0, _ := ret[0].(*eth.ValidatorChangeSet)
@@ -417,13 +417,13 @@ func (m *MockBeaconChain_StreamValidatorsInfoServer) Recv() (*eth.ValidatorChang
 }
 
 // Recv indicates an expected call of Recv.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) Recv() *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) Recv() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).Recv))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).Recv))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamValidatorsInfoServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -431,13 +431,13 @@ func (m *MockBeaconChain_StreamValidatorsInfoServer) RecvMsg(arg0 interface{}) e
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) Send(arg0 *eth.ValidatorInfo) error {
+func (m *BeaconChain_StreamValidatorsInfoServer) Send(arg0 *eth.ValidatorInfo) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -445,13 +445,13 @@ func (m *MockBeaconChain_StreamValidatorsInfoServer) Send(arg0 *eth.ValidatorInf
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamValidatorsInfoServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -459,13 +459,13 @@ func (m *MockBeaconChain_StreamValidatorsInfoServer) SendHeader(arg0 metadata.MD
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamValidatorsInfoServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -473,13 +473,13 @@ func (m *MockBeaconChain_StreamValidatorsInfoServer) SendMsg(arg0 interface{}) e
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamValidatorsInfoServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -487,48 +487,48 @@ func (m *MockBeaconChain_StreamValidatorsInfoServer) SetHeader(arg0 metadata.MD)
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconChain_StreamValidatorsInfoServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconChain_StreamValidatorsInfoServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconChain_StreamValidatorsInfoServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamValidatorsInfoServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconChain_StreamValidatorsInfoServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconChain_StreamValidatorsInfoServer)(nil).SetTrailer), arg0)
 }
 
-// MockBeaconChain_StreamIndexedAttestationsServer is a mock of BeaconChain_StreamIndexedAttestationsServer interface.
+// BeaconChain_StreamIndexedAttestationsServer is a mock of BeaconChain_StreamIndexedAttestationsServer interface.
-type MockBeaconChain_StreamIndexedAttestationsServer struct {
+type BeaconChain_StreamIndexedAttestationsServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder
+	recorder *BeaconChain_StreamIndexedAttestationsServerMockRecorder
 }
 
-// MockBeaconChain_StreamIndexedAttestationsServerMockRecorder is the mock recorder for MockBeaconChain_StreamIndexedAttestationsServer.
+// BeaconChain_StreamIndexedAttestationsServerMockRecorder is the mock recorder for MockBeaconChain_StreamIndexedAttestationsServer.
-type MockBeaconChain_StreamIndexedAttestationsServerMockRecorder struct {
+type BeaconChain_StreamIndexedAttestationsServerMockRecorder struct {
-	mock *MockBeaconChain_StreamIndexedAttestationsServer
+	mock *BeaconChain_StreamIndexedAttestationsServer
 }
 
 // NewMockBeaconChain_StreamIndexedAttestationsServer creates a new mock instance.
-func NewMockBeaconChain_StreamIndexedAttestationsServer(ctrl *gomock.Controller) *MockBeaconChain_StreamIndexedAttestationsServer {
+func NewMockBeaconChain_StreamIndexedAttestationsServer(ctrl *gomock.Controller) *BeaconChain_StreamIndexedAttestationsServer {
-	mock := &MockBeaconChain_StreamIndexedAttestationsServer{ctrl: ctrl}
+	mock := &BeaconChain_StreamIndexedAttestationsServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconChain_StreamIndexedAttestationsServerMockRecorder{mock}
+	mock.recorder = &BeaconChain_StreamIndexedAttestationsServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) EXPECT() *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder {
+func (m *BeaconChain_StreamIndexedAttestationsServer) EXPECT() *BeaconChain_StreamIndexedAttestationsServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) Context() context.Context {
+func (m *BeaconChain_StreamIndexedAttestationsServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -536,13 +536,13 @@ func (m *MockBeaconChain_StreamIndexedAttestationsServer) Context() context.Cont
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconChain_StreamIndexedAttestationsServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconChain_StreamIndexedAttestationsServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconChain_StreamIndexedAttestationsServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamIndexedAttestationsServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -550,13 +550,13 @@ func (m *MockBeaconChain_StreamIndexedAttestationsServer) RecvMsg(arg0 interface
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamIndexedAttestationsServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconChain_StreamIndexedAttestationsServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconChain_StreamIndexedAttestationsServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) Send(arg0 *eth.IndexedAttestation) error {
+func (m *BeaconChain_StreamIndexedAttestationsServer) Send(arg0 *eth.IndexedAttestation) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -564,13 +564,13 @@ func (m *MockBeaconChain_StreamIndexedAttestationsServer) Send(arg0 *eth.Indexed
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamIndexedAttestationsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconChain_StreamIndexedAttestationsServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconChain_StreamIndexedAttestationsServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamIndexedAttestationsServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -578,13 +578,13 @@ func (m *MockBeaconChain_StreamIndexedAttestationsServer) SendHeader(arg0 metada
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamIndexedAttestationsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconChain_StreamIndexedAttestationsServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconChain_StreamIndexedAttestationsServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconChain_StreamIndexedAttestationsServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -592,13 +592,13 @@ func (m *MockBeaconChain_StreamIndexedAttestationsServer) SendMsg(arg0 interface
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamIndexedAttestationsServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconChain_StreamIndexedAttestationsServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconChain_StreamIndexedAttestationsServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconChain_StreamIndexedAttestationsServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -606,19 +606,19 @@ func (m *MockBeaconChain_StreamIndexedAttestationsServer) SetHeader(arg0 metadat
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamIndexedAttestationsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconChain_StreamIndexedAttestationsServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconChain_StreamIndexedAttestationsServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconChain_StreamIndexedAttestationsServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconChain_StreamIndexedAttestationsServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconChain_StreamIndexedAttestationsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconChain_StreamIndexedAttestationsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconChain_StreamIndexedAttestationsServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconChain_StreamIndexedAttestationsServer)(nil).SetTrailer), arg0)
 }

testing/mock/beacon_validator_client_mock.go

@@ -15,31 +15,31 @@ import (
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 )
 
-// MockBeaconNodeValidatorClient is a mock of BeaconNodeValidatorClient interface.
+// BeaconNodeValidatorClient is a mock of BeaconNodeValidatorClient interface.
-type MockBeaconNodeValidatorClient struct {
+type BeaconNodeValidatorClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidatorClientMockRecorder
+	recorder *BeaconNodeValidatorClientMockRecorder
 }
 
-// MockBeaconNodeValidatorClientMockRecorder is the mock recorder for MockBeaconNodeValidatorClient.
+// BeaconNodeValidatorClientMockRecorder is the mock recorder for MockBeaconNodeValidatorClient.
-type MockBeaconNodeValidatorClientMockRecorder struct {
+type BeaconNodeValidatorClientMockRecorder struct {
-	mock *MockBeaconNodeValidatorClient
+	mock *BeaconNodeValidatorClient
 }
 
 // NewMockBeaconNodeValidatorClient creates a new mock instance.
-func NewMockBeaconNodeValidatorClient(ctrl *gomock.Controller) *MockBeaconNodeValidatorClient {
+func NewMockBeaconNodeValidatorClient(ctrl *gomock.Controller) *BeaconNodeValidatorClient {
-	mock := &MockBeaconNodeValidatorClient{ctrl: ctrl}
+	mock := &BeaconNodeValidatorClient{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidatorClientMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidatorClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidatorClient) EXPECT() *MockBeaconNodeValidatorClientMockRecorder {
+func (m *BeaconNodeValidatorClient) EXPECT() *BeaconNodeValidatorClientMockRecorder {
 	return m.recorder
 }
 
 // AggregatedSigAndAggregationBits mocks base method.
-func (m *MockBeaconNodeValidatorClient) AggregatedSigAndAggregationBits(arg0 context.Context, arg1 *eth.AggregatedSigAndAggregationBitsRequest, arg2 ...grpc.CallOption) (*eth.AggregatedSigAndAggregationBitsResponse, error) {
+func (m *BeaconNodeValidatorClient) AggregatedSigAndAggregationBits(arg0 context.Context, arg1 *eth.AggregatedSigAndAggregationBitsRequest, arg2 ...grpc.CallOption) (*eth.AggregatedSigAndAggregationBitsResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -52,14 +52,14 @@ func (m *MockBeaconNodeValidatorClient) AggregatedSigAndAggregationBits(arg0 con
 }
 
 // AggregatedSigAndAggregationBits indicates an expected call of AggregatedSigAndAggregationBits.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) AggregatedSigAndAggregationBits(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) AggregatedSigAndAggregationBits(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregatedSigAndAggregationBits", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).AggregatedSigAndAggregationBits), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregatedSigAndAggregationBits", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).AggregatedSigAndAggregationBits), varargs...)
 }
 
 // AssignValidatorToSubnet mocks base method.
-func (m *MockBeaconNodeValidatorClient) AssignValidatorToSubnet(arg0 context.Context, arg1 *eth.AssignValidatorToSubnetRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorClient) AssignValidatorToSubnet(arg0 context.Context, arg1 *eth.AssignValidatorToSubnetRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -72,14 +72,14 @@ func (m *MockBeaconNodeValidatorClient) AssignValidatorToSubnet(arg0 context.Con
 }
 
 // AssignValidatorToSubnet indicates an expected call of AssignValidatorToSubnet.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) AssignValidatorToSubnet(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) AssignValidatorToSubnet(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignValidatorToSubnet", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).AssignValidatorToSubnet), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignValidatorToSubnet", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).AssignValidatorToSubnet), varargs...)
 }
 
 // CheckDoppelGanger mocks base method.
-func (m *MockBeaconNodeValidatorClient) CheckDoppelGanger(arg0 context.Context, arg1 *eth.DoppelGangerRequest, arg2 ...grpc.CallOption) (*eth.DoppelGangerResponse, error) {
+func (m *BeaconNodeValidatorClient) CheckDoppelGanger(arg0 context.Context, arg1 *eth.DoppelGangerRequest, arg2 ...grpc.CallOption) (*eth.DoppelGangerResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -92,14 +92,14 @@ func (m *MockBeaconNodeValidatorClient) CheckDoppelGanger(arg0 context.Context,
 }
 
 // CheckDoppelGanger indicates an expected call of CheckDoppelGanger.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) CheckDoppelGanger(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) CheckDoppelGanger(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDoppelGanger", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).CheckDoppelGanger), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDoppelGanger", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).CheckDoppelGanger), varargs...)
 }
 
 // DomainData mocks base method.
-func (m *MockBeaconNodeValidatorClient) DomainData(arg0 context.Context, arg1 *eth.DomainRequest, arg2 ...grpc.CallOption) (*eth.DomainResponse, error) {
+func (m *BeaconNodeValidatorClient) DomainData(arg0 context.Context, arg1 *eth.DomainRequest, arg2 ...grpc.CallOption) (*eth.DomainResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -112,14 +112,14 @@ func (m *MockBeaconNodeValidatorClient) DomainData(arg0 context.Context, arg1 *e
 }
 
 // DomainData indicates an expected call of DomainData.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) DomainData(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) DomainData(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainData", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).DomainData), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainData", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).DomainData), varargs...)
 }
 
 // GetAttestationData mocks base method.
-func (m *MockBeaconNodeValidatorClient) GetAttestationData(arg0 context.Context, arg1 *eth.AttestationDataRequest, arg2 ...grpc.CallOption) (*eth.AttestationData, error) {
+func (m *BeaconNodeValidatorClient) GetAttestationData(arg0 context.Context, arg1 *eth.AttestationDataRequest, arg2 ...grpc.CallOption) (*eth.AttestationData, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -132,14 +132,14 @@ func (m *MockBeaconNodeValidatorClient) GetAttestationData(arg0 context.Context,
 }
 
 // GetAttestationData indicates an expected call of GetAttestationData.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) GetAttestationData(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) GetAttestationData(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttestationData", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).GetAttestationData), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttestationData", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).GetAttestationData), varargs...)
 }
 
 // GetBeaconBlock mocks base method.
-func (m *MockBeaconNodeValidatorClient) GetBeaconBlock(arg0 context.Context, arg1 *eth.BlockRequest, arg2 ...grpc.CallOption) (*eth.GenericBeaconBlock, error) {
+func (m *BeaconNodeValidatorClient) GetBeaconBlock(arg0 context.Context, arg1 *eth.BlockRequest, arg2 ...grpc.CallOption) (*eth.GenericBeaconBlock, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -152,14 +152,14 @@ func (m *MockBeaconNodeValidatorClient) GetBeaconBlock(arg0 context.Context, arg
 }
 
 // GetBeaconBlock indicates an expected call of GetBeaconBlock.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) GetBeaconBlock(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) GetBeaconBlock(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconBlock", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).GetBeaconBlock), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconBlock", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).GetBeaconBlock), varargs...)
 }
 
 // GetDuties mocks base method.
-func (m *MockBeaconNodeValidatorClient) GetDuties(arg0 context.Context, arg1 *eth.DutiesRequest, arg2 ...grpc.CallOption) (*eth.DutiesResponse, error) {
+func (m *BeaconNodeValidatorClient) GetDuties(arg0 context.Context, arg1 *eth.DutiesRequest, arg2 ...grpc.CallOption) (*eth.DutiesResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -172,14 +172,14 @@ func (m *MockBeaconNodeValidatorClient) GetDuties(arg0 context.Context, arg1 *et
 }
 
 // GetDuties indicates an expected call of GetDuties.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) GetDuties(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) GetDuties(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDuties", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).GetDuties), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDuties", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).GetDuties), varargs...)
 }
 
 // GetFeeRecipientByPubKey mocks base method.
-func (m *MockBeaconNodeValidatorClient) GetFeeRecipientByPubKey(arg0 context.Context, arg1 *eth.FeeRecipientByPubKeyRequest, arg2 ...grpc.CallOption) (*eth.FeeRecipientByPubKeyResponse, error) {
+func (m *BeaconNodeValidatorClient) GetFeeRecipientByPubKey(arg0 context.Context, arg1 *eth.FeeRecipientByPubKeyRequest, arg2 ...grpc.CallOption) (*eth.FeeRecipientByPubKeyResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -192,14 +192,14 @@ func (m *MockBeaconNodeValidatorClient) GetFeeRecipientByPubKey(arg0 context.Con
 }
 
 // GetFeeRecipientByPubKey indicates an expected call of GetFeeRecipientByPubKey.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) GetFeeRecipientByPubKey(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) GetFeeRecipientByPubKey(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeRecipientByPubKey", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).GetFeeRecipientByPubKey), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeRecipientByPubKey", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).GetFeeRecipientByPubKey), varargs...)
 }
 
 // GetSyncCommitteeContribution mocks base method.
-func (m *MockBeaconNodeValidatorClient) GetSyncCommitteeContribution(arg0 context.Context, arg1 *eth.SyncCommitteeContributionRequest, arg2 ...grpc.CallOption) (*eth.SyncCommitteeContribution, error) {
+func (m *BeaconNodeValidatorClient) GetSyncCommitteeContribution(arg0 context.Context, arg1 *eth.SyncCommitteeContributionRequest, arg2 ...grpc.CallOption) (*eth.SyncCommitteeContribution, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -212,14 +212,14 @@ func (m *MockBeaconNodeValidatorClient) GetSyncCommitteeContribution(arg0 contex
 }
 
 // GetSyncCommitteeContribution indicates an expected call of GetSyncCommitteeContribution.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) GetSyncCommitteeContribution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) GetSyncCommitteeContribution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncCommitteeContribution", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).GetSyncCommitteeContribution), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncCommitteeContribution", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).GetSyncCommitteeContribution), varargs...)
 }
 
 // GetSyncMessageBlockRoot mocks base method.
-func (m *MockBeaconNodeValidatorClient) GetSyncMessageBlockRoot(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.SyncMessageBlockRootResponse, error) {
+func (m *BeaconNodeValidatorClient) GetSyncMessageBlockRoot(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.SyncMessageBlockRootResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -232,14 +232,14 @@ func (m *MockBeaconNodeValidatorClient) GetSyncMessageBlockRoot(arg0 context.Con
 }
 
 // GetSyncMessageBlockRoot indicates an expected call of GetSyncMessageBlockRoot.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) GetSyncMessageBlockRoot(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) GetSyncMessageBlockRoot(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncMessageBlockRoot", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).GetSyncMessageBlockRoot), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncMessageBlockRoot", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).GetSyncMessageBlockRoot), varargs...)
 }
 
 // GetSyncSubcommitteeIndex mocks base method.
-func (m *MockBeaconNodeValidatorClient) GetSyncSubcommitteeIndex(arg0 context.Context, arg1 *eth.SyncSubcommitteeIndexRequest, arg2 ...grpc.CallOption) (*eth.SyncSubcommitteeIndexResponse, error) {
+func (m *BeaconNodeValidatorClient) GetSyncSubcommitteeIndex(arg0 context.Context, arg1 *eth.SyncSubcommitteeIndexRequest, arg2 ...grpc.CallOption) (*eth.SyncSubcommitteeIndexResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -252,14 +252,14 @@ func (m *MockBeaconNodeValidatorClient) GetSyncSubcommitteeIndex(arg0 context.Co
 }
 
 // GetSyncSubcommitteeIndex indicates an expected call of GetSyncSubcommitteeIndex.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) GetSyncSubcommitteeIndex(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) GetSyncSubcommitteeIndex(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncSubcommitteeIndex", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).GetSyncSubcommitteeIndex), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncSubcommitteeIndex", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).GetSyncSubcommitteeIndex), varargs...)
 }
 
 // MultipleValidatorStatus mocks base method.
-func (m *MockBeaconNodeValidatorClient) MultipleValidatorStatus(arg0 context.Context, arg1 *eth.MultipleValidatorStatusRequest, arg2 ...grpc.CallOption) (*eth.MultipleValidatorStatusResponse, error) {
+func (m *BeaconNodeValidatorClient) MultipleValidatorStatus(arg0 context.Context, arg1 *eth.MultipleValidatorStatusRequest, arg2 ...grpc.CallOption) (*eth.MultipleValidatorStatusResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -272,14 +272,14 @@ func (m *MockBeaconNodeValidatorClient) MultipleValidatorStatus(arg0 context.Con
 }
 
 // MultipleValidatorStatus indicates an expected call of MultipleValidatorStatus.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) MultipleValidatorStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) MultipleValidatorStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultipleValidatorStatus", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).MultipleValidatorStatus), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultipleValidatorStatus", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).MultipleValidatorStatus), varargs...)
 }
 
 // PrepareBeaconProposer mocks base method.
-func (m *MockBeaconNodeValidatorClient) PrepareBeaconProposer(arg0 context.Context, arg1 *eth.PrepareBeaconProposerRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorClient) PrepareBeaconProposer(arg0 context.Context, arg1 *eth.PrepareBeaconProposerRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -292,14 +292,14 @@ func (m *MockBeaconNodeValidatorClient) PrepareBeaconProposer(arg0 context.Conte
 }
 
 // PrepareBeaconProposer indicates an expected call of PrepareBeaconProposer.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) PrepareBeaconProposer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) PrepareBeaconProposer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareBeaconProposer", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).PrepareBeaconProposer), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareBeaconProposer", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).PrepareBeaconProposer), varargs...)
 }
 
 // ProposeAttestation mocks base method.
-func (m *MockBeaconNodeValidatorClient) ProposeAttestation(arg0 context.Context, arg1 *eth.Attestation, arg2 ...grpc.CallOption) (*eth.AttestResponse, error) {
+func (m *BeaconNodeValidatorClient) ProposeAttestation(arg0 context.Context, arg1 *eth.Attestation, arg2 ...grpc.CallOption) (*eth.AttestResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -312,14 +312,14 @@ func (m *MockBeaconNodeValidatorClient) ProposeAttestation(arg0 context.Context,
 }
 
 // ProposeAttestation indicates an expected call of ProposeAttestation.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) ProposeAttestation(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) ProposeAttestation(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeAttestation", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).ProposeAttestation), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeAttestation", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).ProposeAttestation), varargs...)
 }
 
 // ProposeBeaconBlock mocks base method.
-func (m *MockBeaconNodeValidatorClient) ProposeBeaconBlock(arg0 context.Context, arg1 *eth.GenericSignedBeaconBlock, arg2 ...grpc.CallOption) (*eth.ProposeResponse, error) {
+func (m *BeaconNodeValidatorClient) ProposeBeaconBlock(arg0 context.Context, arg1 *eth.GenericSignedBeaconBlock, arg2 ...grpc.CallOption) (*eth.ProposeResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -332,14 +332,14 @@ func (m *MockBeaconNodeValidatorClient) ProposeBeaconBlock(arg0 context.Context,
 }
 
 // ProposeBeaconBlock indicates an expected call of ProposeBeaconBlock.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) ProposeBeaconBlock(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) ProposeBeaconBlock(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeBeaconBlock", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).ProposeBeaconBlock), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeBeaconBlock", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).ProposeBeaconBlock), varargs...)
 }
 
 // ProposeExit mocks base method.
-func (m *MockBeaconNodeValidatorClient) ProposeExit(arg0 context.Context, arg1 *eth.SignedVoluntaryExit, arg2 ...grpc.CallOption) (*eth.ProposeExitResponse, error) {
+func (m *BeaconNodeValidatorClient) ProposeExit(arg0 context.Context, arg1 *eth.SignedVoluntaryExit, arg2 ...grpc.CallOption) (*eth.ProposeExitResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -352,14 +352,14 @@ func (m *MockBeaconNodeValidatorClient) ProposeExit(arg0 context.Context, arg1 *
 }
 
 // ProposeExit indicates an expected call of ProposeExit.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) ProposeExit(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) ProposeExit(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeExit", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).ProposeExit), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeExit", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).ProposeExit), varargs...)
 }
 
 // StreamBlocksAltair mocks base method.
-func (m *MockBeaconNodeValidatorClient) StreamBlocksAltair(arg0 context.Context, arg1 *eth.StreamBlocksRequest, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_StreamBlocksAltairClient, error) {
+func (m *BeaconNodeValidatorClient) StreamBlocksAltair(arg0 context.Context, arg1 *eth.StreamBlocksRequest, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_StreamBlocksAltairClient, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -372,14 +372,14 @@ func (m *MockBeaconNodeValidatorClient) StreamBlocksAltair(arg0 context.Context,
 }
 
 // StreamBlocksAltair indicates an expected call of StreamBlocksAltair.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) StreamBlocksAltair(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) StreamBlocksAltair(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamBlocksAltair", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).StreamBlocksAltair), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamBlocksAltair", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).StreamBlocksAltair), varargs...)
 }
 
 // StreamDuties mocks base method.
-func (m *MockBeaconNodeValidatorClient) StreamDuties(arg0 context.Context, arg1 *eth.DutiesRequest, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_StreamDutiesClient, error) {
+func (m *BeaconNodeValidatorClient) StreamDuties(arg0 context.Context, arg1 *eth.DutiesRequest, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_StreamDutiesClient, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -392,14 +392,14 @@ func (m *MockBeaconNodeValidatorClient) StreamDuties(arg0 context.Context, arg1
 }
 
 // StreamDuties indicates an expected call of StreamDuties.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) StreamDuties(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) StreamDuties(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamDuties", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).StreamDuties), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamDuties", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).StreamDuties), varargs...)
 }
 
 // SubmitAggregateSelectionProof mocks base method.
-func (m *MockBeaconNodeValidatorClient) SubmitAggregateSelectionProof(arg0 context.Context, arg1 *eth.AggregateSelectionRequest, arg2 ...grpc.CallOption) (*eth.AggregateSelectionResponse, error) {
+func (m *BeaconNodeValidatorClient) SubmitAggregateSelectionProof(arg0 context.Context, arg1 *eth.AggregateSelectionRequest, arg2 ...grpc.CallOption) (*eth.AggregateSelectionResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -412,14 +412,14 @@ func (m *MockBeaconNodeValidatorClient) SubmitAggregateSelectionProof(arg0 conte
 }
 
 // SubmitAggregateSelectionProof indicates an expected call of SubmitAggregateSelectionProof.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) SubmitAggregateSelectionProof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) SubmitAggregateSelectionProof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAggregateSelectionProof", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).SubmitAggregateSelectionProof), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAggregateSelectionProof", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).SubmitAggregateSelectionProof), varargs...)
 }
 
 // SubmitSignedAggregateSelectionProof mocks base method.
-func (m *MockBeaconNodeValidatorClient) SubmitSignedAggregateSelectionProof(arg0 context.Context, arg1 *eth.SignedAggregateSubmitRequest, arg2 ...grpc.CallOption) (*eth.SignedAggregateSubmitResponse, error) {
+func (m *BeaconNodeValidatorClient) SubmitSignedAggregateSelectionProof(arg0 context.Context, arg1 *eth.SignedAggregateSubmitRequest, arg2 ...grpc.CallOption) (*eth.SignedAggregateSubmitResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -432,14 +432,14 @@ func (m *MockBeaconNodeValidatorClient) SubmitSignedAggregateSelectionProof(arg0
 }
 
 // SubmitSignedAggregateSelectionProof indicates an expected call of SubmitSignedAggregateSelectionProof.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) SubmitSignedAggregateSelectionProof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) SubmitSignedAggregateSelectionProof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedAggregateSelectionProof", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).SubmitSignedAggregateSelectionProof), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedAggregateSelectionProof", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).SubmitSignedAggregateSelectionProof), varargs...)
 }
 
 // SubmitSignedContributionAndProof mocks base method.
-func (m *MockBeaconNodeValidatorClient) SubmitSignedContributionAndProof(arg0 context.Context, arg1 *eth.SignedContributionAndProof, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorClient) SubmitSignedContributionAndProof(arg0 context.Context, arg1 *eth.SignedContributionAndProof, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -452,14 +452,14 @@ func (m *MockBeaconNodeValidatorClient) SubmitSignedContributionAndProof(arg0 co
 }
 
 // SubmitSignedContributionAndProof indicates an expected call of SubmitSignedContributionAndProof.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) SubmitSignedContributionAndProof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) SubmitSignedContributionAndProof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedContributionAndProof", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).SubmitSignedContributionAndProof), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedContributionAndProof", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).SubmitSignedContributionAndProof), varargs...)
 }
 
 // SubmitSyncMessage mocks base method.
-func (m *MockBeaconNodeValidatorClient) SubmitSyncMessage(arg0 context.Context, arg1 *eth.SyncCommitteeMessage, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorClient) SubmitSyncMessage(arg0 context.Context, arg1 *eth.SyncCommitteeMessage, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -472,14 +472,14 @@ func (m *MockBeaconNodeValidatorClient) SubmitSyncMessage(arg0 context.Context,
 }
 
 // SubmitSyncMessage indicates an expected call of SubmitSyncMessage.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) SubmitSyncMessage(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) SubmitSyncMessage(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSyncMessage", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).SubmitSyncMessage), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSyncMessage", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).SubmitSyncMessage), varargs...)
 }
 
 // SubmitValidatorRegistrations mocks base method.
-func (m *MockBeaconNodeValidatorClient) SubmitValidatorRegistrations(arg0 context.Context, arg1 *eth.SignedValidatorRegistrationsV1, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorClient) SubmitValidatorRegistrations(arg0 context.Context, arg1 *eth.SignedValidatorRegistrationsV1, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -492,14 +492,14 @@ func (m *MockBeaconNodeValidatorClient) SubmitValidatorRegistrations(arg0 contex
 }
 
 // SubmitValidatorRegistrations indicates an expected call of SubmitValidatorRegistrations.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) SubmitValidatorRegistrations(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) SubmitValidatorRegistrations(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitValidatorRegistrations", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).SubmitValidatorRegistrations), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitValidatorRegistrations", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).SubmitValidatorRegistrations), varargs...)
 }
 
 // SubscribeCommitteeSubnets mocks base method.
-func (m *MockBeaconNodeValidatorClient) SubscribeCommitteeSubnets(arg0 context.Context, arg1 *eth.CommitteeSubnetsSubscribeRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorClient) SubscribeCommitteeSubnets(arg0 context.Context, arg1 *eth.CommitteeSubnetsSubscribeRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -512,14 +512,14 @@ func (m *MockBeaconNodeValidatorClient) SubscribeCommitteeSubnets(arg0 context.C
 }
 
 // SubscribeCommitteeSubnets indicates an expected call of SubscribeCommitteeSubnets.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) SubscribeCommitteeSubnets(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) SubscribeCommitteeSubnets(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeCommitteeSubnets", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).SubscribeCommitteeSubnets), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeCommitteeSubnets", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).SubscribeCommitteeSubnets), varargs...)
 }
 
 // ValidatorIndex mocks base method.
-func (m *MockBeaconNodeValidatorClient) ValidatorIndex(arg0 context.Context, arg1 *eth.ValidatorIndexRequest, arg2 ...grpc.CallOption) (*eth.ValidatorIndexResponse, error) {
+func (m *BeaconNodeValidatorClient) ValidatorIndex(arg0 context.Context, arg1 *eth.ValidatorIndexRequest, arg2 ...grpc.CallOption) (*eth.ValidatorIndexResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -532,14 +532,14 @@ func (m *MockBeaconNodeValidatorClient) ValidatorIndex(arg0 context.Context, arg
 }
 
 // ValidatorIndex indicates an expected call of ValidatorIndex.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) ValidatorIndex(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) ValidatorIndex(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIndex", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).ValidatorIndex), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIndex", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).ValidatorIndex), varargs...)
 }
 
 // ValidatorStatus mocks base method.
-func (m *MockBeaconNodeValidatorClient) ValidatorStatus(arg0 context.Context, arg1 *eth.ValidatorStatusRequest, arg2 ...grpc.CallOption) (*eth.ValidatorStatusResponse, error) {
+func (m *BeaconNodeValidatorClient) ValidatorStatus(arg0 context.Context, arg1 *eth.ValidatorStatusRequest, arg2 ...grpc.CallOption) (*eth.ValidatorStatusResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -552,14 +552,14 @@ func (m *MockBeaconNodeValidatorClient) ValidatorStatus(arg0 context.Context, ar
 }
 
 // ValidatorStatus indicates an expected call of ValidatorStatus.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) ValidatorStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) ValidatorStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorStatus", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).ValidatorStatus), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorStatus", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).ValidatorStatus), varargs...)
 }
 
 // WaitForActivation mocks base method.
-func (m *MockBeaconNodeValidatorClient) WaitForActivation(arg0 context.Context, arg1 *eth.ValidatorActivationRequest, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_WaitForActivationClient, error) {
+func (m *BeaconNodeValidatorClient) WaitForActivation(arg0 context.Context, arg1 *eth.ValidatorActivationRequest, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_WaitForActivationClient, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -572,14 +572,14 @@ func (m *MockBeaconNodeValidatorClient) WaitForActivation(arg0 context.Context,
 }
 
 // WaitForActivation indicates an expected call of WaitForActivation.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) WaitForActivation(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) WaitForActivation(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForActivation", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).WaitForActivation), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForActivation", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).WaitForActivation), varargs...)
 }
 
 // WaitForChainStart mocks base method.
-func (m *MockBeaconNodeValidatorClient) WaitForChainStart(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_WaitForChainStartClient, error) {
+func (m *BeaconNodeValidatorClient) WaitForChainStart(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (eth.BeaconNodeValidator_WaitForChainStartClient, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -592,37 +592,37 @@ func (m *MockBeaconNodeValidatorClient) WaitForChainStart(arg0 context.Context,
 }
 
 // WaitForChainStart indicates an expected call of WaitForChainStart.
-func (mr *MockBeaconNodeValidatorClientMockRecorder) WaitForChainStart(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorClientMockRecorder) WaitForChainStart(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForChainStart", reflect.TypeOf((*MockBeaconNodeValidatorClient)(nil).WaitForChainStart), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForChainStart", reflect.TypeOf((*BeaconNodeValidatorClient)(nil).WaitForChainStart), varargs...)
 }
 
-// MockBeaconNodeValidator_WaitForChainStartClient is a mock of BeaconNodeValidator_WaitForChainStartClient interface.
+// BeaconNodeValidator_WaitForChainStartClient is a mock of BeaconNodeValidator_WaitForChainStartClient interface.
-type MockBeaconNodeValidator_WaitForChainStartClient struct {
+type BeaconNodeValidator_WaitForChainStartClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder
+	recorder *BeaconNodeValidator_WaitForChainStartClientMockRecorder
 }
 
-// MockBeaconNodeValidator_WaitForChainStartClientMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForChainStartClient.
+// BeaconNodeValidator_WaitForChainStartClientMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForChainStartClient.
-type MockBeaconNodeValidator_WaitForChainStartClientMockRecorder struct {
+type BeaconNodeValidator_WaitForChainStartClientMockRecorder struct {
-	mock *MockBeaconNodeValidator_WaitForChainStartClient
+	mock *BeaconNodeValidator_WaitForChainStartClient
 }
 
 // NewMockBeaconNodeValidator_WaitForChainStartClient creates a new mock instance.
-func NewMockBeaconNodeValidator_WaitForChainStartClient(ctrl *gomock.Controller) *MockBeaconNodeValidator_WaitForChainStartClient {
+func NewMockBeaconNodeValidator_WaitForChainStartClient(ctrl *gomock.Controller) *BeaconNodeValidator_WaitForChainStartClient {
-	mock := &MockBeaconNodeValidator_WaitForChainStartClient{ctrl: ctrl}
+	mock := &BeaconNodeValidator_WaitForChainStartClient{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidator_WaitForChainStartClientMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidator_WaitForChainStartClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) EXPECT() *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder {
+func (m *BeaconNodeValidator_WaitForChainStartClient) EXPECT() *BeaconNodeValidator_WaitForChainStartClientMockRecorder {
 	return m.recorder
 }
 
 // CloseSend mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) CloseSend() error {
+func (m *BeaconNodeValidator_WaitForChainStartClient) CloseSend() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseSend")
 	ret0, _ := ret[0].(error)
@@ -630,13 +630,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartClient) CloseSend() error {
 }
 
 // CloseSend indicates an expected call of CloseSend.
-func (mr *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder) CloseSend() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartClientMockRecorder) CloseSend() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartClient)(nil).CloseSend))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartClient)(nil).CloseSend))
 }
 
 // Context mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) Context() context.Context {
+func (m *BeaconNodeValidator_WaitForChainStartClient) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -644,13 +644,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartClient) Context() context.Cont
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartClientMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartClient)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartClient)(nil).Context))
 }
 
 // Header mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) Header() (metadata.MD, error) {
+func (m *BeaconNodeValidator_WaitForChainStartClient) Header() (metadata.MD, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Header")
 	ret0, _ := ret[0].(metadata.MD)
@@ -659,13 +659,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartClient) Header() (metadata.MD,
 }
 
 // Header indicates an expected call of Header.
-func (mr *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder) Header() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartClientMockRecorder) Header() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartClient)(nil).Header))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartClient)(nil).Header))
 }
 
 // Recv mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) Recv() (*eth.ChainStartResponse, error) {
+func (m *BeaconNodeValidator_WaitForChainStartClient) Recv() (*eth.ChainStartResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Recv")
 	ret0, _ := ret[0].(*eth.ChainStartResponse)
@@ -674,13 +674,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartClient) Recv() (*eth.ChainStar
 }
 
 // Recv indicates an expected call of Recv.
-func (mr *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder) Recv() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartClientMockRecorder) Recv() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartClient)(nil).Recv))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartClient)(nil).Recv))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForChainStartClient) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -688,13 +688,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartClient) RecvMsg(arg0 interface
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartClient)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartClient)(nil).RecvMsg), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForChainStartClient) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -702,13 +702,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartClient) SendMsg(arg0 interface
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartClient)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartClient)(nil).SendMsg), arg0)
 }
 
 // Trailer mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartClient) Trailer() metadata.MD {
+func (m *BeaconNodeValidator_WaitForChainStartClient) Trailer() metadata.MD {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Trailer")
 	ret0, _ := ret[0].(metadata.MD)
@@ -716,36 +716,36 @@ func (m *MockBeaconNodeValidator_WaitForChainStartClient) Trailer() metadata.MD
 }
 
 // Trailer indicates an expected call of Trailer.
-func (mr *MockBeaconNodeValidator_WaitForChainStartClientMockRecorder) Trailer() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartClientMockRecorder) Trailer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartClient)(nil).Trailer))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartClient)(nil).Trailer))
 }
 
-// MockBeaconNodeValidator_WaitForActivationClient is a mock of BeaconNodeValidator_WaitForActivationClient interface.
+// BeaconNodeValidator_WaitForActivationClient is a mock of BeaconNodeValidator_WaitForActivationClient interface.
-type MockBeaconNodeValidator_WaitForActivationClient struct {
+type BeaconNodeValidator_WaitForActivationClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidator_WaitForActivationClientMockRecorder
+	recorder *BeaconNodeValidator_WaitForActivationClientMockRecorder
 }
 
-// MockBeaconNodeValidator_WaitForActivationClientMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForActivationClient.
+// BeaconNodeValidator_WaitForActivationClientMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForActivationClient.
-type MockBeaconNodeValidator_WaitForActivationClientMockRecorder struct {
+type BeaconNodeValidator_WaitForActivationClientMockRecorder struct {
-	mock *MockBeaconNodeValidator_WaitForActivationClient
+	mock *BeaconNodeValidator_WaitForActivationClient
 }
 
 // NewMockBeaconNodeValidator_WaitForActivationClient creates a new mock instance.
-func NewMockBeaconNodeValidator_WaitForActivationClient(ctrl *gomock.Controller) *MockBeaconNodeValidator_WaitForActivationClient {
+func NewMockBeaconNodeValidator_WaitForActivationClient(ctrl *gomock.Controller) *BeaconNodeValidator_WaitForActivationClient {
-	mock := &MockBeaconNodeValidator_WaitForActivationClient{ctrl: ctrl}
+	mock := &BeaconNodeValidator_WaitForActivationClient{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidator_WaitForActivationClientMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidator_WaitForActivationClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) EXPECT() *MockBeaconNodeValidator_WaitForActivationClientMockRecorder {
+func (m *BeaconNodeValidator_WaitForActivationClient) EXPECT() *BeaconNodeValidator_WaitForActivationClientMockRecorder {
 	return m.recorder
 }
 
 // CloseSend mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) CloseSend() error {
+func (m *BeaconNodeValidator_WaitForActivationClient) CloseSend() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseSend")
 	ret0, _ := ret[0].(error)
@@ -753,13 +753,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationClient) CloseSend() error {
 }
 
 // CloseSend indicates an expected call of CloseSend.
-func (mr *MockBeaconNodeValidator_WaitForActivationClientMockRecorder) CloseSend() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationClientMockRecorder) CloseSend() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationClient)(nil).CloseSend))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationClient)(nil).CloseSend))
 }
 
 // Context mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) Context() context.Context {
+func (m *BeaconNodeValidator_WaitForActivationClient) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -767,13 +767,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationClient) Context() context.Cont
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconNodeValidator_WaitForActivationClientMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationClientMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationClient)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationClient)(nil).Context))
 }
 
 // Header mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) Header() (metadata.MD, error) {
+func (m *BeaconNodeValidator_WaitForActivationClient) Header() (metadata.MD, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Header")
 	ret0, _ := ret[0].(metadata.MD)
@@ -782,13 +782,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationClient) Header() (metadata.MD,
 }
 
 // Header indicates an expected call of Header.
-func (mr *MockBeaconNodeValidator_WaitForActivationClientMockRecorder) Header() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationClientMockRecorder) Header() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationClient)(nil).Header))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationClient)(nil).Header))
 }
 
 // Recv mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) Recv() (*eth.ValidatorActivationResponse, error) {
+func (m *BeaconNodeValidator_WaitForActivationClient) Recv() (*eth.ValidatorActivationResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Recv")
 	ret0, _ := ret[0].(*eth.ValidatorActivationResponse)
@@ -797,13 +797,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationClient) Recv() (*eth.Validator
 }
 
 // Recv indicates an expected call of Recv.
-func (mr *MockBeaconNodeValidator_WaitForActivationClientMockRecorder) Recv() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationClientMockRecorder) Recv() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationClient)(nil).Recv))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationClient)(nil).Recv))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForActivationClient) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -811,13 +811,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationClient) RecvMsg(arg0 interface
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconNodeValidator_WaitForActivationClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationClient)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationClient)(nil).RecvMsg), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForActivationClient) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -825,13 +825,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationClient) SendMsg(arg0 interface
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconNodeValidator_WaitForActivationClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationClient)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationClient)(nil).SendMsg), arg0)
 }
 
 // Trailer mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationClient) Trailer() metadata.MD {
+func (m *BeaconNodeValidator_WaitForActivationClient) Trailer() metadata.MD {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Trailer")
 	ret0, _ := ret[0].(metadata.MD)
@@ -839,36 +839,36 @@ func (m *MockBeaconNodeValidator_WaitForActivationClient) Trailer() metadata.MD
 }
 
 // Trailer indicates an expected call of Trailer.
-func (mr *MockBeaconNodeValidator_WaitForActivationClientMockRecorder) Trailer() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationClientMockRecorder) Trailer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationClient)(nil).Trailer))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationClient)(nil).Trailer))
 }
 
-// MockBeaconNodeValidator_StreamDutiesClient is a mock of BeaconNodeValidator_StreamDutiesClient interface.
+// BeaconNodeValidator_StreamDutiesClient is a mock of BeaconNodeValidator_StreamDutiesClient interface.
-type MockBeaconNodeValidator_StreamDutiesClient struct {
+type BeaconNodeValidator_StreamDutiesClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidator_StreamDutiesClientMockRecorder
+	recorder *BeaconNodeValidator_StreamDutiesClientMockRecorder
 }
 
-// MockBeaconNodeValidator_StreamDutiesClientMockRecorder is the mock recorder for MockBeaconNodeValidator_StreamDutiesClient.
+// BeaconNodeValidator_StreamDutiesClientMockRecorder is the mock recorder for MockBeaconNodeValidator_StreamDutiesClient.
-type MockBeaconNodeValidator_StreamDutiesClientMockRecorder struct {
+type BeaconNodeValidator_StreamDutiesClientMockRecorder struct {
-	mock *MockBeaconNodeValidator_StreamDutiesClient
+	mock *BeaconNodeValidator_StreamDutiesClient
 }
 
 // NewMockBeaconNodeValidator_StreamDutiesClient creates a new mock instance.
-func NewMockBeaconNodeValidator_StreamDutiesClient(ctrl *gomock.Controller) *MockBeaconNodeValidator_StreamDutiesClient {
+func NewMockBeaconNodeValidator_StreamDutiesClient(ctrl *gomock.Controller) *BeaconNodeValidator_StreamDutiesClient {
-	mock := &MockBeaconNodeValidator_StreamDutiesClient{ctrl: ctrl}
+	mock := &BeaconNodeValidator_StreamDutiesClient{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidator_StreamDutiesClientMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidator_StreamDutiesClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) EXPECT() *MockBeaconNodeValidator_StreamDutiesClientMockRecorder {
+func (m *BeaconNodeValidator_StreamDutiesClient) EXPECT() *BeaconNodeValidator_StreamDutiesClientMockRecorder {
 	return m.recorder
 }
 
 // CloseSend mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) CloseSend() error {
+func (m *BeaconNodeValidator_StreamDutiesClient) CloseSend() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseSend")
 	ret0, _ := ret[0].(error)
@@ -876,13 +876,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesClient) CloseSend() error {
 }
 
 // CloseSend indicates an expected call of CloseSend.
-func (mr *MockBeaconNodeValidator_StreamDutiesClientMockRecorder) CloseSend() *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesClientMockRecorder) CloseSend() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesClient)(nil).CloseSend))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesClient)(nil).CloseSend))
 }
 
 // Context mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) Context() context.Context {
+func (m *BeaconNodeValidator_StreamDutiesClient) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -890,13 +890,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesClient) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconNodeValidator_StreamDutiesClientMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesClientMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesClient)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesClient)(nil).Context))
 }
 
 // Header mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) Header() (metadata.MD, error) {
+func (m *BeaconNodeValidator_StreamDutiesClient) Header() (metadata.MD, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Header")
 	ret0, _ := ret[0].(metadata.MD)
@@ -905,13 +905,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesClient) Header() (metadata.MD, erro
 }
 
 // Header indicates an expected call of Header.
-func (mr *MockBeaconNodeValidator_StreamDutiesClientMockRecorder) Header() *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesClientMockRecorder) Header() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesClient)(nil).Header))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesClient)(nil).Header))
 }
 
 // Recv mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) Recv() (*eth.DutiesResponse, error) {
+func (m *BeaconNodeValidator_StreamDutiesClient) Recv() (*eth.DutiesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Recv")
 	ret0, _ := ret[0].(*eth.DutiesResponse)
@@ -920,13 +920,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesClient) Recv() (*eth.DutiesResponse
 }
 
 // Recv indicates an expected call of Recv.
-func (mr *MockBeaconNodeValidator_StreamDutiesClientMockRecorder) Recv() *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesClientMockRecorder) Recv() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesClient)(nil).Recv))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesClient)(nil).Recv))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_StreamDutiesClient) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -934,13 +934,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesClient) RecvMsg(arg0 interface{}) e
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconNodeValidator_StreamDutiesClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesClient)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesClient)(nil).RecvMsg), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_StreamDutiesClient) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -948,13 +948,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesClient) SendMsg(arg0 interface{}) e
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconNodeValidator_StreamDutiesClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesClient)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesClient)(nil).SendMsg), arg0)
 }
 
 // Trailer mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesClient) Trailer() metadata.MD {
+func (m *BeaconNodeValidator_StreamDutiesClient) Trailer() metadata.MD {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Trailer")
 	ret0, _ := ret[0].(metadata.MD)
@@ -962,7 +962,7 @@ func (m *MockBeaconNodeValidator_StreamDutiesClient) Trailer() metadata.MD {
 }
 
 // Trailer indicates an expected call of Trailer.
-func (mr *MockBeaconNodeValidator_StreamDutiesClientMockRecorder) Trailer() *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesClientMockRecorder) Trailer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesClient)(nil).Trailer))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesClient)(nil).Trailer))
 }

testing/mock/beacon_validator_server_mock.go

@@ -14,31 +14,31 @@ import (
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 )
 
-// MockBeaconNodeValidatorServer is a mock of BeaconNodeValidatorServer interface.
+// BeaconNodeValidatorServer is a mock of BeaconNodeValidatorServer interface.
-type MockBeaconNodeValidatorServer struct {
+type BeaconNodeValidatorServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidatorServerMockRecorder
+	recorder *BeaconNodeValidatorServerMockRecorder
 }
 
-// MockBeaconNodeValidatorServerMockRecorder is the mock recorder for MockBeaconNodeValidatorServer.
+// BeaconNodeValidatorServerMockRecorder is the mock recorder for MockBeaconNodeValidatorServer.
-type MockBeaconNodeValidatorServerMockRecorder struct {
+type BeaconNodeValidatorServerMockRecorder struct {
-	mock *MockBeaconNodeValidatorServer
+	mock *BeaconNodeValidatorServer
 }
 
 // NewMockBeaconNodeValidatorServer creates a new mock instance.
-func NewMockBeaconNodeValidatorServer(ctrl *gomock.Controller) *MockBeaconNodeValidatorServer {
+func NewMockBeaconNodeValidatorServer(ctrl *gomock.Controller) *BeaconNodeValidatorServer {
-	mock := &MockBeaconNodeValidatorServer{ctrl: ctrl}
+	mock := &BeaconNodeValidatorServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidatorServerMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidatorServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidatorServer) EXPECT() *MockBeaconNodeValidatorServerMockRecorder {
+func (m *BeaconNodeValidatorServer) EXPECT() *BeaconNodeValidatorServerMockRecorder {
 	return m.recorder
 }
 
 // AggregatedSigAndAggregationBits mocks base method.
-func (m *MockBeaconNodeValidatorServer) AggregatedSigAndAggregationBits(arg0 context.Context, arg1 *eth.AggregatedSigAndAggregationBitsRequest) (*eth.AggregatedSigAndAggregationBitsResponse, error) {
+func (m *BeaconNodeValidatorServer) AggregatedSigAndAggregationBits(arg0 context.Context, arg1 *eth.AggregatedSigAndAggregationBitsRequest) (*eth.AggregatedSigAndAggregationBitsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AggregatedSigAndAggregationBits", arg0, arg1)
 	ret0, _ := ret[0].(*eth.AggregatedSigAndAggregationBitsResponse)
@@ -47,13 +47,13 @@ func (m *MockBeaconNodeValidatorServer) AggregatedSigAndAggregationBits(arg0 con
 }
 
 // AggregatedSigAndAggregationBits indicates an expected call of AggregatedSigAndAggregationBits.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) AggregatedSigAndAggregationBits(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) AggregatedSigAndAggregationBits(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregatedSigAndAggregationBits", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).AggregatedSigAndAggregationBits), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregatedSigAndAggregationBits", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).AggregatedSigAndAggregationBits), arg0, arg1)
 }
 
 // AssignValidatorToSubnet mocks base method.
-func (m *MockBeaconNodeValidatorServer) AssignValidatorToSubnet(arg0 context.Context, arg1 *eth.AssignValidatorToSubnetRequest) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorServer) AssignValidatorToSubnet(arg0 context.Context, arg1 *eth.AssignValidatorToSubnetRequest) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AssignValidatorToSubnet", arg0, arg1)
 	ret0, _ := ret[0].(*emptypb.Empty)
@@ -62,13 +62,13 @@ func (m *MockBeaconNodeValidatorServer) AssignValidatorToSubnet(arg0 context.Con
 }
 
 // AssignValidatorToSubnet indicates an expected call of AssignValidatorToSubnet.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) AssignValidatorToSubnet(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) AssignValidatorToSubnet(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignValidatorToSubnet", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).AssignValidatorToSubnet), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignValidatorToSubnet", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).AssignValidatorToSubnet), arg0, arg1)
 }
 
 // CheckDoppelGanger mocks base method.
-func (m *MockBeaconNodeValidatorServer) CheckDoppelGanger(arg0 context.Context, arg1 *eth.DoppelGangerRequest) (*eth.DoppelGangerResponse, error) {
+func (m *BeaconNodeValidatorServer) CheckDoppelGanger(arg0 context.Context, arg1 *eth.DoppelGangerRequest) (*eth.DoppelGangerResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CheckDoppelGanger", arg0, arg1)
 	ret0, _ := ret[0].(*eth.DoppelGangerResponse)
@@ -77,13 +77,13 @@ func (m *MockBeaconNodeValidatorServer) CheckDoppelGanger(arg0 context.Context,
 }
 
 // CheckDoppelGanger indicates an expected call of CheckDoppelGanger.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) CheckDoppelGanger(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) CheckDoppelGanger(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDoppelGanger", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).CheckDoppelGanger), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDoppelGanger", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).CheckDoppelGanger), arg0, arg1)
 }
 
 // DomainData mocks base method.
-func (m *MockBeaconNodeValidatorServer) DomainData(arg0 context.Context, arg1 *eth.DomainRequest) (*eth.DomainResponse, error) {
+func (m *BeaconNodeValidatorServer) DomainData(arg0 context.Context, arg1 *eth.DomainRequest) (*eth.DomainResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DomainData", arg0, arg1)
 	ret0, _ := ret[0].(*eth.DomainResponse)
@@ -92,13 +92,13 @@ func (m *MockBeaconNodeValidatorServer) DomainData(arg0 context.Context, arg1 *e
 }
 
 // DomainData indicates an expected call of DomainData.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) DomainData(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) DomainData(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainData", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).DomainData), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainData", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).DomainData), arg0, arg1)
 }
 
 // GetAttestationData mocks base method.
-func (m *MockBeaconNodeValidatorServer) GetAttestationData(arg0 context.Context, arg1 *eth.AttestationDataRequest) (*eth.AttestationData, error) {
+func (m *BeaconNodeValidatorServer) GetAttestationData(arg0 context.Context, arg1 *eth.AttestationDataRequest) (*eth.AttestationData, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAttestationData", arg0, arg1)
 	ret0, _ := ret[0].(*eth.AttestationData)
@@ -107,13 +107,13 @@ func (m *MockBeaconNodeValidatorServer) GetAttestationData(arg0 context.Context,
 }
 
 // GetAttestationData indicates an expected call of GetAttestationData.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) GetAttestationData(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) GetAttestationData(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttestationData", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).GetAttestationData), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttestationData", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).GetAttestationData), arg0, arg1)
 }
 
 // GetBeaconBlock mocks base method.
-func (m *MockBeaconNodeValidatorServer) GetBeaconBlock(arg0 context.Context, arg1 *eth.BlockRequest) (*eth.GenericBeaconBlock, error) {
+func (m *BeaconNodeValidatorServer) GetBeaconBlock(arg0 context.Context, arg1 *eth.BlockRequest) (*eth.GenericBeaconBlock, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBeaconBlock", arg0, arg1)
 	ret0, _ := ret[0].(*eth.GenericBeaconBlock)
@@ -122,13 +122,13 @@ func (m *MockBeaconNodeValidatorServer) GetBeaconBlock(arg0 context.Context, arg
 }
 
 // GetBeaconBlock indicates an expected call of GetBeaconBlock.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) GetBeaconBlock(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) GetBeaconBlock(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconBlock", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).GetBeaconBlock), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconBlock", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).GetBeaconBlock), arg0, arg1)
 }
 
 // GetDuties mocks base method.
-func (m *MockBeaconNodeValidatorServer) GetDuties(arg0 context.Context, arg1 *eth.DutiesRequest) (*eth.DutiesResponse, error) {
+func (m *BeaconNodeValidatorServer) GetDuties(arg0 context.Context, arg1 *eth.DutiesRequest) (*eth.DutiesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetDuties", arg0, arg1)
 	ret0, _ := ret[0].(*eth.DutiesResponse)
@@ -137,13 +137,13 @@ func (m *MockBeaconNodeValidatorServer) GetDuties(arg0 context.Context, arg1 *et
 }
 
 // GetDuties indicates an expected call of GetDuties.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) GetDuties(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) GetDuties(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDuties", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).GetDuties), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDuties", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).GetDuties), arg0, arg1)
 }
 
 // GetFeeRecipientByPubKey mocks base method.
-func (m *MockBeaconNodeValidatorServer) GetFeeRecipientByPubKey(arg0 context.Context, arg1 *eth.FeeRecipientByPubKeyRequest) (*eth.FeeRecipientByPubKeyResponse, error) {
+func (m *BeaconNodeValidatorServer) GetFeeRecipientByPubKey(arg0 context.Context, arg1 *eth.FeeRecipientByPubKeyRequest) (*eth.FeeRecipientByPubKeyResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetFeeRecipientByPubKey", arg0, arg1)
 	ret0, _ := ret[0].(*eth.FeeRecipientByPubKeyResponse)
@@ -152,13 +152,13 @@ func (m *MockBeaconNodeValidatorServer) GetFeeRecipientByPubKey(arg0 context.Con
 }
 
 // GetFeeRecipientByPubKey indicates an expected call of GetFeeRecipientByPubKey.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) GetFeeRecipientByPubKey(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) GetFeeRecipientByPubKey(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeRecipientByPubKey", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).GetFeeRecipientByPubKey), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeRecipientByPubKey", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).GetFeeRecipientByPubKey), arg0, arg1)
 }
 
 // GetSyncCommitteeContribution mocks base method.
-func (m *MockBeaconNodeValidatorServer) GetSyncCommitteeContribution(arg0 context.Context, arg1 *eth.SyncCommitteeContributionRequest) (*eth.SyncCommitteeContribution, error) {
+func (m *BeaconNodeValidatorServer) GetSyncCommitteeContribution(arg0 context.Context, arg1 *eth.SyncCommitteeContributionRequest) (*eth.SyncCommitteeContribution, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSyncCommitteeContribution", arg0, arg1)
 	ret0, _ := ret[0].(*eth.SyncCommitteeContribution)
@@ -167,13 +167,13 @@ func (m *MockBeaconNodeValidatorServer) GetSyncCommitteeContribution(arg0 contex
 }
 
 // GetSyncCommitteeContribution indicates an expected call of GetSyncCommitteeContribution.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) GetSyncCommitteeContribution(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) GetSyncCommitteeContribution(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncCommitteeContribution", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).GetSyncCommitteeContribution), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncCommitteeContribution", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).GetSyncCommitteeContribution), arg0, arg1)
 }
 
 // GetSyncMessageBlockRoot mocks base method.
-func (m *MockBeaconNodeValidatorServer) GetSyncMessageBlockRoot(arg0 context.Context, arg1 *emptypb.Empty) (*eth.SyncMessageBlockRootResponse, error) {
+func (m *BeaconNodeValidatorServer) GetSyncMessageBlockRoot(arg0 context.Context, arg1 *emptypb.Empty) (*eth.SyncMessageBlockRootResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSyncMessageBlockRoot", arg0, arg1)
 	ret0, _ := ret[0].(*eth.SyncMessageBlockRootResponse)
@@ -182,13 +182,13 @@ func (m *MockBeaconNodeValidatorServer) GetSyncMessageBlockRoot(arg0 context.Con
 }
 
 // GetSyncMessageBlockRoot indicates an expected call of GetSyncMessageBlockRoot.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) GetSyncMessageBlockRoot(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) GetSyncMessageBlockRoot(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncMessageBlockRoot", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).GetSyncMessageBlockRoot), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncMessageBlockRoot", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).GetSyncMessageBlockRoot), arg0, arg1)
 }
 
 // GetSyncSubcommitteeIndex mocks base method.
-func (m *MockBeaconNodeValidatorServer) GetSyncSubcommitteeIndex(arg0 context.Context, arg1 *eth.SyncSubcommitteeIndexRequest) (*eth.SyncSubcommitteeIndexResponse, error) {
+func (m *BeaconNodeValidatorServer) GetSyncSubcommitteeIndex(arg0 context.Context, arg1 *eth.SyncSubcommitteeIndexRequest) (*eth.SyncSubcommitteeIndexResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSyncSubcommitteeIndex", arg0, arg1)
 	ret0, _ := ret[0].(*eth.SyncSubcommitteeIndexResponse)
@@ -197,13 +197,13 @@ func (m *MockBeaconNodeValidatorServer) GetSyncSubcommitteeIndex(arg0 context.Co
 }
 
 // GetSyncSubcommitteeIndex indicates an expected call of GetSyncSubcommitteeIndex.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) GetSyncSubcommitteeIndex(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) GetSyncSubcommitteeIndex(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncSubcommitteeIndex", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).GetSyncSubcommitteeIndex), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncSubcommitteeIndex", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).GetSyncSubcommitteeIndex), arg0, arg1)
 }
 
 // MultipleValidatorStatus mocks base method.
-func (m *MockBeaconNodeValidatorServer) MultipleValidatorStatus(arg0 context.Context, arg1 *eth.MultipleValidatorStatusRequest) (*eth.MultipleValidatorStatusResponse, error) {
+func (m *BeaconNodeValidatorServer) MultipleValidatorStatus(arg0 context.Context, arg1 *eth.MultipleValidatorStatusRequest) (*eth.MultipleValidatorStatusResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MultipleValidatorStatus", arg0, arg1)
 	ret0, _ := ret[0].(*eth.MultipleValidatorStatusResponse)
@@ -212,13 +212,13 @@ func (m *MockBeaconNodeValidatorServer) MultipleValidatorStatus(arg0 context.Con
 }
 
 // MultipleValidatorStatus indicates an expected call of MultipleValidatorStatus.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) MultipleValidatorStatus(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) MultipleValidatorStatus(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultipleValidatorStatus", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).MultipleValidatorStatus), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultipleValidatorStatus", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).MultipleValidatorStatus), arg0, arg1)
 }
 
 // PrepareBeaconProposer mocks base method.
-func (m *MockBeaconNodeValidatorServer) PrepareBeaconProposer(arg0 context.Context, arg1 *eth.PrepareBeaconProposerRequest) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorServer) PrepareBeaconProposer(arg0 context.Context, arg1 *eth.PrepareBeaconProposerRequest) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PrepareBeaconProposer", arg0, arg1)
 	ret0, _ := ret[0].(*emptypb.Empty)
@@ -227,13 +227,13 @@ func (m *MockBeaconNodeValidatorServer) PrepareBeaconProposer(arg0 context.Conte
 }
 
 // PrepareBeaconProposer indicates an expected call of PrepareBeaconProposer.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) PrepareBeaconProposer(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) PrepareBeaconProposer(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareBeaconProposer", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).PrepareBeaconProposer), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareBeaconProposer", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).PrepareBeaconProposer), arg0, arg1)
 }
 
 // ProposeAttestation mocks base method.
-func (m *MockBeaconNodeValidatorServer) ProposeAttestation(arg0 context.Context, arg1 *eth.Attestation) (*eth.AttestResponse, error) {
+func (m *BeaconNodeValidatorServer) ProposeAttestation(arg0 context.Context, arg1 *eth.Attestation) (*eth.AttestResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ProposeAttestation", arg0, arg1)
 	ret0, _ := ret[0].(*eth.AttestResponse)
@@ -242,13 +242,13 @@ func (m *MockBeaconNodeValidatorServer) ProposeAttestation(arg0 context.Context,
 }
 
 // ProposeAttestation indicates an expected call of ProposeAttestation.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) ProposeAttestation(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) ProposeAttestation(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeAttestation", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).ProposeAttestation), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeAttestation", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).ProposeAttestation), arg0, arg1)
 }
 
 // ProposeBeaconBlock mocks base method.
-func (m *MockBeaconNodeValidatorServer) ProposeBeaconBlock(arg0 context.Context, arg1 *eth.GenericSignedBeaconBlock) (*eth.ProposeResponse, error) {
+func (m *BeaconNodeValidatorServer) ProposeBeaconBlock(arg0 context.Context, arg1 *eth.GenericSignedBeaconBlock) (*eth.ProposeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ProposeBeaconBlock", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ProposeResponse)
@@ -257,13 +257,13 @@ func (m *MockBeaconNodeValidatorServer) ProposeBeaconBlock(arg0 context.Context,
 }
 
 // ProposeBeaconBlock indicates an expected call of ProposeBeaconBlock.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) ProposeBeaconBlock(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) ProposeBeaconBlock(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeBeaconBlock", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).ProposeBeaconBlock), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeBeaconBlock", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).ProposeBeaconBlock), arg0, arg1)
 }
 
 // ProposeExit mocks base method.
-func (m *MockBeaconNodeValidatorServer) ProposeExit(arg0 context.Context, arg1 *eth.SignedVoluntaryExit) (*eth.ProposeExitResponse, error) {
+func (m *BeaconNodeValidatorServer) ProposeExit(arg0 context.Context, arg1 *eth.SignedVoluntaryExit) (*eth.ProposeExitResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ProposeExit", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ProposeExitResponse)
@@ -272,13 +272,13 @@ func (m *MockBeaconNodeValidatorServer) ProposeExit(arg0 context.Context, arg1 *
 }
 
 // ProposeExit indicates an expected call of ProposeExit.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) ProposeExit(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) ProposeExit(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeExit", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).ProposeExit), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeExit", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).ProposeExit), arg0, arg1)
 }
 
 // StreamBlocksAltair mocks base method.
-func (m *MockBeaconNodeValidatorServer) StreamBlocksAltair(arg0 *eth.StreamBlocksRequest, arg1 eth.BeaconNodeValidator_StreamBlocksAltairServer) error {
+func (m *BeaconNodeValidatorServer) StreamBlocksAltair(arg0 *eth.StreamBlocksRequest, arg1 eth.BeaconNodeValidator_StreamBlocksAltairServer) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamBlocksAltair", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -286,13 +286,13 @@ func (m *MockBeaconNodeValidatorServer) StreamBlocksAltair(arg0 *eth.StreamBlock
 }
 
 // StreamBlocksAltair indicates an expected call of StreamBlocksAltair.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) StreamBlocksAltair(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) StreamBlocksAltair(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamBlocksAltair", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).StreamBlocksAltair), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamBlocksAltair", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).StreamBlocksAltair), arg0, arg1)
 }
 
 // StreamDuties mocks base method.
-func (m *MockBeaconNodeValidatorServer) StreamDuties(arg0 *eth.DutiesRequest, arg1 eth.BeaconNodeValidator_StreamDutiesServer) error {
+func (m *BeaconNodeValidatorServer) StreamDuties(arg0 *eth.DutiesRequest, arg1 eth.BeaconNodeValidator_StreamDutiesServer) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamDuties", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -300,13 +300,13 @@ func (m *MockBeaconNodeValidatorServer) StreamDuties(arg0 *eth.DutiesRequest, ar
 }
 
 // StreamDuties indicates an expected call of StreamDuties.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) StreamDuties(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) StreamDuties(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamDuties", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).StreamDuties), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamDuties", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).StreamDuties), arg0, arg1)
 }
 
 // SubmitAggregateSelectionProof mocks base method.
-func (m *MockBeaconNodeValidatorServer) SubmitAggregateSelectionProof(arg0 context.Context, arg1 *eth.AggregateSelectionRequest) (*eth.AggregateSelectionResponse, error) {
+func (m *BeaconNodeValidatorServer) SubmitAggregateSelectionProof(arg0 context.Context, arg1 *eth.AggregateSelectionRequest) (*eth.AggregateSelectionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubmitAggregateSelectionProof", arg0, arg1)
 	ret0, _ := ret[0].(*eth.AggregateSelectionResponse)
@@ -315,13 +315,13 @@ func (m *MockBeaconNodeValidatorServer) SubmitAggregateSelectionProof(arg0 conte
 }
 
 // SubmitAggregateSelectionProof indicates an expected call of SubmitAggregateSelectionProof.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) SubmitAggregateSelectionProof(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) SubmitAggregateSelectionProof(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAggregateSelectionProof", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).SubmitAggregateSelectionProof), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAggregateSelectionProof", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).SubmitAggregateSelectionProof), arg0, arg1)
 }
 
 // SubmitSignedAggregateSelectionProof mocks base method.
-func (m *MockBeaconNodeValidatorServer) SubmitSignedAggregateSelectionProof(arg0 context.Context, arg1 *eth.SignedAggregateSubmitRequest) (*eth.SignedAggregateSubmitResponse, error) {
+func (m *BeaconNodeValidatorServer) SubmitSignedAggregateSelectionProof(arg0 context.Context, arg1 *eth.SignedAggregateSubmitRequest) (*eth.SignedAggregateSubmitResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubmitSignedAggregateSelectionProof", arg0, arg1)
 	ret0, _ := ret[0].(*eth.SignedAggregateSubmitResponse)
@@ -330,13 +330,13 @@ func (m *MockBeaconNodeValidatorServer) SubmitSignedAggregateSelectionProof(arg0
 }
 
 // SubmitSignedAggregateSelectionProof indicates an expected call of SubmitSignedAggregateSelectionProof.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) SubmitSignedAggregateSelectionProof(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) SubmitSignedAggregateSelectionProof(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedAggregateSelectionProof", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).SubmitSignedAggregateSelectionProof), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedAggregateSelectionProof", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).SubmitSignedAggregateSelectionProof), arg0, arg1)
 }
 
 // SubmitSignedContributionAndProof mocks base method.
-func (m *MockBeaconNodeValidatorServer) SubmitSignedContributionAndProof(arg0 context.Context, arg1 *eth.SignedContributionAndProof) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorServer) SubmitSignedContributionAndProof(arg0 context.Context, arg1 *eth.SignedContributionAndProof) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubmitSignedContributionAndProof", arg0, arg1)
 	ret0, _ := ret[0].(*emptypb.Empty)
@@ -345,13 +345,13 @@ func (m *MockBeaconNodeValidatorServer) SubmitSignedContributionAndProof(arg0 co
 }
 
 // SubmitSignedContributionAndProof indicates an expected call of SubmitSignedContributionAndProof.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) SubmitSignedContributionAndProof(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) SubmitSignedContributionAndProof(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedContributionAndProof", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).SubmitSignedContributionAndProof), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSignedContributionAndProof", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).SubmitSignedContributionAndProof), arg0, arg1)
 }
 
 // SubmitSyncMessage mocks base method.
-func (m *MockBeaconNodeValidatorServer) SubmitSyncMessage(arg0 context.Context, arg1 *eth.SyncCommitteeMessage) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorServer) SubmitSyncMessage(arg0 context.Context, arg1 *eth.SyncCommitteeMessage) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubmitSyncMessage", arg0, arg1)
 	ret0, _ := ret[0].(*emptypb.Empty)
@@ -360,13 +360,13 @@ func (m *MockBeaconNodeValidatorServer) SubmitSyncMessage(arg0 context.Context,
 }
 
 // SubmitSyncMessage indicates an expected call of SubmitSyncMessage.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) SubmitSyncMessage(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) SubmitSyncMessage(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSyncMessage", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).SubmitSyncMessage), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSyncMessage", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).SubmitSyncMessage), arg0, arg1)
 }
 
 // SubmitValidatorRegistrations mocks base method.
-func (m *MockBeaconNodeValidatorServer) SubmitValidatorRegistrations(arg0 context.Context, arg1 *eth.SignedValidatorRegistrationsV1) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorServer) SubmitValidatorRegistrations(arg0 context.Context, arg1 *eth.SignedValidatorRegistrationsV1) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubmitValidatorRegistrations", arg0, arg1)
 	ret0, _ := ret[0].(*emptypb.Empty)
@@ -375,13 +375,13 @@ func (m *MockBeaconNodeValidatorServer) SubmitValidatorRegistrations(arg0 contex
 }
 
 // SubmitValidatorRegistrations indicates an expected call of SubmitValidatorRegistrations.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) SubmitValidatorRegistrations(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) SubmitValidatorRegistrations(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitValidatorRegistrations", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).SubmitValidatorRegistrations), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitValidatorRegistrations", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).SubmitValidatorRegistrations), arg0, arg1)
 }
 
 // SubscribeCommitteeSubnets mocks base method.
-func (m *MockBeaconNodeValidatorServer) SubscribeCommitteeSubnets(arg0 context.Context, arg1 *eth.CommitteeSubnetsSubscribeRequest) (*emptypb.Empty, error) {
+func (m *BeaconNodeValidatorServer) SubscribeCommitteeSubnets(arg0 context.Context, arg1 *eth.CommitteeSubnetsSubscribeRequest) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubscribeCommitteeSubnets", arg0, arg1)
 	ret0, _ := ret[0].(*emptypb.Empty)
@@ -390,13 +390,13 @@ func (m *MockBeaconNodeValidatorServer) SubscribeCommitteeSubnets(arg0 context.C
 }
 
 // SubscribeCommitteeSubnets indicates an expected call of SubscribeCommitteeSubnets.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) SubscribeCommitteeSubnets(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) SubscribeCommitteeSubnets(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeCommitteeSubnets", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).SubscribeCommitteeSubnets), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeCommitteeSubnets", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).SubscribeCommitteeSubnets), arg0, arg1)
 }
 
 // ValidatorIndex mocks base method.
-func (m *MockBeaconNodeValidatorServer) ValidatorIndex(arg0 context.Context, arg1 *eth.ValidatorIndexRequest) (*eth.ValidatorIndexResponse, error) {
+func (m *BeaconNodeValidatorServer) ValidatorIndex(arg0 context.Context, arg1 *eth.ValidatorIndexRequest) (*eth.ValidatorIndexResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ValidatorIndex", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ValidatorIndexResponse)
@@ -405,13 +405,13 @@ func (m *MockBeaconNodeValidatorServer) ValidatorIndex(arg0 context.Context, arg
 }
 
 // ValidatorIndex indicates an expected call of ValidatorIndex.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) ValidatorIndex(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) ValidatorIndex(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIndex", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).ValidatorIndex), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIndex", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).ValidatorIndex), arg0, arg1)
 }
 
 // ValidatorStatus mocks base method.
-func (m *MockBeaconNodeValidatorServer) ValidatorStatus(arg0 context.Context, arg1 *eth.ValidatorStatusRequest) (*eth.ValidatorStatusResponse, error) {
+func (m *BeaconNodeValidatorServer) ValidatorStatus(arg0 context.Context, arg1 *eth.ValidatorStatusRequest) (*eth.ValidatorStatusResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ValidatorStatus", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ValidatorStatusResponse)
@@ -420,13 +420,13 @@ func (m *MockBeaconNodeValidatorServer) ValidatorStatus(arg0 context.Context, ar
 }
 
 // ValidatorStatus indicates an expected call of ValidatorStatus.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) ValidatorStatus(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) ValidatorStatus(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorStatus", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).ValidatorStatus), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorStatus", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).ValidatorStatus), arg0, arg1)
 }
 
 // WaitForActivation mocks base method.
-func (m *MockBeaconNodeValidatorServer) WaitForActivation(arg0 *eth.ValidatorActivationRequest, arg1 eth.BeaconNodeValidator_WaitForActivationServer) error {
+func (m *BeaconNodeValidatorServer) WaitForActivation(arg0 *eth.ValidatorActivationRequest, arg1 eth.BeaconNodeValidator_WaitForActivationServer) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "WaitForActivation", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -434,13 +434,13 @@ func (m *MockBeaconNodeValidatorServer) WaitForActivation(arg0 *eth.ValidatorAct
 }
 
 // WaitForActivation indicates an expected call of WaitForActivation.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) WaitForActivation(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) WaitForActivation(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForActivation", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).WaitForActivation), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForActivation", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).WaitForActivation), arg0, arg1)
 }
 
 // WaitForChainStart mocks base method.
-func (m *MockBeaconNodeValidatorServer) WaitForChainStart(arg0 *emptypb.Empty, arg1 eth.BeaconNodeValidator_WaitForChainStartServer) error {
+func (m *BeaconNodeValidatorServer) WaitForChainStart(arg0 *emptypb.Empty, arg1 eth.BeaconNodeValidator_WaitForChainStartServer) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "WaitForChainStart", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -448,36 +448,36 @@ func (m *MockBeaconNodeValidatorServer) WaitForChainStart(arg0 *emptypb.Empty, a
 }
 
 // WaitForChainStart indicates an expected call of WaitForChainStart.
-func (mr *MockBeaconNodeValidatorServerMockRecorder) WaitForChainStart(arg0, arg1 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidatorServerMockRecorder) WaitForChainStart(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForChainStart", reflect.TypeOf((*MockBeaconNodeValidatorServer)(nil).WaitForChainStart), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForChainStart", reflect.TypeOf((*BeaconNodeValidatorServer)(nil).WaitForChainStart), arg0, arg1)
 }
 
-// MockBeaconNodeValidator_WaitForActivationServer is a mock of BeaconNodeValidator_WaitForActivationServer interface.
+// BeaconNodeValidator_WaitForActivationServer is a mock of BeaconNodeValidator_WaitForActivationServer interface.
-type MockBeaconNodeValidator_WaitForActivationServer struct {
+type BeaconNodeValidator_WaitForActivationServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidator_WaitForActivationServerMockRecorder
+	recorder *BeaconNodeValidator_WaitForActivationServerMockRecorder
 }
 
-// MockBeaconNodeValidator_WaitForActivationServerMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForActivationServer.
+// BeaconNodeValidator_WaitForActivationServerMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForActivationServer.
-type MockBeaconNodeValidator_WaitForActivationServerMockRecorder struct {
+type BeaconNodeValidator_WaitForActivationServerMockRecorder struct {
-	mock *MockBeaconNodeValidator_WaitForActivationServer
+	mock *BeaconNodeValidator_WaitForActivationServer
 }
 
 // NewMockBeaconNodeValidator_WaitForActivationServer creates a new mock instance.
-func NewMockBeaconNodeValidator_WaitForActivationServer(ctrl *gomock.Controller) *MockBeaconNodeValidator_WaitForActivationServer {
+func NewMockBeaconNodeValidator_WaitForActivationServer(ctrl *gomock.Controller) *BeaconNodeValidator_WaitForActivationServer {
-	mock := &MockBeaconNodeValidator_WaitForActivationServer{ctrl: ctrl}
+	mock := &BeaconNodeValidator_WaitForActivationServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidator_WaitForActivationServerMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidator_WaitForActivationServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) EXPECT() *MockBeaconNodeValidator_WaitForActivationServerMockRecorder {
+func (m *BeaconNodeValidator_WaitForActivationServer) EXPECT() *BeaconNodeValidator_WaitForActivationServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) Context() context.Context {
+func (m *BeaconNodeValidator_WaitForActivationServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -485,13 +485,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationServer) Context() context.Cont
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconNodeValidator_WaitForActivationServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForActivationServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -499,13 +499,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationServer) RecvMsg(arg0 interface
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconNodeValidator_WaitForActivationServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) Send(arg0 *eth.ValidatorActivationResponse) error {
+func (m *BeaconNodeValidator_WaitForActivationServer) Send(arg0 *eth.ValidatorActivationResponse) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -513,13 +513,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationServer) Send(arg0 *eth.Validat
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconNodeValidator_WaitForActivationServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidator_WaitForActivationServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -527,13 +527,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationServer) SendHeader(arg0 metada
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconNodeValidator_WaitForActivationServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForActivationServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -541,13 +541,13 @@ func (m *MockBeaconNodeValidator_WaitForActivationServer) SendMsg(arg0 interface
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconNodeValidator_WaitForActivationServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidator_WaitForActivationServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -555,48 +555,48 @@ func (m *MockBeaconNodeValidator_WaitForActivationServer) SetHeader(arg0 metadat
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconNodeValidator_WaitForActivationServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconNodeValidator_WaitForActivationServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconNodeValidator_WaitForActivationServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconNodeValidator_WaitForActivationServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForActivationServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconNodeValidator_WaitForActivationServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconNodeValidator_WaitForActivationServer)(nil).SetTrailer), arg0)
 }
 
-// MockBeaconNodeValidator_WaitForChainStartServer is a mock of BeaconNodeValidator_WaitForChainStartServer interface.
+// BeaconNodeValidator_WaitForChainStartServer is a mock of BeaconNodeValidator_WaitForChainStartServer interface.
-type MockBeaconNodeValidator_WaitForChainStartServer struct {
+type BeaconNodeValidator_WaitForChainStartServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder
+	recorder *BeaconNodeValidator_WaitForChainStartServerMockRecorder
 }
 
-// MockBeaconNodeValidator_WaitForChainStartServerMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForChainStartServer.
+// BeaconNodeValidator_WaitForChainStartServerMockRecorder is the mock recorder for MockBeaconNodeValidator_WaitForChainStartServer.
-type MockBeaconNodeValidator_WaitForChainStartServerMockRecorder struct {
+type BeaconNodeValidator_WaitForChainStartServerMockRecorder struct {
-	mock *MockBeaconNodeValidator_WaitForChainStartServer
+	mock *BeaconNodeValidator_WaitForChainStartServer
 }
 
 // NewMockBeaconNodeValidator_WaitForChainStartServer creates a new mock instance.
-func NewMockBeaconNodeValidator_WaitForChainStartServer(ctrl *gomock.Controller) *MockBeaconNodeValidator_WaitForChainStartServer {
+func NewMockBeaconNodeValidator_WaitForChainStartServer(ctrl *gomock.Controller) *BeaconNodeValidator_WaitForChainStartServer {
-	mock := &MockBeaconNodeValidator_WaitForChainStartServer{ctrl: ctrl}
+	mock := &BeaconNodeValidator_WaitForChainStartServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidator_WaitForChainStartServerMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidator_WaitForChainStartServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) EXPECT() *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder {
+func (m *BeaconNodeValidator_WaitForChainStartServer) EXPECT() *BeaconNodeValidator_WaitForChainStartServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) Context() context.Context {
+func (m *BeaconNodeValidator_WaitForChainStartServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -604,13 +604,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartServer) Context() context.Cont
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForChainStartServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -618,13 +618,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartServer) RecvMsg(arg0 interface
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) Send(arg0 *eth.ChainStartResponse) error {
+func (m *BeaconNodeValidator_WaitForChainStartServer) Send(arg0 *eth.ChainStartResponse) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -632,13 +632,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartServer) Send(arg0 *eth.ChainSt
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidator_WaitForChainStartServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -646,13 +646,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartServer) SendHeader(arg0 metada
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_WaitForChainStartServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -660,13 +660,13 @@ func (m *MockBeaconNodeValidator_WaitForChainStartServer) SendMsg(arg0 interface
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidator_WaitForChainStartServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -674,48 +674,48 @@ func (m *MockBeaconNodeValidator_WaitForChainStartServer) SetHeader(arg0 metadat
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconNodeValidator_WaitForChainStartServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconNodeValidator_WaitForChainStartServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconNodeValidator_WaitForChainStartServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_WaitForChainStartServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconNodeValidator_WaitForChainStartServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconNodeValidator_WaitForChainStartServer)(nil).SetTrailer), arg0)
 }
 
-// MockBeaconNodeValidator_StreamDutiesServer is a mock of BeaconNodeValidator_StreamDutiesServer interface.
+// BeaconNodeValidator_StreamDutiesServer is a mock of BeaconNodeValidator_StreamDutiesServer interface.
-type MockBeaconNodeValidator_StreamDutiesServer struct {
+type BeaconNodeValidator_StreamDutiesServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockBeaconNodeValidator_StreamDutiesServerMockRecorder
+	recorder *BeaconNodeValidator_StreamDutiesServerMockRecorder
 }
 
-// MockBeaconNodeValidator_StreamDutiesServerMockRecorder is the mock recorder for MockBeaconNodeValidator_StreamDutiesServer.
+// BeaconNodeValidator_StreamDutiesServerMockRecorder is the mock recorder for MockBeaconNodeValidator_StreamDutiesServer.
-type MockBeaconNodeValidator_StreamDutiesServerMockRecorder struct {
+type BeaconNodeValidator_StreamDutiesServerMockRecorder struct {
-	mock *MockBeaconNodeValidator_StreamDutiesServer
+	mock *BeaconNodeValidator_StreamDutiesServer
 }
 
 // NewMockBeaconNodeValidator_StreamDutiesServer creates a new mock instance.
-func NewMockBeaconNodeValidator_StreamDutiesServer(ctrl *gomock.Controller) *MockBeaconNodeValidator_StreamDutiesServer {
+func NewMockBeaconNodeValidator_StreamDutiesServer(ctrl *gomock.Controller) *BeaconNodeValidator_StreamDutiesServer {
-	mock := &MockBeaconNodeValidator_StreamDutiesServer{ctrl: ctrl}
+	mock := &BeaconNodeValidator_StreamDutiesServer{ctrl: ctrl}
-	mock.recorder = &MockBeaconNodeValidator_StreamDutiesServerMockRecorder{mock}
+	mock.recorder = &BeaconNodeValidator_StreamDutiesServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) EXPECT() *MockBeaconNodeValidator_StreamDutiesServerMockRecorder {
+func (m *BeaconNodeValidator_StreamDutiesServer) EXPECT() *BeaconNodeValidator_StreamDutiesServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) Context() context.Context {
+func (m *BeaconNodeValidator_StreamDutiesServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -723,13 +723,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesServer) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockBeaconNodeValidator_StreamDutiesServerMockRecorder) Context() *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) RecvMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_StreamDutiesServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -737,13 +737,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesServer) RecvMsg(arg0 interface{}) e
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockBeaconNodeValidator_StreamDutiesServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) Send(arg0 *eth.DutiesResponse) error {
+func (m *BeaconNodeValidator_StreamDutiesServer) Send(arg0 *eth.DutiesResponse) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -751,13 +751,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesServer) Send(arg0 *eth.DutiesRespon
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockBeaconNodeValidator_StreamDutiesServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) SendHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidator_StreamDutiesServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -765,13 +765,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesServer) SendHeader(arg0 metadata.MD
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockBeaconNodeValidator_StreamDutiesServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) SendMsg(arg0 interface{}) error {
+func (m *BeaconNodeValidator_StreamDutiesServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -779,13 +779,13 @@ func (m *MockBeaconNodeValidator_StreamDutiesServer) SendMsg(arg0 interface{}) e
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockBeaconNodeValidator_StreamDutiesServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) SetHeader(arg0 metadata.MD) error {
+func (m *BeaconNodeValidator_StreamDutiesServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -793,19 +793,19 @@ func (m *MockBeaconNodeValidator_StreamDutiesServer) SetHeader(arg0 metadata.MD)
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockBeaconNodeValidator_StreamDutiesServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockBeaconNodeValidator_StreamDutiesServer) SetTrailer(arg0 metadata.MD) {
+func (m *BeaconNodeValidator_StreamDutiesServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockBeaconNodeValidator_StreamDutiesServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *BeaconNodeValidator_StreamDutiesServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockBeaconNodeValidator_StreamDutiesServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*BeaconNodeValidator_StreamDutiesServer)(nil).SetTrailer), arg0)
 }

testing/mock/event_service_mock.go

@@ -17,30 +17,30 @@ import (
 )
 
 // MockEventsClient is a mock of EventsClient interface.
-type MockEventsClient struct {
+type EventsClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockEventsClientMockRecorder
+	recorder *EventsClientMockRecorder
 }
 
 // MockEventsClientMockRecorder is the mock recorder for MockEventsClient.
-type MockEventsClientMockRecorder struct {
+type EventsClientMockRecorder struct {
-	mock *MockEventsClient
+	mock *EventsClient
 }
 
 // NewMockEventsClient creates a new mock instance.
-func NewMockEventsClient(ctrl *gomock.Controller) *MockEventsClient {
+func NewMockEventsClient(ctrl *gomock.Controller) *EventsClient {
-	mock := &MockEventsClient{ctrl: ctrl}
+	mock := &EventsClient{ctrl: ctrl}
-	mock.recorder = &MockEventsClientMockRecorder{mock}
+	mock.recorder = &EventsClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockEventsClient) EXPECT() *MockEventsClientMockRecorder {
+func (m *EventsClient) EXPECT() *EventsClientMockRecorder {
 	return m.recorder
 }
 
 // StreamEvents mocks base method.
-func (m *MockEventsClient) StreamEvents(arg0 context.Context, arg1 *v1.StreamEventsRequest, arg2 ...grpc.CallOption) (service.Events_StreamEventsClient, error) {
+func (m *EventsClient) StreamEvents(arg0 context.Context, arg1 *v1.StreamEventsRequest, arg2 ...grpc.CallOption) (service.Events_StreamEventsClient, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -53,37 +53,37 @@ func (m *MockEventsClient) StreamEvents(arg0 context.Context, arg1 *v1.StreamEve
 }
 
 // StreamEvents indicates an expected call of StreamEvents.
-func (mr *MockEventsClientMockRecorder) StreamEvents(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *EventsClientMockRecorder) StreamEvents(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamEvents", reflect.TypeOf((*MockEventsClient)(nil).StreamEvents), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamEvents", reflect.TypeOf((*EventsClient)(nil).StreamEvents), varargs...)
 }
 
 // MockEvents_StreamEventsClient is a mock of Events_StreamEventsClient interface.
-type MockEvents_StreamEventsClient struct {
+type Events_StreamEventsClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockEvents_StreamEventsClientMockRecorder
+	recorder *Events_StreamEventsClientMockRecorder
 }
 
 // MockEvents_StreamEventsClientMockRecorder is the mock recorder for MockEvents_StreamEventsClient.
-type MockEvents_StreamEventsClientMockRecorder struct {
+type Events_StreamEventsClientMockRecorder struct {
-	mock *MockEvents_StreamEventsClient
+	mock *Events_StreamEventsClient
 }
 
 // NewMockEvents_StreamEventsClient creates a new mock instance.
-func NewMockEvents_StreamEventsClient(ctrl *gomock.Controller) *MockEvents_StreamEventsClient {
+func NewMockEvents_StreamEventsClient(ctrl *gomock.Controller) *Events_StreamEventsClient {
-	mock := &MockEvents_StreamEventsClient{ctrl: ctrl}
+	mock := &Events_StreamEventsClient{ctrl: ctrl}
-	mock.recorder = &MockEvents_StreamEventsClientMockRecorder{mock}
+	mock.recorder = &Events_StreamEventsClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockEvents_StreamEventsClient) EXPECT() *MockEvents_StreamEventsClientMockRecorder {
+func (m *Events_StreamEventsClient) EXPECT() *Events_StreamEventsClientMockRecorder {
 	return m.recorder
 }
 
 // CloseSend mocks base method.
-func (m *MockEvents_StreamEventsClient) CloseSend() error {
+func (m *Events_StreamEventsClient) CloseSend() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseSend")
 	ret0, _ := ret[0].(error)
@@ -91,13 +91,13 @@ func (m *MockEvents_StreamEventsClient) CloseSend() error {
 }
 
 // CloseSend indicates an expected call of CloseSend.
-func (mr *MockEvents_StreamEventsClientMockRecorder) CloseSend() *gomock.Call {
+func (mr *Events_StreamEventsClientMockRecorder) CloseSend() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockEvents_StreamEventsClient)(nil).CloseSend))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*Events_StreamEventsClient)(nil).CloseSend))
 }
 
 // Context mocks base method.
-func (m *MockEvents_StreamEventsClient) Context() context.Context {
+func (m *Events_StreamEventsClient) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -105,13 +105,13 @@ func (m *MockEvents_StreamEventsClient) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockEvents_StreamEventsClientMockRecorder) Context() *gomock.Call {
+func (mr *Events_StreamEventsClientMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockEvents_StreamEventsClient)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*Events_StreamEventsClient)(nil).Context))
 }
 
 // Header mocks base method.
-func (m *MockEvents_StreamEventsClient) Header() (metadata.MD, error) {
+func (m *Events_StreamEventsClient) Header() (metadata.MD, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Header")
 	ret0, _ := ret[0].(metadata.MD)
@@ -120,13 +120,13 @@ func (m *MockEvents_StreamEventsClient) Header() (metadata.MD, error) {
 }
 
 // Header indicates an expected call of Header.
-func (mr *MockEvents_StreamEventsClientMockRecorder) Header() *gomock.Call {
+func (mr *Events_StreamEventsClientMockRecorder) Header() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockEvents_StreamEventsClient)(nil).Header))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*Events_StreamEventsClient)(nil).Header))
 }
 
 // Recv mocks base method.
-func (m *MockEvents_StreamEventsClient) Recv() (*gateway.EventSource, error) {
+func (m *Events_StreamEventsClient) Recv() (*gateway.EventSource, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Recv")
 	ret0, _ := ret[0].(*gateway.EventSource)
@@ -135,13 +135,13 @@ func (m *MockEvents_StreamEventsClient) Recv() (*gateway.EventSource, error) {
 }
 
 // Recv indicates an expected call of Recv.
-func (mr *MockEvents_StreamEventsClientMockRecorder) Recv() *gomock.Call {
+func (mr *Events_StreamEventsClientMockRecorder) Recv() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockEvents_StreamEventsClient)(nil).Recv))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*Events_StreamEventsClient)(nil).Recv))
 }
 
 // RecvMsg mocks base method.
-func (m *MockEvents_StreamEventsClient) RecvMsg(arg0 interface{}) error {
+func (m *Events_StreamEventsClient) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -149,13 +149,13 @@ func (m *MockEvents_StreamEventsClient) RecvMsg(arg0 interface{}) error {
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockEvents_StreamEventsClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsClientMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockEvents_StreamEventsClient)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*Events_StreamEventsClient)(nil).RecvMsg), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockEvents_StreamEventsClient) SendMsg(arg0 interface{}) error {
+func (m *Events_StreamEventsClient) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -163,13 +163,13 @@ func (m *MockEvents_StreamEventsClient) SendMsg(arg0 interface{}) error {
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockEvents_StreamEventsClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsClientMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockEvents_StreamEventsClient)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*Events_StreamEventsClient)(nil).SendMsg), arg0)
 }
 
 // Trailer mocks base method.
-func (m *MockEvents_StreamEventsClient) Trailer() metadata.MD {
+func (m *Events_StreamEventsClient) Trailer() metadata.MD {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Trailer")
 	ret0, _ := ret[0].(metadata.MD)
@@ -177,36 +177,36 @@ func (m *MockEvents_StreamEventsClient) Trailer() metadata.MD {
 }
 
 // Trailer indicates an expected call of Trailer.
-func (mr *MockEvents_StreamEventsClientMockRecorder) Trailer() *gomock.Call {
+func (mr *Events_StreamEventsClientMockRecorder) Trailer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockEvents_StreamEventsClient)(nil).Trailer))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*Events_StreamEventsClient)(nil).Trailer))
 }
 
 // MockEvents_StreamEventsServer is a mock of Events_StreamEventsServer interface.
-type MockEvents_StreamEventsServer struct {
+type Events_StreamEventsServer struct {
 	ctrl     *gomock.Controller
-	recorder *MockEvents_StreamEventsServerMockRecorder
+	recorder *Events_StreamEventsServerMockRecorder
 }
 
 // MockEvents_StreamEventsServerMockRecorder is the mock recorder for MockEvents_StreamEventsServer.
-type MockEvents_StreamEventsServerMockRecorder struct {
+type Events_StreamEventsServerMockRecorder struct {
-	mock *MockEvents_StreamEventsServer
+	mock *Events_StreamEventsServer
 }
 
 // NewMockEvents_StreamEventsServer creates a new mock instance.
-func NewMockEvents_StreamEventsServer(ctrl *gomock.Controller) *MockEvents_StreamEventsServer {
+func NewMockEvents_StreamEventsServer(ctrl *gomock.Controller) *Events_StreamEventsServer {
-	mock := &MockEvents_StreamEventsServer{ctrl: ctrl}
+	mock := &Events_StreamEventsServer{ctrl: ctrl}
-	mock.recorder = &MockEvents_StreamEventsServerMockRecorder{mock}
+	mock.recorder = &Events_StreamEventsServerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockEvents_StreamEventsServer) EXPECT() *MockEvents_StreamEventsServerMockRecorder {
+func (m *Events_StreamEventsServer) EXPECT() *Events_StreamEventsServerMockRecorder {
 	return m.recorder
 }
 
 // Context mocks base method.
-func (m *MockEvents_StreamEventsServer) Context() context.Context {
+func (m *Events_StreamEventsServer) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
 	ret0, _ := ret[0].(context.Context)
@@ -214,13 +214,13 @@ func (m *MockEvents_StreamEventsServer) Context() context.Context {
 }
 
 // Context indicates an expected call of Context.
-func (mr *MockEvents_StreamEventsServerMockRecorder) Context() *gomock.Call {
+func (mr *Events_StreamEventsServerMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockEvents_StreamEventsServer)(nil).Context))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*Events_StreamEventsServer)(nil).Context))
 }
 
 // RecvMsg mocks base method.
-func (m *MockEvents_StreamEventsServer) RecvMsg(arg0 interface{}) error {
+func (m *Events_StreamEventsServer) RecvMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RecvMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -228,13 +228,13 @@ func (m *MockEvents_StreamEventsServer) RecvMsg(arg0 interface{}) error {
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockEvents_StreamEventsServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsServerMockRecorder) RecvMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockEvents_StreamEventsServer)(nil).RecvMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*Events_StreamEventsServer)(nil).RecvMsg), arg0)
 }
 
 // Send mocks base method.
-func (m *MockEvents_StreamEventsServer) Send(arg0 *gateway.EventSource) error {
+func (m *Events_StreamEventsServer) Send(arg0 *gateway.EventSource) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0)
 	ret0, _ := ret[0].(error)
@@ -242,13 +242,13 @@ func (m *MockEvents_StreamEventsServer) Send(arg0 *gateway.EventSource) error {
 }
 
 // Send indicates an expected call of Send.
-func (mr *MockEvents_StreamEventsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockEvents_StreamEventsServer)(nil).Send), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*Events_StreamEventsServer)(nil).Send), arg0)
 }
 
 // SendHeader mocks base method.
-func (m *MockEvents_StreamEventsServer) SendHeader(arg0 metadata.MD) error {
+func (m *Events_StreamEventsServer) SendHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -256,13 +256,13 @@ func (m *MockEvents_StreamEventsServer) SendHeader(arg0 metadata.MD) error {
 }
 
 // SendHeader indicates an expected call of SendHeader.
-func (mr *MockEvents_StreamEventsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockEvents_StreamEventsServer)(nil).SendHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*Events_StreamEventsServer)(nil).SendHeader), arg0)
 }
 
 // SendMsg mocks base method.
-func (m *MockEvents_StreamEventsServer) SendMsg(arg0 interface{}) error {
+func (m *Events_StreamEventsServer) SendMsg(arg0 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMsg", arg0)
 	ret0, _ := ret[0].(error)
@@ -270,13 +270,13 @@ func (m *MockEvents_StreamEventsServer) SendMsg(arg0 interface{}) error {
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockEvents_StreamEventsServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsServerMockRecorder) SendMsg(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockEvents_StreamEventsServer)(nil).SendMsg), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*Events_StreamEventsServer)(nil).SendMsg), arg0)
 }
 
 // SetHeader mocks base method.
-func (m *MockEvents_StreamEventsServer) SetHeader(arg0 metadata.MD) error {
+func (m *Events_StreamEventsServer) SetHeader(arg0 metadata.MD) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetHeader", arg0)
 	ret0, _ := ret[0].(error)
@@ -284,19 +284,19 @@ func (m *MockEvents_StreamEventsServer) SetHeader(arg0 metadata.MD) error {
 }
 
 // SetHeader indicates an expected call of SetHeader.
-func (mr *MockEvents_StreamEventsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockEvents_StreamEventsServer)(nil).SetHeader), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*Events_StreamEventsServer)(nil).SetHeader), arg0)
 }
 
 // SetTrailer mocks base method.
-func (m *MockEvents_StreamEventsServer) SetTrailer(arg0 metadata.MD) {
+func (m *Events_StreamEventsServer) SetTrailer(arg0 metadata.MD) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetTrailer", arg0)
 }
 
 // SetTrailer indicates an expected call of SetTrailer.
-func (mr *MockEvents_StreamEventsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
+func (mr *Events_StreamEventsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockEvents_StreamEventsServer)(nil).SetTrailer), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*Events_StreamEventsServer)(nil).SetTrailer), arg0)
 }

testing/mock/keymanager_mock.go

@@ -14,31 +14,31 @@ import (
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 )
 
-// MockRemoteSignerClient is a mock of RemoteSignerClient interface.
+// RemoteSignerClient is a mock of RemoteSignerClient interface.
-type MockRemoteSignerClient struct {
+type RemoteSignerClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockRemoteSignerClientMockRecorder
+	recorder *RemoteSignerClientMockRecorder
 }
 
-// MockRemoteSignerClientMockRecorder is the mock recorder for MockRemoteSignerClient.
+// RemoteSignerClientMockRecorder is the mock recorder for MockRemoteSignerClient.
-type MockRemoteSignerClientMockRecorder struct {
+type RemoteSignerClientMockRecorder struct {
-	mock *MockRemoteSignerClient
+	mock *RemoteSignerClient
 }
 
 // NewMockRemoteSignerClient creates a new mock instance.
-func NewMockRemoteSignerClient(ctrl *gomock.Controller) *MockRemoteSignerClient {
+func NewMockRemoteSignerClient(ctrl *gomock.Controller) *RemoteSignerClient {
-	mock := &MockRemoteSignerClient{ctrl: ctrl}
+	mock := &RemoteSignerClient{ctrl: ctrl}
-	mock.recorder = &MockRemoteSignerClientMockRecorder{mock}
+	mock.recorder = &RemoteSignerClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockRemoteSignerClient) EXPECT() *MockRemoteSignerClientMockRecorder {
+func (m *RemoteSignerClient) EXPECT() *RemoteSignerClientMockRecorder {
 	return m.recorder
 }
 
 // ListValidatingPublicKeys mocks base method.
-func (m *MockRemoteSignerClient) ListValidatingPublicKeys(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*validatorpb.ListPublicKeysResponse, error) {
+func (m *RemoteSignerClient) ListValidatingPublicKeys(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*validatorpb.ListPublicKeysResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -51,14 +51,14 @@ func (m *MockRemoteSignerClient) ListValidatingPublicKeys(arg0 context.Context,
 }
 
 // ListValidatingPublicKeys indicates an expected call of ListValidatingPublicKeys.
-func (mr *MockRemoteSignerClientMockRecorder) ListValidatingPublicKeys(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *RemoteSignerClientMockRecorder) ListValidatingPublicKeys(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidatingPublicKeys", reflect.TypeOf((*MockRemoteSignerClient)(nil).ListValidatingPublicKeys), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidatingPublicKeys", reflect.TypeOf((*RemoteSignerClient)(nil).ListValidatingPublicKeys), varargs...)
 }
 
 // Sign mocks base method.
-func (m *MockRemoteSignerClient) Sign(arg0 context.Context, arg1 *validatorpb.SignRequest, arg2 ...grpc.CallOption) (*validatorpb.SignResponse, error) {
+func (m *RemoteSignerClient) Sign(arg0 context.Context, arg1 *validatorpb.SignRequest, arg2 ...grpc.CallOption) (*validatorpb.SignResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -71,8 +71,8 @@ func (m *MockRemoteSignerClient) Sign(arg0 context.Context, arg1 *validatorpb.Si
 }
 
 // Sign indicates an expected call of Sign.
-func (mr *MockRemoteSignerClientMockRecorder) Sign(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *RemoteSignerClientMockRecorder) Sign(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sign", reflect.TypeOf((*MockRemoteSignerClient)(nil).Sign), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sign", reflect.TypeOf((*RemoteSignerClient)(nil).Sign), varargs...)
 }

testing/mock/node_service_mock.go

@@ -14,31 +14,31 @@ import (
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 )
 
-// MockNodeClient is a mock of NodeClient interface.
+// NodeClient is a mock of NodeClient interface.
-type MockNodeClient struct {
+type NodeClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockNodeClientMockRecorder
+	recorder *NodeClientMockRecorder
 }
 
-// MockNodeClientMockRecorder is the mock recorder for MockNodeClient.
+// NodeClientMockRecorder is the mock recorder for MockNodeClient.
-type MockNodeClientMockRecorder struct {
+type NodeClientMockRecorder struct {
-	mock *MockNodeClient
+	mock *NodeClient
 }
 
 // NewMockNodeClient creates a new mock instance.
-func NewMockNodeClient(ctrl *gomock.Controller) *MockNodeClient {
+func NewMockNodeClient(ctrl *gomock.Controller) *NodeClient {
-	mock := &MockNodeClient{ctrl: ctrl}
+	mock := &NodeClient{ctrl: ctrl}
-	mock.recorder = &MockNodeClientMockRecorder{mock}
+	mock.recorder = &NodeClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockNodeClient) EXPECT() *MockNodeClientMockRecorder {
+func (m *NodeClient) EXPECT() *NodeClientMockRecorder {
 	return m.recorder
 }
 
 // GetETH1ConnectionStatus mocks base method.
-func (m *MockNodeClient) GetETH1ConnectionStatus(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.ETH1ConnectionStatus, error) {
+func (m *NodeClient) GetETH1ConnectionStatus(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.ETH1ConnectionStatus, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -51,14 +51,14 @@ func (m *MockNodeClient) GetETH1ConnectionStatus(arg0 context.Context, arg1 *emp
 }
 
 // GetETH1ConnectionStatus indicates an expected call of GetETH1ConnectionStatus.
-func (mr *MockNodeClientMockRecorder) GetETH1ConnectionStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) GetETH1ConnectionStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetETH1ConnectionStatus", reflect.TypeOf((*MockNodeClient)(nil).GetETH1ConnectionStatus), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetETH1ConnectionStatus", reflect.TypeOf((*NodeClient)(nil).GetETH1ConnectionStatus), varargs...)
 }
 
 // GetGenesis mocks base method.
-func (m *MockNodeClient) GetGenesis(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.Genesis, error) {
+func (m *NodeClient) GetGenesis(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.Genesis, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -71,14 +71,14 @@ func (m *MockNodeClient) GetGenesis(arg0 context.Context, arg1 *emptypb.Empty, a
 }
 
 // GetGenesis indicates an expected call of GetGenesis.
-func (mr *MockNodeClientMockRecorder) GetGenesis(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) GetGenesis(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGenesis", reflect.TypeOf((*MockNodeClient)(nil).GetGenesis), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGenesis", reflect.TypeOf((*NodeClient)(nil).GetGenesis), varargs...)
 }
 
 // GetHost mocks base method.
-func (m *MockNodeClient) GetHost(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.HostData, error) {
+func (m *NodeClient) GetHost(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.HostData, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -91,14 +91,14 @@ func (m *MockNodeClient) GetHost(arg0 context.Context, arg1 *emptypb.Empty, arg2
 }
 
 // GetHost indicates an expected call of GetHost.
-func (mr *MockNodeClientMockRecorder) GetHost(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) GetHost(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHost", reflect.TypeOf((*MockNodeClient)(nil).GetHost), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHost", reflect.TypeOf((*NodeClient)(nil).GetHost), varargs...)
 }
 
 // GetPeer mocks base method.
-func (m *MockNodeClient) GetPeer(arg0 context.Context, arg1 *eth.PeerRequest, arg2 ...grpc.CallOption) (*eth.Peer, error) {
+func (m *NodeClient) GetPeer(arg0 context.Context, arg1 *eth.PeerRequest, arg2 ...grpc.CallOption) (*eth.Peer, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -111,14 +111,14 @@ func (m *MockNodeClient) GetPeer(arg0 context.Context, arg1 *eth.PeerRequest, ar
 }
 
 // GetPeer indicates an expected call of GetPeer.
-func (mr *MockNodeClientMockRecorder) GetPeer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) GetPeer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeer", reflect.TypeOf((*MockNodeClient)(nil).GetPeer), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeer", reflect.TypeOf((*NodeClient)(nil).GetPeer), varargs...)
 }
 
 // GetSyncStatus mocks base method.
-func (m *MockNodeClient) GetSyncStatus(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.SyncStatus, error) {
+func (m *NodeClient) GetSyncStatus(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.SyncStatus, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -131,14 +131,14 @@ func (m *MockNodeClient) GetSyncStatus(arg0 context.Context, arg1 *emptypb.Empty
 }
 
 // GetSyncStatus indicates an expected call of GetSyncStatus.
-func (mr *MockNodeClientMockRecorder) GetSyncStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) GetSyncStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncStatus", reflect.TypeOf((*MockNodeClient)(nil).GetSyncStatus), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSyncStatus", reflect.TypeOf((*NodeClient)(nil).GetSyncStatus), varargs...)
 }
 
 // GetVersion mocks base method.
-func (m *MockNodeClient) GetVersion(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.Version, error) {
+func (m *NodeClient) GetVersion(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.Version, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -151,14 +151,14 @@ func (m *MockNodeClient) GetVersion(arg0 context.Context, arg1 *emptypb.Empty, a
 }
 
 // GetVersion indicates an expected call of GetVersion.
-func (mr *MockNodeClientMockRecorder) GetVersion(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) GetVersion(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockNodeClient)(nil).GetVersion), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*NodeClient)(nil).GetVersion), varargs...)
 }
 
 // ListImplementedServices mocks base method.
-func (m *MockNodeClient) ListImplementedServices(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.ImplementedServices, error) {
+func (m *NodeClient) ListImplementedServices(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.ImplementedServices, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -171,14 +171,14 @@ func (m *MockNodeClient) ListImplementedServices(arg0 context.Context, arg1 *emp
 }
 
 // ListImplementedServices indicates an expected call of ListImplementedServices.
-func (mr *MockNodeClientMockRecorder) ListImplementedServices(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) ListImplementedServices(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImplementedServices", reflect.TypeOf((*MockNodeClient)(nil).ListImplementedServices), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImplementedServices", reflect.TypeOf((*NodeClient)(nil).ListImplementedServices), varargs...)
 }
 
 // ListPeers mocks base method.
-func (m *MockNodeClient) ListPeers(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.Peers, error) {
+func (m *NodeClient) ListPeers(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*eth.Peers, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
@@ -191,8 +191,8 @@ func (m *MockNodeClient) ListPeers(arg0 context.Context, arg1 *emptypb.Empty, ar
 }
 
 // ListPeers indicates an expected call of ListPeers.
-func (mr *MockNodeClientMockRecorder) ListPeers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *NodeClientMockRecorder) ListPeers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPeers", reflect.TypeOf((*MockNodeClient)(nil).ListPeers), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPeers", reflect.TypeOf((*NodeClient)(nil).ListPeers), varargs...)
 }

testing/slasher/simulator/simulator_test.go

@@ -34,7 +34,7 @@ func setupService(t *testing.T, params *Parameters) *Simulator {
 	err = beaconState.SetValidators(validators)
 	require.NoError(t, err)
 
-	gen := mockstategen.NewMockService()
+	gen := mockstategen.NewService()
 	gen.AddStateForRoot(beaconState, [32]byte{})
 	return &Simulator{
 		srvConfig: &ServiceConfig{

testing/spectest/shared/altair/fork/transition.go

@@ -23,7 +23,7 @@ func init() {
 	transition.SkipSlotCache.Disable()
 }
 
-type ForkConfig struct {
+type Config struct {
 	PostFork    string `json:"post_fork"`
 	ForkEpoch   int    `json:"fork_epoch"`
 	ForkBlock   *int   `json:"fork_block"`
@@ -44,7 +44,7 @@ func RunForkTransitionTest(t *testing.T, config string) {
 			helpers.ClearCache()
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
-			config := &ForkConfig{}
+			config := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
 
 			preforkBlocks := make([]*ethpb.SignedBeaconBlock, 0)

testing/spectest/shared/altair/sanity/block_processing.go

@@ -50,7 +50,7 @@ func RunBlockProcessingTest(t *testing.T, config, folderPath string) {
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
 
-			metaYaml := &SanityConfig{}
+			metaYaml := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, metaYaml), "Failed to Unmarshal")
 
 			var transitionError error

testing/spectest/shared/altair/sanity/block_processing.yaml.go

@@ -1,6 +1,6 @@
 package sanity
 
-// SanityConfig --
+// Config --
-type SanityConfig struct {
+type Config struct {
 	BlocksCount int `json:"blocks_count"`
 }

testing/spectest/shared/bellatrix/fork/transition.go

@@ -18,7 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/testing/util"
 )
 
-type ForkConfig struct {
+type Config struct {
 	PostFork    string `json:"post_fork"`
 	ForkEpoch   int    `json:"fork_epoch"`
 	ForkBlock   *int   `json:"fork_block"`
@@ -39,7 +39,7 @@ func RunForkTransitionTest(t *testing.T, config string) {
 			helpers.ClearCache()
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
-			config := &ForkConfig{}
+			config := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
 
 			preforkBlocks := make([]*ethpb.SignedBeaconBlockAltair, 0)

testing/spectest/shared/bellatrix/sanity/block_processing.go

@@ -50,7 +50,7 @@ func RunBlockProcessingTest(t *testing.T, config, folderPath string) {
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
 
-			metaYaml := &SanityConfig{}
+			metaYaml := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, metaYaml), "Failed to Unmarshal")
 
 			var transitionError error

testing/spectest/shared/bellatrix/sanity/block_processing.yaml.go

@@ -1,6 +1,6 @@
 package sanity
 
-// SanityConfig --
+// Config --
-type SanityConfig struct {
+type Config struct {
 	BlocksCount int `json:"blocks_count"`
 }

testing/spectest/shared/capella/fork/transition.go

@@ -18,7 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/testing/util"
 )
 
-type ForkConfig struct {
+type Config struct {
 	PostFork    string `json:"post_fork"`
 	ForkEpoch   int    `json:"fork_epoch"`
 	ForkBlock   *int   `json:"fork_block"`
@@ -39,7 +39,7 @@ func RunForkTransitionTest(t *testing.T, config string) {
 			helpers.ClearCache()
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
-			config := &ForkConfig{}
+			config := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
 
 			preforkBlocks := make([]*ethpb.SignedBeaconBlockBellatrix, 0)

testing/spectest/shared/capella/sanity/block_processing.go

@@ -50,7 +50,7 @@ func RunBlockProcessingTest(t *testing.T, config, folderPath string) {
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
 
-			metaYaml := &SanityConfig{}
+			metaYaml := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, metaYaml), "Failed to Unmarshal")
 
 			var transitionError error

testing/spectest/shared/capella/sanity/block_processing.yaml.go

@@ -1,6 +1,6 @@
 package sanity
 
-// SanityConfig --
+// Config --
-type SanityConfig struct {
+type Config struct {
 	BlocksCount int `json:"blocks_count"`
 }

testing/spectest/shared/deneb/fork/transition.go

@@ -18,7 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/testing/util"
 )
 
-type ForkConfig struct {
+type Config struct {
 	PostFork    string `json:"post_fork"`
 	ForkEpoch   int    `json:"fork_epoch"`
 	ForkBlock   *int   `json:"fork_block"`
@@ -36,7 +36,7 @@ func RunForkTransitionTest(t *testing.T, config string) {
 			helpers.ClearCache()
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
-			config := &ForkConfig{}
+			config := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
 
 			preforkBlocks := make([]*ethpb.SignedBeaconBlockCapella, 0)

testing/spectest/shared/deneb/sanity/block_processing.go

@@ -46,7 +46,7 @@ func RunBlockProcessingTest(t *testing.T, config, folderPath string) {
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
 
-			metaYaml := &SanityConfig{}
+			metaYaml := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, metaYaml), "Failed to Unmarshal")
 
 			var transitionError error

testing/spectest/shared/deneb/sanity/block_processing.yaml.go

@@ -1,6 +1,6 @@
 package sanity
 
-// SanityConfig --
+// Config --
-type SanityConfig struct {
+type Config struct {
 	BlocksCount int `json:"blocks_count"`
 }

testing/spectest/shared/phase0/sanity/block_processing.go

@@ -50,7 +50,7 @@ func RunBlockProcessingTest(t *testing.T, config, folderPath string) {
 			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "meta.yaml")
 			require.NoError(t, err)
 
-			metaYaml := &SanityConfig{}
+			metaYaml := &Config{}
 			require.NoError(t, utils.UnmarshalYaml(file, metaYaml), "Failed to Unmarshal")
 
 			var transitionError error