feat: run StaticFileProvider::check_consistency on start up

bin/reth/src/commands/db/mod.rs

@@ -14,7 +14,7 @@ use reth_db::{
     version::{get_db_version, DatabaseVersionError, DB_VERSION},
 };
 use reth_primitives::ChainSpec;
-use reth_provider::ProviderFactory;
+use reth_provider::{providers::StaticFileProvider, ProviderFactory};
 use std::{
     io::{self, Write},
     sync::Arc,
@@ -96,7 +96,8 @@ pub enum Subcommands {
 macro_rules! db_ro_exec {
     ($chain:expr, $db_path:expr, $db_args:ident, $sfp:ident, $tool:ident, $command:block) => {
         let db = open_db_read_only($db_path, $db_args)?;
-        let provider_factory = ProviderFactory::new(db, $chain.clone(), $sfp)?;
+        let provider_factory =
+            ProviderFactory::new(db, $chain.clone(), StaticFileProvider::read_only($sfp)?);
 
         let $tool = DbTool::new(provider_factory, $chain.clone())?;
         $command;
@@ -156,16 +157,22 @@ impl Command {
                 }
 
                 let db = open_db(&db_path, db_args)?;
-                let provider_factory =
-                    ProviderFactory::new(db, self.chain.clone(), static_files_path.clone())?;
+                let provider_factory = ProviderFactory::new(
+                    db,
+                    self.chain.clone(),
+                    StaticFileProvider::read_write(&static_files_path)?,
+                );
 
                 let tool = DbTool::new(provider_factory, self.chain.clone())?;
                 tool.drop(db_path, static_files_path)?;
             }
             Subcommands::Clear(command) => {
                 let db = open_db(&db_path, db_args)?;
-                let provider_factory =
-                    ProviderFactory::new(db, self.chain.clone(), static_files_path)?;
+                let provider_factory = ProviderFactory::new(
+                    db,
+                    self.chain.clone(),
+                    StaticFileProvider::read_write(static_files_path)?,
+                );
 
                 command.execute(provider_factory)?;
             }

bin/reth/src/commands/db/static_files/headers.rs

@@ -38,7 +38,7 @@ impl Command {
         let path: PathBuf = StaticFileSegment::Headers
             .filename_with_configuration(filters, compression, &block_range)
             .into();
-        let provider = StaticFileProvider::new(PathBuf::default())?;
+        let provider = StaticFileProvider::read_only(PathBuf::default())?;
         let jar_provider = provider.get_segment_provider_from_block(
             StaticFileSegment::Headers,
             self.from,

bin/reth/src/commands/db/static_files/mod.rs

@@ -16,7 +16,7 @@ use reth_primitives::{
     },
     BlockNumber, ChainSpec, StaticFileSegment,
 };
-use reth_provider::{BlockNumReader, ProviderFactory};
+use reth_provider::{providers::StaticFileProvider, BlockNumReader, ProviderFactory};
 use reth_static_file::{segments as static_file_segments, segments::Segment};
 use std::{
     path::{Path, PathBuf},
@@ -99,7 +99,11 @@ impl Command {
             data_dir.db().as_path(),
             db_args.with_max_read_transaction_duration(Some(MaxReadTransactionDuration::Unbounded)),
         )?;
-        let provider_factory = Arc::new(ProviderFactory::new(db, chain, data_dir.static_files())?);
+        let provider_factory = Arc::new(ProviderFactory::new(
+            db,
+            chain,
+            StaticFileProvider::read_only(data_dir.static_files())?,
+        ));
 
         {
             if !self.only_bench {

bin/reth/src/commands/db/static_files/receipts.rs

@@ -43,7 +43,7 @@ impl Command {
             .filename_with_configuration(filters, compression, &block_range)
             .into();
 
-        let provider = StaticFileProvider::new(PathBuf::default())?;
+        let provider = StaticFileProvider::read_only(PathBuf::default())?;
         let jar_provider = provider.get_segment_provider_from_block(
             StaticFileSegment::Receipts,
             self.from,

bin/reth/src/commands/db/static_files/transactions.rs

@@ -42,7 +42,7 @@ impl Command {
         let path: PathBuf = StaticFileSegment::Transactions
             .filename_with_configuration(filters, compression, &block_range)
             .into();
-        let provider = StaticFileProvider::new(PathBuf::default())?;
+        let provider = StaticFileProvider::read_only(PathBuf::default())?;
         let jar_provider = provider.get_segment_provider_from_block(
             StaticFileSegment::Transactions,
             self.from,

bin/reth/src/commands/db/stats.rs

@@ -168,7 +168,7 @@ impl Command {
         }
 
         let static_files = iter_static_files(data_dir.static_files())?;
-        let static_file_provider = StaticFileProvider::new(data_dir.static_files())?;
+        let static_file_provider = StaticFileProvider::read_only(data_dir.static_files())?;
 
         let mut total_data_size = 0;
         let mut total_index_size = 0;

bin/reth/src/commands/debug_cmd/build_block.rs

@@ -35,8 +35,9 @@ use reth_primitives::{
     U256,
 };
 use reth_provider::{
-    providers::BlockchainProvider, BlockHashReader, BlockReader, BlockWriter,
-    BundleStateWithReceipts, ProviderFactory, StageCheckpointReader, StateProviderFactory,
+    providers::{BlockchainProvider, StaticFileProvider},
+    BlockHashReader, BlockReader, BlockWriter, BundleStateWithReceipts, ProviderFactory,
+    StageCheckpointReader, StateProviderFactory,
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_rpc_types::engine::{BlobsBundleV1, PayloadAttributes};
@@ -113,8 +114,10 @@ impl Command {
         let factory = ProviderFactory::new(
             db,
             self.chain.clone(),
-            self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
-        )?;
+            StaticFileProvider::read_only(
+                self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
+            )?,
+        );
         let provider = factory.provider()?;
 
         let best_number =
@@ -155,8 +158,8 @@ impl Command {
         let provider_factory = ProviderFactory::new(
             Arc::clone(&db),
             Arc::clone(&self.chain),
-            data_dir.static_files(),
-        )?;
+            StaticFileProvider::read_only(data_dir.static_files())?,
+        );
 
         let consensus: Arc<dyn Consensus> =
             Arc::new(EthBeaconConsensus::new(Arc::clone(&self.chain)));

bin/reth/src/commands/debug_cmd/execution.rs

@@ -31,8 +31,8 @@ use reth_primitives::{
     stage::StageId, BlockHashOrNumber, BlockNumber, ChainSpec, PruneModes, B256,
 };
 use reth_provider::{
-    BlockExecutionWriter, HeaderSyncMode, ProviderFactory, StageCheckpointReader,
-    StaticFileProviderFactory,
+    providers::StaticFileProvider, BlockExecutionWriter, HeaderSyncMode, ProviderFactory,
+    StageCheckpointReader, StaticFileProviderFactory,
 };
 use reth_stages::{
     sets::DefaultStages,
@@ -156,6 +156,9 @@ impl Command {
         default_peers_path: PathBuf,
     ) -> eyre::Result<NetworkHandle> {
         let secret_key = get_secret_key(&network_secret_path)?;
+        let static_files = StaticFileProvider::read_only(
+            self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
+        )?;
         let network = self
             .network
             .network_config(config, self.chain.clone(), secret_key, default_peers_path)
@@ -165,11 +168,7 @@ impl Command {
                 self.network.discovery.addr,
                 self.network.discovery.port,
             ))
-            .build(ProviderFactory::new(
-                db,
-                self.chain.clone(),
-                self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
-            )?)
+            .build(ProviderFactory::new(db, self.chain.clone(), static_files))
             .start_network()
             .await?;
         info!(target: "reth::cli", peer_id = %network.peer_id(), local_addr = %network.local_addr(), "Connected to P2P network");
@@ -210,8 +209,11 @@ impl Command {
 
         fs::create_dir_all(&db_path)?;
         let db = Arc::new(init_db(db_path, self.db.database_args())?);
-        let provider_factory =
-            ProviderFactory::new(db.clone(), self.chain.clone(), data_dir.static_files())?;
+        let provider_factory = ProviderFactory::new(
+            db.clone(),
+            self.chain.clone(),
+            StaticFileProvider::read_write(data_dir.static_files())?,
+        );
 
         debug!(target: "reth::cli", chain=%self.chain.chain, genesis=?self.chain.genesis_hash(), "Initializing genesis");
         init_genesis(provider_factory.clone())?;

bin/reth/src/commands/debug_cmd/in_memory_merkle.rs

@@ -22,9 +22,9 @@ use reth_network::NetworkHandle;
 use reth_network_api::NetworkInfo;
 use reth_primitives::{stage::StageId, BlockHashOrNumber, ChainSpec, Receipts};
 use reth_provider::{
-    AccountExtReader, BundleStateWithReceipts, HashingWriter, HeaderProvider,
-    LatestStateProviderRef, OriginalValuesKnown, ProviderFactory, StageCheckpointReader,
-    StateWriter, StaticFileProviderFactory, StorageReader,
+    providers::StaticFileProvider, AccountExtReader, BundleStateWithReceipts, HashingWriter,
+    HeaderProvider, LatestStateProviderRef, OriginalValuesKnown, ProviderFactory,
+    StageCheckpointReader, StateWriter, StaticFileProviderFactory, StorageReader,
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_tasks::TaskExecutor;
@@ -97,8 +97,10 @@ impl Command {
             .build(ProviderFactory::new(
                 db,
                 self.chain.clone(),
-                self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
-            )?)
+                StaticFileProvider::read_only(
+                    self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
+                )?,
+            ))
             .start_network()
             .await?;
         info!(target: "reth::cli", peer_id = %network.peer_id(), local_addr = %network.local_addr(), "Connected to P2P network");
@@ -117,7 +119,11 @@ impl Command {
 
         // initialize the database
         let db = Arc::new(init_db(db_path, self.db.database_args())?);
-        let factory = ProviderFactory::new(&db, self.chain.clone(), data_dir.static_files())?;
+        let factory = ProviderFactory::new(
+            &db,
+            self.chain.clone(),
+            StaticFileProvider::read_only(data_dir.static_files())?,
+        );
         let provider = factory.provider()?;
 
         // Look up merkle checkpoint

bin/reth/src/commands/debug_cmd/merkle.rs

@@ -24,8 +24,9 @@ use reth_network_api::NetworkInfo;
 use reth_network_p2p::full_block::FullBlockClient;
 use reth_primitives::{stage::StageCheckpoint, BlockHashOrNumber, ChainSpec, PruneModes};
 use reth_provider::{
-    BlockNumReader, BlockWriter, BundleStateWithReceipts, HeaderProvider, LatestStateProviderRef,
-    OriginalValuesKnown, ProviderError, ProviderFactory, StateWriter,
+    providers::StaticFileProvider, BlockNumReader, BlockWriter, BundleStateWithReceipts,
+    HeaderProvider, LatestStateProviderRef, OriginalValuesKnown, ProviderError, ProviderFactory,
+    StateWriter,
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_stages::{
@@ -102,8 +103,10 @@ impl Command {
             .build(ProviderFactory::new(
                 db,
                 self.chain.clone(),
-                self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
-            )?)
+                StaticFileProvider::read_only(
+                    self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
+                )?,
+            ))
             .start_network()
             .await?;
         info!(target: "reth::cli", peer_id = %network.peer_id(), local_addr = %network.local_addr(), "Connected to P2P network");
@@ -122,7 +125,11 @@ impl Command {
 
         // initialize the database
         let db = Arc::new(init_db(db_path, self.db.database_args())?);
-        let factory = ProviderFactory::new(&db, self.chain.clone(), data_dir.static_files())?;
+        let factory = ProviderFactory::new(
+            &db,
+            self.chain.clone(),
+            StaticFileProvider::read_only(data_dir.static_files())?,
+        );
         let provider_rw = factory.provider_rw()?;
 
         // Configure and build network

bin/reth/src/commands/debug_cmd/replay_engine.rs

@@ -25,8 +25,8 @@ use reth_node_core::engine::engine_store::{EngineMessageStore, StoredEngineApiMe
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
 use reth_primitives::{ChainSpec, PruneModes};
 use reth_provider::{
-    providers::BlockchainProvider, CanonStateSubscriptions, ProviderFactory,
-    StaticFileProviderFactory,
+    providers::{BlockchainProvider, StaticFileProvider},
+    CanonStateSubscriptions, ProviderFactory, StaticFileProviderFactory,
 };
 use reth_stages::Pipeline;
 use reth_static_file::StaticFileProducer;
@@ -100,8 +100,10 @@ impl Command {
             .build(ProviderFactory::new(
                 db,
                 self.chain.clone(),
-                self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
-            )?)
+                StaticFileProvider::read_only(
+                    self.datadir.unwrap_or_chain_default(self.chain.chain).static_files(),
+                )?,
+            ))
             .start_network()
             .await?;
         info!(target: "reth::cli", peer_id = %network.peer_id(), local_addr = %network.local_addr(), "Connected to P2P network");
@@ -120,8 +122,11 @@ impl Command {
 
         // Initialize the database
         let db = Arc::new(init_db(db_path, self.db.database_args())?);
-        let provider_factory =
-            ProviderFactory::new(db.clone(), self.chain.clone(), data_dir.static_files())?;
+        let provider_factory = ProviderFactory::new(
+            db.clone(),
+            self.chain.clone(),
+            StaticFileProvider::read_only(data_dir.static_files())?,
+        );
 
         let consensus: Arc<dyn Consensus> =
             Arc::new(EthBeaconConsensus::new(Arc::clone(&self.chain)));

bin/reth/src/commands/import.rs

@@ -29,8 +29,9 @@ use reth_network_p2p::{
 use reth_node_events::node::NodeEvent;
 use reth_primitives::{stage::StageId, ChainSpec, PruneModes, B256};
 use reth_provider::{
-    BlockNumReader, ChainSpecProvider, HeaderProvider, HeaderSyncMode, ProviderError,
-    ProviderFactory, StageCheckpointReader, StaticFileProviderFactory,
+    providers::StaticFileProvider, BlockNumReader, ChainSpecProvider, HeaderProvider,
+    HeaderSyncMode, ProviderError, ProviderFactory, StageCheckpointReader,
+    StaticFileProviderFactory,
 };
 use reth_stages::{prelude::*, Pipeline, StageSet};
 use reth_static_file::StaticFileProducer;
@@ -117,8 +118,11 @@ impl ImportCommand {
         info!(target: "reth::cli", path = ?db_path, "Opening database");
         let db = Arc::new(init_db(db_path, self.db.database_args())?);
         info!(target: "reth::cli", "Database opened");
-        let provider_factory =
-            ProviderFactory::new(db.clone(), self.chain.clone(), data_dir.static_files())?;
+        let provider_factory = ProviderFactory::new(
+            db.clone(),
+            self.chain.clone(),
+            StaticFileProvider::read_write(data_dir.static_files())?,
+        );
 
         debug!(target: "reth::cli", chain=%self.chain.chain, genesis=?self.chain.genesis_hash(), "Initializing genesis");
 

bin/reth/src/commands/import_op.rs

@@ -20,7 +20,10 @@ use reth_downloaders::file_client::{
 };
 use reth_optimism_primitives::bedrock_import::is_dup_tx;
 use reth_primitives::{stage::StageId, PruneModes};
-use reth_provider::{ProviderFactory, StageCheckpointReader, StaticFileProviderFactory};
+use reth_provider::{
+    providers::StaticFileProvider, ProviderFactory, StageCheckpointReader,
+    StaticFileProviderFactory,
+};
 use reth_static_file::StaticFileProducer;
 use std::{path::PathBuf, sync::Arc};
 use tracing::{debug, error, info};
@@ -91,8 +94,11 @@ impl ImportOpCommand {
         let db = Arc::new(init_db(db_path, self.db.database_args())?);
 
         info!(target: "reth::cli", "Database opened");
-        let provider_factory =
-            ProviderFactory::new(db.clone(), chain_spec.clone(), data_dir.static_files())?;
+        let provider_factory = ProviderFactory::new(
+            db.clone(),
+            chain_spec.clone(),
+            StaticFileProvider::read_write(data_dir.static_files())?,
+        );
 
         debug!(target: "reth::cli", chain=%chain_spec.chain, genesis=?chain_spec.genesis_hash(), "Initializing genesis");
 

bin/reth/src/commands/import_receipts_op.rs

@@ -16,8 +16,8 @@ use reth_node_core::version::SHORT_VERSION;
 use reth_optimism_primitives::bedrock_import::is_dup_tx;
 use reth_primitives::{stage::StageId, Receipts, StaticFileSegment};
 use reth_provider::{
-    BundleStateWithReceipts, OriginalValuesKnown, ProviderFactory, StageCheckpointReader,
-    StateWriter, StaticFileProviderFactory, StaticFileWriter, StatsReader,
+    providers::StaticFileProvider, BundleStateWithReceipts, OriginalValuesKnown, ProviderFactory,
+    StageCheckpointReader, StateWriter, StaticFileProviderFactory, StaticFileWriter, StatsReader,
 };
 use tracing::{debug, error, info, trace};
 
@@ -77,8 +77,11 @@ impl ImportReceiptsOpCommand {
 
         let db = Arc::new(init_db(db_path, self.db.database_args())?);
         info!(target: "reth::cli", "Database opened");
-        let provider_factory =
-            ProviderFactory::new(db.clone(), chain_spec.clone(), data_dir.static_files())?;
+        let provider_factory = ProviderFactory::new(
+            db.clone(),
+            chain_spec.clone(),
+            StaticFileProvider::read_write(data_dir.static_files())?,
+        );
 
         import_receipts_from_file(
             provider_factory,