Merge pull request #7799 from onflow/leo/pebble-minor-refactors

zhangchiqing · web-flow · commit a41836671242 · 2025-09-05T20:02:02.000Z
[Storage] Minor refactor
diff --git a/cmd/util/cmd/common/state.go b/cmd/util/cmd/common/state.go
@@ -12,7 +12,7 @@ import (
 	"github.com/onflow/flow-go/storage/store"
 )
 
-func InitProtocolState(lockManager lockctx.Manager, db storage.DB, storages *store.All) (protocol.State, error) {
+func OpenProtocolState(lockManager lockctx.Manager, db storage.DB, storages *store.All) (protocol.State, error) {
 	metrics := &metrics.NoopCollector{}
 
 	protocolState, err := protocolbadger.OpenState(
@@ -32,7 +32,7 @@ func InitProtocolState(lockManager lockctx.Manager, db storage.DB, storages *sto
 	)
 
 	if err != nil {
-		return nil, fmt.Errorf("could not init protocol state: %w", err)
+		return nil, fmt.Errorf("could not open protocol state: %w", err)
 	}
 
 	return protocolState, nil
diff --git a/cmd/util/cmd/execution-state-extract/execution_state_extract_test.go b/cmd/util/cmd/execution-state-extract/execution_state_extract_test.go
@@ -37,7 +37,6 @@ func TestExtractExecutionState(t *testing.T) {
 	metr := &metrics.NoopCollector{}
 
 	t.Run("missing block->state commitment mapping", func(t *testing.T) {
-
 		withDirs(t, func(datadir, execdir, outdir string) {
 			// Initialize a proper Badger database instead of using empty directory
 			db := unittest.PebbleDB(t, datadir)
@@ -96,7 +95,6 @@ func TestExtractExecutionState(t *testing.T) {
 		lockManager := storage.NewTestingLockManager()
 
 		withDirs(t, func(datadir, execdir, _ string) {
-
 			const (
 				checkpointDistance = math.MaxInt // A large number to prevent checkpoint creation.
 				checkpointsToKeep  = 1
diff --git a/cmd/util/cmd/export-json-transactions/cmd.go b/cmd/util/cmd/export-json-transactions/cmd.go
@@ -74,9 +74,9 @@ func ExportTransactions(lockManager lockctx.Manager, dataDir string, outputDir s
 	storages := common.InitStorages(db)
 	defer db.Close()
 
-	state, err := common.InitProtocolState(lockManager, db, storages)
+	state, err := common.OpenProtocolState(lockManager, db, storages)
 	if err != nil {
-		return fmt.Errorf("could not init protocol state: %w", err)
+		return fmt.Errorf("could not open protocol state: %w", err)
 	}
 
 	// create finder
diff --git a/cmd/util/cmd/find-inconsistent-result/cmd.go b/cmd/util/cmd/find-inconsistent-result/cmd.go
@@ -101,9 +101,9 @@ func createStorages(dir string, lockManager lockctx.Manager) (
 	}
 
 	storages := common.InitStorages(db)
-	state, err := common.InitProtocolState(lockManager, db, storages)
+	state, err := common.OpenProtocolState(lockManager, db, storages)
 	if err != nil {
-		return nil, nil, nil, nil, db, fmt.Errorf("could not init protocol state: %v", err)
+		return nil, nil, nil, nil, db, fmt.Errorf("could not open protocol state: %v", err)
 	}
 
 	return storages.Headers, storages.Results, storages.Seals, state, db, err
diff --git a/cmd/util/cmd/read-protocol-state/cmd/blocks.go b/cmd/util/cmd/read-protocol-state/cmd/blocks.go
@@ -152,7 +152,7 @@ func runE(*cobra.Command, []string) error {
 	flagDBs := common.ReadDBFlags()
 	return common.WithStorage(flagDBs, func(db storage.DB) error {
 		storages := common.InitStorages(db)
-		state, err := common.InitProtocolState(lockManager, db, storages)
+		state, err := common.OpenProtocolState(lockManager, db, storages)
 
 		if err != nil {
 			log.Fatal().Err(err).Msg("could not init protocol state")
diff --git a/cmd/util/cmd/read-protocol-state/cmd/snapshot.go b/cmd/util/cmd/read-protocol-state/cmd/snapshot.go
@@ -53,7 +53,7 @@ func runSnapshotE(*cobra.Command, []string) error {
 	lockManager := storage.MakeSingletonLockManager()
 	return common.WithStorage(common.ReadDBFlags(), func(db storage.DB) error {
 		storages := common.InitStorages(db)
-		state, err := common.InitProtocolState(lockManager, db, storages)
+		state, err := common.OpenProtocolState(lockManager, db, storages)
 		if err != nil {
 			return fmt.Errorf("could not init protocol state")
 		}
diff --git a/cmd/util/cmd/reindex/cmd/results.go b/cmd/util/cmd/reindex/cmd/results.go
@@ -23,9 +23,9 @@ var resultsCmd = &cobra.Command{
 		}
 		defer db.Close()
 		storages := common.InitStorages(db)
-		state, err := common.InitProtocolState(lockManager, db, storages)
+		state, err := common.OpenProtocolState(lockManager, db, storages)
 		if err != nil {
-			log.Fatal().Err(err).Msg("could not init protocol state")
+			log.Fatal().Err(err).Msg("could not open protocol state")
 		}
 
 		results := storages.Results
diff --git a/cmd/util/cmd/rollback-executed-height/cmd/rollback_executed_height.go b/cmd/util/cmd/rollback-executed-height/cmd/rollback_executed_height.go
@@ -66,9 +66,9 @@ func runE(*cobra.Command, []string) error {
 		return err
 	}
 	storages := common.InitStorages(db)
-	state, err := common.InitProtocolState(lockManager, db, storages)
+	state, err := common.OpenProtocolState(lockManager, db, storages)
 	if err != nil {
-		return fmt.Errorf("could not init protocol states: %w", err)
+		return fmt.Errorf("could not open protocol states: %w", err)
 	}
 
 	metrics := &metrics.NoopCollector{}
diff --git a/cmd/util/cmd/snapshot/cmd.go b/cmd/util/cmd/snapshot/cmd.go
@@ -53,9 +53,9 @@ func run(*cobra.Command, []string) {
 	defer db.Close()
 
 	storages := common.InitStorages(db)
-	state, err := common.InitProtocolState(lockManager, db, storages)
+	state, err := common.OpenProtocolState(lockManager, db, storages)
 	if err != nil {
-		log.Fatal().Err(err).Msg("could not init protocol state")
+		log.Fatal().Err(err).Msg("could not open protocol state")
 	}
 
 	log := log.With().Uint64("block_height", flagHeight).Logger()
diff --git a/engine/access/access_test.go b/engine/access/access_test.go
@@ -636,7 +636,6 @@ func (suite *Suite) TestGetExecutionResultByBlockID() {
 // TestGetSealedTransaction tests that transactions status of transaction that belongs to a sealed block
 // is reported as sealed
 func (suite *Suite) TestGetSealedTransaction() {
-	lockManager := storage.NewTestingLockManager()
 	unittest.RunWithBadgerDB(suite.T(), func(db *badger.DB) {
 		all := bstorage.InitAll(metrics.NewNoopCollector(), db)
 		en := util.ExecutionStorageLayer(suite.T(), db)
@@ -772,11 +771,11 @@ func (suite *Suite) TestGetSealedTransaction() {
 		lctx.Release()
 
 		fctx := suite.lockManager.NewContext()
-		defer fctx.Release()
 		require.NoError(suite.T(), fctx.AcquireLock(storage.LockFinalizeBlock))
 		require.NoError(suite.T(), bdb.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 			return operation.IndexFinalizedBlockByHeight(fctx, rw, block.Height, block.ID())
 		}))
+		fctx.Release()
 
 		suite.sealedBlock = block.ToHeader()
 
@@ -798,7 +797,7 @@ func (suite *Suite) TestGetSealedTransaction() {
 		suite.request.On("EntityByID", collection.ID(), mock.Anything).Return()
 		// 4. Indexer IndexCollection receives the requested collection and all the execution receipts
 		// Create a lock context for indexing
-		indexLctx := lockManager.NewContext()
+		indexLctx := suite.lockManager.NewContext()
 		lockErr := indexLctx.AcquireLock(storage.LockInsertCollection)
 		require.NoError(suite.T(), lockErr)
 		defer indexLctx.Release()
@@ -1149,7 +1148,6 @@ func (suite *Suite) TestGetTransactionResult() {
 // TestExecuteScript tests the three execute Script related calls to make sure that the execution api is called with
 // the correct block id
 func (suite *Suite) TestExecuteScript() {
-	lockManager := storage.NewTestingLockManager()
 	unittest.RunWithBadgerDB(suite.T(), func(badgerdb *badger.DB) {
 		db := badgerimpl.ToDB(badgerdb)
 		all := bstorage.InitAll(metrics.NewNoopCollector(), badgerdb)
@@ -1237,7 +1235,7 @@ func (suite *Suite) TestExecuteScript() {
 			all.Collections,
 			all.Transactions,
 			lastFullBlockHeight,
-			lockManager,
+			suite.lockManager,
 		)
 
 		ingestEng, err := ingestion.New(
@@ -1260,15 +1258,15 @@ func (suite *Suite) TestExecuteScript() {
 
 		// create a block and a seal pointing to that block
 		lastBlock := unittest.BlockWithParentFixture(prevBlock.ToHeader())
-		lctx := lockManager.NewContext()
+		lctx := suite.lockManager.NewContext()
 		require.NoError(suite.T(), lctx.AcquireLock(storage.LockInsertBlock))
 		require.NoError(suite.T(), db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 			return all.Blocks.BatchStore(lctx, rw, unittest.ProposalFromBlock(lastBlock))
 		}))
 		lctx.Release()
 		require.NoError(suite.T(), err)
 
-		fctx := lockManager.NewContext()
+		fctx := suite.lockManager.NewContext()
 		require.NoError(suite.T(), fctx.AcquireLock(storage.LockFinalizeBlock))
 		require.NoError(suite.T(), db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 			return operation.IndexFinalizedBlockByHeight(fctx, rw, lastBlock.Height, lastBlock.ID())
@@ -1285,7 +1283,7 @@ func (suite *Suite) TestExecuteScript() {
 			require.NoError(suite.T(), err)
 		}
 
-		fctx2 := lockManager.NewContext()
+		fctx2 := suite.lockManager.NewContext()
 		require.NoError(suite.T(), fctx2.AcquireLock(storage.LockInsertBlock))
 		require.NoError(suite.T(), fctx2.AcquireLock(storage.LockFinalizeBlock))
 		require.NoError(suite.T(), db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
diff --git a/engine/common/follower/integration_test.go b/engine/common/follower/integration_test.go
@@ -43,10 +43,10 @@ import (
 // Each worker submits batchesPerWorker*blocksPerBatch blocks
 // In total we will submit workers*batchesPerWorker*blocksPerBatch
 func TestFollowerHappyPath(t *testing.T) {
-	lockManager := storage.NewTestingLockManager()
 	allIdentities := unittest.CompleteIdentitySet()
 	rootSnapshot := unittest.RootSnapshotFixture(allIdentities)
 	unittest.RunWithBadgerDB(t, func(db *badger.DB) {
+		lockManager := storage.NewTestingLockManager()
 		metrics := metrics.NewNoopCollector()
 		tracer := trace.NewNoopTracer()
 		log := unittest.Logger()
diff --git a/engine/execution/pruner/core_test.go b/engine/execution/pruner/core_test.go
@@ -49,32 +49,32 @@ func TestLoopPruneExecutionDataFromRootToLatestSealed(t *testing.T) {
 			// indexed by height
 			chunks := make([]*verification.VerifiableChunkData, lastFinalizedHeight+2)
 			parentID := genesis.ID()
-			lctx := lockManager.NewContext()
-			require.NoError(t, lctx.AcquireLock(storage.LockInsertBlock))
+			lctxGenesis := lockManager.NewContext()
+			require.NoError(t, lctxGenesis.AcquireLock(storage.LockInsertBlock))
 			require.NoError(t, db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 				// By convention, root block has no proposer signature - implementation has to handle this edge case
-				return blockstore.BatchStore(lctx, rw, &flow.Proposal{Block: *genesis, ProposerSigData: nil})
+				return blockstore.BatchStore(lctxGenesis, rw, &flow.Proposal{Block: *genesis, ProposerSigData: nil})
 			}))
-			lctx.Release()
+			lctxGenesis.Release()
 
 			for i := 1; i <= lastFinalizedHeight; i++ {
 				chunk, block := unittest.VerifiableChunkDataFixture(0, func(headerBody *flow.HeaderBody) {
 					headerBody.Height = uint64(i)
 					headerBody.ParentID = parentID
 				})
 				chunks[i] = chunk // index by height
-				lctx := lockManager.NewContext()
-				require.NoError(t, lctx.AcquireLock(storage.LockInsertBlock))
+				lctxBlock := lockManager.NewContext()
+				require.NoError(t, lctxBlock.AcquireLock(storage.LockInsertBlock))
 				require.NoError(t, db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
-					return blockstore.BatchStore(lctx, rw, unittest.ProposalFromBlock(block))
+					return blockstore.BatchStore(lctxBlock, rw, unittest.ProposalFromBlock(block))
 				}))
-				lctx.Release()
-				lctx = lockManager.NewContext()
-				require.NoError(t, lctx.AcquireLock(storage.LockFinalizeBlock))
+				lctxBlock.Release()
+				lctxFinality := lockManager.NewContext()
+				require.NoError(t, lctxFinality.AcquireLock(storage.LockFinalizeBlock))
 				require.NoError(t, db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
-					return operation.IndexFinalizedBlockByHeight(lctx, rw, chunk.Header.Height, chunk.Header.ID())
+					return operation.IndexFinalizedBlockByHeight(lctxFinality, rw, chunk.Header.Height, chunk.Header.ID())
 				}))
-				lctx.Release()
+				lctxFinality.Release()
 				require.NoError(t, results.Store(chunk.Result))
 				require.NoError(t, results.Index(chunk.Result.BlockID, chunk.Result.ID()))
 				require.NoError(t, chunkDataPacks.Store([]*flow.ChunkDataPack{chunk.ChunkDataPack}))
diff --git a/engine/verification/verifier/verifiers.go b/engine/verification/verifier/verifiers.go
@@ -242,9 +242,9 @@ func initStorages(
 	}
 
 	storages := common.InitStorages(db)
-	state, err := common.InitProtocolState(lockManager, db, storages)
+	state, err := common.OpenProtocolState(lockManager, db, storages)
 	if err != nil {
-		return nil, nil, nil, nil, nil, fmt.Errorf("could not init protocol state: %w", err)
+		return nil, nil, nil, nil, nil, fmt.Errorf("could not open protocol state: %w", err)
 	}
 
 	// require the chunk data pack data must exist before returning the storage module
diff --git a/integration/testnet/network.go b/integration/testnet/network.go
@@ -671,7 +671,6 @@ func PrepareFlowNetwork(t *testing.T, networkConf NetworkConfig, chainID flow.Ch
 }
 
 func (net *FlowNetwork) addConsensusFollower(t *testing.T, rootProtocolSnapshotPath string, followerConf ConsensusFollowerConfig, _ []ContainerConfig) {
-	lockManager := storage.NewTestingLockManager()
 	tmpdir := makeTempSubDir(t, net.baseTempdir, "flow-consensus-follower")
 
 	// create a directory for the follower database
@@ -698,6 +697,7 @@ func (net *FlowNetwork) addConsensusFollower(t *testing.T, rootProtocolSnapshotP
 		WithValueLogMaxEntries(100000) // Default is 1000000
 	badgerDB, err := badgerstorage.InitPublic(dbOpts)
 	require.NoError(t, err)
+	lockManager := storage.NewTestingLockManager()
 
 	bindAddr := gonet.JoinHostPort("localhost", testingdock.RandomPort(t))
 	opts := append(
diff --git a/module/builder/collection/builder_test.go b/module/builder/collection/builder_test.go
@@ -81,7 +81,7 @@ type BuilderSuite struct {
 // runs before each test runs
 func (suite *BuilderSuite) SetupTest() {
 	fmt.Println("SetupTest>>>>")
-	lockManager := storage.NewTestingLockManager()
+	suite.lockManager = storage.NewTestingLockManager()
 	var err error
 
 	suite.genesis, err = unittest.ClusterBlock.Genesis()
@@ -93,7 +93,6 @@ func (suite *BuilderSuite) SetupTest() {
 	suite.dbdir = unittest.TempDir(suite.T())
 	suite.badgerDB = unittest.BadgerDB(suite.T(), suite.dbdir)
 	suite.db = badgerimpl.ToDB(suite.badgerDB)
-	suite.lockManager = lockManager
 
 	metrics := metrics.NewNoopCollector()
 	tracer := trace.NewNoopTracer()
@@ -133,16 +132,16 @@ func (suite *BuilderSuite) SetupTest() {
 	clusterQC := unittest.QuorumCertificateFixture(unittest.QCWithRootBlockID(suite.genesis.ID()))
 	clusterStateRoot, err := clusterkv.NewStateRoot(suite.genesis, clusterQC, suite.epochCounter)
 	suite.Require().NoError(err)
-	clusterState, err := clusterkv.Bootstrap(suite.db, lockManager, clusterStateRoot)
+	clusterState, err := clusterkv.Bootstrap(suite.db, suite.lockManager, clusterStateRoot)
 	suite.Require().NoError(err)
 
-	suite.state, err = clusterkv.NewMutableState(clusterState, lockManager, tracer, suite.headers, suite.payloads)
+	suite.state, err = clusterkv.NewMutableState(clusterState, suite.lockManager, tracer, suite.headers, suite.payloads)
 	suite.Require().NoError(err)
 
 	state, err := pbadger.Bootstrap(
 		metrics,
 		suite.db,
-		lockManager,
+		suite.lockManager,
 		all.Headers,
 		all.Seals,
 		all.Results,
@@ -182,7 +181,7 @@ func (suite *BuilderSuite) SetupTest() {
 	suite.builder, _ = builder.NewBuilder(
 		suite.db,
 		tracer,
-		lockManager,
+		suite.lockManager,
 		metrics,
 		suite.protoState,
 		suite.state,
@@ -216,17 +215,17 @@ func (suite *BuilderSuite) InsertBlock(block *model.Block) {
 }
 
 func (suite *BuilderSuite) FinalizeBlock(block model.Block) {
-	err := suite.db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
+	lctx := suite.lockManager.NewContext()
+	defer lctx.Release()
+	err := lctx.AcquireLock(storage.LockInsertOrFinalizeClusterBlock)
+	suite.Assert().NoError(err)
+
+	err = suite.db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 		var refBlock flow.Header
 		err := operation.RetrieveHeader(rw.GlobalReader(), block.Payload.ReferenceBlockID, &refBlock)
 		if err != nil {
 			return err
 		}
-		lctx := suite.lockManager.NewContext()
-		defer lctx.Release()
-		if err := lctx.AcquireLock(storage.LockInsertOrFinalizeClusterBlock); err != nil {
-			return err
-		}
 		err = procedure.FinalizeClusterBlock(lctx, rw, block.ID())
 		if err != nil {
 			return err
@@ -1544,7 +1543,6 @@ func benchmarkBuildOn(b *testing.B, size int) {
 		)
 		lctx := suite.lockManager.NewContext()
 		require.NoError(b, lctx.AcquireLock(storage.LockInsertOrFinalizeClusterBlock))
-
 		err := suite.db.WithReaderBatchWriter(func(rw storage.ReaderBatchWriter) error {
 			return procedure.InsertClusterBlock(lctx, rw, unittest.ClusterProposalFromBlock(block))
 		})
diff --git a/module/builder/consensus/builder_test.go b/module/builder/consensus/builder_test.go
@@ -178,8 +178,6 @@ func (bs *BuilderSuite) chainSeal(incorporatedResult *flow.IncorporatedResult) {
 // For the verifiers to start checking a result R, they need a source of randomness for the block _incorporating_
 // result R. The result for block [A3] is incorporated in [parent], which does _not_ have a child yet.
 func (bs *BuilderSuite) SetupTest() {
-
-	lockManager := storage.NewTestingLockManager()
 	// set up no-op dependencies
 	noopMetrics := metrics.NewNoopCollector()
 	noopTracer := trace.NewNoopTracer()
@@ -250,6 +248,8 @@ func (bs *BuilderSuite) SetupTest() {
 
 	// set up temporary database for tests
 	bs.db, bs.dir = unittest.TempBadgerDB(bs.T())
+	lockManager := storage.NewTestingLockManager()
+
 	lctx := lockManager.NewContext()
 	require.NoError(bs.T(), lctx.AcquireLock(storage.LockFinalizeBlock))
 	defer lctx.Release()
diff --git a/module/finalizer/consensus/finalizer_test.go b/module/finalizer/consensus/finalizer_test.go
diff --git a/module/state_synchronization/indexer/indexer_core_test.go b/module/state_synchronization/indexer/indexer_core_test.go
diff --git a/state/cluster/badger/mutator_test.go b/state/cluster/badger/mutator_test.go
diff --git a/storage/store/commits_test.go b/storage/store/commits_test.go

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ import (`
`12`	`12`	`"github.com/onflow/flow-go/storage/store"`
`13`	`13`	`)`
`14`	`14`
`15`		`-func InitProtocolState(lockManager lockctx.Manager, db storage.DB, storages *store.All) (protocol.State, error) {`
	`15`	`+func OpenProtocolState(lockManager lockctx.Manager, db storage.DB, storages *store.All) (protocol.State, error) {`
`16`	`16`	`metrics := &metrics.NoopCollector{}`
`17`	`17`
`18`	`18`	`protocolState, err := protocolbadger.OpenState(`
`@@ -32,7 +32,7 @@ func InitProtocolState(lockManager lockctx.Manager, db storage.DB, storages *sto`
`32`	`32`	`)`
`33`	`33`
`34`	`34`	`if err != nil {`
`35`		`- return nil, fmt.Errorf("could not init protocol state: %w", err)`
	`35`	`+ return nil, fmt.Errorf("could not open protocol state: %w", err)`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`return protocolState, nil`
Original file line number	Diff line number	Diff line change
`@@ -101,9 +101,9 @@ func createStorages(dir string, lockManager lockctx.Manager) (`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`storages := common.InitStorages(db)`
`104`		`- state, err := common.InitProtocolState(lockManager, db, storages)`
	`104`	`+ state, err := common.OpenProtocolState(lockManager, db, storages)`
`105`	`105`	`if err != nil {`
`106`		`- return nil, nil, nil, nil, db, fmt.Errorf("could not init protocol state: %v", err)`
	`106`	`+ return nil, nil, nil, nil, db, fmt.Errorf("could not open protocol state: %v", err)`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`return storages.Headers, storages.Results, storages.Seals, state, db, err`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ func runSnapshotE(*cobra.Command, []string) error {`
`53`	`53`	`lockManager := storage.MakeSingletonLockManager()`
`54`	`54`	`return common.WithStorage(common.ReadDBFlags(), func(db storage.DB) error {`
`55`	`55`	`storages := common.InitStorages(db)`
`56`		`- state, err := common.InitProtocolState(lockManager, db, storages)`
	`56`	`+ state, err := common.OpenProtocolState(lockManager, db, storages)`
`57`	`57`	`if err != nil {`
`58`	`58`	`return fmt.Errorf("could not init protocol state")`
`59`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,9 +23,9 @@ var resultsCmd = &cobra.Command{`
`23`	`23`	`}`
`24`	`24`	`defer db.Close()`
`25`	`25`	`storages := common.InitStorages(db)`
`26`		`- state, err := common.InitProtocolState(lockManager, db, storages)`
	`26`	`+ state, err := common.OpenProtocolState(lockManager, db, storages)`
`27`	`27`	`if err != nil {`
`28`		`- log.Fatal().Err(err).Msg("could not init protocol state")`
	`28`	`+ log.Fatal().Err(err).Msg("could not open protocol state")`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`results := storages.Results`
Original file line number	Diff line number	Diff line change
`@@ -66,9 +66,9 @@ func runE(*cobra.Command, []string) error {`
`66`	`66`	`return err`
`67`	`67`	`}`
`68`	`68`	`storages := common.InitStorages(db)`
`69`		`- state, err := common.InitProtocolState(lockManager, db, storages)`
	`69`	`+ state, err := common.OpenProtocolState(lockManager, db, storages)`
`70`	`70`	`if err != nil {`
`71`		`- return fmt.Errorf("could not init protocol states: %w", err)`
	`71`	`+ return fmt.Errorf("could not open protocol states: %w", err)`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`metrics := &metrics.NoopCollector{}`