chore: cargo fmt

Author: uri-99

batcher/aligned-batcher/src/lib.rs

@@ -1273,7 +1273,7 @@ impl Batcher {
                 self.cancel_create_new_task_tx(fee_params.gas_price).await;
                 Err(BatcherError::ReceiptNotFoundError)
             }
-            Err(RetryError::Permanent(e))|Err(RetryError::Transient(e)) => Err(e),
+            Err(RetryError::Permanent(e)) | Err(RetryError::Transient(e)) => Err(e),
         }
     }
 

batcher/aligned-batcher/src/retry/batcher_retryables.rs

@@ -129,7 +129,9 @@ pub async fn create_new_task_retryable(
         Err(ContractError::Revert(err)) => {
             // Since transaction was reverted, we don't want to retry with fallback.
             warn!("Transaction reverted {:?}", err);
-            return Err(RetryError::Permanent(BatcherError::TransactionSendError(err.to_string())));
+            return Err(RetryError::Permanent(BatcherError::TransactionSendError(
+                err.to_string(),
+            )));
         }
         _ => {
             call_fallback = payment_service_fallback
@@ -146,9 +148,15 @@ pub async fn create_new_task_retryable(
                 Ok(pending_tx) => pending_tx,
                 Err(ContractError::Revert(err)) => {
                     warn!("Transaction reverted {:?}", err);
-                    return Err(RetryError::Permanent(BatcherError::TransactionSendError(err.to_string())));
+                    return Err(RetryError::Permanent(BatcherError::TransactionSendError(
+                        err.to_string(),
+                    )));
+                }
+                Err(err) => {
+                    return Err(RetryError::Transient(BatcherError::TransactionSendError(
+                        err.to_string(),
+                    )))
                 }
-                Err(err) => return Err(RetryError::Transient(BatcherError::TransactionSendError(err.to_string()))),
             }
         }
     };

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

