refactor(prune): remove receipts log filter segment

crates/config/src/config.rs

@@ -33,7 +33,7 @@ pub struct Config {
 
 impl Config {
     /// Sets the pruning configuration.
-    pub fn set_prune_config(&mut self, prune_config: PruneConfig) {
+    pub const fn set_prune_config(&mut self, prune_config: PruneConfig) {
         self.prune = prune_config;
     }
 }
@@ -451,13 +451,14 @@ impl PruneConfig {
     }
 
     /// Returns whether there is any kind of receipt pruning configuration.
-    pub fn has_receipts_pruning(&self) -> bool {
-        self.segments.receipts.is_some() || !self.segments.receipts_log_filter.is_empty()
+    pub const fn has_receipts_pruning(&self) -> bool {
+        self.segments.receipts.is_some()
     }
 
     /// Merges another `PruneConfig` into this one, taking values from the other config if and only
     /// if the corresponding value in this config is not set.
     pub fn merge(&mut self, other: Self) {
+        #[expect(deprecated)]
         let Self {
             block_interval,
             segments:
@@ -469,7 +470,7 @@ impl PruneConfig {
                     storage_history,
                     bodies_history,
                     merkle_changesets,
-                    receipts_log_filter,
+                    receipts_log_filter: (),
                 },
         } = other;
 
@@ -487,10 +488,6 @@ impl PruneConfig {
         self.segments.bodies_history = self.segments.bodies_history.or(bodies_history);
         // Merkle changesets is not optional, so we just replace it if provided
         self.segments.merkle_changesets = merkle_changesets;
-
-        if self.segments.receipts_log_filter.0.is_empty() && !receipts_log_filter.0.is_empty() {
-            self.segments.receipts_log_filter = receipts_log_filter;
-        }
     }
 }
 
@@ -517,10 +514,9 @@ where
 mod tests {
     use super::{Config, EXTENSION};
     use crate::PruneConfig;
-    use alloy_primitives::Address;
     use reth_network_peers::TrustedPeer;
-    use reth_prune_types::{PruneMode, PruneModes, ReceiptsLogPruneConfig};
-    use std::{collections::BTreeMap, path::Path, str::FromStr, time::Duration};
+    use reth_prune_types::{PruneMode, PruneModes};
+    use std::{path::Path, str::FromStr, time::Duration};
 
     fn with_tempdir(filename: &str, proc: fn(&std::path::Path)) {
         let temp_dir = tempfile::tempdir().unwrap();
@@ -1009,10 +1005,8 @@ receipts = 'full'
                 storage_history: Some(PruneMode::Before(5000)),
                 bodies_history: None,
                 merkle_changesets: PruneMode::Before(0),
-                receipts_log_filter: ReceiptsLogPruneConfig(BTreeMap::from([(
-                    Address::random(),
-                    PruneMode::Full,
-                )])),
+                #[expect(deprecated)]
+                receipts_log_filter: (),
             },
         };
 
@@ -1026,14 +1020,11 @@ receipts = 'full'
                 storage_history: Some(PruneMode::Distance(3000)),
                 bodies_history: None,
                 merkle_changesets: PruneMode::Distance(10000),
-                receipts_log_filter: ReceiptsLogPruneConfig(BTreeMap::from([
-                    (Address::random(), PruneMode::Distance(1000)),
-                    (Address::random(), PruneMode::Before(2000)),
-                ])),
+                #[expect(deprecated)]
+                receipts_log_filter: (),
             },
         };
 
-        let original_filter = config1.segments.receipts_log_filter.clone();
         config1.merge(config2);
 
         // Check that the configuration has been merged. Any configuration present in config1
@@ -1045,7 +1036,6 @@ receipts = 'full'
         assert_eq!(config1.segments.account_history, Some(PruneMode::Distance(2000)));
         assert_eq!(config1.segments.storage_history, Some(PruneMode::Before(5000)));
         assert_eq!(config1.segments.merkle_changesets, PruneMode::Distance(10000));
-        assert_eq!(config1.segments.receipts_log_filter, original_filter);
     }
 
     #[test]

crates/exex/exex/src/backfill/factory.rs

@@ -39,7 +39,7 @@ impl<E, P> BackfillJobFactory<E, P> {
     }
 
     /// Sets the prune modes
