Use nodeIDs to generate root cluster block

Author: tim-barry

cmd/bootstrap/run/cluster_block.go

@@ -16,7 +16,7 @@ func GenerateRootClusterBlocks(epoch uint64, clusters flow.ClusterList) []*clust
 			panic(fmt.Sprintf("failed to get cluster by index: %v", i))
 		}
 
-		rootBlock, err := clusterstate.CanonicalRootBlock(epoch, cluster)
+		rootBlock, err := clusterstate.CanonicalRootBlock(epoch, cluster.NodeIDs())
 		if err != nil {
 			panic(fmt.Errorf("failed to get canonical root block: %w", err))
 		}

consensus/hotstuff/committees/cluster_committee_test.go

@@ -49,7 +49,7 @@ func (suite *ClusterSuite) SetupTest() {
 	suite.members = unittest.IdentityListFixture(5, unittest.WithRole(flow.RoleCollection))
 	suite.me = suite.members[0]
 	counter := uint64(1)
-	rootBlock, err := clusterstate.CanonicalRootBlock(counter, suite.members.ToSkeleton())
+	rootBlock, err := clusterstate.CanonicalRootBlock(counter, suite.members.ToSkeleton().NodeIDs())
 	suite.Require().NoError(err)
 	suite.root = rootBlock
 

engine/collection/test/cluster_switchover_test.go

@@ -173,7 +173,7 @@ func NewClusterSwitchoverTestCase(t *testing.T, conf ClusterSwitchoverTestConf)
 			}
 
 			// generate root cluster block
-			rootClusterBlock, err := cluster.CanonicalRootBlock(commit.Counter, model.ToIdentityList(signers).ToSkeleton())
+			rootClusterBlock, err := cluster.CanonicalRootBlock(commit.Counter, clusterQC.VoterIDs)
 			require.NoError(tc.T(), err)
 			// generate cluster root qc
 			qc, err := run.GenerateClusterRootQC(signers, model.ToIdentityList(signers).ToSkeleton(), rootClusterBlock)

integration/epochs/epoch_qc_test.go

@@ -66,7 +66,7 @@ func (s *Suite) TestEpochQuorumCertificate() {
 
 		// find cluster and create root block
 		cluster, _, _ := clustering.ByNodeID(node.NodeID)
-		rootBlock, err := clusterstate.CanonicalRootBlock(uint64(epochCounter), cluster)
+		rootBlock, err := clusterstate.CanonicalRootBlock(epochCounter, cluster.NodeIDs())
 		s.Require().NoError(err)
 
 		key, signer := test.AccountKeyGenerator().NewWithSigner()

integration/testnet/network.go

@@ -1419,35 +1419,35 @@ func setupClusterGenesisBlockQCs(nClusters uint, epochCounter uint64, confs []Co
 	participants := participantsUnsorted.Sort(flow.Canonical[flow.Identity])
 	collectors := participants.Filter(filter.HasRole[flow.Identity](flow.RoleCollection)).ToSkeleton()
 	assignments := unittest.ClusterAssignment(nClusters, collectors)
-	clusters, err := factory.NewClusterList(assignments, collectors)
+	_, err := factory.NewClusterList(assignments, collectors)
 	if err != nil {
 		return nil, nil, nil, fmt.Errorf("could not create cluster list: %w", err)
 	}
 
 	rootBlocks := make([]*cluster.Block, 0, nClusters)
 	qcs := make([]*flow.QuorumCertificate, 0, nClusters)
 
-	for _, cluster := range clusters {
+	for _, assignment := range assignments {
 		// generate root cluster block
-		block, err := clusterstate.CanonicalRootBlock(epochCounter, cluster)
+		block, err := clusterstate.CanonicalRootBlock(epochCounter, assignment)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("failed to generate canonical root block: %w", err)
 		}
 
 		lookup := make(map[flow.Identifier]struct{})
-		for _, node := range cluster {
-			lookup[node.NodeID] = struct{}{}
+		for _, nodeID := range assignment {
+			lookup[nodeID] = struct{}{}
 		}
 
 		// gather cluster participants
-		clusterNodeInfos := make([]bootstrap.NodeInfo, 0, len(cluster))
+		clusterNodeInfos := make([]bootstrap.NodeInfo, 0, len(assignment))
 		for _, conf := range confs {
 			_, exists := lookup[conf.NodeID]
 			if exists {
 				clusterNodeInfos = append(clusterNodeInfos, conf.NodeInfo)
 			}
 		}
-		if len(cluster) != len(clusterNodeInfos) { // sanity check
+		if len(assignment) != len(clusterNodeInfos) { // sanity check
 			return nil, nil, nil, fmt.Errorf("requiring a node info for each cluster participant")
 		}
 

integration/tests/collection/suite.go

@@ -339,7 +339,7 @@ func (suite *CollectorSuite) ClusterStateFor(id flow.Identifier) *clusterstateim
 
 	setup, ok := suite.net.Result().ServiceEvents[0].Event.(*flow.EpochSetup)
 	suite.Require().True(ok, "could not get root seal setup")
-	rootBlock, err := clusterstate.CanonicalRootBlock(setup.Counter, myCluster)
+	rootBlock, err := clusterstate.CanonicalRootBlock(setup.Counter, myCluster.NodeIDs())
 	suite.Require().NoError(err)
 	node := suite.net.ContainerByID(id)
 

module/epochs/qc_voter.go

@@ -99,7 +99,7 @@ func (voter *RootQCVoter) Vote(ctx context.Context, epoch protocol.TentativeEpoc
 	log.Info().Msg("preparing to generate vote for cluster root qc")
 
 	// create the canonical root block for our cluster
-	root, err := clusterstate.CanonicalRootBlock(counter, cluster)
+	root, err := clusterstate.CanonicalRootBlock(counter, cluster.NodeIDs())
 	if err != nil {
 		return fmt.Errorf("could not create cluster root block: %w", err)
 	}

state/cluster/root_block.go

@@ -15,8 +15,8 @@ func CanonicalClusterID(epoch uint64, participants flow.IdentifierList) flow.Cha
 
 // CanonicalRootBlock returns the canonical root block for the given
 // cluster in the given epoch. It contains an empty collection referencing
-func CanonicalRootBlock(epoch uint64, participants flow.IdentitySkeletonList) (*cluster.Block, error) {
-	chainID := CanonicalClusterID(epoch, participants.NodeIDs())
+func CanonicalRootBlock(epoch uint64, participants flow.IdentifierList) (*cluster.Block, error) {
+	chainID := CanonicalClusterID(epoch, participants)
 	rootHeaderBody, err := flow.NewRootHeaderBody(flow.UntrustedHeaderBody{
 		ChainID:            chainID,
 		ParentID:           flow.ZeroID,

state/protocol/inmem/epoch.go

@@ -234,7 +234,7 @@ func (es *committedEpoch) Cluster(index uint) (protocol.Cluster, error) {
 		return nil, fmt.Errorf("could not encode signer indices for rootQCVoteData.VoterIDs: %w", err)
 	}
 
-	rootBlock, err := cluster.CanonicalRootBlock(epochCounter, members)
+	rootBlock, err := cluster.CanonicalRootBlock(epochCounter, members.NodeIDs())
 	if err != nil {
 		return nil, fmt.Errorf("could not generate canonical root block: %w", err)
 	}