refactor: simplify core and lib modules

- core: extract helpers (build_batch_blocks, verify_parent_hash_chain,
  get_prover_config), fix EventFilterConditioin typo, add constants
- lib: extract reth_chain_spec_for_name, active_fork_spec_id, simplify
  matches!/clamp/is_empty, dedupe keccak in mpt, add docs

Made-with: Cursor

Author: smtmfft

core/src/interfaces.rs

@@ -390,22 +390,16 @@ impl std::str::FromStr for BatchMetadata {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let parts: Vec<&str> = s.split(':').collect();
-        if parts.len() != 2 {
+        let [batch_id_str, l1_str] = parts.as_slice() else {
             return Err(anyhow::anyhow!(
                 "Invalid BatchMetadata format. Expected 'batch_id:l1_inclusion_block_number'"
             ));
-        }
-
-        let batch_id = parts[0]
-            .parse::<u64>()
-            .map_err(|_| anyhow::anyhow!("Invalid batch_id"))?;
-        let l1_inclusion_block_number = parts[1]
-            .parse::<u64>()
-            .map_err(|_| anyhow::anyhow!("Invalid l1_inclusion_block_number"))?;
-
+        };
         Ok(Self {
-            batch_id,
-            l1_inclusion_block_number,
+            batch_id: batch_id_str.parse().map_err(|_| anyhow::anyhow!("Invalid batch_id"))?,
+            l1_inclusion_block_number: l1_str
+                .parse()
+                .map_err(|_| anyhow::anyhow!("Invalid l1_inclusion_block_number"))?,
         })
     }
 }

core/src/lib.rs

