[EFM] Update protocol.DKG to use IndexMap

cmd/bootstrap/run/qc.go

@@ -24,21 +24,26 @@ type Participant struct {
 	RandomBeaconPrivKey crypto.PrivateKey
 }
 
+// ParticipantData represents a subset of all consensus participants that contributing to some signing process (at the moment, we only use
+// it for the contributors for the root QC). For mainnet, this a *strict subset* of all consensus participants:
+//   - In an early step during the bootstrapping process, every node operator locally generates votes for the root block from the nodes they
+//     operate. During the vote-generation step, (see function `constructRootVotes`), `Participants` represents only the operator's own
+//     nodes (generally a small minority of the entire consensus committee).
+//   - During a subsequent step of the bootstrapping process, the Flow Foundation collects a supermajority of votes from the consensus
+//     participants and constructs the root QC  (see function `constructRootQC`). Here, `Participants` is only populated with
+//     the information of the internal does that the Flow Foundation runs, but not used.
+//
+// Furthermore, ParticipantData contains auxiliary data about the DKG to set up the random beacon. Note that the consensus committee 𝒞 and the
+// DKG committee 𝒟 are generally _not_ identical. We explicitly want to support that _either_ set can have nodes that are not in
+// the other set (formally 𝒟 \ 𝒞 ≠ ∅ and 𝒞 \ 𝒟 ≠ ∅). ParticipantData has no direct representation of the consensus committee 𝒞.
 type ParticipantData struct {
+	// Participants of the signing process: only members of the consensus committee can vote (formally Participants ⊊ 𝒞).
+	// However, we allow for consensus committee members that are _not_ part of the random beacon committee 𝒟 (formally
+	// ∅ ≠ Participants \ 𝒟).
 	Participants []Participant
-	Lookup       map[flow.Identifier]flow.DKGParticipant
-	GroupKey     crypto.PublicKey
-}
 
-// PublicBeaconKeys returns the nodes' individual public random-beacon keys (excluding
-// the group public key). The keys are returned in the same order as the nodes appear
-// in the Participants list, which must be the DKG index order.
-func (pd *ParticipantData) PublicBeaconKeys() []crypto.PublicKey {
-	keys := make([]crypto.PublicKey, len(pd.Participants))
-	for i, participant := range pd.Participants {
-		keys[i] = participant.RandomBeaconPrivKey.PublicKey()
-	}
-	return keys
+	DKGCommittee map[flow.Identifier]flow.DKGParticipant // DKG committee 𝒟 (to set up the random beacon)
+	DKGGroupKey  crypto.PublicKey                        // group key for the DKG committee 𝒟
 }
 
 func (pd *ParticipantData) Identities() flow.IdentityList {
@@ -49,6 +54,26 @@ func (pd *ParticipantData) Identities() flow.IdentityList {
 	return bootstrap.ToIdentityList(nodes)
 }
 
+// DKGData returns a map from node ID to DKG index and a list of public keys, one per DKG participant, ordered by Random Beacon index.
+// Can be used to reconstruct EpochCommit.
+// This implementation guarantees the following protocol-mandated invariants (or returns an
+// exception for non-compliant `ParticipantData`):
+//   - len(DKGParticipantKeys) == len(DKGData)
+//   - DKGData values form the set {0, 1, ..., n-1} where n=len(DKGParticipantKeys)
+//
+// CAUTION: This mapping may include identifiers for nodes which do not exist in the consensus committee
+//
+//	and may NOT include identifiers for all nodes in the consensus committee.
+func (pd *ParticipantData) DKGData() (flow.DKGIndexMap, []crypto.PublicKey) {
+	indexMap := make(flow.DKGIndexMap, len(pd.DKGCommittee))
+	keys := make([]crypto.PublicKey, len(pd.DKGCommittee))
+	for nodeID, participant := range pd.DKGCommittee {
+		indexMap[nodeID] = int(participant.Index)
+		keys[participant.Index] = participant.KeyShare
+	}
+	return indexMap, keys
+}
+
 // GenerateRootQC generates QC for root block, caller needs to provide votes for root QC and
 // participantData to build the QC.
 // NOTE: at the moment, we require private keys for one node because we we re-using the full business logic,
@@ -64,7 +89,7 @@ func GenerateRootQC(block *flow.Block, votes []*model.Vote, participantData *Par
 	error, // exception or could not construct qc
 ) {
 	// create consensus committee's state
-	committee, err := committees.NewStaticCommittee(identities, flow.Identifier{}, participantData.Lookup, participantData.GroupKey)
+	committee, err := committees.NewStaticCommittee(identities, flow.Identifier{}, participantData.DKGCommittee, participantData.DKGGroupKey)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -209,8 +234,8 @@ func GenerateQCParticipantData(allNodes, internalNodes []bootstrap.NodeInfo, dkg
 		})
 	}
 
