Merge branch 'master' into petera/streaming-execution-data-api

Author: peterargue

admin/command_runner.go

@@ -76,9 +76,15 @@ func NewCommandRunnerBootstrapper() *CommandRunnerBootstrapper {
 func (r *CommandRunnerBootstrapper) Bootstrap(logger zerolog.Logger, bindAddress string, opts ...CommandRunnerOption) *CommandRunner {
 	handlers := make(map[string]CommandHandler)
 	commands := make([]interface{}, 0, len(r.handlers))
+
+	r.RegisterHandler("ping", func(ctx context.Context, req *CommandRequest) (interface{}, error) {
+		return "pong", nil
+	})
+
 	r.RegisterHandler("list-commands", func(ctx context.Context, req *CommandRequest) (interface{}, error) {
 		return commands, nil
 	})
+
 	for command, handler := range r.handlers {
 		handlers[command] = handler
 		commands = append(commands, command)

cmd/access/node_builder/access_node_builder.go

@@ -180,7 +180,7 @@ func DefaultAccessNodeConfig() *AccessNodeConfig {
 			BindAddress: cmd.NotSet,
 			Metrics:     metrics.NewNoopCollector(),
 		},
-		executionDataSyncEnabled: false,
+		executionDataSyncEnabled: true,
 		executionDataDir:         filepath.Join(homedir, ".flow", "execution_data"),
 		executionDataStartHeight: 0,
 		executionDataConfig: edrequester.ExecutionDataConfig{

cmd/observer/node_builder/observer_builder.go

@@ -566,7 +566,7 @@ func NewFlowObserverServiceBuilder(opts ...Option) *ObserverServiceBuilder {
 	}
 	anb := &ObserverServiceBuilder{
 		ObserverServiceConfig:   config,
-		FlowNodeBuilder:         cmd.FlowNode(flow.RoleAccess.String()),
+		FlowNodeBuilder:         cmd.FlowNode("observer"),
 		FinalizationDistributor: pubsub.NewFinalizationDistributor(),
 	}
 	anb.FinalizationDistributor.AddConsumer(notifications.NewSlashingViolationsConsumer(anb.Logger))

consensus/hotstuff/forks/blockQC.go

@@ -1,13 +1 @@
 package forks
-
-import (
-	"github.com/onflow/flow-go/consensus/hotstuff/model"
-	"github.com/onflow/flow-go/model/flow"
-)
-
-// BlockQC is a Block with a QC that pointing to it, meaning a Quorum Certified Block.
-// This implies Block.View == QC.View && Block.BlockID == QC.BlockID
-type BlockQC struct {
-	Block *model.Block
-	QC    *flow.QuorumCertificate
-}

consensus/hotstuff/forks/block_builder_test.go

@@ -145,7 +145,7 @@ func makeBlockID(block *model.Block) flow.Identifier {
 	})
 }
 
-func makeGenesis() *BlockQC {
+func makeGenesis() *model.CertifiedBlock {
 	genesis := &model.Block{
 		View: 1,
 	}
@@ -155,9 +155,9 @@ func makeGenesis() *BlockQC {
 		View:    1,
 		BlockID: genesis.BlockID,
 	}
-	genesisBQ := &BlockQC{
-		Block: genesis,
-		QC:    genesisQC,
+	certifiedGenesisBlock, err := model.NewCertifiedBlock(genesis, genesisQC)
+	if err != nil {
+		panic(fmt.Sprintf("combining genesis block and genensis QC to certified block failed: %s", err.Error()))
 	}
-	return genesisBQ
+	return &certifiedGenesisBlock
 }

consensus/hotstuff/forks/forks.go

@@ -26,8 +26,8 @@ var ErrPrunedAncestry = errors.New("cannot resolve pruned ancestor")
 //	[b<-qc_b]  [b'<-qc_b']  [b*]
 type ancestryChain struct {
 	block    *BlockContainer
-	oneChain *BlockQC
-	twoChain *BlockQC
+	oneChain *model.CertifiedBlock
+	twoChain *model.CertifiedBlock
 }
 
 // Forks enforces structural validity of the consensus state and implements
@@ -40,13 +40,13 @@ type Forks struct {
 	forest   forest.LevelledForest
 
 	finalizationCallback module.Finalizer
-	newestView           uint64   // newestView is the highest view of block proposal stored in Forks
-	lastFinalized        *BlockQC // lastFinalized is the QC that POINTS TO the most recently finalized locked block
+	newestView           uint64                // newestView is the highest view of block proposal stored in Forks
+	lastFinalized        *model.CertifiedBlock // the most recently finalized block and the QC that certifies it
 }
 
 var _ hotstuff.Forks = (*Forks)(nil)
 
-func New(trustedRoot *BlockQC, finalizationCallback module.Finalizer, notifier hotstuff.FinalizationConsumer) (*Forks, error) {
+func New(trustedRoot *model.CertifiedBlock, finalizationCallback module.Finalizer, notifier hotstuff.FinalizationConsumer) (*Forks, error) {
 	if (trustedRoot.Block.BlockID != trustedRoot.QC.BlockID) || (trustedRoot.Block.View != trustedRoot.QC.View) {
 		return nil, model.NewConfigurationErrorf("invalid root: root QC is not pointing to root block")
 	}
@@ -341,7 +341,7 @@ func (f *Forks) getTwoChain(blockContainer *BlockContainer) (*ancestryChain, err
 //   - model.MissingBlockError if the parent block does not exist in the forest
 //     (but is above the pruned view)
 //   - generic error in case of unexpected bug or internal state corruption
-func (f *Forks) getNextAncestryLevel(block *model.Block) (*BlockQC, error) {
+func (f *Forks) getNextAncestryLevel(block *model.Block) (*model.CertifiedBlock, error) {
 	// The finalizer prunes all blocks in forest which are below the most recently finalized block.
 	// Hence, we have a pruned ancestry if and only if either of the following conditions applies:
 	//    (a) if a block's parent view (i.e. block.QC.View) is below the most recently finalized block.
@@ -367,9 +367,11 @@ func (f *Forks) getNextAncestryLevel(block *model.Block) (*BlockQC, error) {
 			block.BlockID, block.View, block.QC.View, block.QC.BlockID, parentBlock.BlockID, parentBlock.View)
 	}
 
-	blockQC := BlockQC{Block: parentBlock, QC: block.QC}
-
-	return &blockQC, nil
+	certifiedBlock, err := model.NewCertifiedBlock(parentBlock, block.QC)
+	if err != nil {
+		return nil, fmt.Errorf("constructing certified block failed: %w", err)
+	}
+	return &certifiedBlock, nil
 }
 
 // finalizeUpToBlock finalizes all blocks up to (and including) the block pointed to by `qc`.
@@ -416,7 +418,10 @@ func (f *Forks) finalizeUpToBlock(qc *flow.QuorumCertificate) error {
 	}
 
 	// finalize block itself:
-	f.lastFinalized = &BlockQC{Block: block, QC: qc}
+	*f.lastFinalized, err = model.NewCertifiedBlock(block, qc)
+	if err != nil {
+		return fmt.Errorf("constructing certified block failed: %w", err)
+	}
 	err = f.forest.PruneUpToLevel(block.View)
 	if err != nil {
 		if mempool.IsBelowPrunedThresholdError(err) {

consensus/hotstuff/integration/instance_test.go

@@ -378,7 +378,8 @@ func NewInstance(t *testing.T, options ...Option) *Instance {
 		BlockID:       rootBlock.BlockID,
 		SignerIndices: signerIndices,
 	}
-	rootBlockQC := &forks.BlockQC{Block: rootBlock, QC: rootQC}
+	certifiedRootBlock, err := model.NewCertifiedBlock(rootBlock, rootQC)
+	require.NoError(t, err)
 
 	livenessData := &hotstuff.LivenessData{
 		CurrentView: rootQC.View + 1,
@@ -393,7 +394,7 @@ func NewInstance(t *testing.T, options ...Option) *Instance {
 	require.NoError(t, err)
 
 	// initialize the forks handler
-	in.forks, err = forks.New(rootBlockQC, in.finalizer, notifier)
+	in.forks, err = forks.New(&certifiedRootBlock, in.finalizer, notifier)
 	require.NoError(t, err)
 
 	// initialize the validator

consensus/hotstuff/model/block.go

@@ -1,6 +1,7 @@
 package model
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/onflow/flow-go/model/flow"
@@ -44,3 +45,40 @@ func GenesisBlockFromFlow(header *flow.Header) *Block {
 	}
 	return genesis
 }
+
+// CertifiedBlock holds a certified block, which is a block and a QC that is pointing to
+// the block. A QC is the aggregated form of votes from a supermajority of HotStuff and
+// therefore proves validity of the block. A certified block satisfies:
+// Block.View == QC.View and Block.BlockID == QC.BlockID
+type CertifiedBlock struct {
+	Block *Block
+	QC    *flow.QuorumCertificate
+}
+
+// NewCertifiedBlock constructs a new certified block. It checks the consistency
+// requirements and returns an exception otherwise:
+//
+//	Block.View == QC.View and Block.BlockID == QC.BlockID
+func NewCertifiedBlock(block *Block, qc *flow.QuorumCertificate) (CertifiedBlock, error) {
+	if block.View != qc.View {
+		return CertifiedBlock{}, fmt.Errorf("block's view (%d) should equal the qc's view (%d)", block.View, qc.View)
+	}
+	if block.BlockID != qc.BlockID {
+		return CertifiedBlock{}, fmt.Errorf("block's ID (%v) should equal the block referenced by the qc (%d)", block.BlockID, qc.BlockID)
+	}
+	return CertifiedBlock{
+		Block: block,
+		QC:    qc,
+	}, nil
+}
+
+// ID returns unique identifier for the block.
+// To avoid repeated computation, we use value from the QC.
+func (b *CertifiedBlock) ID() flow.Identifier {
+	return b.QC.BlockID
+}
+
+// View returns view where the block was proposed.
+func (b *CertifiedBlock) View() uint64 {
+	return b.QC.View
+}