fmt + clippy

Author: PatStiles

batcher/aligned-batcher/src/lib.rs

@@ -658,8 +658,11 @@ impl Batcher {
         if self.user_balance_is_unlocked(&addr).await {
             send_message(
                 ws_conn_sink.clone(),
-                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
-                SubmitProofResponseMessage::InsufficientBalance(addr, nonced_verification_data.nonce),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1.
+                SubmitProofResponseMessage::InsufficientBalance(
+                    addr,
+                    nonced_verification_data.nonce,
+                ),
             )
             .await;
             self.metrics.user_error(&["insufficient_balance", ""]);
@@ -751,8 +754,11 @@ impl Batcher {
             std::mem::drop(batch_state_lock);
             send_message(
                 ws_conn_sink.clone(),
-                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
-                SubmitProofResponseMessage::InsufficientBalance(addr, nonced_verification_data.nonce - 1),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1.
+                SubmitProofResponseMessage::InsufficientBalance(
+                    addr,
+                    nonced_verification_data.nonce - 1,
+                ),
             )
             .await;
             self.metrics.user_error(&["insufficient_balance", ""]);
@@ -1687,8 +1693,11 @@ impl Batcher {
             error!("Could not get balance for non-paying address {replacement_addr:?}");
             send_message(
                 ws_sink.clone(),
-                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
-                SubmitProofResponseMessage::InsufficientBalance(replacement_addr, client_msg.verification_data.nonce - 1),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1.
+                SubmitProofResponseMessage::InsufficientBalance(
+                    replacement_addr,
+                    client_msg.verification_data.nonce - 1,
+                ),
             )
             .await;
             return Ok(());
@@ -1698,8 +1707,11 @@ impl Batcher {
             error!("Insufficient funds for non-paying address {replacement_addr:?}");
             send_message(
                 ws_sink.clone(),
-                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
-                SubmitProofResponseMessage::InsufficientBalance(replacement_addr, client_msg.verification_data.nonce - 1),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1.
+                SubmitProofResponseMessage::InsufficientBalance(
+                    replacement_addr,
+                    client_msg.verification_data.nonce - 1,
+                ),
             )
             .await;
             return Ok(());

batcher/aligned-sdk/src/communication/messaging.rs

@@ -127,13 +127,13 @@ pub async fn receive(
             Ok(data) => data,
             Err(e) => {
                 warn!("Error while handling batcher response: {:?}", e);
-                // In the case of submitting multiple proofs we can have an multiple proofs be submitted but there 
+                // In the case of submitting multiple proofs we can have an multiple proofs be submitted but there
                 // insufficient balance we still want to read and return the `batch_inclusion_data` of the proofs that were approved.
-                // `last_valid_nonce` corresponds to the nonce of the proof that triggered InsufficientBalance. 
+                // `last_valid_nonce` corresponds to the nonce of the proof that triggered InsufficientBalance.
                 // Therefore the other proofs are in order and we set the last_proof_nonce to the nonce of the InsufficientBalance.
                 if let SubmitError::InsufficientBalance(_, last_valid_nonce) = e {
                     aligned_submitted_data.push(Err(e));
-                    // last_valid_nonce = last_nonce - 1. In the case 
+                    // last_valid_nonce = last_nonce - 1. In the case
                     info!("last_proof_nonce: {}", last_proof_nonce);
                     info!("last_valid_nonce: {}", last_valid_nonce);
                     // In the case all proofs are insufficient balance we go over them.
@@ -184,7 +184,10 @@ pub async fn receive(
         debug!("Message response handled successfully");
 
         info!("last_proof_nonce: {}", last_proof_nonce);
-        info!("batch_inclusion_data_message.user_nonce: {}", batch_inclusion_data_message.user_nonce);
+        info!(
+            "batch_inclusion_data_message.user_nonce: {}",
+            batch_inclusion_data_message.user_nonce
+        );
 
         if batch_inclusion_data_message.user_nonce == last_proof_nonce {
             break;
@@ -220,7 +223,10 @@ async fn handle_batcher_response(msg: Message) -> Result<BatchInclusionData, Sub
         Ok(SubmitProofResponseMessage::InsufficientBalance(addr, last_sent_valid_nonce)) => {
             // If we receive an invalid balance we should grab the last_sent_valid_nonce.
             error!("Batcher responded with insufficient balance");
-            Err(SubmitError::InsufficientBalance(addr, last_sent_valid_nonce))
+            Err(SubmitError::InsufficientBalance(
+                addr,
+                last_sent_valid_nonce,
+            ))
         }
         Ok(SubmitProofResponseMessage::InvalidChainId) => {
             error!("Batcher responded with invalid chain id");
@@ -332,4 +338,4 @@ fn get_biggest_nonce(
         }
     }
     biggest_nonce
-}
+}

batcher/aligned-sdk/src/core/errors.rs

@@ -196,7 +196,11 @@ impl fmt::Display for SubmitError {
             SubmitError::ProofTooLarge => write!(f, "Proof too Large"),
             SubmitError::InvalidReplacementMessage => write!(f, "Invalid replacement message"),
             SubmitError::InsufficientBalance(addr, last_sent_valid_nonce) => {
-                write!(f, "Insufficient balance, address: {} last_sent_valid_nonce: {}", addr, last_sent_valid_nonce)
+                write!(
+                    f,
+                    "Insufficient balance, address: {} last_sent_valid_nonce: {}",
+                    addr, last_sent_valid_nonce
+                )
             }
             SubmitError::InvalidPaymentServiceAddress(received_addr, expected_addr) => {
                 write!(

batcher/aligned/src/main.rs

@@ -395,7 +395,7 @@ async fn main() -> Result<(), AlignedError> {
                         handle_submit_err(&e).await;
                         // In the case of an InsufficientBalance error we record and continue processing the entire msg queue.
                         // This covers the case of multiple submissions that succeed but fail for a comulative balance of all max_fee's.
-                        if let SubmitError::InsufficientBalance(_,_) = e {
+                        if let SubmitError::InsufficientBalance(_, _) = e {
                             continue;
                         } else {
                             return Ok(());
@@ -621,8 +621,7 @@ async fn handle_submit_err(err: &SubmitError) {
         SubmitError::InsufficientBalance(sender_address, last_sent_valid_nonce) => {
             error!(
                 "Insufficient balance to pay for the transaction, address: {} last_valid_nonce: {}",
-                sender_address,
-                last_sent_valid_nonce
+                sender_address, last_sent_valid_nonce
             )
         }
         _ => {}