-	qcData.Lookup = participantLookup
-	qcData.GroupKey = dkgData.PubGroupKey
+	qcData.DKGCommittee = participantLookup
+	qcData.DKGGroupKey = dkgData.PubGroupKey
 
 	return qcData, nil
 }

cmd/bootstrap/run/qc_test.go

@@ -85,8 +85,8 @@ func createSignerData(t *testing.T, n int) *ParticipantData {
 
 	participantData := &ParticipantData{
 		Participants: participants,
-		Lookup:       participantLookup,
-		GroupKey:     groupKey,
+		DKGCommittee: participantLookup,
+		DKGGroupKey:  groupKey,
 	}
 
 	return participantData

consensus/hotstuff/committees/static.go

@@ -147,3 +147,16 @@ func (s staticDKG) KeyShare(nodeID flow.Identifier) (crypto.PublicKey, error) {
 	}
 	return participant.KeyShare, nil
 }
+
+// NodeID returns the node identifier for the given index.
+// An exception is returned if the index is ≥ Size().
+// Intended for use outside the hotpath, with runtime
+// scaling linearly in the number of DKG participants (ie. Size())
+func (s staticDKG) NodeID(index uint) (flow.Identifier, error) {
+	for nodeID, participant := range s.dkgParticipants {
+		if participant.Index == index {
+			return nodeID, nil
+		}
+	}
+	return flow.ZeroID, fmt.Errorf("index %d not found in DKG", index)
+}

consensus/hotstuff/signature/randombeacon_reconstructor_test.go

