[Dynamic Protocol State] InstanceParams refactoring

cmd/scaffold.go

@@ -1096,7 +1096,7 @@ func (fnb *FlowNodeBuilder) initState() error {
 		fnb.State = state
 
 		// set root snapshot field
-		rootBlock, err := state.Params().FinalizedRoot()
+		rootBlock := state.Params().FinalizedRoot()
 		if err != nil {
 			return fmt.Errorf("could not get root block from protocol state: %w", err)
 		}
@@ -1252,7 +1252,7 @@ func (fnb *FlowNodeBuilder) initLocal() error {
 	// We enforce this strictly for MainNet. For other networks (e.g. TestNet or BenchNet), we
 	// are lenient, to allow ghost node to run as any role.
 	if self.Role.String() != fnb.BaseConfig.NodeRole {
-		rootBlockHeader, err := fnb.State.Params().FinalizedRoot()
+		rootBlockHeader := fnb.State.Params().FinalizedRoot()
 		if err != nil {
 			return fmt.Errorf("could not get root block from protocol state: %w", err)
 		}

cmd/util/cmd/read-hotstuff/cmd/get_liveness.go

@@ -27,7 +27,7 @@ func runGetLivenessData(*cobra.Command, []string) {
 		log.Fatal().Err(err).Msg("could not init protocol state")
 	}
 
-	rootBlock, err := state.Params().FinalizedRoot()
+	rootBlock := state.Params().FinalizedRoot()
 	if err != nil {
 		log.Fatal().Err(err).Msgf("could not get root block")
 	}

cmd/util/cmd/read-hotstuff/cmd/get_safety.go

@@ -27,10 +27,7 @@ func runGetSafetyData(*cobra.Command, []string) {
 		log.Fatal().Err(err).Msg("could not init protocol state")
 	}
 
-	rootBlock, err := state.Params().FinalizedRoot()
-	if err != nil {
-		log.Fatal().Err(err).Msgf("could not get root block")
-	}
+	rootBlock := state.Params().FinalizedRoot()
 
 	reader := NewHotstuffReader(db, rootBlock.ChainID)
 

cmd/util/cmd/reindex/cmd/results.go

@@ -26,7 +26,7 @@ var resultsCmd = &cobra.Command{
 		results := storages.Results
 		blocks := storages.Blocks
 
-		root, err := state.Params().FinalizedRoot()
+		root := state.Params().FinalizedRoot()
 		if err != nil {
 			log.Fatal().Err(err).Msg("could not get root header from protocol state")
 		}

cmd/util/cmd/rollback-executed-height/cmd/rollback_executed_height.go

@@ -121,10 +121,7 @@ func removeExecutionResultsFromHeight(
 	fromHeight uint64) error {
 	log.Info().Msgf("removing results for blocks from height: %v", fromHeight)
 
-	root, err := protoState.Params().FinalizedRoot()
-	if err != nil {
-		return fmt.Errorf("could not get root: %w", err)
-	}
+	root := protoState.Params().FinalizedRoot()
 
 	if fromHeight <= root.Height {
 		return fmt.Errorf("can only remove results for block above root block. fromHeight: %v, rootHeight: %v", fromHeight, root.Height)

engine/access/ingestion/engine.go

@@ -196,11 +196,8 @@ func (e *Engine) Start(parent irrecoverable.SignalerContext) {
 // If the index has already been initialized, this is a no-op.
 // No errors are expected during normal operation.
 func (e *Engine) initLastFullBlockHeightIndex() error {
-	rootBlock, err := e.state.Params().FinalizedRoot()
-	if err != nil {
-		return fmt.Errorf("failed to get root block: %w", err)
-	}
-	err = e.blocks.InsertLastFullBlockHeightIfNotExists(rootBlock.Height)
+	rootBlock := e.state.Params().FinalizedRoot()
+	err := e.blocks.InsertLastFullBlockHeightIfNotExists(rootBlock.Height)
 	if err != nil {
 		return fmt.Errorf("failed to update last full block height during ingestion engine startup: %w", err)
 	}
@@ -691,13 +688,7 @@ func (e *Engine) updateLastFullBlockReceivedIndex() {
 			logError(err)
 			return
 		}
-		// use the root height as the last full height
-		header, err := e.state.Params().FinalizedRoot()
-		if err != nil {
-			logError(err)
-			return
-		}
-		lastFullHeight = header.Height
+		lastFullHeight = e.state.Params().FinalizedRoot().Height
 	}
 
 	e.log.Debug().Uint64("last_full_block_height", lastFullHeight).Msg("updating LastFullBlockReceived index...")

engine/access/rpc/backend/backend.go

@@ -138,10 +138,7 @@ func New(params Params) (*Backend, error) {
 	}
 
 	// initialize node version info
-	nodeInfo, err := getNodeVersionInfo(params.State.Params())
-	if err != nil {
-		return nil, fmt.Errorf("failed to initialize node version info: %w", err)
-	}
+	nodeInfo := getNodeVersionInfo(params.State.Params())
 
 	b := &Backend{
 		state: params.State,
@@ -305,15 +302,12 @@ func (b *Backend) GetNodeVersionInfo(_ context.Context) (*access.NodeVersionInfo
 
 // getNodeVersionInfo returns the NodeVersionInfo for the node.
 // Since these values are static while the node is running, it is safe to cache.
-func getNodeVersionInfo(stateParams protocol.Params) (*access.NodeVersionInfo, error) {
+func getNodeVersionInfo(stateParams protocol.Params) *access.NodeVersionInfo {
 	sporkID := stateParams.SporkID()
 	protocolVersion := stateParams.ProtocolVersion()
 	sporkRootBlockHeight := stateParams.SporkRootBlockHeight()
 
-	nodeRootBlockHeader, err := stateParams.SealedRoot()
-	if err != nil {
-		return nil, fmt.Errorf("failed to read node root block: %w", err)
-	}
+	nodeRootBlockHeader := stateParams.SealedRoot()
 
 	nodeInfo := &access.NodeVersionInfo{
 		Semver:               build.Version(),
@@ -324,7 +318,7 @@ func getNodeVersionInfo(stateParams protocol.Params) (*access.NodeVersionInfo, e
 		NodeRootBlockHeight:  nodeRootBlockHeader.Height,
 	}
 
-	return nodeInfo, nil
+	return nodeInfo
 }
 
 func (b *Backend) GetCollectionByID(_ context.Context, colID flow.Identifier) (*flow.LightCollection, error) {
@@ -371,14 +365,14 @@ func executionNodesForBlockID(
 	log zerolog.Logger,
 ) (flow.IdentitySkeletonList, error) {
 
-	var executorIDs flow.IdentifierList
+	var (
+		executorIDs flow.IdentifierList
+		err         error
+	)
 
 	// check if the block ID is of the root block. If it is then don't look for execution receipts since they
 	// will not be present for the root block.
-	rootBlock, err := state.Params().FinalizedRoot()
-	if err != nil {
-		return nil, fmt.Errorf("failed to retreive execution IDs for block ID %v: %w", blockID, err)
-	}
+	rootBlock := state.Params().FinalizedRoot()
 
 	if rootBlock.ID() == blockID {
 		executorIdentities, err := state.Final().Identities(filter.HasRole[flow.Identity](flow.RoleExecution))

engine/access/rpc/backend/backend_test.go

@@ -1662,24 +1662,6 @@ func (suite *Suite) TestGetNodeVersionInfo() {
 
 		suite.Require().Equal(expected, actual)
 	})
-
-	suite.Run("backend construct fails when SealedRoot lookup fails", func() {
-		stateParams := protocol.NewParams(suite.T())
-		stateParams.On("SporkID").Return(sporkID, nil)
-		stateParams.On("ProtocolVersion").Return(protocolVersion, nil)
-		stateParams.On("SporkRootBlockHeight").Return(sporkRootBlock.Height, nil)
-		stateParams.On("SealedRoot").Return(nil, fmt.Errorf("fail"))
-
-		state := protocol.NewState(suite.T())
-		state.On("Params").Return(stateParams, nil).Maybe()
-
-		params := suite.defaultBackendParams()
-		params.State = state
-
-		backend, err := New(params)
-		suite.Require().Error(err)
-		suite.Require().Nil(backend)
-	})
 }
 
 func (suite *Suite) TestGetNetworkParameters() {

engine/consensus/sealing/core.go

@@ -1,5 +1,3 @@
-// (c) 2021 Dapper Labs - ALL RIGHTS RESERVED
-
 package sealing
 
 import (
@@ -137,7 +135,7 @@ func (c *Core) RepopulateAssignmentCollectorTree(payloads storage.Payloads) erro
 
 	// Get the root block of our local state - we allow references to unknown
 	// blocks below the root height
-	rootHeader, err := c.state.Params().FinalizedRoot()
+	rootHeader := c.state.Params().FinalizedRoot()
 	if err != nil {
 		return fmt.Errorf("could not retrieve root header: %w", err)
 	}

engine/consensus/sealing/engine.go

@@ -104,10 +104,7 @@ func NewEngine(log zerolog.Logger,
 	sealsMempool mempool.IncorporatedResultSeals,
 	requiredApprovalsForSealConstructionGetter module.SealingConfigsGetter,
 ) (*Engine, error) {
-	rootHeader, err := state.Params().FinalizedRoot()
-	if err != nil {
-		return nil, fmt.Errorf("could not retrieve root block: %w", err)
-	}
+	rootHeader := state.Params().FinalizedRoot()
 
 	unit := engine.NewUnit()
 	e := &Engine{
@@ -124,7 +121,7 @@ func NewEngine(log zerolog.Logger,
 		rootHeader:    rootHeader,
 	}
 
-	err = e.setupTrustedInboundQueues()
+	err := e.setupTrustedInboundQueues()
 	if err != nil {
 		return nil, fmt.Errorf("initialization of inbound queues for trusted inputs failed: %w", err)
 	}

engine/consensus/sealing/engine_test.go

@@ -1,5 +1,3 @@
-// (c) 2021 Dapper Labs - ALL RIGHTS RESERVED
-
 package sealing
 
 import (

engine/execution/ingestion/loader/unexecuted_loader.go

@@ -58,10 +58,7 @@ func (e *UnexecutedLoader) LoadUnexecuted(ctx context.Context) ([]flow.Identifie
 	}
 
 	// don't reload root block
-	rootBlock, err := e.state.Params().SealedRoot()
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve root block: %w", err)
-	}
+	rootBlock := e.state.Params().SealedRoot()
 
 	blockIDs := make([]flow.Identifier, 0)
 	isRoot := rootBlock.ID() == last.ID()
@@ -151,10 +148,7 @@ func (e *UnexecutedLoader) finalizedUnexecutedBlocks(ctx context.Context, finali
 
 	// dynamically bootstrapped execution node will reload blocks from
 	// [sealedRoot.Height + 1, finalizedRoot.Height] and execute them on startup.
-	rootBlock, err := e.state.Params().SealedRoot()
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve root block: %w", err)
-	}
+	rootBlock := e.state.Params().SealedRoot()
 
 	for ; lastExecuted > rootBlock.Height; lastExecuted-- {
 		header, err := e.getHeaderByHeight(lastExecuted)

engine/testutil/nodes.go

@@ -824,8 +824,7 @@ func ExecutionNode(t *testing.T, hub *stub.Hub, identity bootstrap.NodeInfo, ide
 }
 
 func getRoot(t *testing.T, node *testmock.GenericNode) (*flow.Header, *flow.QuorumCertificate) {
-	rootHead, err := node.State.Params().FinalizedRoot()
-	require.NoError(t, err)
+	rootHead := node.State.Params().FinalizedRoot()
 
 	signers, err := node.State.AtHeight(0).Identities(filter.HasRole[flow.Identity](flow.RoleConsensus))
 	require.NoError(t, err)

model/flow/filter/id/identifier.go

@@ -1,4 +1,3 @@
-// (c) 2021 Dapper Labs - ALL RIGHTS RESERVED
 package id
 
 import "github.com/onflow/flow-go/model/flow"

module/builder/collection/builder_test.go

@@ -188,9 +188,7 @@ func (suite *BuilderSuite) Payload(transactions ...*flow.TransactionBody) model.
 
 // ProtoStateRoot returns the root block of the protocol state.
 func (suite *BuilderSuite) ProtoStateRoot() *flow.Header {
-	root, err := suite.protoState.Params().FinalizedRoot()
-	suite.Require().NoError(err)
-	return root
+	return suite.protoState.Params().FinalizedRoot()
 }
 
 // ClearPool removes all items from the pool