Merge pull request #36 from x100111010/rust_1.86

style: fix clippy rust 1.86

Author: 0xA001113

LICENSE

@@ -1,6 +1,6 @@
 ISC License
 
-Copyright (c) 2024-2024 Spectre developers
+Copyright (c) 2024-2025 Spectre developers
 Copyright (c) 2022-2024 Kaspa developers
 
 Permission to use, copy, modify, and distribute this software for any

cli/src/cli.rs

@@ -807,7 +807,7 @@ impl SpectreCli {
                 }
                 SyncState::UtxoResync => Some([style("SYNC").red().to_string(), style("UTXO").black().to_string()].join(" ")),
                 SyncState::NotSynced => Some([style("SYNC").red().to_string(), style("...").black().to_string()].join(" ")),
-                SyncState::Synced { .. } => None,
+                SyncState::Synced => None,
             }
         } else {
             Some(style("SYNC").red().to_string())

components/addressmanager/src/lib.rs

@@ -227,7 +227,7 @@ impl AddressManager {
                     ExtendHelper { gateway, local_addr, external_port: desired_external_port },
                 )))
             }
-            Err(AddPortError::PortInUse {}) => {
+            Err(AddPortError::PortInUse) => {
                 let port = gateway.add_any_port(
                     igd::PortMappingProtocol::TCP,
                     local_addr,

consensus/src/pipeline/pruning_processor/processor.rs

@@ -361,7 +361,7 @@ impl PruningProcessor {
                 info!(
                     "Header and Block pruning: pruned {} tips: {}...{}",
                     pruned_tips.len(),
-                    pruned_tips.iter().take(5.min((pruned_tips.len() + 1) / 2)).reusable_format(", "),
+                    pruned_tips.iter().take(5.min(pruned_tips.len().div_ceil(2))).reusable_format(", "),
                     pruned_tips.iter().rev().take(5.min(pruned_tips.len() / 2)).reusable_format(", ")
                 )
             }

consensus/src/processes/past_median_time.rs

@@ -54,7 +54,7 @@ impl<T: HeaderStoreReader> SampledPastMedianTimeManager<T> {
         window_timestamps.sort_unstable(); // This is deterministic because we sort u64
         let avg_frame_size = window_timestamps.len().min(AVERAGE_FRAME_SIZE);
         // Define the slice so that the average is the highest among the 2 possible solutions in case of an even frame size
-        let ending_index = (window_timestamps.len() + avg_frame_size + 1) / 2;
+        let ending_index = (window_timestamps.len() + avg_frame_size).div_ceil(2);
         let timestamp = (window_timestamps[ending_index - avg_frame_size..ending_index].iter().sum::<u64>()
             + avg_frame_size as u64 / 2)
             / avg_frame_size as u64;

crypto/txscript/src/script_builder.rs

@@ -281,7 +281,7 @@ impl Default for ScriptBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::iter::{once, repeat};
+    use std::iter::once;
 
     // Tests that pushing opcodes to a script via the ScriptBuilder API works as expected.
     #[test]
@@ -433,39 +433,39 @@ mod tests {
             Test {
                 name: "push data len 17",
                 data: vec![0x49; 17],
-                expected: Ok(once(OpData17).chain(repeat(0x49).take(17)).collect()),
+                expected: Ok(once(OpData17).chain(std::iter::repeat_n(0x49, 17)).collect()),
                 unchecked: false,
             },
             Test {
                 name: "push data len 75",
                 data: vec![0x49; 75],
-                expected: Ok(once(OpData75).chain(repeat(0x49).take(75)).collect()),
+                expected: Ok(once(OpData75).chain(std::iter::repeat_n(0x49, 75)).collect()),
                 unchecked: false,
             },
             // BIP0062: Pushing 76 to 255 bytes must use OP_PUSHDATA1.
             Test {
                 name: "push data len 76",
                 data: vec![0x49; 76],
-                expected: Ok(once(OpPushData1).chain(once(76)).chain(repeat(0x49).take(76)).collect()),
+                expected: Ok(once(OpPushData1).chain(once(76)).chain(std::iter::repeat_n(0x49, 76)).collect()),
                 unchecked: false,
             },
             Test {
                 name: "push data len 255",
                 data: vec![0x49; 255],
-                expected: Ok(once(OpPushData1).chain(once(255)).chain(repeat(0x49).take(255)).collect()),
+                expected: Ok(once(OpPushData1).chain(once(255)).chain(std::iter::repeat_n(0x49, 255)).collect()),
                 unchecked: false,
             },
-            // // BIP0062: Pushing 256 to 520 bytes must use OP_PUSHDATA2.
+            // BIP0062: Pushing 256 to 520 bytes must use OP_PUSHDATA2.
             Test {
                 name: "push data len 256",
                 data: vec![0x49; 256],
-                expected: Ok(once(OpPushData2).chain([0, 1]).chain(repeat(0x49).take(256)).collect()),
+                expected: Ok(once(OpPushData2).chain([0, 1]).chain(std::iter::repeat_n(0x49, 256)).collect()),
                 unchecked: false,
             },
             Test {
                 name: "push data len 520",
                 data: vec![0x49; 520],
-                expected: Ok(once(OpPushData2).chain([8, 2]).chain(repeat(0x49).take(520)).collect()),
+                expected: Ok(once(OpPushData2).chain([8, 2]).chain(std::iter::repeat_n(0x49, 520)).collect()),
                 unchecked: false,
             },
             // BIP0062: OP_PUSHDATA4 can never be used, as pushes over 520
@@ -497,14 +497,14 @@ mod tests {
             Test {
                 name: "push data len 32767 (non-canonical)",
                 data: vec![0x49; 32767],
-                expected: Ok(once(OpPushData2).chain([255, 127]).chain(repeat(0x49).take(32767)).collect()),
+                expected: Ok(once(OpPushData2).chain([255, 127]).chain(std::iter::repeat_n(0x49, 32767)).collect()),
                 unchecked: true,
             },
             // 5-byte data push via OP_PUSHDATA_4.
             Test {
                 name: "push data len 65536 (non-canonical)",
                 data: vec![0x49; 65536],
-                expected: Ok(once(OpPushData4).chain([0, 0, 1, 0]).chain(repeat(0x49).take(65536)).collect()),
+                expected: Ok(once(OpPushData4).chain([0, 0, 1, 0]).chain(std::iter::repeat_n(0x49, 65536)).collect()),
                 unchecked: true,
             },
         ];
@@ -549,7 +549,11 @@ mod tests {
                 value: 0xffeeddccbbaa9988,
                 expected: vec![OpData8, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff],
             },
-            Test { name: "0xffffffffffffffff", value: u64::MAX, expected: once(OpData8).chain(repeat(0xff).take(8)).collect() },
+            Test {
+                name: "0xffffffffffffffff",
+                value: u64::MAX,
+                expected: once(OpData8).chain(std::iter::repeat_n(0xff, 8)).collect(),
+            },
         ];
 
         for test in tests {

math/src/lib.rs

@@ -85,7 +85,7 @@ impl Uint256 {
     #[inline]
     /// Computes the target value in float format from BigInt format.
     pub fn compact_target_bits(self) -> u32 {
-        let mut size = (self.bits() + 7) / 8;
+        let mut size = self.bits().div_ceil(8);
         let mut compact = if size <= 3 {
             (self.as_u64() << (8 * (3 - size))) as u32
         } else {

mining/src/manager.rs

@@ -1074,15 +1074,14 @@ fn feerate_stats(transactions: Vec<Transaction>, calculated_fees: Vec<u64>) -> O
 mod tests {
     use super::*;
     use spectre_consensus_core::subnets;
-    use std::iter::repeat;
 
     fn transactions(length: usize) -> Vec<Transaction> {
         let tx = || {
             let tx = Transaction::new(0, vec![], vec![], 0, Default::default(), 0, vec![]);
             tx.set_mass(2);
             tx
         };
-        let mut txs = repeat(tx()).take(length).collect_vec();
+        let mut txs = std::iter::repeat_n(tx(), length).collect_vec();
         txs[0].subnetwork_id = subnets::SUBNETWORK_ID_COINBASE;
         txs
     }

protocol/p2p/src/core/hub.rs

@@ -91,7 +91,7 @@ impl Hub {
         let total_outbound = peers.values().filter(|peer| peer.is_outbound()).count();
         let total_inbound = peers.len() - total_outbound;
 
-        let mut outbound_count = ((num_peers + 1) / 2).min(total_outbound);
+        let mut outbound_count = num_peers.div_ceil(2).min(total_outbound);
 
         // If there won't be enough inbound peers to meet the num_peers after we've selected only half for outbound,
         // try to require more outbound peers for the difference

rpc/grpc/client/src/lib.rs

@@ -93,10 +93,10 @@ impl GrpcClient {
     /// `notification_mode` determines how notifications are handled:
     ///
     /// - `MultiListeners` => Multiple listeners are supported via the [`RpcApi`] implementation.
-    ///                       Registering listeners is needed before subscribing to notifications.
+    ///   Registering listeners is needed before subscribing to notifications.
     /// - `Direct` => A single listener receives the notification via a channel (see  `self.notification_channel_receiver()`).
-    ///               Registering a listener is pointless and ignored.
-    ///               Subscribing to notifications ignores the listener ID.
+    ///   Registering a listener is pointless and ignored.
+    ///   Subscribing to notifications ignores the listener ID.
     ///
     /// `url`: the server to connect to
     ///

rpc/service/src/service.rs

@@ -624,7 +624,7 @@ NOTE: This error usually indicates an RPC conversion error between the node and
                 .get_virtual_chain_accepted_transaction_ids(&session, &virtual_chain_batch, Some(batch_size))
                 .await?;
             // bound added to the length of the accepted transaction ids, which is bounded by merged blocks
-            virtual_chain_batch.added = virtual_chain_batch.added[..accepted_transaction_ids.len()].to_vec();
+            virtual_chain_batch.added.truncate(accepted_transaction_ids.len());
             accepted_transaction_ids
         } else {
             vec![]

rpc/wrpc/client/src/parse.rs

@@ -139,7 +139,7 @@ pub fn parse_host(input: &str) -> Result<ParseHostOutput, ParseHostError> {
     let has_at_least_one_hyphen = host.contains('-');
     let hyphens_are_separated_by_valid_chars =
         has_at_least_one_hyphen.then(|| host.split('-').all(|part| part.chars().all(|c| c == '.' || c.is_ascii_alphanumeric())));
-    let tld = host.split('.').last();
+    let tld = host.split('.').next_back();
     // Prevents e.g. numbers being used as TLDs (which in turn prevents e.g. mistakes in IPv4 addresses as being detected as a domain).
     let tld_exists_and_is_not_number = tld.map(|tld| tld.parse::<i32>().is_err()).unwrap_or(false);
 

wallet/core/src/compat/gen0.rs

@@ -92,7 +92,7 @@ fn get_v0_parts(data: &str) -> Result<CipherData> {
     while !ptr.is_empty() {
         let len: usize = ptr[0..5].parse().unwrap();
         let mut data = vec![0; len / 2];
-        hex_decode(ptr[5..(5 + len)].as_bytes(), &mut data).unwrap();
+        hex_decode(&ptr.as_bytes()[5..(5 + len)], &mut data).unwrap();
         list.push(data);
         ptr = &ptr[(5 + len)..];
     }

wallet/core/src/events.rs

@@ -290,7 +290,7 @@ pub enum EventKind {
 impl From<&Events> for EventKind {
     fn from(event: &Events) -> Self {
         match event {
-            Events::WalletPing { .. } => EventKind::WalletStart,
+            Events::WalletPing => EventKind::WalletStart,
 
             Events::Connect { .. } => EventKind::Connect,
             Events::Disconnect { .. } => EventKind::Disconnect,

wallet/core/src/utxo/sync.rs

@@ -98,8 +98,8 @@ impl SyncMonitor {
 
     async fn handle_event(&self, event: Box<Events>) -> Result<()> {
         match *event {
-            Events::UtxoProcStart { .. } => {}
-            Events::UtxoProcStop { .. } => {}
+            Events::UtxoProcStart => {}
+            Events::UtxoProcStop => {}
             _ => {}
         }