style: cargo clippy

Author: felicityin

bin/host/src/cli.rs

@@ -57,7 +57,7 @@ impl HostArgs {
         let (rpc_url, chain_id) = match (self.provider.rpc_url.clone(), self.provider.chain_id) {
             (Some(rpc_url), Some(chain_id)) => (Some(rpc_url), chain_id),
             (None, Some(chain_id)) => {
-                match std::env::var(format!("RPC_{}", chain_id)) {
+                match std::env::var(format!("RPC_{chain_id}")) {
                     Ok(rpc_env_var) => {
                         // We don't always need it but if the value exists it has to be valid.
                         (Some(Url::parse(rpc_env_var.as_str())?), chain_id)
@@ -79,7 +79,7 @@ impl HostArgs {
             }
         };
         let debug_rpc_url = self.provider.debug_rpc_url.clone().or_else(|| {
-            std::env::var(format!("DEBUG_RPC_{}", chain_id))
+            std::env::var(format!("DEBUG_RPC_{chain_id}"))
                 .ok()
                 .and_then(|url| Url::parse(&url).ok())
         });

crates/executor/guest/src/lib.rs

@@ -17,10 +17,10 @@ use executor::{EthClientExecutor, DESERIALZE_INPUTS};
 use io::EthClientExecutorInput;
 use std::sync::Arc;
 
-pub fn verify_block(input: &Vec<u8>) -> (B256, B256, B256) {
-    println!("cycle-tracker-report-start: {}", DESERIALZE_INPUTS);
+pub fn verify_block(input: &[u8]) -> (B256, B256, B256) {
+    println!("cycle-tracker-report-start: {DESERIALZE_INPUTS}");
     let input = bincode::deserialize::<EthClientExecutorInput>(input).unwrap();
-    println!("cycle-tracker-report-end: {}", DESERIALZE_INPUTS);
+    println!("cycle-tracker-report-end: {DESERIALZE_INPUTS}");
 
     // Execute the block.
     let executor = EthClientExecutor::eth(

crates/executor/host/src/alerting.rs

@@ -27,7 +27,7 @@ impl AlertingClient {
             event_action: "trigger".to_string(),
         };
 
-        match self.client.post(format!("{}/enqueue", PAGER_DUTY_ENDPOINT)).json(&alert).send().await
+        match self.client.post(format!("{PAGER_DUTY_ENDPOINT}/enqueue")).json(&alert).send().await
         {
             Ok(response) => {
                 if let Err(err) = response.error_for_status() {

crates/executor/host/src/bins/persist_report_hook.rs

@@ -198,7 +198,7 @@ impl ExecutionHooks for PersistExecutionReport {
         executed_block: &Block<P::SignedTx>,
         execution_report: &ExecutionReport,
     ) -> eyre::Result<()> {
-        println!("\nExecution report:\n{}", execution_report);
+        println!("\nExecution report:\n{execution_report}");
 
         // Open the file for appending or create it if it doesn't exist
         let file = OpenOptions::new().append(true).create(true).open(self.report_path.clone())?;

crates/executor/host/src/full_executor.rs

@@ -306,7 +306,7 @@ where
                         std::fs::create_dir_all(&input_folder)?;
                     }
 
-                    let input_path = input_folder.join(format!("{}.bin", block_number));
+                    let input_path = input_folder.join(format!("{block_number}.bin"));
                     let mut cache_file = std::fs::File::create(input_path)?;
 
                     bincode::serialize_into(&mut cache_file, &client_input)?;
@@ -450,7 +450,7 @@ fn try_load_input_from_cache<P: NodePrimitives + DeserializeOwned>(
     chain_id: u64,
     block_number: u64,
 ) -> eyre::Result<Option<ClientExecutorInput<P>>> {
-    let cache_path = cache_dir.join(format!("input/{}/{}.bin", chain_id, block_number));
+    let cache_path = cache_dir.join(format!("input/{chain_id}/{block_number}.bin"));
 
     if cache_path.exists() {
         // TODO: prune the cache if invalid instead

crates/executor/host/src/hooks.rs

@@ -24,6 +24,7 @@ pub trait ExecutionHooks: Send {
         async { Ok(()) }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn on_proving_end(
         &self,
         _block_number: u64,

crates/executor/host/src/host_executor.rs

@@ -184,7 +184,7 @@ impl<C: ConfigureEvm> HostExecutor<C> {
             })
         });
 
-        let after_tasks = state_requests.iter().map(|(address, _)| {
+        let after_tasks = state_requests.keys().map(|address| {
             let permit = semaphore.clone().acquire_owned();
             let provider = provider.clone();
             let address = *address;

crates/executor/host/src/utils.rs

@@ -3,8 +3,8 @@ use zkm_sdk::ZKMStdin;
 /// Dump the program and stdin to files for debugging if `ZKM_DUMP` is set.
 pub(crate) fn zkm_dump(elf: &[u8], stdin: &ZKMStdin, block: u64) {
     if std::env::var("ZKM_DUMP").map(|v| v == "1" || v.to_lowercase() == "true").unwrap_or(false) {
-        std::fs::write(format!("{}-program.bin", block), elf).unwrap();
+        std::fs::write(format!("{block}-program.bin"), elf).unwrap();
         let stdin = bincode::serialize(&stdin).unwrap();
-        std::fs::write(format!("{}-stdin.bin", block), stdin.clone()).unwrap();
+        std::fs::write(format!("{block}-stdin.bin"), stdin.clone()).unwrap();
     }
 }

crates/storage/rpc-db/src/lib.rs

@@ -217,7 +217,7 @@ impl<P: Provider<N> + Clone, N: Network> RpcDb<P, N> {
         info!("Preloading accounts and storage for block: {}", self.block);
         let current_block = self.block.as_u64().unwrap() + 1;
         let params = (
-            format!("0x{:x}", current_block),
+            format!("0x{current_block:x}"),
             serde_json::json!({
                 "disableStorage": false,
                 "disableMemory": true,