fmt

Author: ByteYue

src/async_commit.rs

@@ -24,9 +24,7 @@ where
     state: &'a ParallelState<DB>,
     commit_result: Result<(), GrevmError<DB::Error>>,
     disable_nonce_check: bool,
-    /// Block number for prewarm task validation.
     block_number: u64,
-    /// Optional sender for MPT prewarm tasks.
     prewarm_sender: Option<mpsc::UnboundedSender<PrewarmTask>>,
 }
 
@@ -98,12 +96,7 @@ where
         // integrity and prevent double-spending attacks.
         let ResultAndState { result, state, lazy_reward } = result_and_state;
 
-        // Clone state for prewarm task before it's moved
-        let state_for_prewarm = if self.prewarm_sender.is_some() {
-            Some(state.clone())
-        } else {
-            None
-        };
+        let state_for_prewarm = self.prewarm_sender.as_ref().map(|_| state.clone());
 
         if !self.disable_nonce_check {
             match self.state.basic_ref(tx_env.caller) {
@@ -156,7 +149,10 @@ where
         assert!(self.state_mut().increment_balances(vec![(self.coinbase, lazy_reward)]).is_ok());
 
         // Send prewarm task for MPT prewarming if sender is available
-        if let (Some(ref sender), Some(state)) = (self.prewarm_sender.as_ref(), state_for_prewarm) {
+        if let Some(ref sender) = self.prewarm_sender.as_ref() {
+            // state_for_prewarm is Some if and only if prewarm_sender is Some
+            let state = state_for_prewarm
+                .expect("state_for_prewarm should be Some when prewarm_sender is Some");
             let _ = sender.send(PrewarmTask {
                 block_number: self.block_number,
                 result_and_state: ResultAndState {
@@ -165,7 +161,9 @@ where
                         gas_used: 0,
                         gas_refunded: 0,
                         logs: vec![],
-                        output: revm_context::result::Output::Call(revm_primitives::Bytes::default()),
+                        output: revm_context::result::Output::Call(
+                            revm_primitives::Bytes::default(),
+                        ),
                     },
                     state,
                     lazy_reward,

src/scheduler.rs

@@ -270,9 +270,7 @@ where
     abort: AtomicBool,
     abort_reason: OnceLock<AbortReason>,
     metrics: ExecuteMetricsCollector,
-    /// Block number for prewarm task validation.
     block_number: u64,
-    /// Optional sender for MPT prewarm tasks.
     prewarm_sender: Option<mpsc::UnboundedSender<PrewarmTask>>,
 }
 
@@ -450,11 +448,8 @@ where
         if *FALLBACK_SEQUENTIAL {
             return self.fallback_sequential();
         }
-        let mut commiter = StateAsyncCommit::new(
-            self.env.beneficiary,
-            &self.state,
-            self.cfg.disable_nonce_check,
-        );
+        let mut commiter =
+            StateAsyncCommit::new(self.env.beneficiary, &self.state, self.cfg.disable_nonce_check);
         commiter = commiter.with_block_number(self.block_number);
         if let Some(ref sender) = self.prewarm_sender {
             commiter = commiter.with_prewarm_sender(sender.clone());