Unify GenesisValidator(s)Root throughout the codebase (#10230)

* Unify `GenesisValidator(s)Root` throughout the codebase

* comments and literals

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

beacon-chain/blockchain/chain_info.go

@@ -36,7 +36,7 @@ type TimeFetcher interface {
 
 // GenesisFetcher retrieves the Ethereum consensus data related to its genesis.
 type GenesisFetcher interface {
-	GenesisValidatorRoot() [32]byte
+	GenesisValidatorsRoot() [32]byte
 }
 
 // HeadFetcher defines a common interface for methods in blockchain service which
@@ -48,7 +48,7 @@ type HeadFetcher interface {
 	HeadState(ctx context.Context) (state.BeaconState, error)
 	HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error)
 	HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error)
-	HeadGenesisValidatorRoot() [32]byte
+	HeadGenesisValidatorsRoot() [32]byte
 	HeadETH1Data() *ethpb.Eth1Data
 	HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool)
 	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error)
@@ -214,8 +214,8 @@ func (s *Service) HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, er
 	return helpers.Seed(s.headState(ctx), epoch, params.BeaconConfig().DomainBeaconAttester)
 }
 
-// HeadGenesisValidatorRoot returns genesis validator root of the head state.
-func (s *Service) HeadGenesisValidatorRoot() [32]byte {
+// HeadGenesisValidatorsRoot returns genesis validators root of the head state.
+func (s *Service) HeadGenesisValidatorsRoot() [32]byte {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
@@ -223,7 +223,7 @@ func (s *Service) HeadGenesisValidatorRoot() [32]byte {
 		return [32]byte{}
 	}
 
-	return s.headGenesisValidatorRoot()
+	return s.headGenesisValidatorsRoot()
 }
 
 // HeadETH1Data returns the eth1data of the current head state.
@@ -247,16 +247,16 @@ func (s *Service) GenesisTime() time.Time {
 	return s.genesisTime
 }
 
-// GenesisValidatorRoot returns the genesis validator
+// GenesisValidatorsRoot returns the genesis validator
 // root of the chain.
-func (s *Service) GenesisValidatorRoot() [32]byte {
+func (s *Service) GenesisValidatorsRoot() [32]byte {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
 	if !s.hasHeadState() {
 		return [32]byte{}
 	}
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
 }
 
 // CurrentFork retrieves the latest fork information of the beacon chain.

beacon-chain/blockchain/chain_info_test.go

@@ -185,15 +185,15 @@ func TestCurrentFork_NilHeadSTate(t *testing.T) {
 	}
 }
 
-func TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
+func TestGenesisValidatorsRoot_CanRetrieve(t *testing.T) {
 	// Should not panic if head state is nil.
 	c := &Service{}
-	assert.Equal(t, [32]byte{}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+	assert.Equal(t, [32]byte{}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
 
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
 	require.NoError(t, err)
 	c.head = &head{state: s}
-	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
 }
 
 func TestHeadETH1Data_Nil(t *testing.T) {
@@ -265,17 +265,17 @@ func TestService_HeadSeed(t *testing.T) {
 	require.DeepEqual(t, seed, root)
 }
 
-func TestService_HeadGenesisValidatorRoot(t *testing.T) {
+func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 1)
 	c := &Service{}
 
 	c.head = &head{}
-	root := c.HeadGenesisValidatorRoot()
+	root := c.HeadGenesisValidatorsRoot()
 	require.Equal(t, [32]byte{}, root)
 
 	c.head = &head{state: s}
-	root = c.HeadGenesisValidatorRoot()
-	require.DeepEqual(t, root[:], s.GenesisValidatorRoot())
+	root = c.HeadGenesisValidatorsRoot()
+	require.DeepEqual(t, root[:], s.GenesisValidatorsRoot())
 }
 
 func TestService_ProtoArrayStore(t *testing.T) {

beacon-chain/blockchain/head.go

@@ -265,10 +265,10 @@ func (s *Service) headState(ctx context.Context) state.BeaconState {
 	return s.head.state.Copy()
 }
 
-// This returns the genesis validator root of the head state.
+// This returns the genesis validators root of the head state.
 // This is a lock free version.
-func (s *Service) headGenesisValidatorRoot() [32]byte {
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
+func (s *Service) headGenesisValidatorsRoot() [32]byte {
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
 }
 
 // This returns the validator referenced by the provided index in

beacon-chain/blockchain/head_sync_committee_info.go

@@ -130,7 +130,7 @@ func (s *Service) domainWithHeadState(ctx context.Context, slot types.Slot, doma
 	if err != nil {
 		return nil, err
 	}
-	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorRoot())
+	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorsRoot())
 }
 
 // returns the head state that is advanced up to `slot`. It utilizes the cache `syncCommitteeHeadState` by retrieving using `slot` as key.

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -122,7 +122,7 @@ func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncCommitteeDomain(context.Background(), 0)
@@ -136,7 +136,7 @@ func TestService_HeadSyncContributionProofDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncContributionProofDomain(context.Background(), 0)
@@ -150,7 +150,7 @@ func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncSelectionProofDomain(context.Background(), 0)

beacon-chain/blockchain/service.go

@@ -217,7 +217,7 @@ func (s *Service) startFromSavedState(saved state.BeaconState) error {
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
 			StartTime:             s.genesisTime,
-			GenesisValidatorsRoot: saved.GenesisValidatorRoot(),
+			GenesisValidatorsRoot: saved.GenesisValidatorsRoot(),
 		},
 	})
 
@@ -379,7 +379,7 @@ func (s *Service) onPowchainStart(ctx context.Context, genesisTime time.Time) {
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
 			StartTime:             genesisTime,
-			GenesisValidatorsRoot: initializedState.GenesisValidatorRoot(),
+			GenesisValidatorsRoot: initializedState.GenesisValidatorsRoot(),
 		},
 	})
 }

beacon-chain/blockchain/service_test.go

@@ -347,7 +347,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
@@ -391,7 +391,7 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
@@ -447,7 +447,7 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(headBlock.Block.Slot))
-	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, finalizedRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))

beacon-chain/blockchain/testing/mock.go

@@ -329,8 +329,8 @@ func (s *ChainService) GenesisTime() time.Time {
 	return s.Genesis
 }
 
-// GenesisValidatorRoot mocks the same method in the chain service.
-func (s *ChainService) GenesisValidatorRoot() [32]byte {
+// GenesisValidatorsRoot mocks the same method in the chain service.
+func (s *ChainService) GenesisValidatorsRoot() [32]byte {
 	return s.ValidatorsRoot
 }
 
@@ -370,8 +370,8 @@ func (s *ChainService) HasInitSyncBlock(rt [32]byte) bool {
 	return s.InitSyncBlockRoots[rt]
 }
 
-// HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
-func (_ *ChainService) HeadGenesisValidatorRoot() [32]byte {
+// HeadGenesisValidatorsRoot mocks HeadGenesisValidatorsRoot method in chain service.
+func (_ *ChainService) HeadGenesisValidatorsRoot() [32]byte {
 	return [32]byte{}
 }
 

beacon-chain/core/altair/block.go

@@ -102,7 +102,7 @@ func FilterSyncCommitteeVotes(s state.BeaconStateAltair, sync *ethpb.SyncAggrega
 // VerifySyncCommitteeSig verifies sync committee signature `syncSig` is valid with respect to public keys `syncKeys`.
 func VerifySyncCommitteeSig(s state.BeaconStateAltair, syncKeys []bls.PublicKey, syncSig []byte) error {
 	ps := slots.PrevSlot(s.Slot())
-	d, err := signing.Domain(s.Fork(), slots.ToEpoch(ps), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorRoot())
+	d, err := signing.Domain(s.Fork(), slots.ToEpoch(ps), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}

beacon-chain/core/altair/upgrade.go

@@ -68,7 +68,7 @@ func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.Beacon
 	numValidators := state.NumValidators()
 	s := &ethpb.BeaconStateAltair{
 		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: state.GenesisValidatorRoot(),
+		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
 		Slot:                  state.Slot(),
 		Fork: &ethpb.Fork{
 			PreviousVersion: state.Fork().CurrentVersion,

beacon-chain/core/altair/upgrade_test.go

@@ -77,7 +77,7 @@ func TestUpgradeToAltair(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, preForkState.GenesisTime(), aState.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorRoot(), aState.GenesisValidatorRoot())
+	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), aState.GenesisValidatorsRoot())
 	require.Equal(t, preForkState.Slot(), aState.Slot())
 	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), aState.LatestBlockHeader())
 	require.DeepSSZEqual(t, preForkState.BlockRoots(), aState.BlockRoots())

beacon-chain/core/blocks/attestation.go

@@ -208,7 +208,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBea
 		beaconState.Fork(),
 		indexedAtt.Data.Target.Epoch,
 		params.BeaconConfig().DomainBeaconAttester,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	if err != nil {
 		return err

beacon-chain/core/blocks/attestation_test.go

@@ -417,7 +417,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 			Slot: 1,
 		},
 	})
-	prevDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	prevDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, prevDomain)
 	require.NoError(t, err)
@@ -437,7 +437,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 			CommitteeIndex: 1,
 		},
 	})
-	currDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	currDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err = signing.ComputeSigningRoot(att2.Data, currDomain)
 	require.NoError(t, err)
@@ -476,7 +476,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 			Slot: 1,
 		},
 	})
-	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err)
@@ -540,7 +540,7 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 			Slot: 1,
 		},
 	})
-	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err)

beacon-chain/core/blocks/attester_slashing_test.go

@@ -108,7 +108,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")
@@ -177,7 +177,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")
@@ -246,7 +246,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")

beacon-chain/core/blocks/block_regression_test.go

