feat(storage): write headers and transactions only to static files

crates/cli/commands/src/init_state/mod.rs

@@ -10,7 +10,8 @@ use reth_db_common::init::init_from_state_dump;
 use reth_node_api::NodePrimitives;
 use reth_primitives_traits::{BlockHeader, SealedHeader};
 use reth_provider::{
-    BlockNumReader, DatabaseProviderFactory, StaticFileProviderFactory, StaticFileWriter,
+    BlockNumReader, DBProvider, DatabaseProviderFactory, StaticFileProviderFactory,
+    StaticFileWriter,
 };
 use std::{io::BufReader, path::PathBuf, str::FromStr, sync::Arc};
 use tracing::info;

crates/cli/commands/src/init_state/without_evm.rs

@@ -6,7 +6,7 @@ use reth_node_builder::NodePrimitives;
 use reth_primitives_traits::{SealedBlock, SealedHeader, SealedHeaderFor};
 use reth_provider::{
     providers::StaticFileProvider, BlockWriter, ProviderResult, StageCheckpointWriter,
-    StaticFileProviderFactory, StaticFileWriter, StorageLocation,
+    StaticFileProviderFactory, StaticFileWriter,
 };
 use reth_stages::{StageCheckpoint, StageId};
 use reth_static_file_types::StaticFileSegment;
@@ -81,7 +81,6 @@ where
         )
         .try_recover()
         .expect("no senders or txes"),
-        StorageLocation::Database,
     )?;
 
     let sf_provider = provider_rw.static_file_provider();

crates/cli/commands/src/stage/drop.rs

@@ -15,9 +15,7 @@ use reth_db_common::{
 };
 use reth_node_api::{HeaderTy, ReceiptTy, TxTy};
 use reth_node_core::args::StageEnum;
-use reth_provider::{
-    writer::UnifiedStorageWriter, DatabaseProviderFactory, StaticFileProviderFactory,
-};
+use reth_provider::{DBProvider, DatabaseProviderFactory, StaticFileProviderFactory};
 use reth_prune::PruneSegment;
 use reth_stages::StageId;
 use reth_static_file_types::StaticFileSegment;
@@ -160,7 +158,7 @@ impl<C: ChainSpecParser> Command<C> {
 
         tx.put::<tables::StageCheckpoints>(StageId::Finish.to_string(), Default::default())?;
 
-        UnifiedStorageWriter::commit_unwind(provider_rw)?;
+        provider_rw.commit()?;
 
         Ok(())
     }

crates/cli/commands/src/stage/run.rs

@@ -30,8 +30,8 @@ use reth_node_metrics::{
     version::VersionInfo,
 };
 use reth_provider::{
-    writer::UnifiedStorageWriter, ChainSpecProvider, DatabaseProviderFactory,
-    StageCheckpointReader, StageCheckpointWriter, StaticFileProviderFactory,
+    ChainSpecProvider, DBProvider, DatabaseProviderFactory, StageCheckpointReader,
+    StageCheckpointWriter, StaticFileProviderFactory,
 };
 use reth_stages::{
     stages::{
@@ -342,7 +342,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                 }
 
                 if self.commit {
-                    UnifiedStorageWriter::commit_unwind(provider_rw)?;
+                    provider_rw.commit()?;
                     provider_rw = provider_factory.database_provider_rw()?;
                 }
             }
@@ -365,7 +365,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + Hardforks + EthereumHardforks>
                 provider_rw.save_stage_checkpoint(exec_stage.id(), checkpoint)?;
             }
             if self.commit {
-                UnifiedStorageWriter::commit(provider_rw)?;
+                provider_rw.commit()?;
                 provider_rw = provider_factory.database_provider_rw()?;
             }
 

crates/cli/commands/src/stage/unwind.rs

