fix(ev-deployer): address clippy lints and nightly rustfmt imports

randygrok · randygrok · commit 868bd3ad946f · 2026-03-30T17:54:33.000+02:00
diff --git a/bin/ev-deployer/src/deploy/create2.rs b/bin/ev-deployer/src/deploy/create2.rs
@@ -3,7 +3,7 @@
 use alloy_primitives::{keccak256, Address, Bytes, B256};
 
 /// The deterministic deployer factory address (Nick's factory).
-/// See: https://github.com/Arachnid/deterministic-deployment-proxy
+/// See: <https://github.com/Arachnid/deterministic-deployment-proxy>
 pub(crate) const DETERMINISTIC_DEPLOYER: Address = Address::new(alloy_primitives::hex!(
     "4e59b44847b379578588920ca78fbf26c0b4956c"
 ));
@@ -41,7 +41,7 @@ mod tests {
         let initcode = hex!("60006000f3");
         let addr = compute_address(salt, &initcode);
 
-        let init_hash = keccak256(&initcode);
+        let init_hash = keccak256(initcode);
         let expected = DETERMINISTIC_DEPLOYER.create2(salt, init_hash);
         assert_eq!(addr, expected);
     }
diff --git a/bin/ev-deployer/src/deploy/deployer.rs b/bin/ev-deployer/src/deploy/deployer.rs
@@ -1,8 +1,10 @@
-//! ChainDeployer trait and LiveDeployer implementation.
+//! `ChainDeployer` trait and `LiveDeployer` implementation.
 
 use crate::deploy::create2::{build_factory_calldata, DETERMINISTIC_DEPLOYER};
-use alloy::network::EthereumWallet;
-use alloy::providers::{Provider, ProviderBuilder};
+use alloy::{
+    network::EthereumWallet,
+    providers::{Provider, ProviderBuilder},
+};
 use alloy_primitives::{Address, Bytes, B256};
 use alloy_rpc_types_eth::TransactionRequest;
 use alloy_signer_local::PrivateKeySigner;
