Hardcoded genesisValidator Root instead of computing

CHANGELOG.md

@@ -23,6 +23,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Electra: Updated block publishing beacon APIs to support Electra.
 - "Submitted builder validator registration settings for custom builders" log message moved to debug level.
 - config: Genesis validator root is now hardcoded in params.BeaconConfig()
+- Replaced GenesisValidatorsRoot() function in state with hardcoded value of Genesis validator root
 
 ### Deprecated
 

api/server/structs/conversions_state.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	beaconState "github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 )
 
@@ -74,7 +75,7 @@ func BeaconStateFromConsensus(st beaconState.BeaconState) (*BeaconState, error)
 
 	return &BeaconState{
 		GenesisTime:                 fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:       hexutil.Encode(st.GenesisValidatorsRoot()),
+		GenesisValidatorsRoot:       hexutil.Encode(params.BeaconConfig().GenesisValidatorsRoot[:]),
 		Slot:                        fmt.Sprintf("%d", st.Slot()),
 		Fork:                        ForkFromConsensus(st.Fork()),
 		LatestBlockHeader:           BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
@@ -176,7 +177,7 @@ func BeaconStateAltairFromConsensus(st beaconState.BeaconState) (*BeaconStateAlt
 
 	return &BeaconStateAltair{
 		GenesisTime:                 fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:       hexutil.Encode(st.GenesisValidatorsRoot()),
+		GenesisValidatorsRoot:       hexutil.Encode(params.BeaconConfig().GenesisValidatorsRoot[:]),
 		Slot:                        fmt.Sprintf("%d", st.Slot()),
 		Fork:                        ForkFromConsensus(st.Fork()),
 		LatestBlockHeader:           BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
@@ -293,7 +294,7 @@ func BeaconStateBellatrixFromConsensus(st beaconState.BeaconState) (*BeaconState
 
 	return &BeaconStateBellatrix{
 		GenesisTime:                  fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:        hexutil.Encode(st.GenesisValidatorsRoot()),
+		GenesisValidatorsRoot:        hexutil.Encode(params.BeaconConfig().GenesisValidatorsRoot[:]),
 		Slot:                         fmt.Sprintf("%d", st.Slot()),
 		Fork:                         ForkFromConsensus(st.Fork()),
 		LatestBlockHeader:            BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
@@ -427,7 +428,7 @@ func BeaconStateCapellaFromConsensus(st beaconState.BeaconState) (*BeaconStateCa
 
 	return &BeaconStateCapella{
 		GenesisTime:                  fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:        hexutil.Encode(st.GenesisValidatorsRoot()),
+		GenesisValidatorsRoot:        hexutil.Encode(params.BeaconConfig().GenesisValidatorsRoot[:]),
 		Slot:                         fmt.Sprintf("%d", st.Slot()),
 		Fork:                         ForkFromConsensus(st.Fork()),
 		LatestBlockHeader:            BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
@@ -564,7 +565,7 @@ func BeaconStateDenebFromConsensus(st beaconState.BeaconState) (*BeaconStateDene
 
 	return &BeaconStateDeneb{
 		GenesisTime:                  fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:        hexutil.Encode(st.GenesisValidatorsRoot()),
+		GenesisValidatorsRoot:        hexutil.Encode(params.BeaconConfig().GenesisValidatorsRoot[:]),
 		Slot:                         fmt.Sprintf("%d", st.Slot()),
 		Fork:                         ForkFromConsensus(st.Fork()),
 		LatestBlockHeader:            BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
@@ -737,7 +738,7 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 
 	return &BeaconStateElectra{
 		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
+		GenesisValidatorsRoot:         hexutil.Encode(params.BeaconConfig().GenesisValidatorsRoot[:]),
 		Slot:                          fmt.Sprintf("%d", st.Slot()),
 		Fork:                          ForkFromConsensus(st.Fork()),
 		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),

beacon-chain/blockchain/chain_info.go

@@ -282,7 +282,7 @@ func (s *Service) GenesisValidatorsRoot() [32]byte {
 	if !s.hasHeadState() {
 		return [32]byte{}
 	}
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
+	return params.BeaconConfig().GenesisValidatorsRoot
 }
 
 // CurrentFork retrieves the latest fork information of the beacon chain.

beacon-chain/blockchain/chain_info_test.go

@@ -302,7 +302,7 @@ func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 
 	c.head = &head{state: s}
 	root = c.HeadGenesisValidatorsRoot()
-	require.DeepEqual(t, root[:], s.GenesisValidatorsRoot())
+	require.DeepEqual(t, root[:], params.BeaconConfig().GenesisValidatorsRoot)
 }
 
 //

beacon-chain/blockchain/head.go

@@ -294,8 +294,8 @@ func (s *Service) headStateReadOnly(ctx context.Context) state.ReadOnlyBeaconSta
 
 // This returns the genesis validators root of the head state.
 // This is a lock free version.
-func (s *Service) headGenesisValidatorsRoot() [32]byte {
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
+func (*Service) headGenesisValidatorsRoot() [32]byte {
+	return params.BeaconConfig().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 primitives.Slot,
 	if err != nil {
 		return nil, err
 	}
-	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorsRoot())
+	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, params.BeaconConfig().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

@@ -85,7 +85,7 @@ func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, params.BeaconConfig().GenesisValidatorsRoot[:])
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncCommitteeDomain(context.Background(), 0)
@@ -99,7 +99,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.GenesisValidatorsRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, params.BeaconConfig().GenesisValidatorsRoot[:])
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncContributionProofDomain(context.Background(), 0)
@@ -113,7 +113,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.GenesisValidatorsRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, params.BeaconConfig().GenesisValidatorsRoot[:])
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncSelectionProofDomain(context.Background(), 0)

beacon-chain/blockchain/process_block_test.go

@@ -1036,7 +1036,7 @@ func TestService_insertSlashingsToForkChoiceStore(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().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/blockchain/service.go

@@ -324,7 +324,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "could not verify initial checkpoint provided for chain sync")
 	}
 
-	vr := bytesutil.ToBytes32(saved.GenesisValidatorsRoot())
+	vr := params.BeaconConfig().GenesisValidatorsRoot
 	if err := s.clockSetter.SetClock(startup.NewClock(s.genesisTime, vr)); err != nil {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
@@ -452,7 +452,7 @@ func (s *Service) onExecutionChainStart(ctx context.Context, genesisTime time.Ti
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
 
-	vr := bytesutil.ToBytes32(initializedState.GenesisValidatorsRoot())
+	vr := params.BeaconConfig().GenesisValidatorsRoot
 	if err := s.clockSetter.SetClock(startup.NewClock(genesisTime, vr)); err != nil {
 		log.WithError(err).Fatal("failed to initialize blockchain service from execution start event")
 	}

beacon-chain/blockchain/service_test.go

@@ -416,11 +416,10 @@ func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
 	gs, err := beaconDB.GenesisState(ctx)
 	require.NoError(t, err)
 	require.NotEqual(t, nil, gs)
-	require.Equal(t, 32, len(gs.GenesisValidatorsRoot()))
+	require.Equal(t, 32, len(params.BeaconConfig().GenesisValidatorsRoot))
 	var zero [32]byte
-	require.DeepNotEqual(t, gs.GenesisValidatorsRoot(), zero[:])
+	require.DeepNotEqual(t, params.BeaconConfig().GenesisValidatorsRoot, zero[:])
 	require.Equal(t, gt, mgs.G.GenesisTime())
-	require.Equal(t, bytesutil.ToBytes32(gs.GenesisValidatorsRoot()), mgs.G.GenesisValidatorsRoot())
 }
 
 func BenchmarkHasBlockDB(b *testing.B) {
@@ -477,8 +476,8 @@ func TestChainService_EverythingOptimistic(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	require.NoError(t, err)
 
 	c, tr := minimalTestService(t, WithFinalizedStateAtStartUp(headState))
@@ -533,8 +532,8 @@ func TestStartFromSavedState_ValidatorIndexCacheUpdated(t *testing.T) {
 		},
 	}))
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	require.NoError(t, err)
 
 	c, tr := minimalTestService(t, WithFinalizedStateAtStartUp(headState))

beacon-chain/core/altair/block.go

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

beacon-chain/core/altair/upgrade.go

@@ -73,7 +73,7 @@ func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.Beacon
 	}
 	s := &ethpb.BeaconStateAltair{
 		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
+		GenesisValidatorsRoot: params.BeaconConfig().GenesisValidatorsRoot[:],
 		Slot:                  state.Slot(),
 		Fork: &ethpb.Fork{
 			PreviousVersion: state.Fork().CurrentVersion,

beacon-chain/core/altair/upgrade_test.go

@@ -77,7 +77,6 @@ func TestUpgradeToAltair(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, preForkState.GenesisTime(), aState.GenesisTime())
-	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

@@ -233,7 +233,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBea
 		beaconState.Fork(),
 		indexedAtt.GetData().Target.Epoch,
 		params.BeaconConfig().DomainBeaconAttester,
-		beaconState.GenesisValidatorsRoot(),
+		params.BeaconConfig().GenesisValidatorsRoot[:],
 	)
 	if err != nil {
 		return err

beacon-chain/core/blocks/attestation_test.go

@@ -532,7 +532,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 			Slot: 1,
 		},
 	})
-	prevDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
+	prevDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().GenesisValidatorsRoot[:])
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, prevDomain)
 	require.NoError(t, err)
@@ -552,7 +552,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 			CommitteeIndex: 1,
 		},
 	})