@@ -17,7 +17,7 @@ use reth_evm::ConfigureEvm;
 use reth_exex::ExExManagerHandle;
 use reth_provider::{
     providers::ProviderNodeTypes, BlockExecutionWriter, BlockNumReader, ChainStateBlockReader,
-    ChainStateBlockWriter, ProviderFactory, StaticFileProviderFactory, StorageLocation,
+    ChainStateBlockWriter, ProviderFactory, StaticFileProviderFactory,
 };
 use reth_stages::{
     sets::{DefaultStages, OfflineStages},
@@ -97,7 +97,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> Command<C>
             let provider = provider_factory.provider_rw()?;
 
             provider
-                .remove_block_and_execution_above(target, StorageLocation::Both)
+                .remove_block_and_execution_above(target)
                 .map_err(|err| eyre::eyre!("Transaction error on unwind: {err}"))?;
 
             // update finalized block if needed

crates/engine/tree/src/persistence.rs

@@ -6,8 +6,8 @@ use reth_errors::ProviderError;
 use reth_ethereum_primitives::EthPrimitives;
 use reth_primitives_traits::NodePrimitives;
 use reth_provider::{
-    providers::ProviderNodeTypes, writer::UnifiedStorageWriter, BlockHashReader,
-    ChainStateBlockWriter, DatabaseProviderFactory, ProviderFactory, StaticFileProviderFactory,
+    providers::ProviderNodeTypes, BlockExecutionWriter, BlockHashReader, ChainStateBlockWriter,
+    DBProvider, DatabaseProviderFactory, ProviderFactory,
 };
 use reth_prune::{PrunerError, PrunerOutput, PrunerWithFactory};
 use reth_stages_api::{MetricEvent, MetricEventsSender};
@@ -128,11 +128,10 @@ where
         debug!(target: "engine::persistence", ?new_tip_num, "Removing blocks");
         let start_time = Instant::now();
         let provider_rw = self.provider.database_provider_rw()?;
-        let sf_provider = self.provider.static_file_provider();
 
         let new_tip_hash = provider_rw.block_hash(new_tip_num)?;
-        UnifiedStorageWriter::from(&provider_rw, &sf_provider).remove_blocks_above(new_tip_num)?;
-        UnifiedStorageWriter::commit_unwind(provider_rw)?;
+        provider_rw.remove_block_and_execution_above(new_tip_num)?;
+        provider_rw.commit()?;
 
         debug!(target: "engine::persistence", ?new_tip_num, ?new_tip_hash, "Removed blocks from disk");
         self.metrics.remove_blocks_above_duration_seconds.record(start_time.elapsed());
@@ -152,10 +151,9 @@ where
 
         if last_block_hash_num.is_some() {
             let provider_rw = self.provider.database_provider_rw()?;
-            let static_file_provider = self.provider.static_file_provider();
 
-            UnifiedStorageWriter::from(&provider_rw, &static_file_provider).save_blocks(blocks)?;
-            UnifiedStorageWriter::commit(provider_rw)?;
+            provider_rw.save_blocks(blocks)?;
+            provider_rw.commit()?;
         }
         self.metrics.save_blocks_duration_seconds.record(start_time.elapsed());
         Ok(last_block_hash_num)

crates/era-utils/src/history.rs

@@ -19,15 +19,15 @@ use reth_etl::Collector;
 use reth_fs_util as fs;
 use reth_primitives_traits::{Block, FullBlockBody, FullBlockHeader, NodePrimitives};
 use reth_provider::{
-    providers::StaticFileProviderRWRefMut, writer::UnifiedStorageWriter, BlockWriter,
-    ProviderError, StaticFileProviderFactory, StaticFileSegment, StaticFileWriter,
+    providers::StaticFileProviderRWRefMut, BlockWriter, ProviderError, StaticFileProviderFactory,
+    StaticFileSegment, StaticFileWriter,
 };
 use reth_stages_types::{
     CheckpointBlockRange, EntitiesCheckpoint, HeadersCheckpoint, StageCheckpoint, StageId,
 };
 use reth_storage_api::{
     errors::ProviderResult, DBProvider, DatabaseProviderFactory, HeaderProvider,
-    NodePrimitivesProvider, StageCheckpointWriter, StorageLocation,
+    NodePrimitivesProvider, StageCheckpointWriter,
 };
 use std::{
     collections::Bound,
@@ -102,14 +102,14 @@ where
 
         save_stage_checkpoints(&provider, from, height, height, height)?;
 
-        UnifiedStorageWriter::commit(provider)?;
+        provider.commit()?;
     }
 
     let provider = provider_factory.database_provider_rw()?;
 
     build_index(&provider, hash_collector)?;
 
-    UnifiedStorageWriter::commit(provider)?;
+    provider.commit()?;
 
     Ok(height)
 }
