Merge pull request #877 from TheCharlatan/anotherClippyRound1

Make clippy annoying again

Author: sedited

.github/workflows/binaries.yml

@@ -16,6 +16,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-Dwarnings"
 
 jobs:
   binaries:

.github/workflows/static-analysis.yml

@@ -16,6 +16,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-Dwarnings"
 
 jobs:
   rust_format:

src/config.rs

@@ -153,31 +153,35 @@ impl Config {
                         .bitcoin
                         .get_for_network(network)
                         .or_else(|| ArbConfig::get(arb, network))
-                        .ok_or(config::ConfigError::Message(
-                            "No configuration nor defaults founds!".to_string(),
-                        ))?,
+                        .ok_or_else(|| {
+                            config::ConfigError::Message(
+                                "No configuration nor defaults founds!".to_string(),
+                            )
+                        })?,
                 };
                 let accordant = match acc {
                     AccordantBlockchain::Monero => swap
                         .monero
                         .get_for_network(network)
                         .or_else(|| AccConfig::get(acc, network))
-                        .ok_or(config::ConfigError::Message(
-                            "No configuration nor defaults founds!".to_string(),
-                        ))?,
+                        .ok_or_else(|| {
+                            config::ConfigError::Message(
+                                "No configuration nor defaults founds!".to_string(),
+                            )
+                        })?,
                 };
                 Ok(ParsedSwapConfig {
                     arbitrating,
                     accordant,
                 })
             }
             None => {
-                let arbitrating = ArbConfig::get(arb, network).ok_or(
-                    config::ConfigError::Message("No defaults founds!".to_string()),
-                )?;
-                let accordant = AccConfig::get(acc, network).ok_or(
-                    config::ConfigError::Message("No defaults founds!".to_string()),
-                )?;
+                let arbitrating = ArbConfig::get(arb, network).ok_or_else(|| {
+                    config::ConfigError::Message("No defaults founds!".to_string())
+                })?;
+                let accordant = AccConfig::get(acc, network).ok_or_else(|| {
+                    config::ConfigError::Message("No defaults founds!".to_string())
+                })?;
                 Ok(ParsedSwapConfig {
                     arbitrating,
                     accordant,

src/databased/runtime.rs

@@ -697,7 +697,7 @@ fn test_lmdb_state() {
         service_id: ServiceId::Database,
     };
     let path = std::env::current_dir().unwrap();
-    let mut database = Database::new(path.to_path_buf()).unwrap();
+    let mut database = Database::new(path).unwrap();
     database.set_checkpoint_state(&key1, &val1).unwrap();
     let res = database.get_checkpoint_state(&key1).unwrap();
     assert_eq!(val1, res);
@@ -713,7 +713,7 @@ fn test_lmdb_state() {
 
     let key_info = SwapId(Uuid::new());
     let val_info = CheckpointEntry {
-        swap_id: key_info.clone(),
+        swap_id: key_info,
         trade_role: TradeRole::Maker,
         deal: Deal::from_str("Deal:Cke4ftrP5A781Vq85dgBQJNwYgBS4nuUV1LQM2fvVdFMNR4h5TrWhRR11111uMFuZTAsNgpdK8DiK11111TB9zym113GTvtvqfD1111114A4TTfFfmZoWyvpcjDBtTZCdWFSUWcRKYfEC3Y17hqaXZ3dWz11111111111111111111111111111111111111111AfZ113SEBTEspU3a").unwrap(),
         expected_counterparty_node_id: None,
@@ -736,7 +736,7 @@ fn test_lmdb_state() {
     let val_retrieved = database.get_bitcoin_address_secret_key(&addr).unwrap();
     assert_eq!(addr_info, val_retrieved);
     let addrs = database.get_all_bitcoin_addresses().unwrap();
-    assert!(addrs.iter().find(|(a, _)| *a == addr).is_some());
+    assert!(addrs.iter().any(|(a, _)| *a == addr));
     let key_pair = monero::KeyPair {
         spend: monero::PrivateKey::from_str(
             "77916d0cd56ed1920aef6ca56d8a41bac915b68e4c46a589e0956e27a7b77404",
@@ -759,7 +759,7 @@ fn test_lmdb_state() {
     let val_retrieved = database.get_monero_address_secret_key(&addr).unwrap();
     assert_eq!(addr_info, val_retrieved);
     let addrs = database.get_all_monero_addresses().unwrap();
-    assert!(addrs.iter().find(|(a, _)| *a == addr).is_some());
+    assert!(addrs.iter().any(|(a, _)| *a == addr));
 
     let deal_1 = Deal::from_str("Deal:Cke4ftrP5A7MgLMaQZLZUMTC6TfkqUKBu1LQM2fvVdFMNR4gmBqNCsR11111uMFuZTAsNgpdK8DiK11111TB9zym113GTvtvqfD1111114A4TTF4h53Tv4MR6eS9sdDxV5JCH9xZcKejCqKShnphqndeeD11111111111111111111111111111111111111111AfZ113XRBtrLeA3t").unwrap();
     let deal_2 = Deal::from_str("Deal:Cke4ftrP5A7Km9Kmc2UDBePio1p7wM56P1LQM2fvVdFMNR4gmBqNCsR11111uMFuZTAsNgpdK8DiK11111TB9zym113GTvtvqfD1111114A4TTF4h53Tv4MR6eS9sdDxV5JCH9xZcKejCqKShnphqndeeD11111111111111111111111111111111111111111AfZ113XRBuLWyw3M").unwrap();

src/farcasterd/runtime.rs

@@ -1119,9 +1119,9 @@ impl Runtime {
         );
 
         let address = bind_addr.address();
-        let port = bind_addr.port().ok_or(Error::Farcaster(
-            "listen requires the port to listen on".to_string(),
-        ))?;
+        let port = bind_addr
+            .port()
+            .ok_or_else(|| Error::Farcaster("listen requires the port to listen on".to_string()))?;
 
         debug!("Instantiating peerd...");
         let child = launch(

src/grpcd/runtime.rs

@@ -60,6 +60,7 @@ use tonic::{transport::Server, Request as GrpcRequest, Response as GrpcResponse,
 
 use self::farcaster::*;
 
+#[allow(clippy::all)]
 pub mod farcaster {
     tonic::include_proto!("farcaster");
 }
@@ -1506,8 +1507,10 @@ impl GrpcServer {
     }
 }
 
+type IdBusMsgPair = (u64, BusMsg);
+
 pub fn run(config: ServiceConfig, grpc_port: u16, grpc_ip: String) -> Result<(), Error> {
-    let (tx_response, rx_response): (Sender<(u64, BusMsg)>, Receiver<(u64, BusMsg)>) =
+    let (tx_response, rx_response): (Sender<IdBusMsgPair>, Receiver<IdBusMsgPair>) =
         std::sync::mpsc::channel();
 
     let tx_request = ZMQ_CONTEXT.socket(zmq::PUSH)?;
@@ -1639,7 +1642,7 @@ impl Runtime {
             }) => endpoints.send_to(ServiceBus::Info, source, service_id, BusMsg::Info(request))?,
             BusMsg::Bridge(BridgeMsg::GrpcServerTerminated) => {
                 // Re-create the grpc server runtime.
-                let (tx_response, rx_response): (Sender<(u64, BusMsg)>, Receiver<(u64, BusMsg)>) =
+                let (tx_response, rx_response): (Sender<IdBusMsgPair>, Receiver<IdBusMsgPair>) =
                     std::sync::mpsc::channel();
 
                 let tx_request = ZMQ_CONTEXT.socket(zmq::PUSH)?;

src/swapd/runtime.rs

@@ -702,8 +702,8 @@ impl Runtime {
                 }
             }
             // Try to handle previously unhandled peer message
-            if let Some(peer_msg) = &self.unhandled_peer_message {
-                self.handle_msg(endpoints, source.clone(), peer_msg.clone())?;
+            if let Some(peer_msg) = self.unhandled_peer_message.clone() {
+                self.handle_msg(endpoints, source.clone(), peer_msg)?;
             }
             // Replay confirmation events to ensure we immediately advance through states that can be skipped
             if let Some(buy_tx_confs_req) = self.syncer_state.buy_tx_confs.clone() {

src/swapd/syncer_client.rs

@@ -380,7 +380,7 @@ impl SyncerState {
                             broadcast_tx.tx.clone(),
                         ))
                         .ok()?,
-                        label.clone(),
+                        *label,
                     ))
                 } else {
                     None
@@ -448,17 +448,18 @@ impl SyncerState {
                     }
                     None => {
                         if let Some(tx) = self.broadcasted_txs.get(&txlabel) {
+                            let tx = tx.clone();
                             warn!("{} | Tx {} was re-orged or dropped from the mempool. Re-broadcasting tx", swapid.swap_id(), txlabel.label());
-                            let task = self.broadcast(tx.clone(), txlabel.clone());
-                            if let Err(_) = endpoints.send_to(
+                            let task = self.broadcast(tx, txlabel);
+                            if let Err(err) = endpoints.send_to(
                                 ServiceBus::Sync,
                                 ServiceId::Swap(self.swap_id),
                                 self.bitcoin_syncer(),
                                 BusMsg::Sync(SyncMsg::Task(task)),
                             ) {
                                 error!(
-                                    "{} | failed to send task for re-broadcasting {} transaction",
-                                    swapid, txlabel
+                                    "{} | failed to send task for re-broadcasting {} transaction: {}",
+                                    swapid, txlabel, err
                                 );
                             }
                         }

src/syncerd/bitcoin_syncer.rs

@@ -11,8 +11,8 @@ use crate::error::SyncerError;
 use crate::syncerd::opts::Opts;
 use crate::syncerd::runtime::SyncerdTask;
 use crate::syncerd::runtime::Synclet;
-use crate::syncerd::syncer_state::AddressTx;
-use crate::syncerd::syncer_state::SyncerState;
+use crate::syncerd::syncer_state::{AddressTx, BalanceServiceIdPair, TransactionServiceIdPair};
+use crate::syncerd::syncer_state::{GetTxServiceIdPair, SyncerState};
 use crate::syncerd::types::{AddressAddendum, Boolean, SweepAddressAddendum, Task};
 use crate::syncerd::BtcAddressAddendum;
 use crate::syncerd::Event;
@@ -48,7 +48,7 @@ use tokio::sync::mpsc::Sender as TokioSender;
 use tokio::sync::Mutex;
 
 use super::HealthCheck;
-use super::{GetAddressBalance, TxFilter, Txid};
+use super::{TxFilter, Txid};
 
 const RETRY_TIMEOUT: u64 = 5;
 const PING_WAIT: u8 = 2;
@@ -614,7 +614,7 @@ async fn run_syncerd_task_receiver(
     state: Arc<Mutex<SyncerState>>,
     transaction_broadcast_tx: TokioSender<(BroadcastTransaction, ServiceId)>,
     transaction_get_tx: TokioSender<(GetTx, ServiceId)>,
-    balance_get_tx: TokioSender<(GetAddressBalance, ServiceId)>,
+    balance_get_tx: TokioSender<BalanceServiceIdPair>,
     terminate_tx: TokioSender<()>,
 ) {
     tokio::spawn(async move {
@@ -1154,7 +1154,7 @@ fn sweep_polling(
 fn transaction_fetcher(
     electrum_server: String,
     proxy_address: Option<String>,
-    mut transaction_get_rx: TokioReceiver<(GetTx, ServiceId)>,
+    mut transaction_get_rx: TokioReceiver<GetTxServiceIdPair>,
     tx_event: TokioSender<BridgeEvent>,
 ) -> tokio::task::JoinHandle<()> {
     tokio::task::spawn(async move {
@@ -1207,7 +1207,7 @@ fn transaction_fetcher(
 fn balance_fetcher(
     electrum_server: String,
     proxy_address: Option<String>,
-    mut balance_get_rx: TokioReceiver<(GetAddressBalance, ServiceId)>,
+    mut balance_get_rx: TokioReceiver<BalanceServiceIdPair>,
     tx_event: TokioSender<BridgeEvent>,
 ) -> tokio::task::JoinHandle<()> {
     tokio::task::spawn(async move {
@@ -1320,16 +1320,16 @@ impl Synclet for BitcoinSyncer {
                         TokioReceiver<BridgeEvent>,
                     ) = tokio::sync::mpsc::channel(200);
                     let (transaction_broadcast_tx, transaction_broadcast_rx): (
-                        TokioSender<(BroadcastTransaction, ServiceId)>,
-                        TokioReceiver<(BroadcastTransaction, ServiceId)>,
+                        TokioSender<TransactionServiceIdPair>,
+                        TokioReceiver<TransactionServiceIdPair>,
                     ) = tokio::sync::mpsc::channel(200);
                     let (transaction_get_tx, transaction_get_rx): (
-                        TokioSender<(GetTx, ServiceId)>,
-                        TokioReceiver<(GetTx, ServiceId)>,
+                        TokioSender<GetTxServiceIdPair>,
+                        TokioReceiver<GetTxServiceIdPair>,
                     ) = tokio::sync::mpsc::channel(200);
                     let (balance_get_tx, balance_get_rx): (
-                        TokioSender<(GetAddressBalance, ServiceId)>,
-                        TokioReceiver<(GetAddressBalance, ServiceId)>,
+                        TokioSender<BalanceServiceIdPair>,
+                        TokioReceiver<BalanceServiceIdPair>,
                     ) = tokio::sync::mpsc::channel(200);
                     let (terminate_tx, terminate_rx): (TokioSender<()>, TokioReceiver<()>) =
                         tokio::sync::mpsc::channel(1);

src/syncerd/monero_syncer.rs

@@ -21,7 +21,6 @@ use crate::syncerd::TransactionBroadcasted;
 use crate::syncerd::XmrAddressAddendum;
 use crate::syncerd::{AddressBalance, TxFilter};
 use crate::syncerd::{Event, Health};
-use crate::ServiceId;
 use farcaster_core::blockchain::{Blockchain, Network};
 use internet2::session::LocalSession;
 use internet2::zeromq::ZmqSocketType;
@@ -41,8 +40,7 @@ use tokio::sync::mpsc::Receiver as TokioReceiver;
 use tokio::sync::mpsc::Sender as TokioSender;
 use tokio::sync::Mutex;
 
-use super::HealthCheck;
-use super::{GetAddressBalance, Txid};
+use super::{syncer_state::BalanceServiceIdPair, HealthCheck, Txid};
 
 #[derive(Debug, Clone)]
 pub struct MoneroRpc {
@@ -447,7 +445,7 @@ async fn run_syncerd_task_receiver(
     syncer_servers: MoneroSyncerServers,
     receive_task_channel: Receiver<SyncerdTask>,
     state: Arc<Mutex<SyncerState>>,
-    balance_get_tx: TokioSender<(GetAddressBalance, ServiceId)>,
+    balance_get_tx: TokioSender<BalanceServiceIdPair>,
     tx_event: TokioSender<BridgeEvent>,
     proxy_address: Option<String>,
 ) {
@@ -937,7 +935,7 @@ async fn fetch_balance(
 fn balance_fetcher(
     wallet_mutex: Arc<Mutex<monero_rpc::WalletClient>>,
     wallet_dir_path: Option<PathBuf>,
-    mut balance_get_rx: TokioReceiver<(GetAddressBalance, ServiceId)>,
+    mut balance_get_rx: TokioReceiver<BalanceServiceIdPair>,
     tx_event: TokioSender<BridgeEvent>,
 ) -> tokio::task::JoinHandle<()> {
     tokio::task::spawn(async move {
@@ -1062,8 +1060,8 @@ impl Synclet for MoneroSyncer {
                             .wallet(),
                         ));
                         let (balance_get_tx, balance_get_rx): (
-                            TokioSender<(GetAddressBalance, ServiceId)>,
-                            TokioReceiver<(GetAddressBalance, ServiceId)>,
+                            TokioSender<BalanceServiceIdPair>,
+                            TokioReceiver<BalanceServiceIdPair>,
                         ) = tokio::sync::mpsc::channel(200);
 
                         let (event_tx, event_rx): (