chore: adapt codebase to Rust 1.86

Author: Tommytrg

bridges/centralized-ethereum/src/actors/dr_reporter.rs

@@ -311,7 +311,7 @@ impl Handler<DrReporterMsg> for DrReporter {
                         // Error in call_with_confirmations
                         log::error!(
                             "{}: {:?}",
-                            format!("Cannot call reportResultBatch{:?}", &batched_report),
+                            format_args!("Cannot call reportResultBatch{:?}", &batched_report),
                             e
                         );
                     }

bridges/centralized-ethereum/src/actors/eth_poller.rs

@@ -193,7 +193,7 @@ impl EthPoller {
                             "Fail to get status of queries #{} to #{}: {}",
                             init_index,
                             next_dr_id,
-                            queries_status.unwrap_err().to_string()
+                            queries_status.unwrap_err()
                         );
                     }
                 }

bridges/centralized-ethereum/src/actors/watch_dog.rs

@@ -441,10 +441,7 @@ async fn fetch_wit_info(
     let req = jsonrpc::Request::method("getPkh").timeout(Duration::from_secs(5));
     let res = wit_client.send(req).await;
     let wit_account = match res {
-        Ok(Ok(res)) => match serde_json::from_value::<String>(res) {
-            Ok(pkh) => Some(pkh),
-            Err(_) => None,
-        },
+        Ok(Ok(res)) => serde_json::from_value::<String>(res).ok(),
         Ok(Err(_)) => None,
         Err(err) => {
             log::debug!("fetch_wit_info => method: getPkh; error: {}", err);

crypto/src/merkle.rs

@@ -47,7 +47,7 @@ fn merkle_tree_root_with_hashing_function<T: Copy>(hash_concat: fn(T, T) -> T, h
         n => {
             // n nodes: split into 2 and calculate the root for each half
             // split at the first power of two greater or equal to n / 2
-            let (left, right) = hashes.split_at(((n + 1) / 2).next_power_of_two());
+            let (left, right) = hashes.split_at(n.div_ceil(2).next_power_of_two());
             let left_hash = merkle_tree_root_with_hashing_function(hash_concat, left);
             let right_hash = merkle_tree_root_with_hashing_function(hash_concat, right);
 

data_structures/benches/sort_active_identities.rs

@@ -105,19 +105,18 @@ where
 }
 
 fn staggered(take: usize) -> impl Iterator<Item = u32> {
-    iter::repeat(10000)
-        .take(take)
-        .chain(iter::repeat(1000).take(take))
-        .chain(iter::repeat(100).take(take))
-        .chain(iter::repeat(10).take(take))
+    iter::repeat_n(10000, take)
+        .chain(iter::repeat_n(1000, take))
+        .chain(iter::repeat_n(100, take))
+        .chain(iter::repeat_n(10, take))
 }
 
 fn all_unique(n: u32) -> impl Iterator<Item = u32> {
     1..=n
 }
 
 fn all_equal(n: usize) -> impl Iterator<Item = u32> {
-    iter::repeat(1).take(n)
+    iter::repeat_n(1, n)
 }
 
 fn b_staggered_10000(b: &mut Bencher) {

data_structures/src/radon_report.rs

@@ -239,10 +239,10 @@ where
     ///
     /// * `subscript_index` is used to distinguish the different subscripts in one RADON script.
     /// * `operator_index` is the index of the operator inside the subscript: the partial result.
-    ///     The first element is always the input value, and the last element is the result of the
-    ///     subscript.
+    ///   The first element is always the input value, and the last element is the result of the
+    ///   subscript.
     /// * `element_index` is the index of the element inside the array that serves as the input of
-    ///     the subscript.
+    ///   the subscript.
     pub subscript_partial_results: Vec<Vec<Vec<RT>>>,
 }
 

net/src/client/http/mod.rs

@@ -105,30 +105,28 @@ impl WitnetHttpClient {
             reqwest::redirect::Policy::none()
         };
 
-        let client;
-        match proxy {
+        let client = match proxy {
             Some(proxy) => {
                 let proxy = reqwest::Proxy::http(proxy).map_err(|err| {
                     WitnetHttpError::ClientBuildError {
                         msg: err.to_string(),
                     }
                 })?;
-                client = reqwest::Client::builder()
+
+                reqwest::Client::builder()
                     .proxy(proxy)
                     .redirect(redirect_policy)
                     .build()
                     .map_err(|err| WitnetHttpError::ClientBuildError {
                         msg: err.to_string(),
-                    })?;
-            }
-            None => {
-                client = reqwest::Client::builder()
-                    .redirect(redirect_policy)
-                    .build()
-                    .map_err(|err| WitnetHttpError::ClientBuildError {
-                        msg: err.to_string(),
-                    })?;
+                    })?
             }
+            None => reqwest::Client::builder()
+                .redirect(redirect_policy)
+                .build()
+                .map_err(|err| WitnetHttpError::ClientBuildError {
+                    msg: err.to_string(),
+                })?,
         };
 
         Ok(Self { client })

node/src/actors/chain_manager/handlers.rs

@@ -21,7 +21,6 @@ use witnet_data_structures::{
     proto::versioning::ProtocolVersion,
     refresh_protocol_version,
     staking::{
-        errors::StakesError,
         prelude::{Power, StakeKey},
         stakes::QueryStakesKey,
     },
@@ -861,7 +860,7 @@ impl PeersBeacons {
                     b.as_ref()
                         .map(|last_beacon| last_beacon.highest_superblock_checkpoint)
                 })
-                .chain(std::iter::repeat(None).take(num_missing_peers)),
+                .chain(std::iter::repeat_n(None, num_missing_peers)),
             consensus_threshold,
         )
         // Flatten result:
@@ -1023,7 +1022,7 @@ impl Handler<PeersBeacons> for ChainManager {
         let peers_needed_for_consensus = outbound_limit
             .map(|x| {
                 // ceil(x * consensus_threshold / 100)
-                (usize::from(x) * consensus_threshold + 99) / 100
+                (usize::from(x) * consensus_threshold).div_ceil(100)
             })
             .unwrap_or(1);
 
@@ -1553,11 +1552,7 @@ impl Handler<QueryStakes> for ChainManager {
         let limit = params.limit.unwrap_or(u16::MAX) as usize;
 
         // fetch filtered stake entries from current chain state:
-        let mut stakes = self
-            .chain_state
-            .stakes
-            .query_stakes(filter.clone())
-            .map_err(StakesError::from)?;
+        let mut stakes = self.chain_state.stakes.query_stakes(filter.clone())?;
 
         // filter out stake entries having a nonce, last mining or witnessing epochs (depending
         // on actual ordering field) older than calculated `since_epoch`:

rad/src/lib.rs

@@ -875,8 +875,6 @@ pub mod fromx {
 mod tests {
     use std::convert::TryFrom;
 
-    use tokio;
-
     use serde_cbor::Value;
     use witnet_data_structures::{
         chain::RADFilter,
@@ -1985,11 +1983,7 @@ mod tests {
                         });
                 }
                 Err(e) => {
-                    println!(
-                        "Encountered error for proxy {:?}: {}",
-                        transport,
-                        e.to_string()
-                    );
+                    println!("Encountered error for proxy {:?}: {}", transport, e);
                 }
             }
         }

rad/src/types/boolean.rs

@@ -80,9 +80,9 @@ impl Operable for RadonBoolean {
         match call {
             (RadonOpCodes::Identity, None) => identity(RadonTypes::from(self.clone())),
             (RadonOpCodes::BooleanNegate, None) => Ok(boolean_operators::negate(self).into()),
-            (RadonOpCodes::BooleanAsString, None) => boolean_operators::to_string(self.clone())
-                .map(RadonTypes::from)
-                .map_err(Into::into),
+            (RadonOpCodes::BooleanAsString, None) => {
+                boolean_operators::to_string(self.clone()).map(RadonTypes::from)
+            }
             (op_code, args) => Err(RadError::UnsupportedOperator {
                 input_type: RADON_BOOLEAN_TYPE_NAME.to_string(),
                 operator: op_code.to_string(),