Support Epoch Extensions in HotStuff Committee

consensus/hotstuff/committees/leader/leader_selection.go

@@ -167,12 +167,12 @@ func weightedRandomSelection(
 	return leaders, nil
 }
 
-// binarySearchStriclyBigger finds the index of the first item in the given array that is
+// binarySearchStrictlyBigger finds the index of the first item in the given array that is
 // strictly bigger to the given value.
 // There are a few assumptions on inputs:
-// - `arr` must be non-empty
-// - items in `arr` must be in non-decreasing order
-// - `value` must be less than the last item in `arr`
+//   - `arr` must be non-empty
+//   - items in `arr` must be in non-decreasing order
+//   - `value` must be less than the last item in `arr`
 func binarySearchStrictlyBigger(value uint64, arr []uint64) int {
 	left := 0
 	arrayLen := len(arr)

consensus/hotstuff/committees/leader/leader_selection_test.go

@@ -304,7 +304,7 @@ func TestLeaderSelectionAreWeighted(t *testing.T) {
 
 func BenchmarkLeaderSelection(b *testing.B) {
 
-	const N_VIEWS = 15000000
+	const N_VIEWS = EstimatedSixMonthOfViews
 	const N_NODES = 20
 
 	identities := make(flow.IdentityList, 0, N_NODES)

state/protocol/badger/mutator_test.go

@@ -2348,6 +2348,11 @@ func TestRecoveryFromEpochFallbackMode(t *testing.T) {
 			err = state.Finalize(context.Background(), block9.ID())
 			require.NoError(t, err)
 
+			// After epoch extension, FinalView must be updated accordingly
+			finalView, err := state.Final().Epochs().Current().FinalView()
+			require.NoError(t, err)
+			assert.Equal(t, epochExtensions[0].FinalView, finalView)
+
 			// Constructing blocks
 			//   ... <- B10 <- B11(ER(B4, EpochRecover)) <- B12(S(ER(B4))) <- ...
 			// B10 will be the first block past the epoch extension. Block B11 incorporates the Execution Result [ER]

state/protocol/badger/snapshot.go

@@ -397,9 +397,9 @@ func (q *EpochQuery) Current() protocol.Epoch {
 		return invalid.NewEpochf("could not get current epoch height bounds: %s", err.Error())
 	}
 	if isFirstHeightKnown {
-		return inmem.NewEpochWithStartBoundary(setup, commit, firstHeight)
+		return inmem.NewEpochWithStartBoundary(setup, epochState.EpochExtensions(), commit, firstHeight)
 	}
-	return inmem.NewCommittedEpoch(setup, commit)
+	return inmem.NewCommittedEpoch(setup, epochState.EpochExtensions(), commit)
 }
 
 // Next returns the next epoch, if it is available.
@@ -419,12 +419,12 @@ func (q *EpochQuery) Next() protocol.Epoch {
 	// if we are in setup phase, return a SetupEpoch
 	nextSetup := entry.NextEpochSetup
 	if phase == flow.EpochPhaseSetup {
-		return inmem.NewSetupEpoch(nextSetup)
+		return inmem.NewSetupEpoch(nextSetup, entry.NextEpoch.EpochExtensions)
 	}
 	// if we are in committed phase, return a CommittedEpoch
 	nextCommit := entry.NextEpochCommit
 	if phase == flow.EpochPhaseCommitted {
-		return inmem.NewCommittedEpoch(nextSetup, nextCommit)
+		return inmem.NewCommittedEpoch(nextSetup, entry.NextEpoch.EpochExtensions, nextCommit)
 	}
 	return invalid.NewEpochf("data corruption: unknown epoch phase implies malformed protocol state epoch data")
 }
@@ -457,22 +457,22 @@ func (q *EpochQuery) Previous() protocol.Epoch {
 	}
 	if firstHeightKnown && finalHeightKnown {
 		// typical case - we usually know both boundaries for a past epoch
-		return inmem.NewEpochWithStartAndEndBoundaries(setup, commit, firstHeight, finalHeight)
+		return inmem.NewEpochWithStartAndEndBoundaries(setup, entry.PreviousEpoch.EpochExtensions, commit, firstHeight, finalHeight)
 	}
 	if firstHeightKnown && !finalHeightKnown {
 		// this case is possible when the snapshot reference block is un-finalized
 		// and is past an un-finalized epoch boundary
-		return inmem.NewEpochWithStartBoundary(setup, commit, firstHeight)
+		return inmem.NewEpochWithStartBoundary(setup, entry.PreviousEpoch.EpochExtensions, commit, firstHeight)
 	}
 	if !firstHeightKnown && finalHeightKnown {
 		// this case is possible when this node's lowest known block is after
 		// the queried epoch's start boundary
-		return inmem.NewEpochWithEndBoundary(setup, commit, finalHeight)
+		return inmem.NewEpochWithEndBoundary(setup, entry.PreviousEpoch.EpochExtensions, commit, finalHeight)
 	}
 	if !firstHeightKnown && !finalHeightKnown {
 		// this case is possible when this node's lowest known block is after
 		// the queried epoch's end boundary
-		return inmem.NewCommittedEpoch(setup, commit)
+		return inmem.NewCommittedEpoch(setup, entry.PreviousEpoch.EpochExtensions, commit)
 	}
 	return invalid.NewEpochf("sanity check failed: impossible combination of boundaries for previous epoch")
 }

state/protocol/convert.go

@@ -156,33 +156,6 @@ func GetDKGParticipantKeys(dkg DKG, participants flow.IdentitySkeletonList) ([]c
 	return keys, nil
 }
 
-// ToDKGParticipantLookup computes the nodeID -> DKGParticipant lookup for a
-// DKG instance. The participants must exactly match the DKG instance configuration.
-// All errors indicate inconsistent or invalid inputs.
-// No errors are expected during normal operation.
-func ToDKGParticipantLookup(dkg DKG, participants flow.IdentitySkeletonList) (map[flow.Identifier]flow.DKGParticipant, error) {
-
-	lookup := make(map[flow.Identifier]flow.DKGParticipant)
-	for _, identity := range participants {
-
-		index, err := dkg.Index(identity.NodeID)
-		if err != nil {
-			return nil, fmt.Errorf("could not get index (node=%x): %w", identity.NodeID, err)
-		}
-		key, err := dkg.KeyShare(identity.NodeID)
-		if err != nil {
-			return nil, fmt.Errorf("could not get key share (node=%x): %w", identity.NodeID, err)
-		}
-
-		lookup[identity.NodeID] = flow.DKGParticipant{
-			Index:    index,
-			KeyShare: key,
-		}
-	}
-
-	return lookup, nil
-}
-
 // DKGPhaseViews returns the DKG final phase views for an epoch.
 // Error returns:
 // * protocol.ErrNoPreviousEpoch - if the epoch represents a previous epoch which does not exist.

state/protocol/convert_test.go

@@ -13,7 +13,7 @@ import (
 
 func TestToEpochSetup(t *testing.T) {
 	expected := unittest.EpochSetupFixture()
-	epoch := inmem.NewSetupEpoch(expected)
+	epoch := inmem.NewSetupEpoch(expected, nil)
 
 	got, err := protocol.ToEpochSetup(epoch)
 	require.NoError(t, err)
@@ -26,7 +26,7 @@ func TestToEpochCommit(t *testing.T) {
 		unittest.CommitWithCounter(setup.Counter),
 		unittest.WithDKGFromParticipants(setup.Participants),
 		unittest.WithClusterQCsFromAssignments(setup.Assignments))
-	epoch := inmem.NewCommittedEpoch(setup, expected)
+	epoch := inmem.NewCommittedEpoch(setup, nil, expected)
 
 	got, err := protocol.ToEpochCommit(epoch)
 	require.NoError(t, err)

state/protocol/epoch.go

@@ -94,6 +94,12 @@ type Epoch interface {
 	DKGPhase3FinalView() (uint64, error)
 
 	// FinalView returns the largest view number which still belongs to this epoch.
+	// The largest view number is the greatest of:
+	//   - the FinalView field of the flow.EpochSetup event for this epoch
+	//   - the FinalView field of the most recent flow.EpochExtension for this epoch
+	// If EFM is not triggered during this epoch, this value will be static.
+	// If EFM is triggered during this epoch, this value may increase with increasing
+	// reference block heights, as new epoch extensions are included.
 	// Error returns:
 	// * protocol.ErrNoPreviousEpoch - if the epoch represents a previous epoch which does not exist.
 	// * protocol.ErrNextEpochNotSetup - if the epoch represents a next epoch which has not been set up.

state/protocol/inmem/convert.go

@@ -63,37 +63,6 @@ func FromParams(from protocol.GlobalParams) (*Params, error) {
 	return &Params{params}, nil
 }
 
-// FromCluster converts any protocol.Cluster to a memory-backed Cluster.
-// No errors are expected during normal operation.
-func FromCluster(from protocol.Cluster) (*Cluster, error) {
-	cluster := EncodableCluster{
-		Counter:   from.EpochCounter(),
-		Index:     from.Index(),
-		Members:   from.Members(),
-		RootBlock: from.RootBlock(),
-		RootQC:    from.RootQC(),
-	}
-	return &Cluster{cluster}, nil
-}
-
-// FromDKG converts any protocol.DKG to a memory-backed DKG.
-//
-// The given participant list must exactly match the DKG members.
-// All errors indicate inconsistent or invalid inputs.
-// No errors are expected during normal operation.
-func FromDKG(from protocol.DKG, participants flow.IdentitySkeletonList) (*DKG, error) {
-	var dkg EncodableDKG
-	dkg.GroupKey = encodable.RandomBeaconPubKey{PublicKey: from.GroupKey()}
-
-	lookup, err := protocol.ToDKGParticipantLookup(from, participants)
-	if err != nil {
-		return nil, fmt.Errorf("could not generate dkg participant lookup: %w", err)
-	}
-	dkg.Participants = lookup
-
-	return &DKG{dkg}, nil
-}
-
 // DKGFromEncodable returns a DKG backed by the given encodable representation.
 func DKGFromEncodable(enc EncodableDKG) (*DKG, error) {
 	return &DKG{enc}, nil

state/protocol/inmem/epoch.go

@@ -23,30 +23,32 @@ func (eq Epochs) Previous() protocol.Epoch {
 	if eq.entry.PreviousEpoch == nil {
 		return invalid.NewEpoch(protocol.ErrNoPreviousEpoch)
 	}
-	return NewCommittedEpoch(eq.entry.PreviousEpochSetup, eq.entry.PreviousEpochCommit)
+	return NewCommittedEpoch(eq.entry.PreviousEpochSetup, eq.entry.PreviousEpoch.EpochExtensions, eq.entry.PreviousEpochCommit)
 }
 
 func (eq Epochs) Current() protocol.Epoch {
-	return NewCommittedEpoch(eq.entry.CurrentEpochSetup, eq.entry.CurrentEpochCommit)
+	return NewCommittedEpoch(eq.entry.CurrentEpochSetup, eq.entry.CurrentEpoch.EpochExtensions, eq.entry.CurrentEpochCommit)
 }
 
 func (eq Epochs) Next() protocol.Epoch {
 	switch eq.entry.EpochPhase() {
 	case flow.EpochPhaseStaking, flow.EpochPhaseFallback:
 		return invalid.NewEpoch(protocol.ErrNextEpochNotSetup)
 	case flow.EpochPhaseSetup:
-		return NewSetupEpoch(eq.entry.NextEpochSetup)
+		return NewSetupEpoch(eq.entry.NextEpochSetup, eq.entry.NextEpoch.EpochExtensions)
 	case flow.EpochPhaseCommitted:
-		return NewCommittedEpoch(eq.entry.NextEpochSetup, eq.entry.NextEpochCommit)
+		return NewCommittedEpoch(eq.entry.NextEpochSetup, eq.entry.NextEpoch.EpochExtensions, eq.entry.NextEpochCommit)
 	}
 	return invalid.NewEpochf("unexpected unknown phase in protocol state entry")
 }
 
-// setupEpoch is an implementation of protocol.Epoch backed by an EpochSetup
-// service event. This is used for converting service events to inmem.Epoch.
+// setupEpoch is an implementation of protocol.Epoch backed by an EpochSetup service event.
+// Includes any extensions which have been included as of the reference block.
+// This is used for converting service events to inmem.Epoch.
 type setupEpoch struct {
 	// EpochSetup service event
 	setupEvent *flow.EpochSetup
+	extensions []flow.EpochExtension
 }
 
 func (es *setupEpoch) Counter() (uint64, error) {
@@ -69,7 +71,13 @@ func (es *setupEpoch) DKGPhase3FinalView() (uint64, error) {
 	return es.setupEvent.DKGPhase3FinalView, nil
 }
 
+// FinalView returns the final view of the epoch, taking into account possible epoch extensions.
+// If there are no epoch extensions, the final view is the final view of the current epoch setup,
+// otherwise it is the final view of the last epoch extension.
 func (es *setupEpoch) FinalView() (uint64, error) {
+	if len(es.extensions) > 0 {
+		return es.extensions[len(es.extensions)-1].FinalView, nil
+	}
 	return es.setupEvent.FinalView, nil
 }
 
@@ -235,23 +243,24 @@ func (e *heightBoundedEpoch) FinalHeight() (uint64, error) {
 	return 0, protocol.ErrUnknownEpochBoundary
 }
 
-// NewSetupEpoch returns a memory-backed epoch implementation based on an
-// EpochSetup event. Epoch information available after the setup phase will
-// not be accessible in the resulting epoch instance.
+// NewSetupEpoch returns a memory-backed epoch implementation based on an EpochSetup event.
+// Epoch information available after the setup phase will not be accessible in the resulting epoch instance.
 // No errors are expected during normal operations.
-func NewSetupEpoch(setupEvent *flow.EpochSetup) protocol.Epoch {
+func NewSetupEpoch(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension) protocol.Epoch {
 	return &setupEpoch{
 		setupEvent: setupEvent,
+		extensions: extensions,
 	}
 }
 
 // NewCommittedEpoch returns a memory-backed epoch implementation based on an
 // EpochSetup and EpochCommit events.
 // No errors are expected during normal operations.
-func NewCommittedEpoch(setupEvent *flow.EpochSetup, commitEvent *flow.EpochCommit) protocol.Epoch {
+func NewCommittedEpoch(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit) protocol.Epoch {
 	return &committedEpoch{
 		setupEpoch: setupEpoch{
 			setupEvent: setupEvent,
+			extensions: extensions,
 		},
 		commitEvent: commitEvent,
 	}
@@ -260,11 +269,12 @@ func NewCommittedEpoch(setupEvent *flow.EpochSetup, commitEvent *flow.EpochCommi
 // NewEpochWithStartBoundary returns a memory-backed epoch implementation based on an
 // EpochSetup and EpochCommit events, and the epoch's first block height (start boundary).
 // No errors are expected during normal operations.
-func NewEpochWithStartBoundary(setupEvent *flow.EpochSetup, commitEvent *flow.EpochCommit, firstHeight uint64) protocol.Epoch {
+func NewEpochWithStartBoundary(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit, firstHeight uint64) protocol.Epoch {
 	return &heightBoundedEpoch{
 		committedEpoch: committedEpoch{
 			setupEpoch: setupEpoch{
 				setupEvent: setupEvent,
+				extensions: extensions,
 			},
 			commitEvent: commitEvent,
 		},
@@ -276,11 +286,12 @@ func NewEpochWithStartBoundary(setupEvent *flow.EpochSetup, commitEvent *flow.Ep
 // NewEpochWithEndBoundary returns a memory-backed epoch implementation based on an
 // EpochSetup and EpochCommit events, and the epoch's final block height (end boundary).
 // No errors are expected during normal operations.
-func NewEpochWithEndBoundary(setupEvent *flow.EpochSetup, commitEvent *flow.EpochCommit, finalHeight uint64) protocol.Epoch {
+func NewEpochWithEndBoundary(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit, finalHeight uint64) protocol.Epoch {
 	return &heightBoundedEpoch{
 		committedEpoch: committedEpoch{
 			setupEpoch: setupEpoch{
 				setupEvent: setupEvent,
+				extensions: extensions,
 			},
 			commitEvent: commitEvent,
 		},
@@ -292,11 +303,12 @@ func NewEpochWithEndBoundary(setupEvent *flow.EpochSetup, commitEvent *flow.Epoc
 // NewEpochWithStartAndEndBoundaries returns a memory-backed epoch implementation based on an
 // EpochSetup and EpochCommit events, and the epoch's first and final block heights (start+end boundaries).
 // No errors are expected during normal operations.
-func NewEpochWithStartAndEndBoundaries(setupEvent *flow.EpochSetup, commitEvent *flow.EpochCommit, firstHeight, finalHeight uint64) protocol.Epoch {
+func NewEpochWithStartAndEndBoundaries(setupEvent *flow.EpochSetup, extensions []flow.EpochExtension, commitEvent *flow.EpochCommit, firstHeight, finalHeight uint64) protocol.Epoch {
 	return &heightBoundedEpoch{
 		committedEpoch: committedEpoch{
 			setupEpoch: setupEpoch{
 				setupEvent: setupEvent,
+				extensions: extensions,
 			},
 			commitEvent: commitEvent,
 		},