-    pub fn with_prune_modes(mut self, prune_modes: PruneModes) -> Self {
+    pub const fn with_prune_modes(mut self, prune_modes: PruneModes) -> Self {
         self.prune_modes = prune_modes;
         self
     }

crates/node/builder/src/launch/common.rs

@@ -406,13 +406,14 @@ impl<R, ChainSpec: EthChainSpec> LaunchContextWith<Attached<WithConfigs<ChainSpe
     where
         ChainSpec: reth_chainspec::EthereumHardforks,
     {
+        let toml_config = self.toml_config().prune.clone();
         let Some(mut node_prune_config) = self.node_config().prune_config() else {
             // No CLI config is set, use the toml config.
-            return self.toml_config().prune.clone();
+            return toml_config;
         };
 
         // Otherwise, use the CLI configuration and merge with toml config.
-        node_prune_config.merge(self.toml_config().prune.clone());
+        node_prune_config.merge(toml_config);
         node_prune_config
     }
 
@@ -1206,6 +1207,7 @@ mod tests {
                     storage_history_before: None,
                     bodies_pre_merge: false,
                     bodies_distance: None,
+                    #[expect(deprecated)]
                     receipts_log_filter: None,
                     bodies_before: None,
                 },

crates/node/core/Cargo.toml

@@ -52,7 +52,6 @@ derive_more.workspace = true
 toml.workspace = true
 serde.workspace = true
 strum = { workspace = true, features = ["derive"] }
-thiserror.workspace = true
 url.workspace = true
 
 # io

crates/node/core/src/args/mod.rs

@@ -76,5 +76,4 @@ pub use ress_args::RessArgs;
 mod era;
 pub use era::{DefaultEraHost, EraArgs, EraSourceArgs};
 
-mod error;
 pub mod types;

crates/node/core/src/args/pruning.rs

@@ -1,12 +1,13 @@
 //! Pruning and full node arguments
 
-use crate::{args::error::ReceiptsLogError, primitives::EthereumHardfork};
-use alloy_primitives::{Address, BlockNumber};
+use std::ops::Not;
+
+use crate::primitives::EthereumHardfork;
+use alloy_primitives::BlockNumber;
 use clap::{builder::RangedU64ValueParser, Args};
 use reth_chainspec::EthereumHardforks;
 use reth_config::config::PruneConfig;
-use reth_prune_types::{PruneMode, PruneModes, ReceiptsLogPruneConfig, MINIMUM_PRUNING_DISTANCE};
-use std::{collections::BTreeMap, ops::Not};
+use reth_prune_types::{PruneMode, PruneModes, MINIMUM_PRUNING_DISTANCE};
 
 /// Parameters for pruning and full node
 #[derive(Debug, Clone, Args, PartialEq, Eq, Default)]
@@ -59,12 +60,10 @@ pub struct PruningArgs {
     /// Prune receipts before the specified block number. The specified block number is not pruned.
     #[arg(long = "prune.receipts.before", value_name = "BLOCK_NUMBER", conflicts_with_all = &["receipts_full", "receipts_pre_merge", "receipts_distance"])]
     pub receipts_before: Option<BlockNumber>,
-    // Receipts Log Filter
-    /// Configure receipts log filter. Format:
-    /// <`address`>:<`prune_mode`>... where <`prune_mode`> can be 'full', 'distance:<`blocks`>', or
-    /// 'before:<`block_number`>'
-    #[arg(long = "prune.receiptslogfilter", value_name = "FILTER_CONFIG", conflicts_with_all = &["receipts_full", "receipts_pre_merge", "receipts_distance",  "receipts_before"], value_parser = parse_receipts_log_filter)]
-    pub receipts_log_filter: Option<ReceiptsLogPruneConfig>,
+    /// Receipts Log Filter
+    #[arg(long = "prune.receiptslogfilter", value_name = "FILTER_CONFIG", hide = true)]
+    #[deprecated]
+    pub receipts_log_filter: Option<String>,
 
     // Account History
     /// Prunes all account history.
@@ -130,7 +129,8 @@ impl PruningArgs {
                     // TODO: set default to pre-merge block if available
                     bodies_history: None,
                     merkle_changesets: PruneMode::Distance(MINIMUM_PRUNING_DISTANCE),
-                    receipts_log_filter: Default::default(),
+                    #[expect(deprecated)]
+                    receipts_log_filter: (),
                 },
             }
         }
@@ -157,13 +157,14 @@ impl PruningArgs {
         if let Some(mode) = self.storage_history_prune_mode() {
             config.segments.storage_history = Some(mode);
         }
-        if let Some(receipt_logs) =
-            self.receipts_log_filter.as_ref().filter(|c| !c.is_empty()).cloned()
-        {
-            config.segments.receipts_log_filter = receipt_logs;
-            // need to remove the receipts segment filter entirely because that takes precedence
-            // over the logs filter
-            config.segments.receipts.take();
+
+        // Log warning if receipts_log_filter is set (deprecated feature)
+        #[expect(deprecated)]
+        if self.receipts_log_filter.is_some() {
+            tracing::warn!(
+                target: "reth::cli",
+                "The --prune.receiptslogfilter flag is deprecated and has no effect. It will be removed in a future release."
+            );
         }
 
         config.is_default().not().then_some(config)
@@ -251,141 +252,3 @@ impl PruningArgs {
         }
     }
 }
