running cargo clippy --fix

Rahul Patni · Rahul Patni · commit 1075ba8301ea · 2024-11-13T11:29:53.000-08:00
diff --git a/crates/dservice/src/lib.rs b/crates/dservice/src/lib.rs
@@ -250,7 +250,7 @@ pub async fn run_dserver(
                         }
                     };
 
-                    let _ = scheduling_tasks(schduler.clone(), &accounts_should_scan, blocks)
+                    scheduling_tasks(schduler.clone(), &accounts_should_scan, blocks)
                         .await
                         .unwrap();
                     // avoid too much memory usage
@@ -286,7 +286,7 @@ pub async fn run_dserver(
                         {
                             if let Ok(block) = secondary.shared.rpc_handler.get_block(sequence) {
                                 let block = block.data.block.to_inner();
-                                let _ = scheduling_tasks(
+                                scheduling_tasks(
                                     secondary.clone(),
                                     &vec![ScanRequest {
                                         address: address.clone(),
@@ -366,7 +366,7 @@ pub async fn account_scanner_handler(
         &manager.shared.secp_key.pk,
     ) {
         if x {
-            let _ = manager.accounts_to_scan.write().await.push(message);
+            manager.accounts_to_scan.write().await.push(message);
             return Json(SuccessResponse { success: true });
         }
     }
diff --git a/crates/dservice/src/main.rs b/crates/dservice/src/main.rs
@@ -36,8 +36,8 @@ async fn main() -> Result<()> {
     let pk = std::env::var("PUBLIC_KEY").expect("PUBLIC_KEY not provided in env");
     let mut sk_u8 = [0u8; 32];
     let mut pk_u8 = [0u8; 33];
-    let _ = hex::decode_to_slice(sk, &mut sk_u8).unwrap();
-    let _ = hex::decode_to_slice(pk, &mut pk_u8).unwrap();
+    hex::decode_to_slice(sk, &mut sk_u8).unwrap();
+    hex::decode_to_slice(pk, &mut pk_u8).unwrap();
     let args = Command::parse();
     let Command {
         dlisten,
@@ -52,8 +52,8 @@ async fn main() -> Result<()> {
     let db_config = DbConfig::load(dbconfig).unwrap();
     let db_handler = PgHandler::from_config(&db_config);
     run_dserver(
-        dlisten.into(),
-        restful.into(),
+        dlisten,
+        restful,
         node,
         db_handler,
         server,
diff --git a/crates/dservice/src/manager.rs b/crates/dservice/src/manager.rs
@@ -110,7 +110,7 @@ where
 {
     pub fn new(db_handler: T, endpoint: &str, server: &str, secp_key: SecpKey) -> Self {
         Self {
-            db_handler: db_handler,
+            db_handler,
             rpc_handler: RpcHandler::new(endpoint.into()),
             server_handler: ServerHandler::new(server.into()),
             secp_key,
@@ -158,7 +158,7 @@ impl Manager {
                 let ServerMessage { name, request } = message;
                 match name {
                     Some(name) => {
-                        let _ = worker_server_clone
+                        worker_server_clone
                             .workers
                             .write()
                             .await
@@ -201,7 +201,7 @@ impl Manager {
                                                 let _ = worker_server.workers.write().await.insert(worker_name.clone(), worker);
                                                 match worker_server.task_queue.write().await.pop() {
                                                     Some((task, _)) => {
-                                                        let _ = tx.send(ServerMessage { name: Some(worker_name.clone()), request: task }).await.unwrap();
+                                                        tx.send(ServerMessage { name: Some(worker_name.clone()), request: task }).await.unwrap();
                                                     },
                                                     None => {},
                                                 }
@@ -213,7 +213,7 @@ impl Manager {
                                         debug!("new response from worker {}", response.id);
                                         match worker_server.task_queue.write().await.pop() {
                                             Some((task, _)) => {
-                                                let _ = tx.send(ServerMessage { name: None, request: task }).await.unwrap();
+                                                tx.send(ServerMessage { name: None, request: task }).await.unwrap();
                                             },
                                             None => worker_server.workers.write().await.get_mut(&worker_name).unwrap().status = 1,
                                         }
diff --git a/crates/dworker/src/lib.rs b/crates/dworker/src/lib.rs
@@ -72,7 +72,7 @@ pub async fn decrypt(worker_pool: Arc<ThreadPool>, request: DRequest) -> DRespon
                         Err(_) => {}
                     }
                 }
-                return None;
+                None
             })
             .collect();
         decrypted.into_iter().flatten().collect()
@@ -151,7 +151,7 @@ pub async fn handle_connection(
     let heart_beat_handler = tokio::spawn(async move {
         let _ = router.send(());
         loop {
-            let _ = heart_beat_tx
+            heart_beat_tx
                 .send(DMessage::RegisterWorker(RegisterWorker {
                     name: worker_name.clone(),
                 }))
diff --git a/crates/dworker/src/main.rs b/crates/dworker/src/main.rs
@@ -31,8 +31,7 @@ async fn main() -> Result<()> {
                 "dworker-{:?}-{}",
                 gethostname::gethostname(),
                 rand::thread_rng().gen::<u8>()
-            )
-            .into(),
+            ),
         );
     }
     info!(
diff --git a/crates/networking/src/orescriptions.rs b/crates/networking/src/orescriptions.rs
@@ -15,9 +15,9 @@ pub struct Ores {
 }
 
 pub fn is_ores_local(asset: &AssetBalance) -> bool {
-    asset.asset_id != IRON_NATIVE_ASSET.to_string()
-        && asset.confirmed == OREOS_VALUE.to_string()
-        && asset.unconfirmed == OREOS_VALUE.to_string()
+    asset.asset_id != *IRON_NATIVE_ASSET
+        && asset.confirmed == *OREOS_VALUE
+        && asset.unconfirmed == *OREOS_VALUE
 }
 
 pub async fn get_ores(id: &str) -> anyhow::Result<Ores> {
diff --git a/crates/networking/src/rpc_abi.rs b/crates/networking/src/rpc_abi.rs
@@ -150,11 +150,10 @@ impl RpcGetBalancesResponse {
                 .balances
                 .into_iter()
                 .filter(|x| {
-                    x.asset_verification.status == "verified".to_string()
+                    x.asset_verification.status == *"verified"
                         || x.asset_id == IRON_NATIVE_ASSET
                         || x.asset_name
-                            == "6f7265736372697074696f6e7300000000000000000000000000000000000000"
-                                .to_string()
+                            == *"6f7265736372697074696f6e7300000000000000000000000000000000000000"
                 })
                 .collect::<Vec<AssetBalance>>(),
             ..base
diff --git a/crates/networking/src/rpc_handler/handler.rs b/crates/networking/src/rpc_handler/handler.rs
@@ -81,7 +81,7 @@ impl RpcHandler {
         request: RpcGetAccountStatusRequest,
     ) -> Result<RpcResponse<RpcGetAccountStatusResponse>, OreoError> {
         let path = format!("http://{}/wallet/getAccountStatus", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
@@ -90,7 +90,7 @@ impl RpcHandler {
         request: RpcSetScanningRequest,
     ) -> Result<RpcResponse<Option<()>>, OreoError> {
         let path = format!("http://{}/wallet/setScanning", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
@@ -99,7 +99,7 @@ impl RpcHandler {
         request: RpcSetAccountHeadRequest,
     ) -> Result<RpcResponse<Option<()>>, OreoError> {
         let path = format!("http://{}/wallet/setAccountHead", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
@@ -108,7 +108,7 @@ impl RpcHandler {
         request: RpcResetAccountRequest,
     ) -> Result<RpcResponse<Option<()>>, OreoError> {
         let path = format!("http://{}/wallet/resetAccount", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
@@ -117,7 +117,7 @@ impl RpcHandler {
         request: RpcGetBalancesRequest,
     ) -> Result<RpcResponse<RpcGetBalancesResponse>, OreoError> {
         let path = format!("http://{}/wallet/getBalances", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
@@ -126,7 +126,7 @@ impl RpcHandler {
         request: RpcGetAccountTransactionRequest,
     ) -> Result<RpcResponse<RpcGetAccountTransactionResponse>, OreoError> {
         let path = format!("http://{}/wallet/getAccountTransaction", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
     
@@ -135,7 +135,7 @@ impl RpcHandler {
         request: RpcGetTransactionsRequest,
     ) -> Result<RpcResponse<RpcGetTransactionsResponse>, OreoError> {
         let path = format!("http://{}/wallet/getAccountTransactions", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
     
         match resp {
             Ok(response) => {
@@ -159,7 +159,7 @@ impl RpcHandler {
         request: RpcCreateTxRequest,
     ) -> Result<RpcResponse<RpcCreateTxResponse>, OreoError> {
         let path = format!("http://{}/wallet/createTransaction", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
@@ -168,7 +168,7 @@ impl RpcHandler {
         request: RpcBroadcastTxRequest,
     ) -> Result<RpcResponse<RpcBroadcastTxResponse>, OreoError> {
         let path = format!("http://{}/chain/broadcastTransaction", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
diff --git a/crates/networking/src/rpc_handler/mod.rs b/crates/networking/src/rpc_handler/mod.rs
@@ -20,7 +20,7 @@ impl TryFrom<RpcError> for OreoError {
             "insufficient-balance" => Ok(OreoError::BalanceNotEnough),
             "account-exists" => {
                 // Should never happen
-                return Ok(OreoError::Duplicate("0x00".to_string()));
+                Ok(OreoError::Duplicate("0x00".to_string()))
             }
             _ => Ok(OreoError::InternalRpcError(value.message)),
         }
diff --git a/crates/networking/src/server_handler.rs b/crates/networking/src/server_handler.rs
@@ -29,7 +29,7 @@ impl ServerHandler {
         request: DecryptionMessage<ScanRequest>,
     ) -> Result<SuccessResponse, OreoError> {
         let path = format!("http://{}/scanAccount", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 
@@ -38,7 +38,7 @@ impl ServerHandler {
         request: DecryptionMessage<ScanResponse>,
     ) -> Result<SuccessResponse, OreoError> {
         let path = format!("http://{}/updateScan", self.endpoint);
-        let resp = self.agent.clone().post(&path).send_json(&request);
+        let resp = self.agent.clone().post(&path).send_json(request);
         handle_response(resp)
     }
 }
diff --git a/crates/networking/src/web_abi.rs b/crates/networking/src/web_abi.rs
@@ -99,10 +99,10 @@ impl TransactionDetail {
                 block_sequence,
                 timestamp,
                 asset_balance_deltas,
-                sender: sender.into(),
-                receiver: owner.into(),
-                memo: Some(memo.into()),
-                value: value.into(),
+                sender,
+                receiver: owner,
+                memo: Some(memo),
+                value,
             }),
             None => Err(OreoError::InternalRpcError("no note".to_string())),
         }
diff --git a/crates/prover/src/main.rs b/crates/prover/src/main.rs
@@ -21,6 +21,6 @@ async fn main() -> Result<()> {
     let Command { listen, verbosity } = args;
     initialize_logger(verbosity);
     handle_signals().await?;
-    run_prover(listen.into()).await?;
+    run_prover(listen).await?;
     Ok(())
 }
diff --git a/crates/server/src/handlers.rs b/crates/server/src/handlers.rs
@@ -17,7 +17,7 @@ use networking::{
 };
 use oreo_errors::OreoError;
 use serde_json::json;
-use tracing::{debug, error, info};
+use tracing::{error, info};
 use utils::{default_secp, sign, verify, Signature};
 
 use crate::SharedState;
diff --git a/crates/server/src/lib.rs b/crates/server/src/lib.rs
@@ -44,7 +44,7 @@ where
 {
     pub fn new(db_handler: T, endpoint: &str, scan: &str, secp: SecpKey, genesis_hash: String) -> Self {
         Self {
-            db_handler: db_handler,
+            db_handler,
             rpc_handler: RpcHandler::new(endpoint.into()),
             scan_handler: ServerHandler::new(scan.into()),
             secp,
@@ -70,11 +70,11 @@ pub async fn auth<T: DBHandler>(
             if token_hex != basic.password() {
                 return Err((StatusCode::UNAUTHORIZED, "Invalid token"));
             }
-            return Ok(next.run(req).await);
+            Ok(next.run(req).await)
         }
         Err(_) => {
             // Token is invalid
-            return Err((StatusCode::UNAUTHORIZED, "Invalid token"));
+            Err((StatusCode::UNAUTHORIZED, "Invalid token"))
         }
     }
 }
@@ -89,7 +89,7 @@ pub async fn run_server(
 ) -> Result<()> {
     let genesis_hash;
     {
-        let temp_handler: RpcHandler = RpcHandler::new(rpc_server.clone().into());
+        let temp_handler: RpcHandler = RpcHandler::new(rpc_server.clone());
         let latest_block_response = temp_handler.get_latest_block()?.data;
         genesis_hash = latest_block_response.genesis_block_identifier.hash;
     }
diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs
@@ -33,8 +33,8 @@ async fn main() -> Result<()> {
     let pk = std::env::var("PUBLIC_KEY").expect("PUBLIC_KEY not provided in env");
     let mut sk_u8 = [0u8; 32];
     let mut pk_u8 = [0u8; 33];
-    let _ = hex::decode_to_slice(sk, &mut sk_u8).unwrap();
-    let _ = hex::decode_to_slice(pk, &mut pk_u8).unwrap();
+    hex::decode_to_slice(sk, &mut sk_u8).unwrap();
+    hex::decode_to_slice(pk, &mut pk_u8).unwrap();
     let args = Command::parse();
     let Command {
         listen,
@@ -47,6 +47,6 @@ async fn main() -> Result<()> {
     handle_signals().await?;
     let db_config = DbConfig::load(dbconfig).unwrap();
     let db_handler = PgHandler::from_config(&db_config);
-    run_server(listen.into(), node, db_handler, scan, sk_u8, pk_u8).await?;
+    run_server(listen, node, db_handler, scan, sk_u8, pk_u8).await?;
     Ok(())
 }
diff --git a/crates/utils/src/lib.rs b/crates/utils/src/lib.rs
@@ -34,7 +34,7 @@ pub fn initialize_logger(verbosity: u8) {
     match verbosity {
         0 => std::env::set_var("RUST_LOG", "info"),
         1 => std::env::set_var("RUST_LOG", "debug"),
-        2 | 3 | 4 => std::env::set_var("RUST_LOG", "trace"),
+        2..=4 => std::env::set_var("RUST_LOG", "trace"),
         _ => std::env::set_var("RUST_LOG", "info"),
     };
     tracing_subscriber::fmt()

Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ pub async fn run_dserver(`
`250`	`250`	`}`
`251`	`251`	`};`
`252`	`252`
`253`		`- let _ = scheduling_tasks(schduler.clone(), &accounts_should_scan, blocks)`
	`253`	`+ scheduling_tasks(schduler.clone(), &accounts_should_scan, blocks)`
`254`	`254`	`.await`
`255`	`255`	`.unwrap();`
`256`	`256`	`// avoid too much memory usage`
`@@ -286,7 +286,7 @@ pub async fn run_dserver(`
`286`	`286`	`{`
`287`	`287`	`if let Ok(block) = secondary.shared.rpc_handler.get_block(sequence) {`
`288`	`288`	`let block = block.data.block.to_inner();`
`289`		`- let _ = scheduling_tasks(`
	`289`	`+ scheduling_tasks(`
`290`	`290`	`secondary.clone(),`
`291`	`291`	`&vec![ScanRequest {`
`292`	`292`	`address: address.clone(),`
`@@ -366,7 +366,7 @@ pub async fn account_scanner_handler(`
`366`	`366`	`&manager.shared.secp_key.pk,`
`367`	`367`	`) {`
`368`	`368`	`if x {`
`369`		`- let _ = manager.accounts_to_scan.write().await.push(message);`
	`369`	`+ manager.accounts_to_scan.write().await.push(message);`
`370`	`370`	`return Json(SuccessResponse { success: true });`
`371`	`371`	`}`
`372`	`372`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,9 +15,9 @@ pub struct Ores {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`pub fn is_ores_local(asset: &AssetBalance) -> bool {`
`18`		`- asset.asset_id != IRON_NATIVE_ASSET.to_string()`
`19`		`- && asset.confirmed == OREOS_VALUE.to_string()`
`20`		`- && asset.unconfirmed == OREOS_VALUE.to_string()`
	`18`	`+ asset.asset_id != *IRON_NATIVE_ASSET`
	`19`	`+ && asset.confirmed == *OREOS_VALUE`
	`20`	`+ && asset.unconfirmed == *OREOS_VALUE`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`pub async fn get_ores(id: &str) -> anyhow::Result<Ores> {`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ impl TryFrom<RpcError> for OreoError {`
`20`	`20`	`"insufficient-balance" => Ok(OreoError::BalanceNotEnough),`
`21`	`21`	`"account-exists" => {`
`22`	`22`	`// Should never happen`
`23`		`- return Ok(OreoError::Duplicate("0x00".to_string()));`
	`23`	`+ Ok(OreoError::Duplicate("0x00".to_string()))`
`24`	`24`	`}`
`25`	`25`	`_ => Ok(OreoError::InternalRpcError(value.message)),`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ impl ServerHandler {`
`29`	`29`	`request: DecryptionMessage<ScanRequest>,`
`30`	`30`	`) -> Result<SuccessResponse, OreoError> {`
`31`	`31`	`let path = format!("http://{}/scanAccount", self.endpoint);`
`32`		`- let resp = self.agent.clone().post(&path).send_json(&request);`
	`32`	`+ let resp = self.agent.clone().post(&path).send_json(request);`
`33`	`33`	`handle_response(resp)`
`34`	`34`	`}`
`35`	`35`
`@@ -38,7 +38,7 @@ impl ServerHandler {`
`38`	`38`	`request: DecryptionMessage<ScanResponse>,`
`39`	`39`	`) -> Result<SuccessResponse, OreoError> {`
`40`	`40`	`let path = format!("http://{}/updateScan", self.endpoint);`
`41`		`- let resp = self.agent.clone().post(&path).send_json(&request);`
	`41`	`+ let resp = self.agent.clone().post(&path).send_json(request);`
`42`	`42`	`handle_response(resp)`
`43`	`43`	`}`
`44`	`44`	`}`