refactor(fuzz): extract chainstate setup into shared library

Refactor chainstate manager initialization into fuzz_common library for
reuse across mutliple fuzz targets.

- Add ChainstateSetupConfig and FuzzChainType to common/lib.rs
- Extract create_chainstate_manager() and cleanup helpers
- Update fizz_target_chainman to use shared utilities

Author: alexanderwiederin

fuzz/Cargo.toml

@@ -14,6 +14,10 @@ arbitrary = { version = "1.1", features = ["derive"] }
 [dependencies.bitcoinkernel]
 path = ".."
 
+[lib]
+name = "fuzz_common"
+path = "common/lib.rs"
+
 [[bin]]
 name = "fuzz_target_chainman"
 path = "fuzz_targets/fuzz_target_chainman.rs"

fuzz/common/lib.rs

@@ -0,0 +1,106 @@
+use arbitrary::Arbitrary;
+use bitcoinkernel::{ChainType, ChainstateManager, ChainstateManagerOptions, Context, KernelError};
+use std::sync::{Arc, Once};
+
+#[derive(Debug, Clone, Arbitrary)]
+pub enum FuzzChainType {
+    MAINNET,
+    TESTNET,
+    REGTEST,
+    SIGNET,
+}
+
+impl From<FuzzChainType> for ChainType {
+    fn from(val: FuzzChainType) -> ChainType {
+        match val {
+            FuzzChainType::MAINNET => ChainType::Mainnet,
+            FuzzChainType::TESTNET => ChainType::Testnet,
+            FuzzChainType::REGTEST => ChainType::Regtest,
+            FuzzChainType::SIGNET => ChainType::Signet,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Arbitrary)]
+pub struct ChainstateSetupConfig {
+    pub data_dir: String,
+    pub chain_type: FuzzChainType,
+    pub wipe_block_index: bool,
+    pub wipe_chainstate_index: bool,
+    pub block_tree_db_in_memory: bool,
+    pub chainstate_db_in_memory: bool,
+    pub worker_threads: i32,
+}
+
+impl ChainstateSetupConfig {
+    /// Sanitize the data directory string for filesystem use
+    pub fn sanitize_data_dir(&self) -> String {
+        let sanitized: String = self
+            .data_dir
+            .chars()
+            .filter(|c| c.is_alphanumeric() || *c == '_' || *c == '-')
+            .take(60)
+            .collect();
+
+        if sanitized.is_empty() {
+            "default".to_string()
+        } else {
+            sanitized
+        }
+    }
+
+    pub fn create_fuzz_data_dir(&self, prefix: &str) -> String {
+        format!(
+            "/tmp/rust_kernel_fuzz_{}/{}",
+            prefix,
+            self.sanitize_data_dir()
+        )
+    }
+
+    pub fn create_blocks_dir(&self, data_dir: &str) -> String {
+        format!("{}/blocks", data_dir)
+    }
+}
+
+static INIT: Once = Once::new();
+
+pub fn init_logging() {
+    INIT.call_once(|| {
+        bitcoinkernel::disable_logging();
+    });
+}
+
+pub fn create_chainstate_manager(
+    context: &Arc<Context>,
+    config: &ChainstateSetupConfig,
+    data_dir: &str,
+) -> Option<ChainstateManager> {
+    let blocks_dir = config.create_blocks_dir(data_dir);
+
+    let chainman_opts = match ChainstateManagerOptions::new(context, data_dir, &blocks_dir) {
+        Ok(opts) => opts,
+        Err(KernelError::CStringCreationFailed(_)) => return None,
+        Err(err) => panic!("this should never happen: {}", err),
+    }
+    .wipe_db(config.wipe_block_index, config.wipe_chainstate_index)
+    .block_tree_db_in_memory(config.block_tree_db_in_memory)
+    .chainstate_db_in_memory(config.chainstate_db_in_memory)
+    .worker_threads(config.worker_threads);
+
+    match ChainstateManager::new(chainman_opts) {
+        Err(KernelError::Internal(_)) => None,
+        Err(err) => {
+            cleanup_dir(data_dir);
+            panic!("this should never happen: {}", err);
+        }
+        Ok(chainman) => Some(chainman),
+    }
+}
+
+pub fn cleanup_dir(dir: &str) {
+    if let Err(e) = std::fs::remove_dir_all(dir) {
+        if e.kind() != std::io::ErrorKind::NotFound {
+            eprintln!("Cleanup failed for {}: {}", dir, e);
+        }
+    }
+}

fuzz/fuzz_targets/fuzz_target_chainman.rs

@@ -1,19 +1,18 @@
 #![no_main]
 
-use std::sync::{Arc, Once};
+use std::sync::Arc;
 
 use libfuzzer_sys::fuzz_target;
 
 use arbitrary::Arbitrary;
 
 use bitcoinkernel::{
-    disable_logging,
     notifications::types::{BlockValidationStateExt, BlockValidationStateRef},
-    Block, ChainType, ChainstateManager, ChainstateManagerOptions, Context, ContextBuilder,
-    KernelError, ValidationMode,
+    Block, ChainType, Context, ContextBuilder, ValidationMode,
 };
+use fuzz_common::{cleanup_dir, create_chainstate_manager, init_logging, ChainstateSetupConfig};
 
-fn create_context(chain_type: ChainType) -> Arc<Context> {
+pub fn create_context_with_notifications(chain_type: ChainType) -> std::sync::Arc<Context> {
     Arc::new(
         ContextBuilder::new()
             .chain_type(chain_type)
@@ -32,85 +31,32 @@ fn create_context(chain_type: ChainType) -> Arc<Context> {
     )
 }
 
-#[derive(Debug, Arbitrary)]
-pub enum FuzzChainType {
-    MAINNET,
-    TESTNET,
-    REGTEST,
-    SIGNET,
-}
-
-impl Into<ChainType> for FuzzChainType {
-    fn into(self) -> ChainType {
-        match self {
-            FuzzChainType::MAINNET => ChainType::Mainnet,
-            FuzzChainType::TESTNET => ChainType::Testnet,
-            FuzzChainType::REGTEST => ChainType::Regtest,
-            FuzzChainType::SIGNET => ChainType::Signet,
-        }
-    }
-}
-
 #[derive(Debug, Arbitrary)]
 pub struct ChainstateManagerInput {
-    pub data_dir: String,
-    pub chain_type: FuzzChainType,
+    pub setup: ChainstateSetupConfig,
     pub blocks: Vec<Vec<u8>>,
-    pub wipe_block_index: bool,
-    pub wipe_chainstate_index: bool,
-    pub block_tree_db_in_memory: bool,
-    pub chainstate_db_in_memory: bool,
-    pub worker_threads: i32,
 }
 
-static INIT: Once = Once::new();
-
 fuzz_target!(|data: ChainstateManagerInput| {
-    INIT.call_once(|| {
-        disable_logging();
-    });
-
-    let context = create_context(data.chain_type.into());
-    // Sanitize the input string by removing dots and slashes
-    let sanitized_string: String = data
-        .data_dir
-        .chars()
-        .filter(|c| *c != '.' && *c != '/')
-        .take(60)
-        .collect();
+    init_logging();
+    let context = create_context_with_notifications(data.setup.chain_type.clone().into());
+    let data_dir = data.setup.create_fuzz_data_dir("chainstate");
 
-    let data_dir = format!("/tmp/rust_kernel_fuzz/{}", sanitized_string);
-    let blocks_dir = format!("{}/blocks", data_dir);
-    let chainman_opts = match ChainstateManagerOptions::new(&context, &data_dir, &blocks_dir) {
-        Ok(opts) => opts,
-        Err(KernelError::CStringCreationFailed(_)) => return,
-        Err(err) => panic!("this should never happen: {}", err),
-    }
-    .wipe_db(data.wipe_block_index, data.wipe_chainstate_index)
-    .block_tree_db_in_memory(data.block_tree_db_in_memory)
-    .chainstate_db_in_memory(data.chainstate_db_in_memory)
-    .worker_threads(data.worker_threads);
-    let chainman = match ChainstateManager::new(chainman_opts) {
-        Err(KernelError::Internal(_)) => {
-            return;
-        }
-        Err(err) => {
-            let _ = std::fs::remove_dir_all(data_dir);
-            panic!("this should never happen: {}", err);
-        }
-        Ok(chainman) => chainman,
+    let Some(chainman) = create_chainstate_manager(&context, &data.setup, &data_dir) else {
+        return;
     };
 
-    if let Err(err) = chainman.import_blocks() {
-        let _ = std::fs::remove_dir_all(data_dir);
-        panic!("this should never happen: {}", err);
+    if chainman.import_blocks().is_err() {
+        cleanup_dir(&data_dir);
+        return;
     }
 
-    for block in data.blocks {
-        if let Ok(block) = Block::try_from(block.as_slice()) {
+    for block_data in blocks {
+        if let Ok(block) = Block::try_from(block_data.as_slice()) {
             let _ = chainman.process_block(&block);
         }
     }
+
     drop(chainman);
-    let _ = std::fs::remove_dir_all(data_dir);
+    cleanup_dir(&data_dir);
 });