clippy

Author: JohnReedV

node/src/mev_shield/author.rs

@@ -82,6 +82,12 @@ impl ShieldKeys {
     }
 }
 
+impl Default for ShieldKeys {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// Shared context state.
 #[freeze_struct("62af7d26cf7c1271")]
 #[derive(Clone)]
@@ -94,7 +100,10 @@ pub struct ShieldContext {
 pub fn derive_aead_key(ss: &[u8]) -> [u8; 32] {
     let mut key = [0u8; 32];
     let n = ss.len().min(32);
-    key[..n].copy_from_slice(&ss[..n]);
+
+    if let (Some(dst), Some(src)) = (key.get_mut(..n), ss.get(..n)) {
+        dst.copy_from_slice(src);
+    }
     key
 }
 
@@ -123,8 +132,8 @@ const AURA_KEY_TYPE: KeyTypeId = KeyTypeId(*b"aura");
 ///  - at ~announce_at_ms announce the next key bytes on chain,
 pub fn spawn_author_tasks<B, C, Pool>(
     task_spawner: &sc_service::SpawnTaskHandle,
-    client: std::sync::Arc<C>,
-    pool: std::sync::Arc<Pool>,
+    client: Arc<C>,
+    pool: Arc<Pool>,
     keystore: sp_keystore::KeystorePtr,
     timing: TimeParams,
 ) -> ShieldContext
@@ -135,13 +144,13 @@ where
     B::Extrinsic: From<sp_runtime::OpaqueExtrinsic>,
 {
     let ctx = ShieldContext {
-        keys: std::sync::Arc::new(std::sync::Mutex::new(ShieldKeys::new())),
+        keys: Arc::new(Mutex::new(ShieldKeys::new())),
         timing: timing.clone(),
     };
 
     let aura_keys: Vec<sp_core::sr25519::Public> = keystore.sr25519_public_keys(AURA_KEY_TYPE);
 
-    let local_aura_pub = match aura_keys.get(0).cloned() {
+    let local_aura_pub = match aura_keys.first().copied() {
         Some(k) => k,
         None => {
             log::warn!(
@@ -173,20 +182,15 @@ where
             if announce_at_ms > slot_ms {
                 log::warn!(
                     target: "mev-shield",
-                    "spawn_author_tasks: announce_at_ms ({}) > slot_ms ({}); clamping to slot_ms",
-                    announce_at_ms,
-                    slot_ms,
+                    "spawn_author_tasks: announce_at_ms ({announce_at_ms}) > slot_ms ({slot_ms}); clamping to slot_ms",
                 );
                 announce_at_ms = slot_ms;
             }
             let tail_ms = slot_ms.saturating_sub(announce_at_ms);
 
             log::debug!(
                 target: "mev-shield",
-                "author timing: slot_ms={} announce_at_ms={} (effective) tail_ms={}",
-                slot_ms,
-                announce_at_ms,
-                tail_ms
+                "author timing: slot_ms={slot_ms} announce_at_ms={announce_at_ms} (effective) tail_ms={tail_ms}",
             );
 
             let mut import_stream = client_clone.import_notification_stream();
@@ -204,17 +208,15 @@ where
                     Err(e) => {
                         log::debug!(
                             target: "mev-shield",
-                            "spawn_author_tasks: failed to lock ShieldKeys (poisoned?): {:?}",
-                            e
+                            "spawn_author_tasks: failed to lock ShieldKeys (poisoned?): {e:?}",
                         );
                         continue;
                     }
                 };
 
                 log::debug!(
                     target: "mev-shield",
-                    "Slot start (local author): (pk sizes: curr={}B, next={}B)",
-                    curr_pk_len, next_pk_len
+                    "Slot start (local author): (pk sizes: curr={curr_pk_len}B, next={next_pk_len}B)",
                 );
 
                 // Wait until the announce window in this slot.
@@ -228,8 +230,7 @@ where
                     Err(e) => {
                         log::debug!(
                             target: "mev-shield",
-                            "spawn_author_tasks: failed to lock ShieldKeys for next_pk: {:?}",
-                            e
+                            "spawn_author_tasks: failed to lock ShieldKeys for next_pk: {e:?}",
                         );
                         continue;
                     }
@@ -240,7 +241,7 @@ where
                     client_clone.clone(),
                     pool_clone.clone(),
                     keystore_clone.clone(),
-                    local_aura_pub.clone(),
+                    local_aura_pub,
                     next_pk.clone(),
                     local_nonce,
                 )
@@ -257,7 +258,7 @@ where
                                 client_clone.clone(),
                                 pool_clone.clone(),
                                 keystore_clone.clone(),
-                                local_aura_pub.clone(),
+                                local_aura_pub,
                                 next_pk,
                                 local_nonce.saturating_add(1),
                             )
@@ -297,22 +298,21 @@ where
                     Err(e) => {
                         log::debug!(
                             target: "mev-shield",
-                            "spawn_author_tasks: failed to lock ShieldKeys for roll_for_next_slot: {:?}",
-                            e
+                            "spawn_author_tasks: failed to lock ShieldKeys for roll_for_next_slot: {e:?}",
                         );
                     }
                 }
             }
-        }
+        },
     );
 
     ctx
 }
 
 /// Build & submit the signed `announce_next_key` extrinsic OFF-CHAIN
 pub async fn submit_announce_extrinsic<B, C, Pool>(
-    client: std::sync::Arc<C>,
-    pool: std::sync::Arc<Pool>,
+    client: Arc<C>,
+    pool: Arc<Pool>,
     keystore: sp_keystore::KeystorePtr,
     aura_pub: sp_core::sr25519::Public,
     next_public_key: Vec<u8>,
@@ -350,10 +350,9 @@ where
         let src_start = bytes.len().saturating_sub(n);
         let dst_start = 32usize.saturating_sub(n);
 
-        if let (Some(dst), Some(src)) = (
-            out.get_mut(dst_start..32),
-            bytes.get(src_start..src_start + n),
-        ) {
+        let src_slice = bytes.get(src_start..).and_then(|s| s.get(..n));
+
+        if let (Some(dst), Some(src)) = (out.get_mut(dst_start..32), src_slice) {
             dst.copy_from_slice(src);
             H256(out)
         } else {
@@ -411,8 +410,7 @@ where
     );
 
     // Build the exact signable payload.
-    let payload: SignedPayload =
-        SignedPayload::from_raw(call.clone(), extra.clone(), implicit.clone());
+    let payload: SignedPayload = SignedPayload::from_raw(call.clone(), extra.clone(), implicit);
 
     let raw_payload = payload.encode();
 
@@ -432,6 +430,7 @@ where
 
     let xt_bytes = uxt.encode();
     let xt_hash = sp_core::hashing::blake2_256(&xt_bytes);
+    let xt_hash_hex = hex::encode(xt_hash);
 
     let opaque: sp_runtime::OpaqueExtrinsic = uxt.into();
     let xt: <B as sp_runtime::traits::Block>::Extrinsic = opaque.into();
@@ -441,9 +440,7 @@ where
 
     log::debug!(
         target: "mev-shield",
-        "announce_next_key submitted: xt=0x{}, nonce={}",
-        hex::encode(xt_hash),
-        nonce
+        "announce_next_key submitted: xt=0x{xt_hash_hex}, nonce={nonce}",
     );
 
     Ok(())

node/src/mev_shield/proposer.rs

@@ -151,8 +151,7 @@ pub fn spawn_revealer<B, C, Pool>(
                                     Err(e) => {
                                         log::debug!(
                                             target: "mev-shield",
-                                            "    [xt #{idx}] failed to decode UncheckedExtrinsic: {:?}",
-                                            e
+                                            "    [xt #{idx}] failed to decode UncheckedExtrinsic: {e:?}",
                                         );
                                         continue;
                                     }
@@ -227,14 +226,11 @@ pub fn spawn_revealer<B, C, Pool>(
                         }
                         Ok(None) => log::debug!(
                             target: "mev-shield",
-                            "  block_body returned None for hash={:?}",
-                            at_hash
+                            "  block_body returned None for hash={at_hash:?}",
                         ),
                         Err(e) => log::debug!(
                             target: "mev-shield",
-                            "  block_body error for hash={:?}: {:?}",
-                            at_hash,
-                            e
+                            "  block_body error for hash={at_hash:?}: {e:?}",
                         ),
                     }
                 }
@@ -263,9 +259,7 @@ pub fn spawn_revealer<B, C, Pool>(
                 if decrypt_window_ms > slot_ms {
                     log::warn!(
                         target: "mev-shield",
-                        "spawn_revealer: decrypt_window_ms ({}) > slot_ms ({}); clamping to slot_ms",
-                        decrypt_window_ms,
-                        slot_ms
+                        "spawn_revealer: decrypt_window_ms ({decrypt_window_ms}) > slot_ms ({slot_ms}); clamping to slot_ms",
                     );
                     decrypt_window_ms = slot_ms;
                 }
@@ -274,19 +268,13 @@ pub fn spawn_revealer<B, C, Pool>(
 
                 log::debug!(
                     target: "mev-shield",
-                    "revealer timing: slot_ms={} decrypt_window_ms={} (effective) tail_ms={}",
-                    slot_ms,
-                    decrypt_window_ms,
-                    tail_ms
+                    "revealer timing: slot_ms={slot_ms} decrypt_window_ms={decrypt_window_ms} (effective) tail_ms={tail_ms}",
                 );
 
                 loop {
                     log::debug!(
                         target: "mev-shield",
-                        "revealer: sleeping {} ms before decrypt window (slot_ms={}, decrypt_window_ms={})",
-                        tail_ms,
-                        slot_ms,
-                        decrypt_window_ms
+                        "revealer: sleeping {tail_ms} ms before decrypt window (slot_ms={slot_ms}, decrypt_window_ms={decrypt_window_ms})",
                     );
 
                     if tail_ms > 0 {
@@ -307,8 +295,7 @@ pub fn spawn_revealer<B, C, Pool>(
                         Err(e) => {
                             log::debug!(
                                 target: "mev-shield",
-                                "revealer: failed to lock ShieldKeys (poisoned?): {:?}",
-                                e
+                                "revealer: failed to lock ShieldKeys (poisoned?): {e:?}",
                             );
                             None
                         }
@@ -346,8 +333,7 @@ pub fn spawn_revealer<B, C, Pool>(
                             Err(e) => {
                                 log::debug!(
                                     target: "mev-shield",
-                                    "revealer: failed to lock WrapperBuffer for drain_for_block: {:?}",
-                                    e
+                                    "revealer: failed to lock WrapperBuffer for drain_for_block: {e:?}",
                                 );
                                 Vec::new()
                             }

node/src/service.rs

@@ -540,18 +540,13 @@ where
 
     if role.is_authority() {
         let slot_duration = consensus_mechanism.slot_duration(&client)?;
-        let slot_duration_ms: u64 =
-            u64::try_from(slot_duration.as_millis()).unwrap_or(u64::MAX);
+        let slot_duration_ms: u64 = u64::try_from(slot_duration.as_millis()).unwrap_or(u64::MAX);
 
         // For 12s blocks: announce ≈ 7s, decrypt window ≈ 3s.
         // For 250ms blocks: announce ≈ 145ms, decrypt window ≈ 62ms, etc.
-        let announce_at_ms_raw = slot_duration_ms
-            .saturating_mul(7)
-            .saturating_div(12);
+        let announce_at_ms_raw = slot_duration_ms.saturating_mul(7).saturating_div(12);
 
-        let decrypt_window_ms = slot_duration_ms
-            .saturating_mul(3)
-            .saturating_div(12);
+        let decrypt_window_ms = slot_duration_ms.saturating_mul(3).saturating_div(12);
 
         // Ensure announce_at_ms + decrypt_window_ms never exceeds slot_ms.
         let max_announce = slot_duration_ms.saturating_sub(decrypt_window_ms);
@@ -614,20 +609,19 @@ where
             let (slot_ms, decrypt_ms) = mev_timing
                 .as_ref()
                 .map(|t| (t.slot_ms, t.decrypt_window_ms))
-                .unwrap_or((slot_duration.as_millis() as u64, 3_000));
+                .unwrap_or((slot_duration.as_millis(), 3_000));
 
             let guard_ms: u64 = 200; // small cushion so reveals hit the pool first
             let after_decrypt_ms = slot_ms.saturating_sub(decrypt_ms).saturating_add(guard_ms);
 
-            // Clamp into (0.5 .. 0.98] to give the proposer enough time
-            let mut f = (after_decrypt_ms as f32) / (slot_ms as f32);
-            if f < 0.50 {
-                f = 0.50;
-            }
-            if f > 0.98 {
-                f = 0.98;
-            }
-            f
+            let f_raw = if slot_ms > 0 {
+                (after_decrypt_ms as f32) / (slot_ms as f32)
+            } else {
+                // Extremely defensive fallback; should never happen in practice.
+                0.75
+            };
+
+            f_raw.clamp(0.50, 0.98)
         };
 
         let create_inherent_data_providers =

pallets/shield/src/benchmarking.rs

@@ -1,6 +1,3 @@
-//! Benchmarking for pallet-mev-shield.
-#![cfg(feature = "runtime-benchmarks")]
-
 use super::*;
 
 use codec::Encode;
@@ -99,7 +96,7 @@ mod benches {
 
         // Assert: NextKey should be set exactly.
         let stored = NextKey::<T>::get().expect("must be set by announce_next_key");
-        assert_eq!(stored, public_key.as_slice());
+        assert_eq!(stored, public_key);
     }
 
     /// Benchmark `submit_encrypted`.

pallets/shield/src/lib.rs

@@ -195,12 +195,13 @@ pub mod pallet {
         ///   - `aead_ct` is XChaCha20‑Poly1305 over:
         ///       signer || nonce || SCALE(call) || sig_kind || signature
         #[pallet::call_index(1)]
-        #[pallet::weight(({
-            let w = Weight::from_parts(13_980_000, 0)
+        #[pallet::weight((
+            Weight::from_parts(13_980_000, 0)
                 .saturating_add(T::DbWeight::get().reads(1_u64))
-                .saturating_add(T::DbWeight::get().writes(1_u64));
-            w
-        }, DispatchClass::Normal, Pays::Yes))]
+                .saturating_add(T::DbWeight::get().writes(1_u64)),
+            DispatchClass::Normal,
+            Pays::Yes,
+        ))]
         pub fn submit_encrypted(
             origin: OriginFor<T>,
             commitment: T::Hash,
@@ -229,6 +230,7 @@ pub mod pallet {
         #[pallet::weight(Weight::from_parts(77_280_000, 0)
         .saturating_add(T::DbWeight::get().reads(4_u64))
         .saturating_add(T::DbWeight::get().writes(2_u64)))]
+        #[allow(clippy::useless_conversion)]
         pub fn execute_revealed(
             origin: OriginFor<T>,
             id: T::Hash,

pallets/shield/src/mock.rs

@@ -1,5 +1,3 @@
-#![cfg(test)]
-
 use crate as pallet_mev_shield;
 
 use frame_support::{construct_runtime, derive_impl, parameter_types, traits::Everything};

pallets/shield/src/tests.rs

@@ -1,5 +1,3 @@
-#![cfg(test)]
-
 use crate as pallet_mev_shield;
 use crate::mock::*;