-
-/// Parses `,` separated pruning info into [`ReceiptsLogPruneConfig`].
-pub(crate) fn parse_receipts_log_filter(
-    value: &str,
-) -> Result<ReceiptsLogPruneConfig, ReceiptsLogError> {
-    let mut config = BTreeMap::new();
-    // Split out each of the filters.
-    let filters = value.split(',');
-    for filter in filters {
-        let parts: Vec<&str> = filter.split(':').collect();
-        if parts.len() < 2 {
-            return Err(ReceiptsLogError::InvalidFilterFormat(filter.to_string()));
-        }
-        // Parse the address
-        let address = parts[0]
-            .parse::<Address>()
-            .map_err(|_| ReceiptsLogError::InvalidAddress(parts[0].to_string()))?;
-
-        // Parse the prune mode
-        let prune_mode = match parts[1] {
-            "full" => PruneMode::Full,
-            s if s.starts_with("distance") => {
-                if parts.len() < 3 {
-                    return Err(ReceiptsLogError::InvalidFilterFormat(filter.to_string()));
-                }
-                let distance =
-                    parts[2].parse::<u64>().map_err(ReceiptsLogError::InvalidDistance)?;
-                PruneMode::Distance(distance)
-            }
-            s if s.starts_with("before") => {
-                if parts.len() < 3 {
-                    return Err(ReceiptsLogError::InvalidFilterFormat(filter.to_string()));
-                }
-                let block_number =
-                    parts[2].parse::<u64>().map_err(ReceiptsLogError::InvalidBlockNumber)?;
-                PruneMode::Before(block_number)
-            }
-            _ => return Err(ReceiptsLogError::InvalidPruneMode(parts[1].to_string())),
-        };
-        config.insert(address, prune_mode);
-    }
-    Ok(ReceiptsLogPruneConfig(config))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alloy_primitives::address;
-    use clap::Parser;
-
-    /// A helper type to parse Args more easily
-    #[derive(Parser)]
-    struct CommandParser<T: Args> {
-        #[command(flatten)]
-        args: T,
-    }
-
-    #[test]
-    fn pruning_args_sanity_check() {
-        let args = CommandParser::<PruningArgs>::parse_from([
-            "reth",
-            "--prune.receiptslogfilter",
-            "0x0000000000000000000000000000000000000003:before:5000000",
-        ])
-        .args;
-        let mut config = ReceiptsLogPruneConfig::default();
-        config.0.insert(
-            address!("0x0000000000000000000000000000000000000003"),
-            PruneMode::Before(5000000),
-        );
-        assert_eq!(args.receipts_log_filter, Some(config));
-    }
-
-    #[test]
-    fn parse_receiptslogfilter() {
-        let default_args = PruningArgs::default();
-        let args = CommandParser::<PruningArgs>::parse_from(["reth"]).args;
-        assert_eq!(args, default_args);
-    }
-
-    #[test]
-    fn test_parse_receipts_log_filter() {
-        let filter1 = "0x0000000000000000000000000000000000000001:full";
-        let filter2 = "0x0000000000000000000000000000000000000002:distance:1000";
-        let filter3 = "0x0000000000000000000000000000000000000003:before:5000000";
-        let filters = [filter1, filter2, filter3].join(",");
-
-        // Args can be parsed.
-        let result = parse_receipts_log_filter(&filters);
-        assert!(result.is_ok());
-        let config = result.unwrap();
-        assert_eq!(config.0.len(), 3);
-
-        // Check that the args were parsed correctly.
-        let addr1: Address = "0x0000000000000000000000000000000000000001".parse().unwrap();
-        let addr2: Address = "0x0000000000000000000000000000000000000002".parse().unwrap();
-        let addr3: Address = "0x0000000000000000000000000000000000000003".parse().unwrap();
-
-        assert_eq!(config.0.get(&addr1), Some(&PruneMode::Full));
-        assert_eq!(config.0.get(&addr2), Some(&PruneMode::Distance(1000)));
-        assert_eq!(config.0.get(&addr3), Some(&PruneMode::Before(5000000)));
-    }
-
-    #[test]
-    fn test_parse_receipts_log_filter_invalid_filter_format() {
-        let result = parse_receipts_log_filter("invalid_format");
-        assert!(matches!(result, Err(ReceiptsLogError::InvalidFilterFormat(_))));
-    }
-
-    #[test]
-    fn test_parse_receipts_log_filter_invalid_address() {
-        let result = parse_receipts_log_filter("invalid_address:full");
-        assert!(matches!(result, Err(ReceiptsLogError::InvalidAddress(_))));
-    }
-
-    #[test]
-    fn test_parse_receipts_log_filter_invalid_prune_mode() {
-        let result =
-            parse_receipts_log_filter("0x0000000000000000000000000000000000000000:invalid_mode");
-        assert!(matches!(result, Err(ReceiptsLogError::InvalidPruneMode(_))));
-    }
-
-    #[test]
-    fn test_parse_receipts_log_filter_invalid_distance() {
-        let result = parse_receipts_log_filter(
-            "0x0000000000000000000000000000000000000000:distance:invalid_distance",
-        );
-        assert!(matches!(result, Err(ReceiptsLogError::InvalidDistance(_))));
-    }
-
-    #[test]
-    fn test_parse_receipts_log_filter_invalid_block_number() {
-        let result = parse_receipts_log_filter(
-            "0x0000000000000000000000000000000000000000:before:invalid_block",
-        );
-        assert!(matches!(result, Err(ReceiptsLogError::InvalidBlockNumber(_))));
-    }
-}