first final draft

Author: Alexander Hentschel

cmd/access/node_builder/access_node_builder.go

@@ -313,10 +313,8 @@ func (builder *FlowAccessNodeBuilder) buildFollowerCore() *FlowAccessNodeBuilder
 
 		followerCore, err := consensus.NewFollower(
 			node.Logger,
-			builder.Committee,
 			node.Storage.Headers,
 			final,
-			verifier,
 			builder.FinalizationDistributor,
 			node.RootBlock.Header,
 			node.RootQC,

cmd/collection/main.go

@@ -282,16 +282,11 @@ func main() {
 			if err != nil {
 				return nil, fmt.Errorf("could not find latest finalized block and pending blocks to recover consensus follower: %w", err)
 			}
-			packer := hotsignature.NewConsensusSigDataPacker(mainConsensusCommittee)
-			// initialize the verifier for the protocol consensus
-			verifier := verification.NewCombinedVerifier(mainConsensusCommittee, packer)
 			// creates a consensus follower with noop consumer as the notifier
 			followerCore, err = consensus.NewFollower(
 				node.Logger,
-				mainConsensusCommittee,
 				node.Storage.Headers,
 				finalizer,
-				verifier,
 				finalizationDistributor,
 				node.RootBlock.Header,
 				node.RootQC,

cmd/execution_builder.go

@@ -849,10 +849,6 @@ func (exeNode *ExecutionNode) LoadFollowerCore(
 	// state when the follower detects newly finalized blocks
 	final := finalizer.NewFinalizer(node.DB, node.Storage.Headers, exeNode.followerState, node.Tracer)
 
-	packer := signature.NewConsensusSigDataPacker(exeNode.committee)
-	// initialize the verifier for the protocol consensus
-	verifier := verification.NewCombinedVerifier(exeNode.committee, packer)
-
 	finalized, pending, err := recovery.FindLatest(node.State, node.Storage.Headers)
 	if err != nil {
 		return nil, fmt.Errorf("could not find latest finalized block and pending blocks to recover consensus follower: %w", err)
@@ -864,10 +860,8 @@ func (exeNode *ExecutionNode) LoadFollowerCore(
 	// so that it gets notified upon each new finalized block
 	exeNode.followerCore, err = consensus.NewFollower(
 		node.Logger,
-		exeNode.committee,
 		node.Storage.Headers,
 		final,
-		verifier,
 		exeNode.finalizationDistributor,
 		node.RootBlock.Header,
 		node.RootQC,

cmd/observer/node_builder/observer_builder.go

@@ -176,7 +176,6 @@ type ObserverServiceBuilder struct {
 	Finalized               *flow.Header
 	Pending                 []*flow.Header
 	FollowerCore            module.HotStuffFollower
-	Validator               hotstuff.Validator
 	ExecutionDataDownloader execution_data.Downloader
 	ExecutionDataRequester  state_synchronization.ExecutionDataRequester // for the observer, the sync engine participants provider is the libp2p peer store which is not
 	// available until after the network has started. Hence, a factory function that needs to be called just before
@@ -329,17 +328,10 @@ func (builder *ObserverServiceBuilder) buildFollowerCore() *ObserverServiceBuild
 		// state when the follower detects newly finalized blocks
 		final := finalizer.NewFinalizer(node.DB, node.Storage.Headers, builder.FollowerState, node.Tracer)
 
-		packer := hotsignature.NewConsensusSigDataPacker(builder.Committee)
-		// initialize the verifier for the protocol consensus
-		verifier := verification.NewCombinedVerifier(builder.Committee, packer)
-		builder.Validator = hotstuffvalidator.New(builder.Committee, verifier)
-
 		followerCore, err := consensus.NewFollower(
 			node.Logger,
-			builder.Committee,
 			node.Storage.Headers,
 			final,
-			verifier,
 			builder.FinalizationDistributor,
 			node.RootBlock.Header,
 			node.RootQC,
@@ -363,14 +355,18 @@ func (builder *ObserverServiceBuilder) buildFollowerEngine() *ObserverServiceBui
 		if node.HeroCacheMetricsEnable {
 			heroCacheCollector = metrics.FollowerCacheMetrics(node.MetricsRegisterer)
 		}
+		packer := hotsignature.NewConsensusSigDataPacker(builder.Committee)
+		verifier := verification.NewCombinedVerifier(builder.Committee, packer) // verifier for HotStuff signature constructs (QCs, TCs, votes)
+		val := hotstuffvalidator.New(builder.Committee, verifier)
+
 		core, err := follower.NewComplianceCore(
 			node.Logger,
 			node.Metrics.Mempool,
 			heroCacheCollector,
 			builder.FinalizationDistributor,
 			builder.FollowerState,
 			builder.FollowerCore,
-			builder.Validator,
+			val,
 			builder.SyncCore,
 			node.Tracer,
 		)

cmd/verification_builder.go

@@ -332,15 +332,10 @@ func (v *VerificationNodeBuilder) LoadComponentsAndModules() {
 			return committee, err
 		}).
 		Component("follower core", func(node *NodeConfig) (module.ReadyDoneAware, error) {
-
 			// create a finalizer that handles updating the protocol
 			// state when the follower detects newly finalized blocks
 			final := finalizer.NewFinalizer(node.DB, node.Storage.Headers, followerState, node.Tracer)
 
-			packer := hotsignature.NewConsensusSigDataPacker(committee)
-			// initialize the verifier for the protocol consensus
-			verifier := verification.NewCombinedVerifier(committee, packer)
-
 			finalized, pending, err := recoveryprotocol.FindLatest(node.State, node.Storage.Headers)
 			if err != nil {
 				return nil, fmt.Errorf("could not find latest finalized block and pending blocks to recover consensus follower: %w", err)
@@ -352,10 +347,8 @@ func (v *VerificationNodeBuilder) LoadComponentsAndModules() {
 			// so that it gets notified upon each new finalized block
 			followerCore, err = flowconsensus.NewFollower(
 				node.Logger,
-				committee,
 				node.Storage.Headers,
 				final,
-				verifier,
 				finalizationDistributor,
 				node.RootBlock.Header,
 				node.RootQC,

consensus/follower.go

@@ -6,7 +6,6 @@ import (
 	"github.com/rs/zerolog"
 
 	"github.com/onflow/flow-go/consensus/hotstuff"
-	"github.com/onflow/flow-go/consensus/hotstuff/validator"
 	"github.com/onflow/flow-go/consensus/recovery"
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/module"
@@ -15,28 +14,30 @@ import (
 
 // TODO: this needs to be integrated with proper configuration and bootstrapping.
 
+// NewFollower instantiates the consensus follower and recovers its in-memory state of pending blocks.
+// It receives the list `pending` containing _all_ blocks that
+//   - have passed the compliance layer and stored in the protocol state
+//   - descend from the latest finalized block
+//   - are listed in ancestor-first order (i.e. for any block B ∈ pending, B's parent must
+//     be listed before B, unless B's parent is the latest finalized block)
+//
+// CAUTION: all pending blocks are required to be valid (guaranteed if the block passed the compliance layer)
 func NewFollower(log zerolog.Logger,
-	committee hotstuff.DynamicCommittee,
 	headers storage.Headers,
 	updater module.Finalizer,
-	verifier hotstuff.Verifier,
 	notifier hotstuff.FinalizationConsumer,
 	rootHeader *flow.Header,
 	rootQC *flow.QuorumCertificate,
 	finalized *flow.Header,
 	pending []*flow.Header,
 ) (*hotstuff.FollowerLoop, error) {
-
 	forks, err := NewForks(finalized, headers, updater, notifier, rootHeader, rootQC)
 	if err != nil {
 		return nil, fmt.Errorf("could not initialize forks: %w", err)
 	}
 
-	// initialize the Validator
-	validator := validator.New(committee, verifier)
-
-	// recover the HotStuff follower's internal state (inserts all pending blocks into Forks)
-	err = recovery.Follower(log, forks, validator, pending)
+	// recover forks internal state (inserts all pending blocks)
+	err = recovery.Recover(log, pending, recovery.ForksState(forks))
 	if err != nil {
 		return nil, fmt.Errorf("could not recover hotstuff follower state: %w", err)
 	}