@@ -44,7 +44,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 		AttestingIndices: setA,
 		Signature:        make([]byte, 96),
 	}
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err, "Could not get signing root of beacon block header")

beacon-chain/core/blocks/exit.go

@@ -57,7 +57,7 @@ func ProcessVoluntaryExits(
 		if err != nil {
 			return nil, err
 		}
-		if err := VerifyExitAndSignature(val, beaconState.Slot(), beaconState.Fork(), exit, beaconState.GenesisValidatorRoot()); err != nil {
+		if err := VerifyExitAndSignature(val, beaconState.Slot(), beaconState.Fork(), exit, beaconState.GenesisValidatorsRoot()); err != nil {
 			return nil, errors.Wrapf(err, "could not verify exit %d", idx)
 		}
 		beaconState, err = v.InitiateValidatorExit(ctx, beaconState, exit.Exit.ValidatorIndex)

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -378,7 +378,7 @@ func TestVerifyProposerSlashing(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 
 			sk := sks[tt.args.slashing.Header_1.Header.ProposerIndex]
-			d, err := signing.Domain(tt.args.beaconState.Fork(), slots.ToEpoch(tt.args.slashing.Header_1.Header.Slot), params.BeaconConfig().DomainBeaconProposer, tt.args.beaconState.GenesisValidatorRoot())
+			d, err := signing.Domain(tt.args.beaconState.Fork(), slots.ToEpoch(tt.args.slashing.Header_1.Header.Slot), params.BeaconConfig().DomainBeaconProposer, tt.args.beaconState.GenesisValidatorsRoot())
 			require.NoError(t, err)
 			if tt.args.slashing.Header_1.Signature == nil {
 				sr, err := signing.ComputeSigningRoot(tt.args.slashing.Header_1.Header, d)

beacon-chain/core/blocks/randao_test.go

@@ -26,7 +26,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	epoch := types.Epoch(0)
 	buf := make([]byte, 32)
 	binary.LittleEndian.PutUint64(buf, uint64(epoch))
-	domain, err := signing.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := (&ethpb.SigningData{ObjectRoot: buf, Domain: domain}).HashTreeRoot()
 	require.NoError(t, err)

beacon-chain/core/blocks/signature.go

@@ -68,7 +68,7 @@ func VerifyBlockSignature(beaconState state.ReadOnlyBeaconState,
 	sig []byte,
 	rootFunc func() ([32]byte, error)) error {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -83,7 +83,7 @@ func VerifyBlockSignature(beaconState state.ReadOnlyBeaconState,
 // VerifyBlockHeaderSignature verifies the proposer signature of a beacon block header.
 func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.SignedBeaconBlockHeader) error {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -104,7 +104,7 @@ func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState,
 	if err != nil {
 		return err
 	}
-	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -122,7 +122,7 @@ func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
 	sig []byte,
 	rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}
@@ -164,7 +164,7 @@ func randaoSigningData(ctx context.Context, beaconState state.ReadOnlyBeaconStat
 	buf := make([]byte, 32)
 	binary.LittleEndian.PutUint64(buf, uint64(currentEpoch))
 
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -231,7 +231,7 @@ func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBe
 	}
 
 	fork := beaconState.Fork()
-	gvr := beaconState.GenesisValidatorRoot()
+	gvr := beaconState.GenesisValidatorsRoot()
 	dt := params.BeaconConfig().DomainBeaconAttester
 
 	// Split attestations by fork. Note: the signature domain will differ based on the fork.

beacon-chain/core/blocks/signature_test.go

@@ -41,7 +41,7 @@ func TestVerifyBlockHeaderSignature(t *testing.T) {
 		beaconState.Fork(),
 		0,
 		params.BeaconConfig().DomainBeaconProposer,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	require.NoError(t, err)
 	htr, err := blockHeader.Header.HashTreeRoot()
@@ -77,7 +77,7 @@ func TestVerifyBlockSignatureUsingCurrentFork(t *testing.T) {
 		CurrentVersion:  params.BeaconConfig().AltairForkVersion,
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 	}
-	domain, err := signing.Domain(fData, 100, params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorRoot())
+	domain, err := signing.Domain(fData, 100, params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorsRoot())
 	assert.NoError(t, err)
 	rt, err := signing.ComputeSigningRoot(altairBlk.Block, domain)
 	assert.NoError(t, err)

beacon-chain/core/execution/upgrade.go

@@ -38,7 +38,7 @@ func UpgradeToBellatrix(ctx context.Context, state state.BeaconState) (state.Bea
 
 	s := &ethpb.BeaconStateBellatrix{
 		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: state.GenesisValidatorRoot(),
+		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
 		Slot:                  state.Slot(),
 		Fork: &ethpb.Fork{
 			PreviousVersion: state.Fork().CurrentVersion,

beacon-chain/core/execution/upgrade_test.go

@@ -19,7 +19,7 @@ func TestUpgradeToBellatrix(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorRoot(), mSt.GenesisValidatorRoot())
+	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), mSt.GenesisValidatorsRoot())
 	require.Equal(t, preForkState.Slot(), mSt.Slot())
 	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
 	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())

beacon-chain/core/signing/signing_root.go

@@ -23,7 +23,7 @@ var ErrSigFailedToVerify = errors.New("signature did not verify")
 
 // ComputeDomainAndSign computes the domain and signing root and sign it using the passed in private key.
 func ComputeDomainAndSign(st state.ReadOnlyBeaconState, epoch types.Epoch, obj fssz.HashRoot, domain [4]byte, key bls.SecretKey) ([]byte, error) {
-	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
+	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}
@@ -69,7 +69,7 @@ func ComputeDomainVerifySigningRoot(st state.ReadOnlyBeaconState, index types.Va
 	if err != nil {
 		return err
 	}
-	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
+	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -219,7 +219,7 @@ func computeForkDataRoot(version, root []byte) ([32]byte, error) {
 	return r, nil
 }
 
-// ComputeForkDigest returns the fork for the current version and genesis validator root
+// ComputeForkDigest returns the fork for the current version and genesis validators root
 //
 // Spec pseudocode definition:
 //	def compute_fork_digest(current_version: Version, genesis_validators_root: Root) -> ForkDigest:

beacon-chain/core/transition/transition_test.go

@@ -253,7 +253,7 @@ func createFullBlockWithOperations(t *testing.T) (state.BeaconState,
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err)

beacon-chain/p2p/pubsub.go

@@ -98,7 +98,7 @@ func (s *Service) PublishToTopic(ctx context.Context, topic string, data []byte,
 
 // SubscribeToTopic joins (if necessary) and subscribes to PubSub topic.
 func (s *Service) SubscribeToTopic(topic string, opts ...pubsub.SubOpt) (*pubsub.Subscription, error) {
-	s.awaitStateInitialized() // Genesis time and genesis validator root are required to subscribe.
+	s.awaitStateInitialized() // Genesis time and genesis validators root are required to subscribe.
 
 	topicHandle, err := s.JoinTopic(topic)
 	if err != nil {

beacon-chain/p2p/service.go

@@ -490,7 +490,7 @@ func (s *Service) connectToBootnodes() error {
 	return nil
 }
 
-// Returns true if the service is aware of the genesis time and genesis validator root. This is
+// Returns true if the service is aware of the genesis time and genesis validators root. This is
 // required for discovery and pubsub validation.
 func (s *Service) isInitialized() bool {
 	return !s.genesisTime.IsZero() && len(s.genesisValidatorsRoot) == 32

beacon-chain/p2p/service_test.go

@@ -306,7 +306,7 @@ func TestService_JoinLeaveTopic(t *testing.T) {
 // digest associated with that genesis event.
 func initializeStateWithForkDigest(ctx context.Context, t *testing.T, ef *event.Feed) [4]byte {
 	gt := prysmTime.Now()
-	gvr := bytesutil.PadTo([]byte("genesis validator root"), 32)
+	gvr := bytesutil.PadTo([]byte("genesis validators root"), 32)
 	for n := 0; n == 0; {
 		if ctx.Err() != nil {
 			t.Fatal(ctx.Err())

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

@@ -275,7 +275,7 @@ func (bs *Server) SubmitVoluntaryExit(ctx context.Context, req *ethpbv1.SignedVo
 		return nil, status.Errorf(codes.Internal, "Could not get exiting validator: %v", err)
 	}
 	alphaExit := migration.V1ExitToV1Alpha1(req)
-	err = blocks.VerifyExitAndSignature(validator, headState.Slot(), headState.Fork(), alphaExit, headState.GenesisValidatorRoot())
+	err = blocks.VerifyExitAndSignature(validator, headState.Slot(), headState.Fork(), alphaExit, headState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, status.Errorf(codes.InvalidArgument, "Invalid voluntary exit: %v", err)
 	}

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

@@ -34,7 +34,7 @@ func (bs *Server) GetGenesis(ctx context.Context, _ *emptypb.Empty) (*ethpb.Gene
 	if genesisTime.IsZero() {
 		return nil, status.Errorf(codes.NotFound, "Chain genesis info is not yet known")
 	}
-	validatorRoot := bs.ChainInfoFetcher.GenesisValidatorRoot()
+	validatorRoot := bs.ChainInfoFetcher.GenesisValidatorsRoot()
 	if bytes.Equal(validatorRoot[:], params.BeaconConfig().ZeroHash[:]) {
 		return nil, status.Errorf(codes.NotFound, "Chain genesis info is not yet known")
 	}

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

@@ -56,7 +56,7 @@ func TestGetGenesis(t *testing.T) {
 		assert.ErrorContains(t, "Chain genesis info is not yet known", err)
 	})
 
-	t.Run("No genesis validator root", func(t *testing.T) {
+	t.Run("No genesis validators root", func(t *testing.T) {
 		chainService := &chainMock.ChainService{
 			Genesis:        genesis,
 			ValidatorsRoot: [32]byte{},

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

@@ -910,7 +910,7 @@ func TestServer_StreamIndexedAttestations_OK(t *testing.T) {
 					},
 				},
 			}
-			domain, err := signing.Domain(headState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, headState.GenesisValidatorRoot())
+			domain, err := signing.Domain(headState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, headState.GenesisValidatorsRoot())
 			require.NoError(t, err)
 			encoded, err := signing.ComputeSigningRoot(attExample.Data, domain)
 			require.NoError(t, err)

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

@@ -68,7 +68,7 @@ func (ns *Server) GetGenesis(ctx context.Context, _ *empty.Empty) (*ethpb.Genesi
 		gt = timestamppb.New(genesisTime)
 	}
 
-	genValRoot := ns.GenesisFetcher.GenesisValidatorRoot()
+	genValRoot := ns.GenesisFetcher.GenesisValidatorsRoot()
 	return &ethpb.Genesis{
 		GenesisTime:            gt,
 		DepositContractAddress: contractAddr,

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

@@ -34,7 +34,7 @@ func (vs *Server) ProposeExit(ctx context.Context, req *ethpb.SignedVoluntaryExi
 		return nil, status.Error(codes.InvalidArgument, "validator index exceeds validator set length")
 	}
 
-	if err := blocks.VerifyExitAndSignature(val, s.Slot(), s.Fork(), req, s.GenesisValidatorRoot()); err != nil {
+	if err := blocks.VerifyExitAndSignature(val, s.Slot(), s.Fork(), req, s.GenesisValidatorsRoot()); err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 

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

@@ -144,7 +144,7 @@ func (vs *Server) buildPhase0BlockData(ctx context.Context, req *ethpb.BlockRequ
 			log.WithError(err).Warn("Proposer: invalid exit")
 			continue
 		}
-		if err := blocks.VerifyExitAndSignature(val, head.Slot(), head.Fork(), exit, head.GenesisValidatorRoot()); err != nil {
+		if err := blocks.VerifyExitAndSignature(val, head.Slot(), head.Fork(), exit, head.GenesisValidatorsRoot()); err != nil {
 			log.WithError(err).Warn("Proposer: invalid exit")
 			continue
 		}

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

@@ -1830,7 +1830,7 @@ func TestProposer_FilterAttestation(t *testing.T) {
 
 	numValidators := uint64(64)
 	state, privKeys := util.DeterministicGenesisState(t, numValidators)
-	require.NoError(t, state.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, state.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	assert.NoError(t, state.SetSlot(1))
 
 	genesisRoot, err := genesis.Block.HashTreeRoot()

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

@@ -127,8 +127,8 @@ func (vs *Server) DomainData(_ context.Context, request *ethpb.DomainRequest) (*
 	if err != nil {
 		return nil, err
 	}
-	headGenesisValidatorRoot := vs.HeadFetcher.HeadGenesisValidatorRoot()
-	dv, err := signing.Domain(fork, request.Epoch, bytesutil.ToBytes4(request.Domain), headGenesisValidatorRoot[:])
+	headGenesisValidatorsRoot := vs.HeadFetcher.HeadGenesisValidatorsRoot()
+	dv, err := signing.Domain(fork, request.Epoch, bytesutil.ToBytes4(request.Domain), headGenesisValidatorsRoot[:])
 	if err != nil {
 		return nil, err
 	}
@@ -164,7 +164,7 @@ func (vs *Server) WaitForChainStart(_ *emptypb.Empty, stream ethpb.BeaconNodeVal
 		res := &ethpb.ChainStartResponse{
 			Started:               true,
 			GenesisTime:           head.GenesisTime(),
-			GenesisValidatorsRoot: head.GenesisValidatorRoot(),
+			GenesisValidatorsRoot: head.GenesisValidatorsRoot(),
 		}
 		return stream.Send(res)
 	}

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

@@ -297,7 +297,7 @@ func TestWaitForChainStart_AlreadyStarted(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(3))
 	genesisValidatorsRoot := bytesutil.ToBytes32([]byte("validators"))
-	require.NoError(t, st.SetGenesisValidatorRoot(genesisValidatorsRoot[:]))
+	require.NoError(t, st.SetGenesisValidatorsRoot(genesisValidatorsRoot[:]))
 
 	chainService := &mockChain.ChainService{State: st, ValidatorsRoot: genesisValidatorsRoot}
 	Server := &Server{
@@ -323,7 +323,7 @@ func TestWaitForChainStart_AlreadyStarted(t *testing.T) {
 }
 
 func TestWaitForChainStart_HeadStateDoesNotExist(t *testing.T) {
-	genesisValidatorRoot := params.BeaconConfig().ZeroHash
+	genesisValidatorsRoot := params.BeaconConfig().ZeroHash
 
 	// Set head state to nil
 	chainService := &mockChain.ChainService{State: nil}
@@ -353,7 +353,7 @@ func TestWaitForChainStart_HeadStateDoesNotExist(t *testing.T) {
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
 			StartTime:             time.Unix(0, 0),
-			GenesisValidatorsRoot: genesisValidatorRoot[:],
+			GenesisValidatorsRoot: genesisValidatorsRoot[:],
 		},
 	})
 	util.WaitTimeout(wg, time.Second)

beacon-chain/slasher/detect_attestations_test.go

@@ -215,7 +215,7 @@ func Test_processQueuedAttestations(t *testing.T) {
 				beaconState.Fork(),
 				0,
 				params.BeaconConfig().DomainBeaconAttester,
-				beaconState.GenesisValidatorRoot(),
+				beaconState.GenesisValidatorsRoot(),
 			)
 			require.NoError(t, err)
 

beacon-chain/slasher/detect_blocks_test.go

@@ -48,7 +48,7 @@ func Test_processQueuedBlocks_DetectsDoubleProposals(t *testing.T) {
 		beaconState.Fork(),
 		0,
 		params.BeaconConfig().DomainBeaconProposer,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	require.NoError(t, err)
 

beacon-chain/slasher/process_slashings_test.go

@@ -61,7 +61,7 @@ func TestService_processAttesterSlashings(t *testing.T) {
 		beaconState.Fork(),
 		0,
 		params.BeaconConfig().DomainBeaconAttester,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(firstAtt.Data, domain)
@@ -180,7 +180,7 @@ func TestService_processProposerSlashings(t *testing.T) {
 		beaconState.Fork(),
 		0,
 		params.BeaconConfig().DomainBeaconProposer,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	require.NoError(t, err)
 	htr, err := firstBlockHeader.Header.HashTreeRoot()

beacon-chain/state/phase0.go

@@ -42,7 +42,7 @@ type ReadOnlyBeaconState interface {
 	InnerStateUnsafe() interface{}
 	CloneInnerState() interface{}
 	GenesisTime() uint64
-	GenesisValidatorRoot() []byte
+	GenesisValidatorsRoot() []byte
 	Slot() types.Slot
 	Fork() *ethpb.Fork
 	LatestBlockHeader() *ethpb.BeaconBlockHeader
@@ -66,7 +66,7 @@ type WriteOnlyBeaconState interface {
 	WriteOnlyCheckpoint
 	WriteOnlyAttestations
 	SetGenesisTime(val uint64) error
-	SetGenesisValidatorRoot(val []byte) error
+	SetGenesisValidatorsRoot(val []byte) error
 	SetSlot(val types.Slot) error
 	SetFork(val *ethpb.Fork) error
 	SetLatestBlockHeader(val *ethpb.BeaconBlockHeader) error

beacon-chain/state/state-native/v1/getters_misc.go

@@ -14,8 +14,8 @@ func (b *BeaconState) GenesisTime() uint64 {
 	return b.genesisTime
 }
 
-// GenesisValidatorRoot of the beacon state.
-func (b *BeaconState) GenesisValidatorRoot() []byte {
+// GenesisValidatorsRoot of the beacon state.
+func (b *BeaconState) GenesisValidatorsRoot() []byte {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 

beacon-chain/state/state-native/v1/setters_misc.go

@@ -51,16 +51,16 @@ func (b *BeaconState) SetGenesisTime(val uint64) error {
 	return nil
 }
 
-// SetGenesisValidatorRoot for the beacon state.
-func (b *BeaconState) SetGenesisValidatorRoot(val []byte) error {
+// SetGenesisValidatorsRoot for the beacon state.
+func (b *BeaconState) SetGenesisValidatorsRoot(val []byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
 	if len(val) != fieldparams.RootLength {
-		return errors.New("incorrect validator root length")
+		return errors.New("incorrect validators root length")
 	}
 	b.genesisValidatorsRoot = bytesutil.ToBytes32(val)
-	b.markFieldAsDirty(genesisValidatorRoot)
+	b.markFieldAsDirty(genesisValidatorsRoot)
 	return nil
 }
 

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

@@ -311,7 +311,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 	switch field {
 	case genesisTime:
 		return ssz.Uint64Root(b.genesisTime), nil
-	case genesisValidatorRoot:
+	case genesisValidatorsRoot:
 		return b.genesisValidatorsRoot, nil
 	case slot:
 		return ssz.Uint64Root(uint64(b.slot)), nil

beacon-chain/state/state-native/v1/types.go

@@ -31,7 +31,7 @@ var fieldMap map[types.FieldIndex]types.DataType
 // Field Aliases for values from the types package.
 const (
 	genesisTime                 = types.GenesisTime
-	genesisValidatorRoot        = types.GenesisValidatorRoot
+	genesisValidatorsRoot       = types.GenesisValidatorsRoot
 	slot                        = types.Slot
 	fork                        = types.Fork
 	latestBlockHeader           = types.LatestBlockHeader

beacon-chain/state/state-native/v2/getters_misc.go

@@ -14,8 +14,8 @@ func (b *BeaconState) GenesisTime() uint64 {
 	return b.genesisTime
 }
 
-// GenesisValidatorRoot of the beacon state.
-func (b *BeaconState) GenesisValidatorRoot() []byte {
+// GenesisValidatorsRoot of the beacon state.
+func (b *BeaconState) GenesisValidatorsRoot() []byte {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 

beacon-chain/state/state-native/v2/setters_misc.go

@@ -50,16 +50,16 @@ func (b *BeaconState) SetGenesisTime(val uint64) error {
 	return nil
 }
 
-// SetGenesisValidatorRoot for the beacon state.
-func (b *BeaconState) SetGenesisValidatorRoot(val []byte) error {
+// SetGenesisValidatorsRoot for the beacon state.
+func (b *BeaconState) SetGenesisValidatorsRoot(val []byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
 	if len(val) != fieldparams.RootLength {
-		return errors.New("incorrect validator root length")
+		return errors.New("incorrect validators root length")
 	}
 	b.genesisValidatorsRoot = bytesutil.ToBytes32(val)
-	b.markFieldAsDirty(genesisValidatorRoot)
+	b.markFieldAsDirty(genesisValidatorsRoot)
 	return nil
 }
 

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

@@ -339,7 +339,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 	switch field {
 	case genesisTime:
 		return ssz.Uint64Root(b.genesisTime), nil
-	case genesisValidatorRoot:
+	case genesisValidatorsRoot:
 		return b.genesisValidatorsRoot, nil
 	case slot:
 		return ssz.Uint64Root(uint64(b.slot)), nil

beacon-chain/state/state-native/v2/types.go

@@ -28,7 +28,7 @@ var fieldMap map[types.FieldIndex]types.DataType
 // Field Aliases for values from the types package.
 const (
 	genesisTime                    = types.GenesisTime
-	genesisValidatorRoot           = types.GenesisValidatorRoot
+	genesisValidatorsRoot          = types.GenesisValidatorsRoot
 	slot                           = types.Slot
 	fork                           = types.Fork
 	latestBlockHeader              = types.LatestBlockHeader

beacon-chain/state/state-native/v3/getters_misc.go

@@ -14,8 +14,8 @@ func (b *BeaconState) GenesisTime() uint64 {
 	return b.genesisTime
 }
 
-// GenesisValidatorRoot of the beacon state.
-func (b *BeaconState) GenesisValidatorRoot() []byte {
+// GenesisValidatorsRoot of the beacon state.
+func (b *BeaconState) GenesisValidatorsRoot() []byte {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 

beacon-chain/state/state-native/v3/setters_misc.go

@@ -50,16 +50,16 @@ func (b *BeaconState) SetGenesisTime(val uint64) error {
 	return nil
 }
 
-// SetGenesisValidatorRoot for the beacon state.
-func (b *BeaconState) SetGenesisValidatorRoot(val []byte) error {
+// SetGenesisValidatorsRoot for the beacon state.
+func (b *BeaconState) SetGenesisValidatorsRoot(val []byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
 	if len(val) != fieldparams.RootLength {
-		return errors.New("incorrect validator root length")
+		return errors.New("incorrect validators root length")
 	}
 	b.genesisValidatorsRoot = bytesutil.ToBytes32(val)
-	b.markFieldAsDirty(genesisValidatorRoot)
+	b.markFieldAsDirty(genesisValidatorsRoot)
 	return nil
 }
 

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

@@ -315,7 +315,7 @@ func (b *BeaconState) rootSelector(field types.FieldIndex) ([32]byte, error) {
 	switch field {
 	case genesisTime:
 		return ssz.Uint64Root(b.genesisTime), nil
-	case genesisValidatorRoot:
+	case genesisValidatorsRoot:
 		return b.genesisValidatorsRoot, nil
 	case slot:
 		return ssz.Uint64Root(uint64(b.slot)), nil

beacon-chain/state/state-native/v3/types.go

@@ -22,7 +22,7 @@ func init() {
 // Field Aliases for values from the types package.
 const (
 	genesisTime                    = types.GenesisTime
-	genesisValidatorRoot           = types.GenesisValidatorRoot
+	genesisValidatorsRoot          = types.GenesisValidatorsRoot
 	slot                           = types.Slot
 	fork                           = types.Fork
 	latestBlockHeader              = types.LatestBlockHeader

beacon-chain/state/stateutil/state_hasher.go

@@ -67,7 +67,7 @@ func (h *stateRootHasher) ComputeFieldRootsWithHasherPhase0(ctx context.Context,
 	genesisRoot := ssz.Uint64Root(state.GenesisTime)
 	fieldRoots[0] = genesisRoot[:]
 
-	// Genesis validator root.
+	// Genesis validators root.
 	r := [32]byte{}
 	copy(r[:], state.GenesisValidatorsRoot)
 	fieldRoots[1] = r[:]
@@ -215,7 +215,7 @@ func (h *stateRootHasher) ComputeFieldRootsWithHasherAltair(ctx context.Context,
 	genesisRoot := ssz.Uint64Root(state.GenesisTime)
 	fieldRoots[0] = genesisRoot[:]
 
-	// Genesis validator root.
+	// Genesis validators root.
 	r := [32]byte{}
 	copy(r[:], state.GenesisValidatorsRoot)
 	fieldRoots[1] = r[:]
@@ -385,7 +385,7 @@ func (h *stateRootHasher) ComputeFieldRootsWithHasherBellatrix(ctx context.Conte
 	genesisRoot := ssz.Uint64Root(state.GenesisTime)
 	fieldRoots[0] = genesisRoot[:]
 
-	// Genesis validator root.
+	// Genesis validators root.
 	r := [32]byte{}
 	copy(r[:], state.GenesisValidatorsRoot)
 	fieldRoots[1] = r[:]

beacon-chain/state/types/types.go

@@ -30,8 +30,8 @@ func (f FieldIndex) String(stateVersion int) string {
 	switch f {
 	case GenesisTime:
 		return "genesisTime"
-	case GenesisValidatorRoot:
-		return "genesisValidatorRoot"
+	case GenesisValidatorsRoot:
+		return "genesisValidatorsRoot"
 	case Slot:
 		return "slot"
 	case Fork:
@@ -108,7 +108,7 @@ func (f FieldIndex) ElemsInChunk() (uint64, error) {
 // to the v1 state.
 const (
 	GenesisTime FieldIndex = iota
-	GenesisValidatorRoot
+	GenesisValidatorsRoot
 	Slot
 	Fork
 	LatestBlockHeader

beacon-chain/state/types/types_test.go

@@ -8,7 +8,7 @@ import (
 
 func TestStateFieldIndexes(t *testing.T) {
 	assert.Equal(t, FieldIndex(0), GenesisTime)
-	assert.Equal(t, FieldIndex(1), GenesisValidatorRoot)
+	assert.Equal(t, FieldIndex(1), GenesisValidatorsRoot)
 	assert.Equal(t, FieldIndex(2), Slot)
 	assert.Equal(t, FieldIndex(3), Fork)
 	assert.Equal(t, FieldIndex(4), LatestBlockHeader)

beacon-chain/state/v1/getters_misc.go

@@ -30,8 +30,8 @@ func (b *BeaconState) genesisTime() uint64 {
 	return b.state.GenesisTime
 }
 
-// GenesisValidatorRoot of the beacon state.
-func (b *BeaconState) GenesisValidatorRoot() []byte {
+// GenesisValidatorsRoot of the beacon state.
+func (b *BeaconState) GenesisValidatorsRoot() []byte {
 	if !b.hasInnerState() {
 		return nil
 	}
@@ -42,12 +42,12 @@ func (b *BeaconState) GenesisValidatorRoot() []byte {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return b.genesisValidatorRoot()
+	return b.genesisValidatorsRoot()
 }
 
-// genesisValidatorRoot of the beacon state.
+// genesisValidatorsRoot of the beacon state.
 // This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) genesisValidatorRoot() []byte {
+func (b *BeaconState) genesisValidatorsRoot() []byte {
 	if !b.hasInnerState() {
 		return nil
 	}

beacon-chain/state/v1/getters_state.go

@@ -25,7 +25,7 @@ func (b *BeaconState) CloneInnerState() interface{} {
 	defer b.lock.RUnlock()
 	return &ethpb.BeaconState{
 		GenesisTime:                 b.genesisTime(),
-		GenesisValidatorsRoot:       b.genesisValidatorRoot(),
+		GenesisValidatorsRoot:       b.genesisValidatorsRoot(),
 		Slot:                        b.slot(),
 		Fork:                        b.fork(),
 		LatestBlockHeader:           b.latestBlockHeader(),

beacon-chain/state/v1/getters_test.go

@@ -26,8 +26,8 @@ func TestNilState_NoPanic(t *testing.T) {
 	}()
 	// retrieve elements from nil state
 	_ = st.GenesisTime()
-	_ = st.GenesisValidatorRoot()
-	_ = st.GenesisValidatorRoot()
+	_ = st.GenesisValidatorsRoot()
+	_ = st.GenesisValidatorsRoot()
 	_ = st.Slot()
 	_ = st.Fork()
 	_ = st.LatestBlockHeader()

beacon-chain/state/v1/setters_misc.go

@@ -49,13 +49,13 @@ func (b *BeaconState) SetGenesisTime(val uint64) error {
 	return nil
 }
 
-// SetGenesisValidatorRoot for the beacon state.
-func (b *BeaconState) SetGenesisValidatorRoot(val []byte) error {
+// SetGenesisValidatorsRoot for the beacon state.
+func (b *BeaconState) SetGenesisValidatorsRoot(val []byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
 	b.state.GenesisValidatorsRoot = val
-	b.markFieldAsDirty(genesisValidatorRoot)
+	b.markFieldAsDirty(genesisValidatorsRoot)
 	return nil
 }
 

beacon-chain/state/v1/state_trie.go

@@ -118,7 +118,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 			PreviousJustifiedCheckpoint: b.previousJustifiedCheckpoint(),
 			CurrentJustifiedCheckpoint:  b.currentJustifiedCheckpoint(),
 			FinalizedCheckpoint:         b.finalizedCheckpoint(),
-			GenesisValidatorsRoot:       b.genesisValidatorRoot(),
+			GenesisValidatorsRoot:       b.genesisValidatorsRoot(),
 		},
 		dirtyFields:           make(map[types.FieldIndex]bool, fieldCount),
 		dirtyIndices:          make(map[types.FieldIndex][]uint64, fieldCount),
@@ -278,7 +278,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 	switch field {
 	case genesisTime:
 		return ssz.Uint64Root(b.state.GenesisTime), nil
-	case genesisValidatorRoot:
+	case genesisValidatorsRoot:
 		return bytesutil.ToBytes32(b.state.GenesisValidatorsRoot), nil
 	case slot:
 		return ssz.Uint64Root(uint64(b.state.Slot)), nil

beacon-chain/state/v1/types.go

@@ -55,7 +55,7 @@ type BeaconState struct {
 // Field Aliases for values from the types package.
 const (
 	genesisTime                 = types.GenesisTime
-	genesisValidatorRoot        = types.GenesisValidatorRoot
+	genesisValidatorsRoot       = types.GenesisValidatorsRoot
 	slot                        = types.Slot
 	fork                        = types.Fork
 	latestBlockHeader           = types.LatestBlockHeader

beacon-chain/state/v2/getters_misc.go

@@ -31,8 +31,8 @@ func (b *BeaconState) genesisTime() uint64 {
 	return b.state.GenesisTime
 }
 
-// GenesisValidatorRoot of the beacon state.
-func (b *BeaconState) GenesisValidatorRoot() []byte {
+// GenesisValidatorsRoot of the beacon state.
+func (b *BeaconState) GenesisValidatorsRoot() []byte {
 	if !b.hasInnerState() {
 		return nil
 	}
@@ -43,12 +43,12 @@ func (b *BeaconState) GenesisValidatorRoot() []byte {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return b.genesisValidatorRoot()
+	return b.genesisValidatorsRoot()
 }
 
-// genesisValidatorRoot of the beacon state.
+// genesisValidatorsRoot of the beacon state.
 // This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) genesisValidatorRoot() []byte {
+func (b *BeaconState) genesisValidatorsRoot() []byte {
 	if !b.hasInnerState() {
 		return nil
 	}

beacon-chain/state/v2/getters_state.go

@@ -25,7 +25,7 @@ func (b *BeaconState) CloneInnerState() interface{} {
 	defer b.lock.RUnlock()
 	return &ethpb.BeaconStateAltair{
 		GenesisTime:                 b.genesisTime(),
-		GenesisValidatorsRoot:       b.genesisValidatorRoot(),
+		GenesisValidatorsRoot:       b.genesisValidatorsRoot(),
 		Slot:                        b.slot(),
 		Fork:                        b.fork(),
 		LatestBlockHeader:           b.latestBlockHeader(),

beacon-chain/state/v2/getters_test.go

@@ -25,8 +25,8 @@ func TestNilState_NoPanic(t *testing.T) {
 	}()
 	// retrieve elements from nil state
 	_ = st.GenesisTime()
-	_ = st.GenesisValidatorRoot()
-	_ = st.GenesisValidatorRoot()
+	_ = st.GenesisValidatorsRoot()
+	_ = st.GenesisValidatorsRoot()
 	_ = st.Slot()
 	_ = st.Fork()
 	_ = st.LatestBlockHeader()

beacon-chain/state/v2/setters_misc.go

@@ -48,13 +48,13 @@ func (b *BeaconState) SetGenesisTime(val uint64) error {
 	return nil
 }
 
-// SetGenesisValidatorRoot for the beacon state.
-func (b *BeaconState) SetGenesisValidatorRoot(val []byte) error {
+// SetGenesisValidatorsRoot for the beacon state.
+func (b *BeaconState) SetGenesisValidatorsRoot(val []byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
 	b.state.GenesisValidatorsRoot = val
-	b.markFieldAsDirty(genesisValidatorRoot)
+	b.markFieldAsDirty(genesisValidatorsRoot)
 	return nil
 }
 

beacon-chain/state/v2/state_trie.go

@@ -150,7 +150,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 			PreviousJustifiedCheckpoint: b.previousJustifiedCheckpoint(),
 			CurrentJustifiedCheckpoint:  b.currentJustifiedCheckpoint(),
 			FinalizedCheckpoint:         b.finalizedCheckpoint(),
-			GenesisValidatorsRoot:       b.genesisValidatorRoot(),
+			GenesisValidatorsRoot:       b.genesisValidatorsRoot(),
 			CurrentSyncCommittee:        b.currentSyncCommittee(),
 			NextSyncCommittee:           b.nextSyncCommittee(),
 		},
@@ -312,7 +312,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 	switch field {
 	case genesisTime:
 		return ssz.Uint64Root(b.state.GenesisTime), nil
-	case genesisValidatorRoot:
+	case genesisValidatorsRoot:
 		return bytesutil.ToBytes32(b.state.GenesisValidatorsRoot), nil
 	case slot:
 		return ssz.Uint64Root(uint64(b.state.Slot)), nil

beacon-chain/state/v2/types.go

@@ -52,7 +52,7 @@ type BeaconState struct {
 // Field Aliases for values from the types package.
 const (
 	genesisTime                    = types.GenesisTime
-	genesisValidatorRoot           = types.GenesisValidatorRoot
+	genesisValidatorsRoot          = types.GenesisValidatorsRoot
 	slot                           = types.Slot
 	fork                           = types.Fork
 	latestBlockHeader              = types.LatestBlockHeader

beacon-chain/state/v3/getters_misc.go

@@ -30,8 +30,8 @@ func (b *BeaconState) genesisTime() uint64 {
 	return b.state.GenesisTime
 }
 
-// GenesisValidatorRoot of the beacon state.
-func (b *BeaconState) GenesisValidatorRoot() []byte {
+// GenesisValidatorsRoot of the beacon state.
+func (b *BeaconState) GenesisValidatorsRoot() []byte {
 	if !b.hasInnerState() {
 		return nil
 	}
@@ -42,12 +42,12 @@ func (b *BeaconState) GenesisValidatorRoot() []byte {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return b.genesisValidatorRoot()
+	return b.genesisValidatorsRoot()
 }
 
-// genesisValidatorRoot of the beacon state.
+// genesisValidatorsRoot of the beacon state.
 // This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) genesisValidatorRoot() []byte {
+func (b *BeaconState) genesisValidatorsRoot() []byte {
 	if !b.hasInnerState() {
 		return nil
 	}

beacon-chain/state/v3/getters_state.go

@@ -25,7 +25,7 @@ func (b *BeaconState) CloneInnerState() interface{} {
 	defer b.lock.RUnlock()
 	return &ethpb.BeaconStateBellatrix{
 		GenesisTime:                  b.genesisTime(),
-		GenesisValidatorsRoot:        b.genesisValidatorRoot(),
+		GenesisValidatorsRoot:        b.genesisValidatorsRoot(),
 		Slot:                         b.slot(),
 		Fork:                         b.fork(),
 		LatestBlockHeader:            b.latestBlockHeader(),

beacon-chain/state/v3/getters_test.go

@@ -25,8 +25,8 @@ func TestNilState_NoPanic(t *testing.T) {
 	}()
 	// retrieve elements from nil state
 	_ = st.GenesisTime()
-	_ = st.GenesisValidatorRoot()
-	_ = st.GenesisValidatorRoot()
+	_ = st.GenesisValidatorsRoot()
+	_ = st.GenesisValidatorsRoot()
 	_ = st.Slot()
 	_ = st.Fork()
 	_ = st.LatestBlockHeader()

beacon-chain/state/v3/setters_misc.go

@@ -48,13 +48,13 @@ func (b *BeaconState) SetGenesisTime(val uint64) error {
 	return nil
 }
 
-// SetGenesisValidatorRoot for the beacon state.
-func (b *BeaconState) SetGenesisValidatorRoot(val []byte) error {
+// SetGenesisValidatorsRoot for the beacon state.
+func (b *BeaconState) SetGenesisValidatorsRoot(val []byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
 	b.state.GenesisValidatorsRoot = val
-	b.markFieldAsDirty(genesisValidatorRoot)
+	b.markFieldAsDirty(genesisValidatorsRoot)
 	return nil
 }
 

beacon-chain/state/v3/state_trie.go

@@ -121,7 +121,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 			PreviousJustifiedCheckpoint:  b.previousJustifiedCheckpoint(),
 			CurrentJustifiedCheckpoint:   b.currentJustifiedCheckpoint(),
 			FinalizedCheckpoint:          b.finalizedCheckpoint(),
-			GenesisValidatorsRoot:        b.genesisValidatorRoot(),
+			GenesisValidatorsRoot:        b.genesisValidatorsRoot(),
 			CurrentSyncCommittee:         b.currentSyncCommittee(),
 			NextSyncCommittee:            b.nextSyncCommittee(),
 			LatestExecutionPayloadHeader: b.latestExecutionPayloadHeader(),
@@ -279,7 +279,7 @@ func (b *BeaconState) rootSelector(field types.FieldIndex) ([32]byte, error) {
 	switch field {
 	case genesisTime:
 		return ssz.Uint64Root(b.state.GenesisTime), nil
-	case genesisValidatorRoot:
+	case genesisValidatorsRoot:
 		return bytesutil.ToBytes32(b.state.GenesisValidatorsRoot), nil
 	case slot:
 		return ssz.Uint64Root(uint64(b.state.Slot)), nil

beacon-chain/state/v3/types.go

@@ -28,7 +28,7 @@ func init() {
 // Field Aliases for values from the types package.
 const (
 	genesisTime                    = types.GenesisTime
-	genesisValidatorRoot           = types.GenesisValidatorRoot
+	genesisValidatorsRoot          = types.GenesisValidatorsRoot
 	slot                           = types.Slot
 	fork                           = types.Fork
 	latestBlockHeader              = types.LatestBlockHeader

beacon-chain/sync/context.go

@@ -61,7 +61,7 @@ func rpcContext(stream network.Stream, chain blockchain.ChainInfoFetcher) ([]byt
 		return []byte{}, nil
 	case p2p.SchemaVersionV2:
 		currFork := chain.CurrentFork()
-		genRoot := chain.GenesisValidatorRoot()
+		genRoot := chain.GenesisValidatorsRoot()
 		digest, err := signing.ComputeForkDigest(currFork.CurrentVersion, genRoot[:])
 		if err != nil {
 			return nil, err

beacon-chain/sync/fork_watcher.go

@@ -39,7 +39,7 @@ func (s *Service) forkWatcher() {
 // Checks if there is a fork in the next epoch and if there is
 // it registers the appropriate gossip and rpc topics.
 func (s *Service) registerForUpcomingFork(currEpoch types.Epoch) error {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	isNextForkEpoch, err := forks.IsForkNextEpoch(s.cfg.chain.GenesisTime(), genRoot[:])
 	if err != nil {
 		return errors.Wrap(err, "Could not retrieve next fork epoch")
@@ -77,7 +77,7 @@ func (s *Service) registerForUpcomingFork(currEpoch types.Epoch) error {
 // Checks if there was a fork in the previous epoch, and if there
 // was then we deregister the topics from that particular fork.
 func (s *Service) deregisterFromPastFork(currEpoch types.Epoch) error {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	// This method takes care of the de-registration of
 	// old gossip pubsub handlers. Once we are at the epoch
 	// after the fork, we de-register from all the outdated topics.

beacon-chain/sync/fork_watcher_test.go

@@ -84,7 +84,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) {
 			currEpoch: 4,
 			wantErr:   false,
 			postSvcCheck: func(t *testing.T, s *Service) {
-				genRoot := s.cfg.chain.GenesisValidatorRoot()
+				genRoot := s.cfg.chain.GenesisValidatorsRoot()
 				digest, err := forks.ForkDigestFromEpoch(5, genRoot[:])
 				assert.NoError(t, err)
 				assert.Equal(t, true, s.subHandler.digestExists(digest))
@@ -128,7 +128,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) {
 			currEpoch: 4,
 			wantErr:   false,
 			postSvcCheck: func(t *testing.T, s *Service) {
-				genRoot := s.cfg.chain.GenesisValidatorRoot()
+				genRoot := s.cfg.chain.GenesisValidatorsRoot()
 				digest, err := forks.ForkDigestFromEpoch(5, genRoot[:])
 				assert.NoError(t, err)
 				assert.Equal(t, true, s.subHandler.digestExists(digest))
@@ -232,7 +232,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) {
 				chainService.Genesis = prevGenesis
 				r.registerRPCHandlersAltair()
 
-				genRoot := r.cfg.chain.GenesisValidatorRoot()
+				genRoot := r.cfg.chain.GenesisValidatorsRoot()
 				digest, err := forks.ForkDigestFromEpoch(0, genRoot[:])
 				assert.NoError(t, err)
 				r.registerSubscribers(0, digest)
@@ -248,7 +248,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) {
 			currEpoch: 4,
 			wantErr:   false,
 			postSvcCheck: func(t *testing.T, s *Service) {
-				genRoot := s.cfg.chain.GenesisValidatorRoot()
+				genRoot := s.cfg.chain.GenesisValidatorsRoot()
 				digest, err := forks.ForkDigestFromEpoch(0, genRoot[:])
 				assert.NoError(t, err)
 				assert.Equal(t, false, s.subHandler.digestExists(digest))
@@ -299,7 +299,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) {
 					chainStarted: abool.New(),
 					subHandler:   newSubTopicHandler(),
 				}
-				genRoot := r.cfg.chain.GenesisValidatorRoot()
+				genRoot := r.cfg.chain.GenesisValidatorsRoot()
 				digest, err := forks.ForkDigestFromEpoch(1, genRoot[:])
 				assert.NoError(t, err)
 				r.registerSubscribers(1, digest)
@@ -315,7 +315,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) {
 			currEpoch: 4,
 			wantErr:   false,
 			postSvcCheck: func(t *testing.T, s *Service) {
-				genRoot := s.cfg.chain.GenesisValidatorRoot()
+				genRoot := s.cfg.chain.GenesisValidatorsRoot()
 				digest, err := forks.ForkDigestFromEpoch(1, genRoot[:])
 				assert.NoError(t, err)
 				assert.Equal(t, false, s.subHandler.digestExists(digest))

beacon-chain/sync/pending_attestations_queue_test.go

@@ -83,7 +83,7 @@ func TestProcessPendingAtts_HasBlockSaveUnAggregatedAtt(t *testing.T) {
 	assert.NoError(t, err)
 	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
-	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
 	assert.NoError(t, err)
@@ -194,7 +194,7 @@ func TestProcessPendingAtts_NoBroadcastWithBadSignature(t *testing.T) {
 	assert.NoError(t, err)
 	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
-	attesterDomain, err := signing.Domain(s.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, s.GenesisValidatorRoot())
+	attesterDomain, err := signing.Domain(s.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
 	assert.NoError(t, err)
@@ -267,7 +267,7 @@ func TestProcessPendingAtts_HasBlockSaveAggregatedAtt(t *testing.T) {
 	assert.NoError(t, err)
 	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
-	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
 	assert.NoError(t, err)

beacon-chain/sync/rpc_chunked_response.go

@@ -32,21 +32,21 @@ func WriteBlockChunk(stream libp2pcore.Stream, chain blockchain.ChainInfoFetcher
 	var obtainedCtx []byte
 	switch blk.Version() {
 	case version.Phase0:
-		valRoot := chain.GenesisValidatorRoot()
+		valRoot := chain.GenesisValidatorsRoot()
 		digest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().GenesisEpoch, valRoot[:])
 		if err != nil {
 			return err
 		}
 		obtainedCtx = digest[:]
 	case version.Altair:
-		valRoot := chain.GenesisValidatorRoot()
+		valRoot := chain.GenesisValidatorsRoot()
 		digest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().AltairForkEpoch, valRoot[:])
 		if err != nil {
 			return err
 		}
 		obtainedCtx = digest[:]
 	case version.Bellatrix:
-		valRoot := chain.GenesisValidatorRoot()
+		valRoot := chain.GenesisValidatorsRoot()
 		digest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().BellatrixForkEpoch, valRoot[:])
 		if err != nil {
 			return err
@@ -129,7 +129,7 @@ func extractBlockDataType(digest []byte, chain blockchain.ChainInfoFetcher) (blo
 	if len(digest) != forkDigestLength {
 		return nil, errors.Errorf("invalid digest returned, wanted a length of %d but received %d", forkDigestLength, len(digest))
 	}
-	vRoot := chain.GenesisValidatorRoot()
+	vRoot := chain.GenesisValidatorsRoot()
 	for k, blkFunc := range types.BlockMap {
 		rDigest, err := signing.ComputeForkDigest(k[:], vRoot[:])
 		if err != nil {

beacon-chain/sync/rpc_metadata.go

@@ -106,7 +106,7 @@ func (s *Service) sendMetaDataRequest(ctx context.Context, id peer.ID) (metadata
 		s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(stream.Conn().RemotePeer())
 		return nil, errors.New(errMsg)
 	}
-	valRoot := s.cfg.chain.GenesisValidatorRoot()
+	valRoot := s.cfg.chain.GenesisValidatorsRoot()
 	rpcCtx, err := forks.ForkDigestFromEpoch(slots.ToEpoch(s.cfg.chain.CurrentSlot()), valRoot[:])
 	if err != nil {
 		return nil, err
@@ -143,7 +143,7 @@ func extractMetaDataType(digest []byte, chain blockchain.ChainInfoFetcher) (meta
 	if len(digest) != forkDigestLength {
 		return nil, errors.Errorf("invalid digest returned, wanted a length of %d but received %d", forkDigestLength, len(digest))
 	}
-	vRoot := chain.GenesisValidatorRoot()
+	vRoot := chain.GenesisValidatorsRoot()
 	for k, mdFunc := range types.MetaDataMap {
 		rDigest, err := signing.ComputeForkDigest(k[:], vRoot[:])
 		if err != nil {

beacon-chain/sync/subscriber.go

@@ -123,7 +123,7 @@ func (s *Service) registerSubscribers(epoch types.Epoch, digest [4]byte) {
 // subscribe to a given topic with a given validator and subscription handler.
 // The base protobuf message is used to initialize new messages for decoding.
 func (s *Service) subscribe(topic string, validator wrappedVal, handle subHandler, digest [4]byte) *pubsub.Subscription {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	_, e, err := forks.RetrieveForkDataFromDigest(digest, genRoot[:])
 	if err != nil {
 		// Impossible condition as it would mean digest does not exist.
@@ -285,7 +285,7 @@ func (s *Service) wrapAndReportValidation(topic string, v wrappedVal) (string, p
 // subscribe to a static subnet  with the given topic and index.A given validator and subscription handler is
 // used to handle messages from the subnet. The base protobuf message is used to initialize new messages for decoding.
 func (s *Service) subscribeStaticWithSubnets(topic string, validator wrappedVal, handle subHandler, digest [4]byte) {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	_, e, err := forks.RetrieveForkDataFromDigest(digest, genRoot[:])
 	if err != nil {
 		// Impossible condition as it would mean digest does not exist.
@@ -358,7 +358,7 @@ func (s *Service) subscribeDynamicWithSubnets(
 	handle subHandler,
 	digest [4]byte,
 ) {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	_, e, err := forks.RetrieveForkDataFromDigest(digest, genRoot[:])
 	if err != nil {
 		// Impossible condition as it would mean digest does not exist.
@@ -487,7 +487,7 @@ func (s *Service) subscribeSyncSubnet(
 // subscribe to a static subnet with the given topic and index. A given validator and subscription handler is
 // used to handle messages from the subnet. The base protobuf message is used to initialize new messages for decoding.
 func (s *Service) subscribeStaticWithSyncSubnets(topic string, validator wrappedVal, handle subHandler, digest [4]byte) {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	_, e, err := forks.RetrieveForkDataFromDigest(digest, genRoot[:])
 	if err != nil {
 		panic(err)
@@ -558,7 +558,7 @@ func (s *Service) subscribeDynamicWithSyncSubnets(
 	handle subHandler,
 	digest [4]byte,
 ) {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	_, e, err := forks.RetrieveForkDataFromDigest(digest, genRoot[:])
 	if err != nil {
 		panic(err)
@@ -724,7 +724,7 @@ func (_ *Service) addDigestAndIndexToTopic(topic string, digest [4]byte, idx uin
 }
 
 func (s *Service) currentForkDigest() ([4]byte, error) {
-	genRoot := s.cfg.chain.GenesisValidatorRoot()
+	genRoot := s.cfg.chain.GenesisValidatorsRoot()
 	return forks.CreateForkDigest(s.cfg.chain.GenesisTime(), genRoot[:])
 }
 

beacon-chain/sync/subscriber_test.go

@@ -597,7 +597,7 @@ func TestSubscribeWithSyncSubnets_StaticSwitchFork(t *testing.T) {
 	}
 	// Empty cache at the end of the test.
 	defer cache.SyncSubnetIDs.EmptyAllCaches()
-	genRoot := r.cfg.chain.GenesisValidatorRoot()
+	genRoot := r.cfg.chain.GenesisValidatorsRoot()
 	digest, err := signing.ComputeForkDigest(params.BeaconConfig().GenesisForkVersion, genRoot[:])
 	assert.NoError(t, err)
 	r.subscribeStaticWithSyncSubnets(p2p.SyncCommitteeSubnetTopicFormat, nil, nil, digest)
@@ -637,7 +637,7 @@ func TestSubscribeWithSyncSubnets_DynamicSwitchFork(t *testing.T) {
 	// Empty cache at the end of the test.
 	defer cache.SyncSubnetIDs.EmptyAllCaches()
 	cache.SyncSubnetIDs.AddSyncCommitteeSubnets([]byte("pubkey"), 0, []uint64{0, 1}, 10*time.Second)
-	genRoot := r.cfg.chain.GenesisValidatorRoot()
+	genRoot := r.cfg.chain.GenesisValidatorsRoot()
 	digest, err := signing.ComputeForkDigest(params.BeaconConfig().GenesisForkVersion, genRoot[:])
 	assert.NoError(t, err)
 

beacon-chain/sync/validate_aggregate_proof.go

@@ -293,7 +293,7 @@ func validateSelectionIndex(
 		return nil, err
 	}
 
-	d, err := signing.Domain(bs.Fork(), epoch, domain, bs.GenesisValidatorRoot())
+	d, err := signing.Domain(bs.Fork(), epoch, domain, bs.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}
@@ -321,7 +321,7 @@ func aggSigSet(s state.ReadOnlyBeaconState, a *ethpb.SignedAggregateAttestationA
 	}
 
 	epoch := slots.ToEpoch(a.Message.Aggregate.Data.Slot)
-	d, err := signing.Domain(s.Fork(), epoch, params.BeaconConfig().DomainAggregateAndProof, s.GenesisValidatorRoot())
+	d, err := signing.Domain(s.Fork(), epoch, params.BeaconConfig().DomainAggregateAndProof, s.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}

beacon-chain/sync/validate_aggregate_proof_test.go

@@ -330,7 +330,7 @@ func TestValidateAggregateAndProof_CanValidate(t *testing.T) {
 	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
 	assert.NoError(t, err)
-	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	assert.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
 	assert.NoError(t, err)
@@ -424,7 +424,7 @@ func TestVerifyIndexInCommittee_SeenAggregatorEpoch(t *testing.T) {
 	require.NoError(t, err)
 	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
-	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
 	assert.NoError(t, err)
@@ -537,7 +537,7 @@ func TestValidateAggregateAndProof_BadBlock(t *testing.T) {
 	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
 	assert.NoError(t, err)
-	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	assert.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
 	assert.NoError(t, err)
@@ -628,7 +628,7 @@ func TestValidateAggregateAndProof_RejectWhenAttEpochDoesntEqualTargetEpoch(t *t
 	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
 	require.NoError(t, err)
 	assert.NoError(t, err)
-	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	assert.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
 	assert.NoError(t, err)

beacon-chain/sync/validate_attester_slashing_test.go

@@ -39,7 +39,7 @@ func setupValidAttesterSlashing(t *testing.T) (*ethpb.AttesterSlashing, state.Be
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(state.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, state.GenesisValidatorRoot())
+	domain, err := signing.Domain(state.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, state.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	assert.NoError(t, err)

beacon-chain/sync/validate_beacon_attestation_test.go

@@ -258,7 +258,7 @@ func TestService_validateCommitteeIndexBeaconAttestation(t *testing.T) {
 			if tt.validAttestationSignature {
 				com, err := helpers.BeaconCommitteeFromState(context.Background(), savedState, tt.msg.Data.Slot, tt.msg.Data.CommitteeIndex)
 				require.NoError(t, err)
-				domain, err := signing.Domain(savedState.Fork(), tt.msg.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, savedState.GenesisValidatorRoot())
+				domain, err := signing.Domain(savedState.Fork(), tt.msg.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, savedState.GenesisValidatorsRoot())
 				require.NoError(t, err)
 				attRoot, err := signing.ComputeSigningRoot(tt.msg.Data, domain)
 				require.NoError(t, err)

beacon-chain/sync/validate_beacon_blocks_test.go

@@ -1104,8 +1104,8 @@ func TestValidateBeaconBlockPubSub_ValidExecutionPayload(t *testing.T) {
 	_, err = p.Encoding().EncodeGossip(buf, msg)
 	require.NoError(t, err)
 	topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)]
-	genesisValidatorRoot := r.cfg.chain.GenesisValidatorRoot()
-	BellatrixDigest, err := signing.ComputeForkDigest(params.BeaconConfig().BellatrixForkVersion, genesisValidatorRoot[:])
+	genesisValidatorsRoot := r.cfg.chain.GenesisValidatorsRoot()
+	BellatrixDigest, err := signing.ComputeForkDigest(params.BeaconConfig().BellatrixForkVersion, genesisValidatorsRoot[:])
 	require.NoError(t, err)
 	topic = r.addDigestToTopic(topic, BellatrixDigest)
 	m := &pubsub.Message{
@@ -1177,8 +1177,8 @@ func TestValidateBeaconBlockPubSub_InvalidPayloadTimestamp(t *testing.T) {
 	_, err = p.Encoding().EncodeGossip(buf, msg)
 	require.NoError(t, err)
 	topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)]
-	genesisValidatorRoot := r.cfg.chain.GenesisValidatorRoot()
-	BellatrixDigest, err := signing.ComputeForkDigest(params.BeaconConfig().BellatrixForkVersion, genesisValidatorRoot[:])
+	genesisValidatorsRoot := r.cfg.chain.GenesisValidatorsRoot()
+	BellatrixDigest, err := signing.ComputeForkDigest(params.BeaconConfig().BellatrixForkVersion, genesisValidatorsRoot[:])
 	assert.NoError(t, err)
 	topic = r.addDigestToTopic(topic, BellatrixDigest)
 	m := &pubsub.Message{

beacon-chain/sync/validate_sync_committee_message_test.go

@@ -319,7 +319,7 @@ func TestService_ValidateSyncCommitteeMessage(t *testing.T) {
 				msg.ValidatorIndex = types.ValidatorIndex(chosenVal)
 				msg.Slot = slots.PrevSlot(hState.Slot())
 
-				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorRoot())
+				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorsRoot())
 				assert.NoError(t, err)
 				subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
 				s.cfg.chain = &mockChain.ChainService{
@@ -370,7 +370,7 @@ func TestService_ValidateSyncCommitteeMessage(t *testing.T) {
 				numOfVals := hState.NumValidators()
 
 				chosenVal := numOfVals - 10
-				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorRoot())
+				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorsRoot())
 				assert.NoError(t, err)
 				rawBytes := p2ptypes.SSZBytes(headRoot[:])
 				sigRoot, err := signing.ComputeSigningRoot(&rawBytes, d)

beacon-chain/sync/validate_sync_contribution_proof_test.go

@@ -472,7 +472,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 						}
 					}
 				}
-				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorRoot())
+				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorsRoot())
 				require.NoError(t, err)
 				subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
 				s.cfg.chain = &mockChain.ChainService{
@@ -548,7 +548,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 							msg.Message.Contribution.AggregationBits.SetBitAt(1, true)
 							msg.Signature = infiniteSig[:]
 
-							d, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorRoot())
+							d, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorsRoot())
 							assert.NoError(t, err)
 							sigRoot, err := signing.ComputeSigningRoot(msg.Message, d)
 							assert.NoError(t, err)
@@ -605,7 +605,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 				assert.NoError(t, err)
 				sc, err := hState.CurrentSyncCommittee()
 				assert.NoError(t, err)
-				cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorRoot())
+				cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorsRoot())
 				assert.NoError(t, err)
 				for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSubnetCount; i++ {
 					coms, err := altair.SyncSubCommitteePubkeys(sc, types.CommitteeIndex(i))
@@ -637,7 +637,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 					}
 				}
 
-				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorRoot())
+				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorsRoot())
 				require.NoError(t, err)
 				subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
 				s.cfg.chain = &mockChain.ChainService{
@@ -689,9 +689,9 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 				assert.NoError(t, err)
 				sc, err := hState.CurrentSyncCommittee()
 				assert.NoError(t, err)
-				cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorRoot())
+				cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorsRoot())
 				assert.NoError(t, err)
-				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorRoot())
+				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorsRoot())
 				assert.NoError(t, err)
 				var pubkeys [][]byte
 				for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSubnetCount; i++ {
@@ -732,7 +732,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 					}
 				}
 
-				pd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorRoot())
+				pd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorsRoot())
 				require.NoError(t, err)
 				subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
 				s.cfg.chain = &mockChain.ChainService{
@@ -785,9 +785,9 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 				assert.NoError(t, err)
 				sc, err := hState.CurrentSyncCommittee()
 				assert.NoError(t, err)
-				cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorRoot())
+				cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorsRoot())
 				assert.NoError(t, err)
-				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorRoot())
+				d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorsRoot())
 				assert.NoError(t, err)
 				var pubkeys [][]byte
 				for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSubnetCount; i++ {
@@ -830,7 +830,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 					}
 				}
 
-				pd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorRoot())
+				pd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorsRoot())
 				require.NoError(t, err)
 				subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
 				s.cfg.chain = &mockChain.ChainService{
@@ -931,9 +931,9 @@ func TestService_ValidateSyncContributionAndProof_Broadcast(t *testing.T) {
 	assert.NoError(t, err)
 	sc, err := hState.CurrentSyncCommittee()
 	assert.NoError(t, err)
-	cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorRoot())
+	cd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainContributionAndProof, hState.GenesisValidatorsRoot())
 	assert.NoError(t, err)
-	d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorRoot())
+	d, err := signing.Domain(hState.Fork(), slots.ToEpoch(hState.Slot()), params.BeaconConfig().DomainSyncCommittee, hState.GenesisValidatorsRoot())
 	assert.NoError(t, err)
 	var pubkeys [][]byte
 	for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSubnetCount; i++ {
@@ -974,7 +974,7 @@ func TestService_ValidateSyncContributionAndProof_Broadcast(t *testing.T) {
 		}
 	}
 
-	pd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorRoot())
+	pd, err := signing.Domain(hState.Fork(), slots.ToEpoch(slots.PrevSlot(hState.Slot())), params.BeaconConfig().DomainSyncCommitteeSelectionProof, hState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	subCommitteeSize := params.BeaconConfig().SyncCommitteeSize / params.BeaconConfig().SyncCommitteeSubnetCount
 	s.cfg.chain = &mockChain.ChainService{
@@ -1054,7 +1054,7 @@ func fillUpBlocksAndState(ctx context.Context, t *testing.T, beaconDB db.Databas
 }
 
 func syncSelectionProofSigningRoot(st state.BeaconState, slot types.Slot, comIdx types.CommitteeIndex) ([32]byte, error) {
-	dom, err := signing.Domain(st.Fork(), slots.ToEpoch(slot), params.BeaconConfig().DomainSyncCommitteeSelectionProof, st.GenesisValidatorRoot())
+	dom, err := signing.Domain(st.Fork(), slots.ToEpoch(slot), params.BeaconConfig().DomainSyncCommitteeSelectionProof, st.GenesisValidatorsRoot())
 	if err != nil {
 		return [32]byte{}, err
 	}

beacon-chain/sync/validate_voluntary_exit.go

@@ -62,7 +62,7 @@ func (s *Service) validateVoluntaryExit(ctx context.Context, pid peer.ID, msg *p
 	if err != nil {
 		return pubsub.ValidationIgnore, err
 	}
-	if err := blocks.VerifyExitAndSignature(val, headState.Slot(), headState.Fork(), exit, headState.GenesisValidatorRoot()); err != nil {
+	if err := blocks.VerifyExitAndSignature(val, headState.Slot(), headState.Fork(), exit, headState.GenesisValidatorsRoot()); err != nil {
 		return pubsub.ValidationReject, err
 	}
 

proto/migration/v1alpha1_to_v1.go

@@ -438,7 +438,7 @@ func BeaconStateToV1(state state.BeaconState) (*ethpbv1.BeaconState, error) {
 
 	result := &ethpbv1.BeaconState{
 		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: bytesutil.SafeCopyBytes(state.GenesisValidatorRoot()),
+		GenesisValidatorsRoot: bytesutil.SafeCopyBytes(state.GenesisValidatorsRoot()),
 		Slot:                  state.Slot(),
 		Fork: &ethpbv1.Fork{
 			PreviousVersion: bytesutil.SafeCopyBytes(sourceFork.PreviousVersion),

proto/migration/v1alpha1_to_v1_test.go

@@ -439,7 +439,7 @@ func Test_V1AttestationToV1Alpha1(t *testing.T) {
 func TestBeaconStateToV1(t *testing.T) {
 	source, err := util.NewBeaconState(util.FillRootsNaturalOpt, func(state *ethpbalpha.BeaconState) error {
 		state.GenesisTime = 1
-		state.GenesisValidatorsRoot = bytesutil.PadTo([]byte("genesisvalidatorroot"), 32)
+		state.GenesisValidatorsRoot = bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32)
 		state.Slot = 2
 		state.Fork = &ethpbalpha.Fork{
 			PreviousVersion: bytesutil.PadTo([]byte("123"), 4),
@@ -537,7 +537,7 @@ func TestBeaconStateToV1(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, result)
 	assert.Equal(t, uint64(1), result.GenesisTime)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("genesisvalidatorroot"), 32), result.GenesisValidatorsRoot)
+	assert.DeepEqual(t, bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32), result.GenesisValidatorsRoot)
 	assert.Equal(t, types.Slot(2), result.Slot)
 	resultFork := result.Fork
 	require.NotNil(t, resultFork)

proto/migration/v1alpha1_to_v2.go

@@ -105,7 +105,7 @@ func BeaconStateAltairToV2(altairState state.BeaconStateAltair) (*ethpbv2.Beacon
 
 	result := &ethpbv2.BeaconStateV2{
 		GenesisTime:           altairState.GenesisTime(),
-		GenesisValidatorsRoot: bytesutil.SafeCopyBytes(altairState.GenesisValidatorRoot()),
+		GenesisValidatorsRoot: bytesutil.SafeCopyBytes(altairState.GenesisValidatorsRoot()),
 		Slot:                  altairState.Slot(),
 		Fork: &ethpbv1.Fork{
 			PreviousVersion: bytesutil.SafeCopyBytes(sourceFork.PreviousVersion),

testing/slasher/simulator/attestation_generator.go

@@ -114,7 +114,7 @@ func (s *Simulator) aggregateSigForAttestation(
 		beaconState.Fork(),
 		att.Data.Target.Epoch,
 		params.BeaconConfig().DomainBeaconAttester,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	if err != nil {
 		return nil, err

testing/slasher/simulator/block_generator.go

@@ -76,7 +76,7 @@ func (s *Simulator) signBlockHeader(
 		beaconState.Fork(),
 		0,
 		params.BeaconConfig().DomainBeaconProposer,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	if err != nil {
 		return nil, err

testing/util/altair.go

@@ -287,7 +287,7 @@ func BlockSignatureAltair(
 		return nil, err
 	}
 	block.StateRoot = s[:]
-	domain, err := signing.Domain(bState.Fork(), time.CurrentEpoch(bState), params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorRoot())
+	domain, err := signing.Domain(bState.Fork(), time.CurrentEpoch(bState), params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}

testing/util/attestation.go

@@ -151,7 +151,7 @@ func GenerateAttestations(
 		)
 	}
 
-	domain, err := signing.Domain(bState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, bState.GenesisValidatorRoot())
+	domain, err := signing.Domain(bState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, bState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}

testing/util/bellatrix.go

@@ -30,7 +30,7 @@ func BlockSignatureBellatrix(
 		return nil, err
 	}
 	block.StateRoot = s[:]
-	domain, err := signing.Domain(bState.Fork(), time.CurrentEpoch(bState), params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorRoot())
+	domain, err := signing.Domain(bState.Fork(), time.CurrentEpoch(bState), params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}

testing/util/helpers.go

@@ -46,7 +46,7 @@ func BlockSignature(
 		return nil, err
 	}
 	block.StateRoot = s[:]
-	domain, err := signing.Domain(bState.Fork(), time.CurrentEpoch(bState), params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorRoot())
+	domain, err := signing.Domain(bState.Fork(), time.CurrentEpoch(bState), params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}

testing/util/sync_aggregate.go

@@ -52,7 +52,7 @@ func generateSyncAggregate(bState state.BeaconState, privs []bls.SecretKey, pare
 		if !ok {
 			continue
 		}
-		d, err := signing.Domain(st.Fork(), slots.ToEpoch(st.Slot()), params.BeaconConfig().DomainSyncCommittee, st.GenesisValidatorRoot())
+		d, err := signing.Domain(st.Fork(), slots.ToEpoch(st.Slot()), params.BeaconConfig().DomainSyncCommittee, st.GenesisValidatorsRoot())
 		if err != nil {
 			return nil, err
 		}