-	currDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
+	currDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().GenesisValidatorsRoot[:])
 	require.NoError(t, err)
 	root, err = signing.ComputeSigningRoot(att2.Data, currDomain)
 	require.NoError(t, err)
@@ -592,7 +592,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 				Slot: 1,
 			},
 		})
-		domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
+		domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().GenesisValidatorsRoot[:])
 		require.NoError(t, err)
 		root, err := signing.ComputeSigningRoot(att1.Data, domain)
 		require.NoError(t, err)
@@ -644,7 +644,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 				Slot: 1,
 			},
 		})
-		domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
+		domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().GenesisValidatorsRoot[:])
 		require.NoError(t, err)
 		root, err := signing.ComputeSigningRoot(att1.Data, domain)
 		require.NoError(t, err)
@@ -711,7 +711,7 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 			Slot: 1,
 		},
 	})
-	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
+	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().GenesisValidatorsRoot[:])
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err)

beacon-chain/core/blocks/attester_slashing_test.go

@@ -116,7 +116,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().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")
@@ -189,7 +189,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().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")
@@ -262,7 +262,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().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")
@@ -335,7 +335,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusCapella(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().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.GenesisValidatorsRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().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

@@ -116,7 +116,7 @@ func VerifyExitAndSignature(
 	}
 
 	fork := state.Fork()
-	genesisRoot := state.GenesisValidatorsRoot()
+	genesisRoot := params.BeaconConfig().GenesisValidatorsRoot[:]
 
 	// EIP-7044: Beginning in Deneb, fix the fork version to Capella.
 	// This allows for signed validator exits to be valid forever.

beacon-chain/core/blocks/exit_test.go

@@ -259,7 +259,7 @@ func TestVerifyExitAndSignature(t *testing.T) {
 				}
 				bs, keys := util.DeterministicGenesisState(t, 1)
 				bs, err := state_native.InitializeFromProtoUnsafeDeneb(&ethpb.BeaconStateDeneb{
-					GenesisValidatorsRoot: bs.GenesisValidatorsRoot(),
+					GenesisValidatorsRoot: params.BeaconConfig().GenesisValidatorsRoot[:],
 					Fork:                  fork,
 					Slot:                  denebSlot,
 					Validators:            bs.Validators(),
@@ -298,7 +298,7 @@ func TestVerifyExitAndSignature(t *testing.T) {
 				require.NoError(t, err)
 				bs, keys := util.DeterministicGenesisState(t, 1)
 				bs, err = state_native.InitializeFromProtoUnsafeElectra(&ethpb.BeaconStateElectra{
-					GenesisValidatorsRoot: bs.GenesisValidatorsRoot(),
+					GenesisValidatorsRoot: params.BeaconConfig().GenesisValidatorsRoot[:],
 					Fork:                  fork,
 					Slot:                  electraSlot,
 					Validators:            bs.Validators(),

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -426,7 +426,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.GenesisValidatorsRoot())
+			d, err := signing.Domain(tt.args.beaconState.Fork(), slots.ToEpoch(tt.args.slashing.Header_1.Header.Slot), params.BeaconConfig().DomainBeaconProposer, params.BeaconConfig().GenesisValidatorsRoot[:])
 			require.NoError(t, err)
 			if tt.args.slashing.Header_1.Signature == nil {
 				sr, err := signing.ComputeSigningRoot(tt.args.slashing.Header_1.Header, d)