@@ -56,15 +56,15 @@ pub async fn send_messages(
 
         nonce += U256::one();
         let msg = ClientMessage::new(verification_data.clone(), wallet.clone()).await;
-        let msg_bin = match cbor_serialize(&msg).map_err(SubmitError::SerializationError) {
+        let msg_bin = match cbor_serialize(&msg) {
             Ok(bin) => bin,
             Err(e) => {
                 error!("Error while serializing message: {:?}", e);
-                sent_verification_data.push(Err(e));
+                sent_verification_data.push(Err(SubmitError::SerializationError(e)));
                 return sent_verification_data;
             }
         };
-        
+
         // Send the message
         if let Err(e) = ws_write.send(Message::Binary(msg_bin.clone())).await {
             error!("Error while sending message: {:?}", e);
@@ -75,7 +75,7 @@ pub async fn send_messages(
         debug!("{:?} Message sent", idx);
 
         // Save the verification data commitment to read its response later
-        sent_verification_data.push(Ok(verification_data)); 
+        sent_verification_data.push(Ok(verification_data));
     }
 
     info!("All proofs sent");
@@ -108,10 +108,14 @@ pub async fn receive(
         if let Message::Close(close_frame) = msg {
             warn!("Unexpected WS close");
             if let Some(close_msg) = close_frame {
-                aligned_submitted_data.push(Err(SubmitError::WebSocketClosedUnexpectedlyError(close_msg.to_owned())));
+                aligned_submitted_data.push(Err(SubmitError::WebSocketClosedUnexpectedlyError(
+                    close_msg.to_owned(),
+                )));
                 break;
             }
-            aligned_submitted_data.push(Err(SubmitError::GenericError("Connection was closed before receive() processed all sent messages ".to_string())));
+            aligned_submitted_data.push(Err(SubmitError::GenericError(
+                "Connection was closed before receive() processed all sent messages ".to_string(),
+            )));
             break;
         }
 
@@ -126,16 +130,25 @@ pub async fn receive(
             }
         };
 
-        let related_verification_data = match match_batcher_response_with_stored_verification_data(&batch_inclusion_data_message, &mut sent_verification_data_rev) {
+        let related_verification_data = match match_batcher_response_with_stored_verification_data(
+            &batch_inclusion_data_message,
+            &mut sent_verification_data_rev,
+        ) {
             Ok(data) => data,
             Err(e) => {
-                warn!("Error while matching batcher response with sent data: {:?}", e);
+                warn!(
+                    "Error while matching batcher response with sent data: {:?}",
+                    e
+                );
                 aligned_submitted_data.push(Err(e));
                 break;
             }
         };
 
-        let aligned_verification_data = match process_batcher_response(&batch_inclusion_data_message, &related_verification_data) {
+        let aligned_verification_data = match process_batcher_response(
+            &batch_inclusion_data_message,
+            &related_verification_data,
+        ) {
             Ok(data) => data,
             Err(e) => {
                 warn!("Error while processing batcher response: {:?}", e);
@@ -254,7 +267,10 @@ fn match_batcher_response_with_stored_verification_data(
 ) -> Result<VerificationDataCommitment, SubmitError> {
     debug!("Matching verification data with batcher response ...");
     let mut index = None;
-    for (i, sent_nonced_verification_data) in sent_verification_data_rev.iter_mut().enumerate().rev() { // iterate in reverse since the last element is the most probable to match
+    for (i, sent_nonced_verification_data) in
+        sent_verification_data_rev.iter_mut().enumerate().rev()
+    {
+        // iterate in reverse since the last element is the most probable to match
         if let Ok(sent_nonced_verification_data) = sent_nonced_verification_data {
             if sent_nonced_verification_data.nonce == batch_inclusion_data.user_nonce {
                 debug!("local nonced verification data matched with batcher response");
@@ -276,7 +292,9 @@ fn match_batcher_response_with_stored_verification_data(
 // Returns the biggest nonce from the sent verification data
 // Used to know which is the last proof sent to the Batcher,
 // to know when to stop reading the WS for responses
-fn get_biggest_nonce(sent_verification_data: &[Result<NoncedVerificationData, SubmitError>]) -> U256 {
+fn get_biggest_nonce(
+    sent_verification_data: &[Result<NoncedVerificationData, SubmitError>],
+) -> U256 {
     let mut biggest_nonce = U256::zero();
     for verification_data in sent_verification_data.iter() {
         if let Ok(verification_data) = verification_data {

batcher/aligned-sdk/src/sdk.rs

@@ -101,7 +101,9 @@ pub async fn submit_multiple_and_wait_verification(
     let mut error_awaiting_batch_verification: Option<errors::SubmitError> = None;
     for aligned_verification_data_item in aligned_verification_data.iter() {
         if let Ok(aligned_verification_data_item) = aligned_verification_data_item {
-            if let Err(e) = await_batch_verification(aligned_verification_data_item, eth_rpc_url, network).await {
+            if let Err(e) =
+                await_batch_verification(aligned_verification_data_item, eth_rpc_url, network).await
+            {
                 error_awaiting_batch_verification = Some(e);
                 break;
             }
@@ -250,9 +252,7 @@ pub async fn submit_multiple(
 ) -> Vec<Result<AlignedVerificationData, errors::SubmitError>> {
     let (ws_stream, _) = match connect_async(batcher_url).await {
         Ok((ws_stream, response)) => (ws_stream, response),
-        Err(e) => {
-            return vec![Err(errors::SubmitError::WebSocketConnectionError(e))]
-        }
+        Err(e) => return vec![Err(errors::SubmitError::WebSocketConnectionError(e))],
     };
 
     debug!("WebSocket handshake has been successfully completed");
@@ -407,7 +407,9 @@ pub async fn submit_and_wait_verification(
     match aligned_verification_data.get(0) {
         Some(Ok(aligned_verification_data)) => Ok(aligned_verification_data.clone()),
         Some(Err(e)) => Err(errors::SubmitError::GenericError(e.to_string())),
-        None => Err(errors::SubmitError::GenericError("No response from the batcher".to_string())),
+        None => Err(errors::SubmitError::GenericError(
+            "No response from the batcher".to_string(),
+        )),
     }
 }
 
@@ -460,7 +462,9 @@ pub async fn submit(
     match aligned_verification_data.get(0) {
         Some(Ok(aligned_verification_data)) => Ok(aligned_verification_data.clone()),
         Some(Err(e)) => Err(errors::SubmitError::GenericError(e.to_string())),
-        None => Err(errors::SubmitError::GenericError("No response from the batcher".to_string())),
+        None => Err(errors::SubmitError::GenericError(
+            "No response from the batcher".to_string(),
+        )),
     }
 }
 
@@ -687,7 +691,10 @@ pub fn save_response(
     batch_inclusion_data_directory_path: PathBuf,
     aligned_verification_data: &AlignedVerificationData,
 ) -> Result<(), errors::FileError> {
-    info!("Saving batch inclusion data files in folder {}", batch_inclusion_data_directory_path.display());
+    info!(
+        "Saving batch inclusion data files in folder {}",
+        batch_inclusion_data_directory_path.display()
+    );
     save_response_cbor(
         batch_inclusion_data_directory_path.clone(),
         &aligned_verification_data.clone(),

batcher/aligned/src/main.rs

@@ -336,13 +336,17 @@ async fn main() -> Result<(), AlignedError> {
             for aligned_verification_data in aligned_verification_data_vec {
                 match aligned_verification_data {
                     Ok(aligned_verification_data) => {
-                        info!("Proof submitted to aligned. Batch merkle root: 0x{}", hex::encode(aligned_verification_data.batch_merkle_root));
+                        info!(
+                            "Proof submitted to aligned. Batch merkle root: 0x{}",
+                            hex::encode(aligned_verification_data.batch_merkle_root)
+                        );
                         save_response(
                             batch_inclusion_data_directory_path.clone(),
                             &aligned_verification_data,
                         )?;
-                        unique_batch_merkle_roots.insert(aligned_verification_data.batch_merkle_root);
-                    },
+                        unique_batch_merkle_roots
+                            .insert(aligned_verification_data.batch_merkle_root);
+                    }
                     Err(e) => {
                         warn!("Error while submitting proof: {:?}", e);
                         let nonce_file = format!("nonce_{:?}.bin", wallet.address());