@@ -54,16 +54,12 @@ impl Raiko {
             batch_id: self.request.batch_id,
             block_numbers: self.request.l2_block_numbers.clone(),
             l1_inclusion_block_number: self.request.l1_inclusion_block_number,
-            l1_chain_spec: self.l1_chain_spec.to_owned(),
-            taiko_chain_spec: self.taiko_chain_spec.to_owned(),
+            l1_chain_spec: self.l1_chain_spec.clone(),
+            taiko_chain_spec: self.taiko_chain_spec.clone(),
             prover_data: TaikoProverData {
                 graffiti: self.request.graffiti,
                 actual_prover: self.request.prover,
-                checkpoint: self
-                    .request
-                    .checkpoint
-                    .clone()
-                    .map(ShastaProposalCheckpoint::into),
+                checkpoint: self.request.checkpoint.clone().map(ShastaProposalCheckpoint::into),
                 last_anchor_block_number: self.request.last_anchor_block_number,
             },
             blob_proof_type: self.request.blob_proof_type.clone(),
@@ -95,66 +91,31 @@ impl Raiko {
         builder
             .execute_transactions(pool_tx, false)
             .expect("execute");
-        let result = builder.finalize();
-
-        match result {
-            Ok(header) => {
-                debug!("Verifying final state using provider data ...");
-                debug!(
-                    "Final block hash derived successfully. {}",
-                    header.hash_slow()
-                );
-                debug!("Final block header derived successfully. {header:?}");
-                // Check if the header is the expected one
-                check_header(&input.block.header, &header)?;
-
-                Ok(GuestOutput {
-                    header: header.clone(),
-                    hash: ProtocolInstance::new(input, &header, self.request.proof_type)?
-                        .instance_hash(),
-                })
-            }
-            Err(e) => {
-                warn!("Proving bad block construction!");
-                Err(RaikoError::Guest(
-                    raiko_lib::prover::ProverError::GuestError(e.to_string()),
-                ))
-            }
-        }
+
+        let header = builder.finalize().map_err(|e| {
+            warn!("Proving bad block construction!");
+            RaikoError::Guest(raiko_lib::prover::ProverError::GuestError(e.to_string()))
+        })?;
+
+        debug!("Verifying final state using provider data ...");
+        debug!("Final block hash derived successfully. {}", header.hash_slow());
+        debug!("Final block header derived successfully. {header:?}");
+        check_header(&input.block.header, &header)?;
+
+        Ok(GuestOutput {
+            header: header.clone(),
+            hash: ProtocolInstance::new(input, &header, self.request.proof_type)?.instance_hash(),
+        })
     }
 
     pub fn get_batch_output(&self, batch_input: &GuestBatchInput) -> RaikoResult<GuestBatchOutput> {
         info!(
             "Generating {} output for batch id: {}",
             self.request.proof_type, batch_input.taiko.batch_id
         );
-        let pool_txs_list = generate_transactions_for_batch_blocks(&batch_input);
-        let blocks = batch_input
-            .inputs
-            .iter()
-            .zip(pool_txs_list)
-            .enumerate()
-            .try_fold(
-                Vec::new(),
-                |mut acc, (idx, input_and_txs)| -> RaikoResult<Vec<Block>> {
-                    let (input, txs_with_flag) = input_and_txs;
-                    let (pool_txs, _) = txs_with_flag;
-                    let output = self.single_output_for_batch(pool_txs, input, idx == 0)?;
-                    acc.push(output);
-                    Ok(acc)
-                },
-            )?;
-
-        blocks.windows(2).try_for_each(|window| {
-            let parent = &window[0];
-            let current = &window[1];
-            if parent.header.hash_slow() != current.header.parent_hash {
-                return Err(RaikoError::Guest(
-                    raiko_lib::prover::ProverError::GuestError("Parent hash mismatch".to_string()),
-                ));
-            }
-            Ok(())
-        })?;
+        let pool_txs_list = generate_transactions_for_batch_blocks(batch_input);
+        let blocks = self.build_batch_blocks(&batch_input.inputs, &pool_txs_list)?;
+        verify_parent_hash_chain(&blocks)?;
 
         Ok(GuestBatchOutput {
             blocks: blocks.clone(),
@@ -163,6 +124,21 @@ impl Raiko {
         })
     }
 
+    fn build_batch_blocks(
+        &self,
+        inputs: &[GuestInput],
+        pool_txs_list: &[(Vec<reth_primitives::TransactionSigned>, bool)],
+    ) -> RaikoResult<Vec<Block>> {
+        inputs
+            .iter()
+            .zip(pool_txs_list)
+            .enumerate()
+            .map(|(idx, (input, (pool_txs, _)))| {
+                self.single_output_for_batch(pool_txs.clone(), input, idx == 0)
+            })
+            .collect()
+    }
+
     fn single_output_for_batch(
         &self,
         origin_pool_txs: Vec<reth_primitives::TransactionSigned>,
@@ -174,38 +150,27 @@ impl Raiko {
             .set_is_first_block_in_proposal(is_first_block_in_proposal);
 
         let mut pool_txs = vec![input.taiko.anchor_tx.clone().unwrap()];
-        pool_txs.extend_from_slice(&origin_pool_txs);
+        pool_txs.extend(origin_pool_txs);
 
         builder
             .execute_transactions(pool_txs, false)
             .expect("execute");
-        let result = builder.finalize_block();
-
-        match result {
-            Ok(block) => {
-                let header = block.header.clone();
-                debug!(
-                    "Verifying final block {} state using provider data ...",
-                    header.number
-                );
-                debug!(
-                    "Final block {} hash derived successfully. {}",
-                    header.number,
-                    header.hash_slow()
-                );
-                debug!("Final block derived successfully. {block:?}");
-                // Check if the header is the expected one
-                check_header(&input.block.header, &header)?;
-
-                Ok(block.clone())
-            }
-            Err(e) => {
-                warn!("Proving bad block construction!");
-                Err(RaikoError::Guest(
-                    raiko_lib::prover::ProverError::GuestError(e.to_string()),
-                ))
-            }
-        }
+        let block = builder.finalize_block().map_err(|e| {
+            warn!("Proving bad block construction!");
+            RaikoError::Guest(raiko_lib::prover::ProverError::GuestError(e.to_string()))
+        })?;
+
+        let header = &block.header;
+        debug!("Verifying final block {} state using provider data ...", header.number);
+        debug!("Final block {} hash derived successfully. {}", header.number, header.hash_slow());
+        debug!("Final block derived successfully. {block:?}");
+        check_header(&input.block.header, header)?;
+
+        Ok(block)
+    }
+
+    fn get_prover_config(&self) -> RaikoResult<Value> {
+        serde_json::to_value(&self.request).map_err(Into::into)
     }
 
     pub async fn prove(
@@ -214,7 +179,7 @@ impl Raiko {
         output: &GuestOutput,
         store: Option<&mut dyn IdWrite>,
     ) -> RaikoResult<Proof> {
-        let config = serde_json::to_value(&self.request)?;
+        let config = self.get_prover_config()?;
         run_prover(self.request.proof_type, input, output, &config, store).await
     }
 
@@ -224,7 +189,7 @@ impl Raiko {
         output: &GuestBatchOutput,
         store: Option<&mut dyn IdWrite>,
     ) -> RaikoResult<Proof> {
-        let config = serde_json::to_value(&self.request)?;
+        let config = self.get_prover_config()?;
         run_batch_prover(self.request.proof_type, input, output, &config, store).await
     }
 
@@ -234,7 +199,7 @@ impl Raiko {
         output: &GuestBatchOutput,
         store: Option<&mut dyn IdWrite>,
     ) -> RaikoResult<Proof> {
-        let config = serde_json::to_value(&self.request)?;
+        let config = self.get_prover_config()?;
         run_shasta_proposal_prover(self.request.proof_type, input, output, &config, store).await
     }
 
@@ -247,6 +212,18 @@ impl Raiko {
     }
 }
 
+fn verify_parent_hash_chain(blocks: &[Block]) -> RaikoResult<()> {
+    for window in blocks.windows(2) {
+        let (parent, current) = (&window[0], &window[1]);
+        if parent.header.hash_slow() != current.header.parent_hash {
+            return Err(RaikoError::Guest(
+                raiko_lib::prover::ProverError::GuestError("Parent hash mismatch".to_string()),
+            ));
+        }
+    }
+    Ok(())
+}
+
 fn check_header(exp: &Header, header: &Header) -> Result<(), RaikoError> {
     // Check against the expected value of all fields for easy debugability
     check_eq(&exp.parent_hash, &header.parent_hash, "parent_hash");
@@ -290,7 +267,7 @@ fn check_header(exp: &Header, header: &Header) -> Result<(), RaikoError> {
     );
     check_eq(&exp.extra_data, &header.extra_data, "extra_data");
 
-    // Make sure the blockhash from the node matches the one from the builder
+    // Block hash must match: node-provided header vs builder-derived header
     require_eq(
         &exp.hash_slow(),
         &header.hash_slow(),
@@ -299,8 +276,6 @@ fn check_header(exp: &Header, header: &Header) -> Result<(), RaikoError> {
 }
 
 fn check_eq<T: std::cmp::PartialEq + std::fmt::Debug>(expected: &T, actual: &T, message: &str) {
-    // printing out error, if any, but ignoring the result
-    // making sure it's not optimized out
     let _ = black_box(require_eq(expected, actual, message));
 }
 

core/src/preflight/lru.rs

@@ -2,20 +2,19 @@
 use lazy_static::lazy_static;
 use std::{collections::HashMap, num::NonZeroUsize, sync::Mutex};
 
+use lru::LruCache;
 use raiko_lib::mem_db::MemDb;
 use reth_primitives::{Header, B256};
 use tracing::debug;
 
-use lru::LruCache;
-
 type ChainBlockCacheKey = (u64, B256);
 type ChainBlockCacheEntry = (MemDb, HashMap<u64, Header>);
 
+const LRU_CAPACITY: usize = 256;
+
 lazy_static! {
     static ref HISTORY_STATE_DB: Mutex<LruCache<ChainBlockCacheKey, ChainBlockCacheEntry>> =
-        Mutex::new(LruCache::<ChainBlockCacheKey, ChainBlockCacheEntry>::new(
-            NonZeroUsize::new(256).unwrap()
-        ));
+        Mutex::new(LruCache::new(NonZeroUsize::new(LRU_CAPACITY).unwrap()));
 }
 
 #[cfg(test)]

core/src/preflight/mod.rs

@@ -1,5 +1,8 @@
 use std::{collections::HashSet, env};
 
+/// Default number of blocks to process per prefetch task.
+const PREFETCH_CHUNK_SIZE_DEFAULT: usize = 7;
+
 use crate::{
     interfaces::{RaikoError, RaikoResult},
     provider::{db::ProviderDb, rpc::RpcBlockDataProvider, BlockDataProvider},
@@ -76,10 +79,8 @@ pub async fn batch_preflight<BDP: BlockDataProvider>(
         )
     };
 
-    let l2_block_numbers: Vec<(u64, Option<u64>)> = block_numbers
-        .iter()
-        .map(|&block_number| (block_number, None))
-        .collect::<Vec<(u64, Option<u64>)>>();
+    let l2_block_numbers: Vec<(u64, Option<u64>)> =
+        block_numbers.iter().map(|&n| (n, None)).collect();
     info!(
         "batch preflight {} l2_block_numbers: {:?} to {:?}.",
         l2_block_numbers.len(),
@@ -139,11 +140,12 @@ pub async fn batch_preflight<BDP: BlockDataProvider>(
 
     assert_eq!(block_parent_pairs.len(), pool_txs_list.len());
 
-    let mut handles = Vec::new();
     let chunk_size = env::var("PREFETCH_CHUNK_SIZE")
-        .unwrap_or("10".to_owned())
-        .parse()
-        .unwrap_or(10);
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(PREFETCH_CHUNK_SIZE_DEFAULT);
+
+    let mut handles = Vec::new();
     let tasks: Vec<(
         (reth_primitives::Block, alloy_rpc_types::Block),
         (Vec<TransactionSigned>, bool),