@@ -35,7 +37,7 @@ pub(crate) struct LiveDeployer {
 }
 
 impl LiveDeployer {
-    /// Create a new LiveDeployer from an RPC URL and a hex-encoded private key.
+    /// Create a new `LiveDeployer` from an RPC URL and a hex-encoded private key.
     pub(crate) fn new(rpc_url: &str, private_key_hex: &str) -> eyre::Result<Self> {
         let key_hex = private_key_hex
             .strip_prefix("0x")
diff --git a/bin/ev-deployer/src/deploy/pipeline.rs b/bin/ev-deployer/src/deploy/pipeline.rs
@@ -1,10 +1,14 @@
 //! Deploy pipeline: orchestrates the full deployment flow.
 
-use crate::config::DeployConfig;
-use crate::contracts;
-use crate::deploy::create2::{compute_address, DETERMINISTIC_DEPLOYER};
-use crate::deploy::deployer::ChainDeployer;
-use crate::deploy::state::{ContractState, ContractStatus, DeployState};
+use crate::{
+    config::DeployConfig,
+    contracts,
+    deploy::{
+        create2::{compute_address, DETERMINISTIC_DEPLOYER},
+        deployer::ChainDeployer,
+        state::{ContractState, ContractStatus, DeployState},
+    },
+};
 use alloy_primitives::{Address, B256};
 use std::path::{Path, PathBuf};
 
@@ -68,31 +72,25 @@ pub(crate) async fn run(
         deploy_contract(
             deployer,
             &mut state,
-            "admin_proxy",
-            address,
-            salt,
-            &initcode,
-            contracts::admin_proxy::ADMIN_PROXY_BYTECODE,
-            &pipeline_cfg.state_path,
+            &DeployContractParams {
+                name: "admin_proxy",
+                address,
+                salt,
+                initcode: &initcode,
+                expected_runtime: contracts::admin_proxy::ADMIN_PROXY_BYTECODE,
+                state_path: &pipeline_cfg.state_path,
+            },
         )
         .await?;
     } else {
         eprintln!("[3/5] AdminProxy not configured, skipping");
     }
 
     // ── Step 3: Deploy Permit2 ──
-    if pipeline_cfg.config.contracts.permit2.is_some() {
+    if let Some(ref p2_config) = pipeline_cfg.config.contracts.permit2 {
         eprintln!("[4/5] Deploying Permit2...");
 
-        if pipeline_cfg
-            .config
-            .contracts
-            .permit2
-            .as_ref()
-            .unwrap()
-            .address
-            .is_some()
-        {
+        if p2_config.address.is_some() {
             eprintln!("       WARN: contracts.permit2.address is ignored in deploy mode");
         }
 
@@ -104,12 +102,14 @@ pub(crate) async fn run(
         deploy_contract(
             deployer,
             &mut state,
-            "permit2",
-            address,
-            salt,
-            &initcode,
-            &expected_runtime,
-            &pipeline_cfg.state_path,
+            &DeployContractParams {
+                name: "permit2",
+                address,
+                salt,
+                initcode: &initcode,
+                expected_runtime: &expected_runtime,
+                state_path: &pipeline_cfg.state_path,
+            },
         )
         .await?;
     } else {
@@ -139,25 +139,38 @@ pub(crate) async fn run(
     Ok(())
 }
 
-/// Build AdminProxy initcode with constructor argument.
+/// Build `AdminProxy` initcode with constructor argument.
 fn build_admin_proxy_initcode(owner: Address) -> Vec<u8> {
     let mut initcode = contracts::admin_proxy::ADMIN_PROXY_INITCODE.to_vec();
     // ABI-encode the owner address as a 32-byte word and append
     initcode.extend_from_slice(owner.into_word().as_slice());
     initcode
 }
 
+/// Parameters for deploying a single contract.
+struct DeployContractParams<'a> {
+    name: &'a str,
+    address: Address,
+    salt: B256,
+    initcode: &'a [u8],
+    expected_runtime: &'a [u8],
+    state_path: &'a Path,
+}
+
 /// Deploy a single contract via CREATE2 with idempotency.
 async fn deploy_contract(
     deployer: &dyn ChainDeployer,
     state: &mut DeployState,
-    name: &str,
-    address: Address,
-    salt: B256,
-    initcode: &[u8],
-    expected_runtime: &[u8],
-    state_path: &Path,
+    params: &DeployContractParams<'_>,
 ) -> eyre::Result<()> {
+    let DeployContractParams {
+        name,
+        address,
+        salt,
+        initcode,
+        expected_runtime,
+        state_path,
+    } = params;
     // Check if already deployed or verified in state
     let current_status = get_contract_status(state, name);
     if current_status >= Some(ContractStatus::Deployed) {
@@ -166,32 +179,31 @@ async fn deploy_contract(
     }
 
     // Idempotency: check if code already exists on-chain
-    let existing_code = deployer.get_code(address).await?;
+    let existing_code = deployer.get_code(*address).await?;
     if !existing_code.is_empty() {
-        if existing_code.as_ref() == expected_runtime {
+        if existing_code.as_ref() == *expected_runtime {
             eprintln!("       found matching bytecode at {address}, marking as deployed");
             set_contract_state(
                 state,
                 name,
                 ContractState {
                     status: ContractStatus::Deployed,
-                    address,
+                    address: *address,
                     deploy_tx: None,
                 },
             );
             state.save(state_path)?;
             return Ok(());
-        } else {
-            eyre::bail!(
-                "unexpected bytecode at {address}: expected {} bytes, found {} bytes",
-                expected_runtime.len(),
-                existing_code.len()
-            );
         }
+        eyre::bail!(
+            "unexpected bytecode at {address}: expected {} bytes, found {} bytes",
+            expected_runtime.len(),
+            existing_code.len()
+        );
     }
 
     // Deploy
-    let receipt = deployer.deploy_create2(salt, initcode).await?;
+    let receipt = deployer.deploy_create2(*salt, initcode).await?;
     eyre::ensure!(
         receipt.success,
         "CREATE2 deploy tx reverted for {name}: tx={}",
@@ -205,7 +217,7 @@ async fn deploy_contract(
         name,
         ContractState {
             status: ContractStatus::Deployed,
-            address,
+            address: *address,
             deploy_tx: Some(receipt.tx_hash),
         },
     );
@@ -294,12 +306,10 @@ fn build_deploy_manifest(state: &DeployState) -> serde_json::Value {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::config::*;
-    use crate::deploy::deployer::TxReceipt;
+    use crate::{config::*, deploy::deployer::TxReceipt};
     use alloy_primitives::{address, Bytes};
     use async_trait::async_trait;
-    use std::collections::HashMap;
-    use std::sync::Mutex;
+    use std::{collections::HashMap, sync::Mutex};
 
     /// Mock deployer for testing the pipeline without a live chain.
     struct MockDeployer {
diff --git a/bin/ev-deployer/src/deploy/state.rs b/bin/ev-deployer/src/deploy/state.rs
@@ -207,9 +207,8 @@ mod tests {
 
     #[test]
     fn immutability_rejects_chain_id_change() {
-        let config = test_config();
-        let state = DeployState::new(&config);
-        let mut changed = config.clone();
+        let mut changed = test_config();
+        let state = DeployState::new(&changed);
         changed.chain.chain_id = 9999;
         let err = state
             .validate_immutability(&changed)
@@ -220,9 +219,8 @@ mod tests {
 
     #[test]
     fn immutability_rejects_owner_change() {
-        let config = test_config();
-        let state = DeployState::new(&config);
-        let mut changed = config.clone();
+        let mut changed = test_config();
+        let state = DeployState::new(&changed);
         changed.contracts.admin_proxy.as_mut().unwrap().owner =
             address!("0000000000000000000000000000000000000001");
         let err = state
@@ -247,16 +245,15 @@ mod tests {
         let state = DeployState::new(&config);
 
         // Now add permit2 — this should be allowed
-        let mut extended = config.clone();
+        let mut extended = config;
         extended.contracts.permit2 = Some(Permit2Config { address: None });
         assert!(state.validate_immutability(&extended).is_ok());
     }
 
     #[test]
     fn immutability_rejects_removing_contract() {
-        let config = test_config();
-        let state = DeployState::new(&config);
-        let mut changed = config.clone();
+        let mut changed = test_config();
+        let state = DeployState::new(&changed);
         changed.contracts.admin_proxy = None;
         let err = state
             .validate_immutability(&changed)
