fix: resolve clippy beta channel lint failures

Author: iostat

crates/ledger/src/proofs/public_input/scalars.rs

@@ -705,7 +705,7 @@ mod tests {
 
         // HashMap deliberately uses an unstable order; here we sort to ensure that the output is
         // consistent when printing.
-        index_terms_fp.sort_by(|(x, _), (y, _)| x.cmp(y));
+        index_terms_fp.sort_by_key(|(x, _)| *x);
 
         let fp_other_terms: Vec<(String, String)> = index_terms_fp
             .iter()
@@ -772,7 +772,7 @@ mod tests {
 
         // HashMap deliberately uses an unstable order; here we sort to ensure that the output is
         // consistent when printing.
-        index_terms_fq.sort_by(|(x, _), (y, _)| x.cmp(y));
+        index_terms_fq.sort_by_key(|(x, _)| *x);
 
         // dbg!(index_terms_fq)
 

crates/ledger/src/proofs/verifiers.rs

@@ -399,8 +399,7 @@ pub fn make_zkapp_verifier_index(vk: &VerificationKey) -> VerifierIndex<Fq> {
 
     let public = 40; // Is that constant ?
 
-    let domain: Radix2EvaluationDomain<Fq> =
-        Radix2EvaluationDomain::new(1 << log2_size as u64).unwrap();
+    let domain: Radix2EvaluationDomain<Fq> = Radix2EvaluationDomain::new(1 << log2_size).unwrap();
 
     let srs = {
         let degree = 1 << BACKEND_TOCK_ROUNDS_N;

crates/ledger/src/scan_state/transaction_logic/mod.rs

@@ -856,8 +856,8 @@ impl UserCommand {
         accounts: &BTreeMap<AccountId, Account>,
     ) -> HashMap<AccountId, VerificationKeyWire> {
         accounts
-            .iter()
-            .filter_map(|(_, account)| {
+            .values()
+            .filter_map(|account| {
                 let zkapp = account.zkapp.as_ref()?;
                 let vk = zkapp.verification_key.clone()?;
                 Some((account.id(), vk))

crates/ledger/src/transaction_pool.rs

@@ -1669,13 +1669,10 @@ impl TransactionPool {
     fn has_sufficient_fee(&self, pool_max_size: usize, cmd: &valid::UserCommand) -> bool {
         match self.pool.min_fee() {
             None => true,
-            Some(min_fee) => {
-                if self.pool.size() >= pool_max_size {
-                    cmd.forget_check().fee_per_wu() > min_fee
-                } else {
-                    true
-                }
+            Some(min_fee) if self.pool.size() >= pool_max_size => {
+                cmd.forget_check().fee_per_wu() > min_fee
             }
+            Some(_) => true,
         }
     }
 

crates/node/src/p2p/callbacks/p2p_callbacks_reducer.rs

@@ -471,8 +471,8 @@ impl crate::State {
                 let p2p = p2p_ready!(state.p2p, meta.time());
                 let peers = p2p
                     .peers
-                    .iter()
-                    .filter_map(|(_, v)| v.dial_opts.clone())
+                    .values()
+                    .filter_map(|v| v.dial_opts.clone())
                     .collect();
                 let response = Some(Box::new(P2pRpcResponse::InitialPeers(peers)));
 

crates/node/src/snark_pool/candidate/snark_pool_candidate_state.rs

@@ -200,8 +200,8 @@ impl SnarkPoolCandidatesState {
                     let peer_jobs = self.by_peer.get(peer_id)?;
                     if peer_jobs.get(job_id)?.work().is_some() {
                         let jobs = peer_jobs
-                            .iter()
-                            .filter_map(|(_, v)| match v {
+                            .values()
+                            .filter_map(|v| match v {
                                 SnarkPoolCandidateState::WorkReceived { work, .. } => Some(work),
                                 _ => None,
                             })

crates/node/src/stats/stats_sync.rs

@@ -426,8 +426,8 @@ impl SyncBlock {
         match state {
             TransitionFrontierSyncBlockState::FetchPending { attempts, .. } => {
                 if let Some(time) = attempts
-                    .iter()
-                    .filter_map(|(_, v)| v.fetch_pending_since())
+                    .values()
+                    .filter_map(|v| v.fetch_pending_since())
                     .min()
                 {
                     self.status = SyncBlockStatus::Fetching;

crates/node/src/transaction_pool/candidate/transaction_pool_candidate_state.rs

@@ -251,8 +251,8 @@ impl TransactionPoolCandidatesState {
                     let peer_transactions = self.by_peer.get(peer_id)?;
                     if peer_transactions.get(hash)?.transaction().is_some() {
                         let transactions = peer_transactions
-                            .iter()
-                            .filter_map(|(_, v)| match v {
+                            .values()
+                            .filter_map(|v| match v {
                                 TransactionPoolCandidateState::Received { transaction, .. } => {
                                     Some(transaction)
                                 }

crates/node/src/transition_frontier/sync/ledger/snarked/transition_frontier_sync_ledger_snarked_actions.rs

@@ -352,8 +352,8 @@ impl redux::EnablingCondition<crate::State> for TransitionFrontierSyncLedgerSnar
                 .and_then(|s| s.snarked()?.fetch_pending())
                 .is_some_and(|pending| {
                     pending
-                        .iter()
-                        .filter_map(|(_, query_state)| query_state.attempts.get(peer_id))
+                        .values()
+                        .filter_map(|query_state| query_state.attempts.get(peer_id))
                         .any(|peer_rpc_state| matches!(peer_rpc_state, PeerRpcState::Init { .. }))
                 }),
             TransitionFrontierSyncLedgerSnarkedAction::PeerQueryAddressError {

crates/p2p/src/network/identify/p2p_network_identify_protocol.rs

@@ -151,7 +151,7 @@ impl<'a> TryFrom<&'a P2pNetworkIdentify> for super::pb::Identify {
                 .iter()
                 .map(|v| match v {
                     StreamProtocolId::Known(k) => k.name_str().into(),
-                    StreamProtocolId::Unknown(s) => s.clone().into(),
+                    StreamProtocolId::Unknown(s) => s.clone(),
                 })
                 .collect(),
         })