cargo fmt

Author: Oppen

batcher/aligned-batcher/src/connection.rs

@@ -16,7 +16,8 @@ use tokio_tungstenite::{
     WebSocketStream,
 };
 
-pub(crate) type WsMessageSink = Arc<RwLock<SplitSink<WebSocketStream<TlsStream<TcpStream>>, Message>>>;
+pub(crate) type WsMessageSink =
+    Arc<RwLock<SplitSink<WebSocketStream<TlsStream<TcpStream>>, Message>>>;
 
 pub(crate) async fn send_batch_inclusion_data_responses(
     finalized_batch: Vec<BatchQueueEntry>,

batcher/aligned-batcher/src/lib.rs

@@ -11,15 +11,15 @@ use retry::batcher_retryables::{
     get_user_nonce_from_ethereum_retryable, user_balance_is_unlocked_retryable,
 };
 use retry::{retry_function, RetryError};
-use tokio::time::timeout;
-use types::batch_state::BatchState;
-use types::user_state::UserState;
 use std::collections::HashMap;
 use std::env;
 use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
+use tokio::time::timeout;
+use types::batch_state::BatchState;
+use types::user_state::UserState;
 
 use aligned_sdk::core::constants::{
     ADDITIONAL_SUBMISSION_GAS_COST_PER_PROOF, AGGREGATOR_GAS_COST, BUMP_BACKOFF_FACTOR,
@@ -263,17 +263,20 @@ impl Batcher {
         }
     }
 
-    pub async fn listen_connections(self: Arc<Self>, address: &str, cert: PathBuf, key: PathBuf) -> Result<(), BatcherError> {
+    pub async fn listen_connections(
+        self: Arc<Self>,
+        address: &str,
+        cert: PathBuf,
+        key: PathBuf,
+    ) -> Result<(), BatcherError> {
         // let mut acceptor_builder = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
         // acceptor_builder.set_private_key_file(key, SslFiletype::PEM).unwrap();
         // acceptor_builder.set_certificate_chain_file(cert).unwrap();
         // acceptor_builder.check_private_key().unwrap();
         // let acceptor = Arc::new(acceptor_builder.build());
         // Reference: https://github.com/rustls/tokio-rustls/blob/main/examples/server.rs
-        let cert = vec![
-            CertificateDer::from_pem_file(cert)
-                .map_err(|e| BatcherError::TlsError(format!("{e}")))?,
-        ];
+        let cert = vec![CertificateDer::from_pem_file(cert)
+            .map_err(|e| BatcherError::TlsError(format!("{e}")))?];
         let key = PrivateKeyDer::from_pem_file(key)
             .map_err(|e| BatcherError::TlsError(format!("{e}")))?;
 
@@ -393,7 +396,8 @@ impl Batcher {
     ) -> Result<(), BatcherError> {
         info!("Incoming TCP connection from: {}", addr);
         self.metrics.open_connections.inc();
-        let tls_stream = acceptor.accept(raw_stream)
+        let tls_stream = acceptor
+            .accept(raw_stream)
             .await
             .map_err(|e| BatcherError::TlsError(e.to_string()))?;
         let ws_stream_future = tokio_tungstenite::accept_async(tls_stream);

batcher/aligned-batcher/src/main.rs

@@ -1,10 +1,10 @@
 extern crate dotenvy;
 
-use std::path::PathBuf;
-use std::sync::Arc;
 use clap::Parser;
 use env_logger::Env;
-use rustls::crypto::{CryptoProvider, aws_lc_rs};
+use rustls::crypto::{aws_lc_rs, CryptoProvider};
+use std::path::PathBuf;
+use std::sync::Arc;
 
 use aligned_batcher::{types::errors::BatcherError, Batcher};
 
@@ -59,9 +59,9 @@ async fn main() -> Result<(), BatcherError> {
                 .expect("Error listening for new blocks exiting")
         }
     });
-    
+
     batcher.metrics.inc_batcher_restart();
-    
+
     let addr = format!("0.0.0.0:{}", port);
     batcher.listen_connections(&addr, cli.cert, cli.key).await?;
 

batcher/aligned-sdk/src/sdk.rs

@@ -568,9 +568,9 @@ pub async fn get_nonce_from_batcher(
     batcher_ws_url: &str,
     address: Address,
 ) -> Result<U256, GetNonceError> {
-    let (ws_stream, _) = connect_async(batcher_ws_url).await.map_err(|e| {
-        GetNonceError::ConnectionFailed(e.to_string())
-    })?;
+    let (ws_stream, _) = connect_async(batcher_ws_url)
+        .await
+        .map_err(|e| GetNonceError::ConnectionFailed(e.to_string()))?;
 
     debug!("WebSocket handshake has been successfully completed");
     let (mut ws_write, mut ws_read) = ws_stream.split();