@@ -13,8 +13,8 @@ import (
 // TestRandomBeaconReconstructor_InvalidSignerID tests that RandomBeaconReconstructor doesn't forward calls to
 // RandomBeaconInspector if it fails to map signerID to signerIndex
 func TestRandomBeaconReconstructor_InvalidSignerID(t *testing.T) {
-	dkg := &mockhotstuff.DKG{}
-	inspector := &mockhotstuff.RandomBeaconInspector{}
+	dkg := mockhotstuff.NewDKG(t)
+	inspector := mockhotstuff.NewRandomBeaconInspector(t)
 	reconstructor := NewRandomBeaconReconstructor(dkg, inspector)
 	exception := errors.New("invalid-signer-id")
 	t.Run("trustedAdd", func(t *testing.T) {
@@ -31,7 +31,4 @@ func TestRandomBeaconReconstructor_InvalidSignerID(t *testing.T) {
 		require.ErrorAs(t, err, &exception)
 		inspector.AssertNotCalled(t, "Verify")
 	})
-
-	dkg.AssertExpectations(t)
-	inspector.AssertExpectations(t)
 }

consensus/hotstuff/votecollector/combined_vote_processor_v2_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	"go.uber.org/atomic"
+	"golang.org/x/exp/slices"
 	"pgregory.net/rapid"
 
 	bootstrapDKG "github.com/onflow/flow-go/cmd/bootstrap/dkg"
@@ -28,7 +29,6 @@ import (
 	"github.com/onflow/flow-go/module/local"
 	modulemock "github.com/onflow/flow-go/module/mock"
 	msig "github.com/onflow/flow-go/module/signature"
-	"github.com/onflow/flow-go/state/protocol/inmem"
 	storagemock "github.com/onflow/flow-go/storage/mock"
 	"github.com/onflow/flow-go/utils/unittest"
 )
@@ -796,6 +796,7 @@ func TestCombinedVoteProcessorV2_BuildVerifyQC(t *testing.T) {
 	stakingSigners := unittest.IdentityListFixture(3)
 	beaconSigners := unittest.IdentityListFixture(8)
 	allIdentities := append(stakingSigners, beaconSigners...)
+	slices.SortFunc(allIdentities, flow.Canonical[flow.Identity]) // sort in place to avoid taking a copy.
 	require.Equal(t, len(dkgData.PubKeyShares), len(allIdentities))
 	dkgParticipants := make(map[flow.Identifier]flow.DKGParticipant)
 	// fill dkg participants data
@@ -827,7 +828,6 @@ func TestCombinedVoteProcessorV2_BuildVerifyQC(t *testing.T) {
 		identity.StakingPubKey = stakingPriv.PublicKey()
 
 		participantData := dkgParticipants[identity.NodeID]
-
 		dkgKey := encodable.RandomBeaconPrivKey{
 			PrivateKey: dkgData.PrivKeyShares[participantData.Index],
 		}
@@ -844,25 +844,14 @@ func TestCombinedVoteProcessorV2_BuildVerifyQC(t *testing.T) {
 		signers[identity.NodeID] = verification.NewCombinedSigner(me, beaconSignerStore)
 	}
 
-	leader := stakingSigners[0]
+	leader := allIdentities[0]
 
 	block := helper.MakeBlock(helper.WithBlockView(view),
 		helper.WithBlockProposer(leader.NodeID))
 
-	inmemDKG, err := inmem.DKGFromEncodable(inmem.EncodableDKG{
-		GroupKey: encodable.RandomBeaconPubKey{
-			PublicKey: dkgData.PubGroupKey,
-		},
-		Participants: dkgParticipants,
-	})
+	committee, err := committees.NewStaticCommittee(allIdentities, flow.ZeroID, dkgParticipants, dkgData.PubGroupKey)
 	require.NoError(t, err)
 
-	committee := &mockhotstuff.DynamicCommittee{}
-	committee.On("QuorumThresholdForView", mock.Anything).Return(committees.WeightThresholdToBuildQC(allIdentities.ToSkeleton().TotalWeight()), nil)
-	committee.On("IdentitiesByEpoch", block.View).Return(allIdentities.ToSkeleton(), nil)
-	committee.On("IdentitiesByBlock", block.BlockID).Return(allIdentities, nil)
-	committee.On("DKG", block.View).Return(inmemDKG, nil)
-
 	votes := make([]*model.Vote, 0, len(allIdentities))
 
 	// first staking signer will be leader collecting votes for proposal

consensus/hotstuff/votecollector/combined_vote_processor_v3_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	"go.uber.org/atomic"
+	"golang.org/x/exp/slices"
 	"pgregory.net/rapid"
 
 	bootstrapDKG "github.com/onflow/flow-go/cmd/bootstrap/dkg"
@@ -27,7 +28,6 @@ import (
 	"github.com/onflow/flow-go/module/local"
 	modulemock "github.com/onflow/flow-go/module/mock"
 	"github.com/onflow/flow-go/module/signature"
-	"github.com/onflow/flow-go/state/protocol/inmem"
 	storagemock "github.com/onflow/flow-go/storage/mock"
 	"github.com/onflow/flow-go/utils/unittest"
 )
@@ -932,6 +932,7 @@ func TestCombinedVoteProcessorV3_BuildVerifyQC(t *testing.T) {
 	stakingSigners := unittest.IdentityListFixture(3)
 	beaconSigners := unittest.IdentityListFixture(8)
 	allIdentities := append(stakingSigners, beaconSigners...)
+	slices.SortFunc(allIdentities, flow.Canonical[flow.Identity]) // sort in place to avoid taking a copy.
 	require.Equal(t, len(dkgData.PubKeyShares), len(allIdentities))
 	dkgParticipants := make(map[flow.Identifier]flow.DKGParticipant)
 	// fill dkg participants data
@@ -980,25 +981,14 @@ func TestCombinedVoteProcessorV3_BuildVerifyQC(t *testing.T) {
 		signers[identity.NodeID] = verification.NewCombinedSignerV3(me, beaconSignerStore)
 	}
 
-	leader := stakingSigners[0]
+	leader := allIdentities[0]
 
 	block := helper.MakeBlock(helper.WithBlockView(view),
 		helper.WithBlockProposer(leader.NodeID))
 
-	inmemDKG, err := inmem.DKGFromEncodable(inmem.EncodableDKG{
-		GroupKey: encodable.RandomBeaconPubKey{
-			PublicKey: dkgData.PubGroupKey,
-		},
-		Participants: dkgParticipants,
-	})
+	committee, err := committees.NewStaticCommittee(allIdentities, flow.ZeroID, dkgParticipants, dkgData.PubGroupKey)
 	require.NoError(t, err)
 
-	committee := &mockhotstuff.DynamicCommittee{}
-	committee.On("IdentitiesByBlock", block.BlockID).Return(allIdentities, nil)
-	committee.On("IdentitiesByEpoch", block.View).Return(allIdentities.ToSkeleton(), nil)
-	committee.On("QuorumThresholdForView", mock.Anything).Return(committees.WeightThresholdToBuildQC(allIdentities.ToSkeleton().TotalWeight()), nil)
-	committee.On("DKG", block.View).Return(inmemDKG, nil)
-
 	votes := make([]*model.Vote, 0, len(allIdentities))
 
 	// first staking signer will be leader collecting votes for proposal

consensus/integration/epoch_test.go

@@ -226,11 +226,13 @@ func withNextEpoch(
 		Participants: nextEpochIdentities.ToSkeleton(),
 		Assignments:  unittest.ClusterAssignment(1, nextEpochIdentities.ToSkeleton()),
 	}
+	dkgIndexMap, dkgParticipantKeys := nextEpochParticipantData.DKGData()
 	nextEpochCommit := &flow.EpochCommit{
 		Counter:            nextEpochSetup.Counter,
 		ClusterQCs:         currEpochCommit.ClusterQCs,
-		DKGParticipantKeys: nextEpochParticipantData.PublicBeaconKeys(),
-		DKGGroupKey:        nextEpochParticipantData.GroupKey,
+		DKGParticipantKeys: dkgParticipantKeys,
+		DKGGroupKey:        nextEpochParticipantData.DKGGroupKey,
+		DKGIndexMap:        dkgIndexMap,
 	}
 
 	// Construct the new min epoch state entry

consensus/integration/nodes_test.go

@@ -95,7 +95,7 @@ func NewConsensusParticipants(data *run.ParticipantData) *ConsensusParticipants
 			beaconInfoByEpoch: map[uint64]RandomBeaconNodeInfo{
 				1: {
 					RandomBeaconPrivKey: participant.RandomBeaconPrivKey,
-					DKGParticipant:      data.Lookup[participant.NodeID],
+					DKGParticipant:      data.DKGCommittee[participant.NodeID],
 				},
 			},
 		}
@@ -118,7 +118,7 @@ func (p *ConsensusParticipants) Lookup(nodeID flow.Identifier) *ConsensusPartici
 // If this node was part of previous epoch it will get updated, if not created.
 func (p *ConsensusParticipants) Update(epochCounter uint64, data *run.ParticipantData) {
 	for _, participant := range data.Participants {
-		dkgParticipant := data.Lookup[participant.NodeID]
+		dkgParticipant := data.DKGCommittee[participant.NodeID]
 		entry, ok := p.lookup[participant.NodeID]
 		if !ok {
 			entry = ConsensusParticipant{
@@ -257,12 +257,13 @@ func createRootBlockData(t *testing.T, participantData *run.ParticipantData) (*f
 	consensusParticipants := participantData.Identities()
 
 	// add other roles to create a complete identity list
-	participants := unittest.CompleteIdentitySet(consensusParticipants...)
-	participants.Sort(flow.Canonical[flow.Identity])
-
+	participants := unittest.CompleteIdentitySet(consensusParticipants...).Sort(flow.Canonical[flow.Identity])
+	dkgParticipants := participants.ToSkeleton().Filter(filter.IsValidDKGParticipant)
 	dkgParticipantsKeys := make([]crypto.PublicKey, 0, len(consensusParticipants))
-	for _, participant := range participants.Filter(filter.HasRole[flow.Identity](flow.RoleConsensus)) {
-		dkgParticipantsKeys = append(dkgParticipantsKeys, participantData.Lookup[participant.NodeID].KeyShare)
+	dkgIndexMap := make(flow.DKGIndexMap)
+	for index, participant := range dkgParticipants {
+		dkgParticipantsKeys = append(dkgParticipantsKeys, participantData.DKGCommittee[participant.NodeID].KeyShare)
+		dkgIndexMap[participant.NodeID] = index
 	}
 
 	counter := uint64(1)
@@ -276,8 +277,9 @@ func createRootBlockData(t *testing.T, participantData *run.ParticipantData) (*f
 		unittest.CommitWithCounter(counter),
 		unittest.WithClusterQCsFromAssignments(setup.Assignments),
 		func(commit *flow.EpochCommit) {
-			commit.DKGGroupKey = participantData.GroupKey
+			commit.DKGGroupKey = participantData.DKGGroupKey
 			commit.DKGParticipantKeys = dkgParticipantsKeys
+			commit.DKGIndexMap = dkgIndexMap
 		},
 	)
 
@@ -327,16 +329,16 @@ func completeConsensusIdentities(t *testing.T, nodeInfos []bootstrap.NodeInfo) *
 
 	participantData := &run.ParticipantData{
 		Participants: make([]run.Participant, 0, len(nodeInfos)),
-		Lookup:       make(map[flow.Identifier]flow.DKGParticipant),
-		GroupKey:     dkgData.PubGroupKey,
+		DKGCommittee: make(map[flow.Identifier]flow.DKGParticipant),
+		DKGGroupKey:  dkgData.PubGroupKey,
 	}
 	for index, node := range nodeInfos {
 		participant := run.Participant{
 			NodeInfo:            node,
 			RandomBeaconPrivKey: dkgData.PrivKeyShares[index],
 		}
 		participantData.Participants = append(participantData.Participants, participant)
-		participantData.Lookup[node.NodeID] = flow.DKGParticipant{
+		participantData.DKGCommittee[node.NodeID] = flow.DKGParticipant{
 			Index:    uint(index),
 			KeyShare: dkgData.PubKeyShares[index],
 		}