chore: cargo fmt

Author: uri-99

batcher/aligned-batcher/src/connection.rs

@@ -6,7 +6,7 @@ use aligned_sdk::{
 };
 use futures_util::{stream::SplitSink, SinkExt};
 use lambdaworks_crypto::merkle_tree::merkle::MerkleTree;
-use log::{error, debug};
+use log::{debug, error};
 use serde::Serialize;
 use tokio::{net::TcpStream, sync::RwLock};
 use tokio_tungstenite::{
@@ -23,7 +23,11 @@ pub(crate) async fn send_batch_inclusion_data_responses(
     batch_merkle_tree: &MerkleTree<VerificationCommitmentBatch>,
 ) -> Result<(), BatcherError> {
     for (vd_batch_idx, entry) in finalized_batch.iter().enumerate() {
-        let batch_inclusion_data = BatchInclusionData::new(vd_batch_idx, batch_merkle_tree, entry.nonced_verification_data.nonce);
+        let batch_inclusion_data = BatchInclusionData::new(
+            vd_batch_idx,
+            batch_merkle_tree,
+            entry.nonced_verification_data.nonce,
+        );
         let response = ResponseMessage::BatchInclusionData(batch_inclusion_data);
 
         let serialized_response = cbor_serialize(&response)

batcher/aligned-batcher/src/lib.rs

@@ -368,11 +368,7 @@ impl Batcher {
         let msg_chain_id = client_msg.verification_data.chain_id;
         if msg_chain_id != self.chain_id {
             warn!("Received message with incorrect chain id: {msg_chain_id}");
-            send_message(
-                ws_conn_sink.clone(),
-                ResponseMessage::InvalidChainId,
-            )
-            .await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidChainId).await;
 
             return Ok(());
         }
@@ -396,11 +392,7 @@ impl Batcher {
         info!("Verifying message signature...");
         let Ok(addr) = client_msg.verify_signature() else {
             error!("Signature verification error");
-            send_message(
-                ws_conn_sink.clone(),
-                ResponseMessage::InvalidSignature,
-            )
-            .await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidSignature).await;
             return Ok(());
         };
         info!("Message signature verified");

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

@@ -4,7 +4,8 @@ use crate::{
     core::{
         errors,
         types::{
-            AlignedVerificationData, BatchInclusionData, Network, VerificationCommitmentBatch, VerificationDataCommitment
+            AlignedVerificationData, BatchInclusionData, Network, VerificationCommitmentBatch,
+            VerificationDataCommitment,
         },
     },
     sdk::is_proof_verified,
@@ -25,12 +26,10 @@ pub fn process_batcher_response(
     debug!("Index in batch: {}", batch_inclusion_data.index_in_batch);
 
     if verify_proof_inclusion(verification_data_commitment, batch_inclusion_data) {
-        Ok(
-            AlignedVerificationData::new(
-                verification_data_commitment,
-                batch_inclusion_data,
-            )
-        )
+        Ok(AlignedVerificationData::new(
+            verification_data_commitment,
+            batch_inclusion_data,
+        ))
     } else {
         Err(errors::SubmitError::InvalidProofInclusionData)
     }

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

@@ -65,23 +65,15 @@ pub async fn send_messages(
             .map_err(SubmitError::WebSocketConnectionError)?;
 
         debug!("{:?} Message sent", idx);
-        
+
         // Save the verification data commitment to read its response later
         sent_verification_data.push(verification_data);
     }
 
     info!("All messages sent");
-    Ok(sent_verification_data) 
+    Ok(sent_verification_data)
 }
 
-
-// Instead of using a channel, use a storage.
-// Using a 
-// From there, you can match received messages to the ones you sent.
-
-// TODO missing analyzing which is the last expected nonce.
-// When received message of last expected nonce, i can exit this function
-
 // Receives the array of proofs sent
 // Reads the WS responses
 // Matches each response with the corresponding proof sent
@@ -105,24 +97,19 @@ pub async fn receive(
                 ));
             }
             return Err(SubmitError::GenericError(
-                "Connection was closed before receive() processed all sent messages "
-                    .to_string(),
+                "Connection was closed before receive() processed all sent messages ".to_string(),
             ));
         }
- 
-        let batch_inclusion_data_message = handle_batcher_response(
-            msg,
-        ).await?;
+
+        let batch_inclusion_data_message = handle_batcher_response(msg).await?;
 
         let related_verification_data = match_batcher_response_with_stored_verification_data(
             &batch_inclusion_data_message,
             &mut sent_verification_data,
         )?;
-            
-        let aligned_verification_data = process_batcher_response(
-            &batch_inclusion_data_message,
-            &related_verification_data,
-        )?;
+
+        let aligned_verification_data =
+            process_batcher_response(&batch_inclusion_data_message, &related_verification_data)?;
 
         aligned_submitted_data.push(aligned_verification_data);
         info!("Message response handled succesfully");
@@ -136,13 +123,11 @@ pub async fn receive(
     Ok(aligned_submitted_data)
 }
 
-async fn handle_batcher_response(
-    msg: Message,
-) -> Result<BatchInclusionData, SubmitError> {
-
+async fn handle_batcher_response(msg: Message) -> Result<BatchInclusionData, SubmitError> {
     let data = msg.into_data();
     match cbor_deserialize(data.as_slice()) {
-        Ok(ResponseMessage::BatchInclusionData(batch_inclusion_data)) => { //OK case. Proofs was valid and it was included in this batch.
+        Ok(ResponseMessage::BatchInclusionData(batch_inclusion_data)) => {
+            //OK case. Proofs was valid and it was included in this batch.
             return Ok(batch_inclusion_data);
         }
         Ok(ResponseMessage::InvalidNonce) => {
@@ -193,14 +178,17 @@ async fn handle_batcher_response(
                 expected_addr,
             ));
         }
-        Ok(ResponseMessage::InvalidProof(reason)) => { 
+        Ok(ResponseMessage::InvalidProof(reason)) => {
             error!("Batcher responded with invalid proof: {}", reason);
             return Err(SubmitError::InvalidProof(reason));
         }
         Ok(ResponseMessage::CreateNewTaskError(merkle_root, error)) => {
             error!("Batcher responded with create new task error: {}", error);
             return Err(SubmitError::BatchSubmissionFailed(
-                "Could not create task with merkle root ".to_owned() + &merkle_root + ", failed with error: " + &error, 
+                "Could not create task with merkle root ".to_owned()
+                    + &merkle_root
+                    + ", failed with error: "
+                    + &error,
             ));
         }
         Ok(ResponseMessage::ProtocolVersion(_)) => {
@@ -216,7 +204,7 @@ async fn handle_batcher_response(
         }
         Ok(ResponseMessage::Error(e)) => {
             error!("Batcher responded with error: {}", e);
-            return Err(SubmitError::GenericError(e))
+            return Err(SubmitError::GenericError(e));
         }
         Err(e) => {
             error!("Error while deserializing batch inclusion data: {}", e);

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

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

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

@@ -332,7 +332,6 @@ impl AlignedVerificationData {
     }
 }
 
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ProofInvalidReason {
     RejectedProof,

batcher/aligned-sdk/src/sdk.rs

@@ -38,13 +38,13 @@ use log::{debug, info};
 
 use futures_util::{
     stream::{SplitSink, SplitStream},
-    StreamExt, TryStreamExt, SinkExt
+    SinkExt, StreamExt, TryStreamExt,
 };
 
+use serde_json::json;
 use std::fs::File;
 use std::io::Write;
 use std::path::PathBuf;
-use serde_json::json;
 
 /// Submits multiple proofs to the batcher to be verified in Aligned and waits for the verification on-chain.
 /// # Arguments
@@ -297,7 +297,8 @@ async fn _submit_multiple(
             "verification_data".to_string(),
         ));
     }
-    if verification_data.len() > 10000 { //TODO Magic number
+    if verification_data.len() > 10000 {
+        //TODO Magic number
         return Err(errors::SubmitError::GenericError(
             "Trying to submit too many proofs at once".to_string(),
         ));
@@ -313,9 +314,18 @@ async fn _submit_multiple(
     let payment_service_addr = get_payment_service_address(network);
 
     let result = async {
-        let sent_verification_data = send_messages(ws_write, payment_service_addr, verification_data, max_fees, wallet, nonce).await?;
+        let sent_verification_data = send_messages(
+            ws_write,
+            payment_service_addr,
+            verification_data,
+            max_fees,
+            wallet,
+            nonce,
+        )
+        .await?;
         receive(response_stream, sent_verification_data).await
-    }.await;
+    }
+    .await;
 
     // Close connection
     info!("Closing WS connection");

batcher/aligned/src/main.rs

@@ -551,7 +551,10 @@ async fn handle_submit_err(err: SubmitError, nonce_file: &str) {
         }
         SubmitError::InvalidProof(reason) => error!("Submitted proof is invalid: {}", reason),
         SubmitError::InsufficientBalance(sender_address) => {
-            error!("Insufficient balance to pay for the transaction, address: {}", sender_address)
+            error!(
+                "Insufficient balance to pay for the transaction, address: {}",
+                sender_address
+            )
         }
         _ => {}
     }