refactor: clean up and optimize code structure

- Removed unused BatchMetadata and BatchProofRequest structs from interfaces.rs.
- Simplified various function implementations and improved readability across multiple files.
- Adjusted logging statements for better clarity and consistency.
- Enhanced type handling and reduced complexity in preflight and provider modules.

Made-with: Cursor

Author: smtmfft

ballot/src/poisson.rs

@@ -20,6 +20,7 @@ impl PoissionDrawer {
         let mut last_draw_time = HashMap::new();
 
         for (ptype, (_rate, per_day)) in config {
+            #[allow(clippy::clone_on_copy)]
             per_day_limit.insert(ptype.clone(), per_day as usize);
             let interval = if per_day == 0 {
                 0
@@ -60,7 +61,7 @@ impl PoissionDrawer {
             .get(proof_type)
             .cloned()
             .unwrap_or_default();
-        let delta = now.signed_duration_since(&last_time).num_seconds();
+        let delta = now.signed_duration_since(last_time).num_seconds();
         if delta <= 0 {
             return false;
         }

core/src/interfaces.rs

@@ -378,122 +378,6 @@ pub struct ProofRequest {
     pub cached_event_data: Option<raiko_lib::input::BlockProposedFork>,
 }
 
-#[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
-pub struct BatchMetadata {
-    pub batch_id: u64,
-    pub l1_inclusion_block_number: u64,
-}
-
-impl std::str::FromStr for BatchMetadata {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let parts: Vec<&str> = s.split(':').collect();
-        let [batch_id_str, l1_str] = parts.as_slice() else {
-            return Err(anyhow::anyhow!(
-                "Invalid BatchMetadata format. Expected 'batch_id:l1_inclusion_block_number'"
-            ));
-        };
-        Ok(Self {
-            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"))?,
-        })
-    }
-}
-
-impl std::fmt::Display for BatchMetadata {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}:{}", self.batch_id, self.l1_inclusion_block_number)
-    }
-}
-
-#[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
-pub struct BatchProofRequest {
-    pub batches: Vec<BatchMetadata>,
-    pub aggregate: bool,
-    pub proof_type: ProofType,
-
-    pub network: String,
-    pub l1_network: String,
-    pub graffiti: B256,
-    #[serde_as(as = "DisplayFromStr")]
-    pub prover: Address,
-    pub blob_proof_type: BlobProofType,
-    #[serde(flatten)]
-    pub prover_args: ProverSpecificOpts,
-}
-
-#[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
-pub struct BatchProofRequestOpt {
-    // Required fields
-    pub batches: Vec<BatchMetadata>,
-    pub aggregate: Option<bool>,
-    pub proof_type: String,
-
-    // Optional fields, if not provided, the default values will be used
-    pub network: Option<String>,
-    pub l1_network: Option<String>,
-    pub graffiti: Option<String>,
-    pub prover: Option<String>,
-    pub blob_proof_type: Option<String>,
-    #[serde(flatten)]
-    pub prover_args: Option<ProverSpecificOpts>,
-}
-
-impl TryFrom<BatchProofRequestOpt> for BatchProofRequest {
-    type Error = RaikoError;
-
-    fn try_from(value: BatchProofRequestOpt) -> Result<Self, Self::Error> {
-        Ok(Self {
-            batches: value.batches,
-            aggregate: value.aggregate.unwrap_or(false),
-            proof_type: value
-                .proof_type
-                .parse()
-                .map_err(|_| RaikoError::InvalidRequestConfig("Invalid proof_type".to_string()))?,
-
-            network: value.network.ok_or(RaikoError::InvalidRequestConfig(
-                "Missing network".to_string(),
-            ))?,
-            l1_network: value.l1_network.ok_or(RaikoError::InvalidRequestConfig(
-                "Missing l1_network".to_string(),
-            ))?,
-            graffiti: value
-                .graffiti
-                .ok_or(RaikoError::InvalidRequestConfig(
-                    "Missing graffiti".to_string(),
-                ))?
-                .parse()
-                .map_err(|_| RaikoError::InvalidRequestConfig("Invalid graffiti".to_string()))?,
-            prover: value
-                .prover
-                .ok_or(RaikoError::InvalidRequestConfig(
-                    "Missing prover".to_string(),
-                ))?
-                .parse()
-                .map_err(|_| RaikoError::InvalidRequestConfig("Invalid prover".to_string()))?,
-            blob_proof_type: value
-                .blob_proof_type
-                .unwrap_or("proof_of_equivalence".to_string())
-                .parse()
-                .map_err(|_| {
-                    RaikoError::InvalidRequestConfig("Invalid blob_proof_type".to_string())
-                })?,
-            prover_args: value
-                .prover_args
-                .ok_or(RaikoError::InvalidRequestConfig(
-                    "Missing prover_args".to_string(),
-                ))?
-                .into(),
-        })
-    }
-}
-
 #[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq)]
 pub struct ShastaProposalCheckpoint {
     pub block_number: u64,
@@ -504,7 +388,7 @@ pub struct ShastaProposalCheckpoint {
 impl From<ShastaProposalCheckpoint> for Checkpoint {
     fn from(value: ShastaProposalCheckpoint) -> Self {
         Checkpoint {
-            blockNumber: value.block_number.into(),
+            blockNumber: value.block_number,
             blockHash: value.block_hash,
             stateRoot: value.state_root,
         }
@@ -526,9 +410,7 @@ impl std::fmt::Display for ShastaProposal {
         write!(
             f,
             "{}:{:?}:{}",
-            self.proposal_id,
-            self.checkpoint,
-            self.l1_inclusion_block_number
+            self.proposal_id, self.checkpoint, self.l1_inclusion_block_number
         )
     }
 }
@@ -602,12 +484,9 @@ impl TryFrom<ShastaProofRequestOpt> for ShastaProofRequest {
                 .map_err(|_| {
                     RaikoError::InvalidRequestConfig("Invalid blob_proof_type".to_string())
                 })?,
-            prover_args: value
-                .prover_args
-                .ok_or(RaikoError::InvalidRequestConfig(
-                    "Missing prover_args".to_string(),
-                ))?
-                .into(),
+            prover_args: value.prover_args.ok_or(RaikoError::InvalidRequestConfig(
+                "Missing prover_args".to_string(),
+            ))?,
         })
     }
 }

core/src/lib.rs

@@ -59,7 +59,11 @@ impl Raiko {
             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(),
@@ -74,9 +78,7 @@ impl Raiko {
         //TODO: read fork from config
         let preflight_data = self.get_batch_preflight_data();
         info!("Generating batch input for batch {}", self.request.batch_id);
-        batch_preflight(provider, preflight_data)
-            .await
-            .map_err(Into::<RaikoError>::into)
+        batch_preflight(provider, preflight_data).await
     }
 
     pub fn get_output(&self, input: &GuestInput) -> RaikoResult<GuestOutput> {
@@ -98,7 +100,10 @@ impl Raiko {
         })?;
 
         debug!("Verifying final state using provider data ...");
-        debug!("Final block hash derived successfully. {}", header.hash_slow());
+        debug!(
+            "Final block hash derived successfully. {}",
+            header.hash_slow()
+        );
         debug!("Final block header derived successfully. {header:?}");
         check_header(&input.block.header, &header)?;
 
@@ -161,8 +166,15 @@ impl Raiko {
         })?;
 
         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!(
+            "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)?;
 
@@ -528,5 +540,4 @@ mod tests {
         let aggregated_proof = aggregate_single_shasta_proof(&proof_request, &proof).await;
         println!("aggregated shasta proof: {aggregated_proof:?}");
     }
-
 }

core/src/preflight/lru.rs

@@ -1,4 +1,3 @@
-#![cfg(feature = "statedb_lru")]
 use lazy_static::lazy_static;
 use std::{collections::HashMap, num::NonZeroUsize, sync::Mutex};
 

core/src/preflight/mod.rs

@@ -25,9 +25,7 @@ use tracing::{debug, info};
 
 use util::{execute_txs, get_batch_blocks_and_parent_data, prepare_taiko_chain_batch_input};
 
-pub use util::{
-    parse_l1_batch_proposal_tx_for_shasta_fork,
-};
+pub use util::parse_l1_batch_proposal_tx_for_shasta_fork;
 
 #[cfg(feature = "statedb_lru")]
 use lru::{load_state_db, save_state_db};
@@ -146,6 +144,7 @@ pub async fn batch_preflight<BDP: BlockDataProvider>(
         .unwrap_or(PREFETCH_CHUNK_SIZE_DEFAULT);
 
     let mut handles = Vec::new();
+    #[allow(clippy::type_complexity)]
     let tasks: Vec<(
         (reth_primitives::Block, alloy_rpc_types::Block),
         (Vec<TransactionSigned>, bool),

core/src/preflight/util.rs

@@ -17,8 +17,7 @@ use raiko_lib::{
     inplace_print,
     input::{
         shasta::{Proposed as ShastaProposed, ShastaEventData},
-        BlobProofType, BlockProposedFork, InputDataSource, TaikoGuestBatchInput,
-        TaikoProverData,
+        BlobProofType, BlockProposedFork, InputDataSource, TaikoGuestBatchInput, TaikoProverData,
     },
     primitives::eip4844::{self, commitment_to_version_hash, KZG_SETTINGS},
     utils::shasta_rules::anchor_max_offset_for_chain,
@@ -36,8 +35,8 @@ use crate::{
 };
 
 /// Optimize data gathering by executing the transactions multiple times so data can be requested in batches
-pub async fn execute_txs<'a, BDP>(
-    builder: &mut RethBlockBuilder<ProviderDb<'a, BDP>>,
+pub async fn execute_txs<BDP>(
+    builder: &mut RethBlockBuilder<ProviderDb<'_, BDP>>,
     pool_txs: Vec<reth_primitives::TransactionSigned>,
 ) -> RaikoResult<()>
 where
@@ -126,6 +125,7 @@ pub async fn parse_l1_batch_proposal_tx_for_shasta_fork(
 }
 
 /// Prepare Shasta batch input
+#[allow(clippy::too_many_arguments)]
 async fn prepare_shasta_batch_input(
     shasta_event_data: raiko_lib::input::shasta::ShastaEventData,
     batch_id: u64,
@@ -200,6 +200,7 @@ async fn prepare_shasta_batch_input(
     })
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn prepare_taiko_chain_batch_input_shasta(
     l1_chain_spec: &ChainSpec,
     taiko_chain_spec: &ChainSpec,
@@ -258,6 +259,7 @@ async fn prepare_taiko_chain_batch_input_shasta(
 }
 
 /// Prepare the input for a Taiko chain
+#[allow(clippy::too_many_arguments)]
 pub async fn prepare_taiko_chain_batch_input(
     l1_chain_spec: &ChainSpec,
     taiko_chain_spec: &ChainSpec,
@@ -422,8 +424,8 @@ pub async fn filter_block_proposed_event(
     let l1_address = chain_spec
         .l1_contract
         .get(&fork)
-        .ok_or_else(|| anyhow!("L1 contract address not found for fork {fork:?}"))?
-        .clone();
+        .copied()
+        .ok_or_else(|| anyhow!("L1 contract address not found for fork {fork:?}"))?;
 
     // Get the event signature (value can differ between chains)
     let event_signature = match fork {
@@ -508,11 +510,6 @@ pub async fn filter_block_proposed_event(
                 .expect("couldn't query the propose tx")
                 .expect("Could not find the propose tx");
 
-            let block_propose_event = match block_propose_event {
-                BlockProposedFork::Shasta(event_data) => BlockProposedFork::Shasta(event_data),
-                _ => block_propose_event,
-            };
-
             return Ok((log.block_number.unwrap(), tx, block_propose_event));
         } else {
             info!("block_or_batch_id: {block_or_batch_id} != block_num_or_batch_id: {block_num_or_batch_id}");

core/src/prover.rs

@@ -142,9 +142,12 @@ impl Prover for NativeProver {
             proofs: input
                 .proofs
                 .iter()
-                .map(|proof| RawProof {
-                    input: proof.input.clone().unwrap(),
-                    proof: Default::default(),
+                .map(|proof| {
+                    #[allow(clippy::clone_on_copy)]
+                    RawProof {
+                        input: proof.input.clone().unwrap(),
+                        proof: Default::default(),
+                    }
                 })
                 .collect(),
             proof_carry_data_vec: input

core/src/provider/db.rs

@@ -60,7 +60,10 @@ impl<'a, BDP: BlockDataProvider> ProviderDb<'a, BDP> {
         let absent_block_numbers = all_init_block_numbers
             .into_iter()
             .filter(|(block_number, _)| {
-                !provider_db.initial_db.block_hashes.contains_key(block_number)
+                !provider_db
+                    .initial_db
+                    .block_hashes
+                    .contains_key(block_number)
             })
             .collect::<Vec<(u64, bool)>>();
         let initial_history_blocks = provider_db
@@ -163,7 +166,7 @@ impl<'a, BDP: BlockDataProvider> ProviderDb<'a, BDP> {
     }
 }
 
-impl<'a, BDP: BlockDataProvider> Database for ProviderDb<'a, BDP> {
+impl<BDP: BlockDataProvider> Database for ProviderDb<'_, BDP> {
     type Error = ProviderError;
 
     fn basic(&mut self, address: Address) -> Result<Option<AccountInfo>, Self::Error> {
@@ -299,13 +302,13 @@ impl<'a, BDP: BlockDataProvider> Database for ProviderDb<'a, BDP> {
     }
 }
 
-impl<'a, BDP: BlockDataProvider> DatabaseCommit for ProviderDb<'a, BDP> {
+impl<BDP: BlockDataProvider> DatabaseCommit for ProviderDb<'_, BDP> {
     fn commit(&mut self, changes: HashMap<Address, Account>) {
         self.current_db.commit(changes);
     }
 }
 
-impl<'a, BDP: BlockDataProvider> OptimisticDatabase for ProviderDb<'a, BDP> {
+impl<BDP: BlockDataProvider> OptimisticDatabase for ProviderDb<'_, BDP> {
     async fn fetch_data(&mut self) -> bool {
         let valid_run = self.is_valid_run();
 

core/src/provider/mod.rs

@@ -57,4 +57,4 @@ pub async fn get_task_data(
         .hash
         .ok_or_else(|| RaikoError::RPC("No block hash for requested block".to_string()))?;
     Ok((taiko_chain_spec.chain_id, blockhash))
-}
+}

core/src/provider/rpc.rs

@@ -297,7 +297,7 @@ impl BlockDataProvider for RpcBlockDataProvider {
             let mut requests = Vec::new();
 
             let mut batch_size = 0;
-                while !accounts.is_empty() && batch_size < PROOF_BATCH_LIMIT {
+            while !accounts.is_empty() && batch_size < PROOF_BATCH_LIMIT {
                 let mut address_to_remove = None;
 
                 if let Some((address, keys)) = accounts.iter_mut().next() {