@@ -318,11 +318,7 @@ where
         writer.append_header(&header, *total_difficulty, &hash)?;
 
         // Write bodies to database.
-        provider.append_block_bodies(
-            vec![(header.number(), Some(body))],
-            // We are writing transactions directly to static files.
-            StorageLocation::StaticFiles,
-        )?;
+        provider.append_block_bodies(vec![(header.number(), Some(body))])?;
 
         hash_collector.insert(hash, number)?;
     }

crates/exex/exex/src/manager.rs

@@ -667,7 +667,7 @@ mod tests {
     use reth_primitives_traits::RecoveredBlock;
     use reth_provider::{
         providers::BlockchainProvider, test_utils::create_test_provider_factory, BlockReader,
-        BlockWriter, Chain, DatabaseProviderFactory, StorageLocation, TransactionVariant,
+        BlockWriter, Chain, DBProvider, DatabaseProviderFactory, TransactionVariant,
     };
     use reth_testing_utils::generators::{self, random_block, BlockParams};
 
@@ -1303,7 +1303,7 @@ mod tests {
         .try_recover()
         .unwrap();
         let provider_rw = provider_factory.database_provider_rw().unwrap();
-        provider_rw.insert_block(block.clone(), StorageLocation::Database).unwrap();
+        provider_rw.insert_block(block.clone()).unwrap();
         provider_rw.commit().unwrap();
 
         let provider = BlockchainProvider::new(provider_factory).unwrap();

crates/exex/exex/src/notifications.rs

@@ -457,7 +457,7 @@ mod tests {
     use reth_primitives_traits::Block as _;
     use reth_provider::{
         providers::BlockchainProvider, test_utils::create_test_provider_factory, BlockWriter,
-        Chain, DatabaseProviderFactory, StorageLocation,
+        Chain, DBProvider, DatabaseProviderFactory,
     };
     use reth_testing_utils::generators::{self, random_block, BlockParams};
     use tokio::sync::mpsc;
@@ -483,8 +483,7 @@ mod tests {
             BlockParams { parent: Some(genesis_hash), tx_count: Some(0), ..Default::default() },
         );
         let provider_rw = provider_factory.provider_rw()?;
-        provider_rw
-            .insert_block(node_head_block.clone().try_recover()?, StorageLocation::Database)?;
+        provider_rw.insert_block(node_head_block.clone().try_recover()?)?;
         provider_rw.commit()?;
 
         let node_head = node_head_block.num_hash();
@@ -614,7 +613,7 @@ mod tests {
         .try_recover()?;
         let node_head = node_head_block.num_hash();
         let provider_rw = provider.database_provider_rw()?;
-        provider_rw.insert_block(node_head_block, StorageLocation::Database)?;
+        provider_rw.insert_block(node_head_block)?;
         provider_rw.commit()?;
         let node_head_notification = ExExNotification::ChainCommitted {
             new: Arc::new(

crates/optimism/cli/src/commands/import_receipts.rs

@@ -17,9 +17,9 @@ use reth_optimism_chainspec::OpChainSpec;
 use reth_optimism_primitives::{bedrock::is_dup_tx, OpPrimitives, OpReceipt};
 use reth_primitives_traits::NodePrimitives;
 use reth_provider::{
-    providers::ProviderNodeTypes, writer::UnifiedStorageWriter, DatabaseProviderFactory,
-    OriginalValuesKnown, ProviderFactory, StageCheckpointReader, StageCheckpointWriter,
-    StateWriter, StaticFileProviderFactory, StatsReader, StorageLocation,
+    providers::ProviderNodeTypes, DBProvider, DatabaseProviderFactory, OriginalValuesKnown,
+    ProviderFactory, StageCheckpointReader, StageCheckpointWriter, StateWriter,
+    StaticFileProviderFactory, StatsReader,
 };
 use reth_stages::{StageCheckpoint, StageId};
 use reth_static_file_types::StaticFileSegment;
@@ -224,18 +224,11 @@ where
         // Update total_receipts after all filtering
         total_receipts += receipts.iter().map(|v| v.len()).sum::<usize>();
 
-        // We're reusing receipt writing code internal to
-        // `UnifiedStorageWriter::append_receipts_from_blocks`, so we just use a default empty
-        // `BundleState`.
         let execution_outcome =
             ExecutionOutcome::new(Default::default(), receipts, first_block, Default::default());
 
         // finally, write the receipts
-        provider.write_state(
-            &execution_outcome,
-            OriginalValuesKnown::Yes,
-            StorageLocation::StaticFiles,
-        )?;
+        provider.write_state(&execution_outcome, OriginalValuesKnown::Yes)?;
     }
 
     // Only commit if we have imported as many receipts as the number of transactions.
@@ -260,7 +253,7 @@ where
     provider
         .save_stage_checkpoint(StageId::Execution, StageCheckpoint::new(highest_block_receipts))?;
 
-    UnifiedStorageWriter::commit(provider)?;
+    provider.commit()?;
 
     Ok(ImportReceiptsResult { total_decoded_receipts, total_filtered_out_dup_txns })
 }

crates/optimism/cli/src/commands/init_state.rs

@@ -12,8 +12,8 @@ use reth_optimism_primitives::{
 };
 use reth_primitives_traits::SealedHeader;
 use reth_provider::{
-    BlockNumReader, ChainSpecProvider, DatabaseProviderFactory, StaticFileProviderFactory,
-    StaticFileWriter,
+    BlockNumReader, ChainSpecProvider, DBProvider, DatabaseProviderFactory,
+    StaticFileProviderFactory, StaticFileWriter,
 };
 use std::{io::BufReader, sync::Arc};
 use tracing::info;

crates/prune/prune/src/segments/mod.rs

@@ -149,6 +149,7 @@ mod tests {
     use reth_provider::{
         providers::BlockchainProvider,
         test_utils::{create_test_provider_factory, MockEthProvider},
+        BlockWriter,
     };
     use reth_testing_utils::generators::{self, random_block_range, BlockRangeParams};
 
@@ -190,7 +191,7 @@ mod tests {
         let provider_rw = factory.provider_rw().expect("failed to get provider_rw");
         for block in &blocks {
             provider_rw
-                .insert_historical_block(
+                .insert_block(
                     block.clone().try_recover().expect("failed to seal block with senders"),
                 )
                 .expect("failed to insert block");
@@ -228,7 +229,7 @@ mod tests {
         let provider_rw = factory.provider_rw().expect("failed to get provider_rw");
         for block in &blocks {
             provider_rw
-                .insert_historical_block(
+                .insert_block(
                     block.clone().try_recover().expect("failed to seal block with senders"),
                 )
                 .expect("failed to insert block");
@@ -274,7 +275,7 @@ mod tests {
         let provider_rw = factory.provider_rw().expect("failed to get provider_rw");
         for block in &blocks {
             provider_rw
-                .insert_historical_block(
+                .insert_block(
                     block.clone().try_recover().expect("failed to seal block with senders"),
                 )
                 .expect("failed to insert block");
@@ -310,7 +311,7 @@ mod tests {
         let provider_rw = factory.provider_rw().expect("failed to get provider_rw");
         for block in &blocks {
             provider_rw
-                .insert_historical_block(
+                .insert_block(
                     block.clone().try_recover().expect("failed to seal block with senders"),
                 )
                 .expect("failed to insert block");

crates/prune/prune/src/segments/receipts.rs

@@ -89,7 +89,7 @@ mod tests {
         Itertools,
     };
     use reth_db_api::tables;
-    use reth_provider::{DatabaseProviderFactory, PruneCheckpointReader};
+    use reth_provider::{DBProvider, DatabaseProviderFactory, PruneCheckpointReader};
     use reth_prune_types::{
         PruneCheckpoint, PruneInterruptReason, PruneMode, PruneProgress, PruneSegment,
     };

crates/prune/prune/src/segments/static_file/headers.rs

@@ -220,7 +220,7 @@ mod tests {
     use assert_matches::assert_matches;
     use reth_db_api::{tables, transaction::DbTx};
     use reth_provider::{
-        DatabaseProviderFactory, PruneCheckpointReader, PruneCheckpointWriter,
+        DBProvider, DatabaseProviderFactory, PruneCheckpointReader, PruneCheckpointWriter,
         StaticFileProviderFactory,
     };
     use reth_prune_types::{

crates/prune/prune/src/segments/static_file/transactions.rs

@@ -101,7 +101,7 @@ mod tests {
     };
     use reth_db_api::tables;
     use reth_provider::{
-        DatabaseProviderFactory, PruneCheckpointReader, PruneCheckpointWriter,
+        DBProvider, DatabaseProviderFactory, PruneCheckpointReader, PruneCheckpointWriter,
         StaticFileProviderFactory,
     };
     use reth_prune_types::{

crates/prune/prune/src/segments/user/account_history.rs

@@ -133,7 +133,7 @@ mod tests {
     use alloy_primitives::{BlockNumber, B256};
     use assert_matches::assert_matches;
     use reth_db_api::{tables, BlockNumberList};
-    use reth_provider::{DatabaseProviderFactory, PruneCheckpointReader};
+    use reth_provider::{DBProvider, DatabaseProviderFactory, PruneCheckpointReader};
     use reth_prune_types::{
         PruneCheckpoint, PruneInterruptReason, PruneMode, PruneProgress, PruneSegment,
     };

crates/prune/prune/src/segments/user/receipts_by_logs.rs

@@ -232,7 +232,9 @@ mod tests {
     use assert_matches::assert_matches;
     use reth_db_api::{cursor::DbCursorRO, tables, transaction::DbTx};
     use reth_primitives_traits::InMemorySize;
-    use reth_provider::{DatabaseProviderFactory, PruneCheckpointReader, TransactionsProvider};
+    use reth_provider::{
+        DBProvider, DatabaseProviderFactory, PruneCheckpointReader, TransactionsProvider,
+    };
     use reth_prune_types::{PruneMode, PruneSegment, ReceiptsLogPruneConfig};
     use reth_stages::test_utils::{StorageKind, TestStageDB};
     use reth_testing_utils::generators::{

crates/prune/prune/src/segments/user/sender_recovery.rs

@@ -91,7 +91,7 @@ mod tests {
     };
     use reth_db_api::tables;
     use reth_primitives_traits::SignerRecoverable;
-    use reth_provider::{DatabaseProviderFactory, PruneCheckpointReader};
+    use reth_provider::{DBProvider, DatabaseProviderFactory, PruneCheckpointReader};
     use reth_prune_types::{PruneCheckpoint, PruneMode, PruneProgress, PruneSegment};
     use reth_stages::test_utils::{StorageKind, TestStageDB};
     use reth_testing_utils::generators::{self, random_block_range, BlockRangeParams};

crates/prune/prune/src/segments/user/storage_history.rs

@@ -140,7 +140,7 @@ mod tests {
     use alloy_primitives::{BlockNumber, B256};
     use assert_matches::assert_matches;
     use reth_db_api::{tables, BlockNumberList};
-    use reth_provider::{DatabaseProviderFactory, PruneCheckpointReader};
+    use reth_provider::{DBProvider, DatabaseProviderFactory, PruneCheckpointReader};
     use reth_prune_types::{PruneCheckpoint, PruneMode, PruneProgress, PruneSegment};
     use reth_stages::test_utils::{StorageKind, TestStageDB};
     use reth_testing_utils::generators::{

crates/prune/prune/src/segments/user/transaction_lookup.rs

@@ -139,7 +139,7 @@ mod tests {
         Itertools,
     };
     use reth_db_api::tables;
-    use reth_provider::{DatabaseProviderFactory, PruneCheckpointReader};
+    use reth_provider::{DBProvider, DatabaseProviderFactory, PruneCheckpointReader};
     use reth_prune_types::{
         PruneCheckpoint, PruneInterruptReason, PruneMode, PruneProgress, PruneSegment,
     };