lint: run cargo fmt

Author: sapinb

crates/cac/types/src/lib.rs

@@ -4,12 +4,10 @@
 //! to ever interact with directly, so this can have types that we don't want to
 //! expose in the RPC interface (or be compiled into RPC libraries).
 
-pub use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
-
 // Used by examples
 use ark_ec as _;
 use ark_ff as _;
-
+pub use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 // Used by benchmarks
 #[cfg(test)]
 use criterion as _;

crates/net/svc/src/api.rs

@@ -8,8 +8,7 @@ use std::sync::Arc;
 
 use kanal::{AsyncReceiver, AsyncSender};
 
-use crate::config::NetServiceConfig;
-use crate::tls::PeerId;
+use crate::{config::NetServiceConfig, tls::PeerId};
 
 /// A buffer for payload data.
 ///
@@ -315,8 +314,8 @@ impl NetServiceHandle {
     /// # Arguments
     ///
     /// * `peer` - The peer to open the stream to (must be in config).
-    /// * `priority` - Stream priority. Higher = more important. Use 0 for normal,
-    ///   1 for high (ACKs), -1 for low.
+    /// * `priority` - Stream priority. Higher = more important. Use 0 for normal, 1 for high
+    ///   (ACKs), -1 for low.
     pub async fn open_protocol_stream(
         &self,
         peer: PeerId,

crates/net/svc/src/svc/handlers.rs

@@ -14,13 +14,16 @@
 
 use kanal::{AsyncReceiver, bounded_async};
 
-use crate::api::{ExpectError, NetCommand, OpenStreamError, Stream};
-use crate::tls::PeerId;
-
-use super::state::{
-    ConnectionDirection, PendingStreamRequest, ServiceEvent, ServiceState, TrackedConnection,
+use super::{
+    state::{
+        ConnectionDirection, PendingStreamRequest, ServiceEvent, ServiceState, TrackedConnection,
+    },
+    tasks,
+};
+use crate::{
+    api::{ExpectError, NetCommand, OpenStreamError, Stream},
+    tls::PeerId,
 };
-use super::tasks;
 
 /// Handle a command from a NetServiceHandle.
 ///

crates/net/svc/src/svc/mod.rs

@@ -24,21 +24,24 @@ mod state;
 mod stream;
 mod tasks;
 
-use std::collections::HashSet;
-use std::sync::Arc;
-use std::thread::{self, JoinHandle};
-use std::time::Duration;
+use std::{
+    collections::HashSet,
+    sync::Arc,
+    thread::{self, JoinHandle},
+    time::Duration,
+};
 
 use ahash::{HashMap, HashMapExt};
 use kanal::{AsyncReceiver, AsyncSender, bounded_async};
 use quinn::{Endpoint, ServerConfig};
+use state::{ServiceEvent, ServiceState, TrackedConnection};
 use tokio::runtime::Builder;
 
-use crate::api::{NetCommand, NetServiceHandle, Stream};
-use crate::config::NetServiceConfig;
-use crate::tls::{self, PeerId};
-
-use state::{ServiceEvent, ServiceState, TrackedConnection};
+use crate::{
+    api::{NetCommand, NetServiceHandle, Stream},
+    config::NetServiceConfig,
+    tls::{self, PeerId},
+};
 
 /// Handle to control the network service.
 pub struct NetServiceController {

crates/net/svc/src/svc/state.rs

@@ -3,16 +3,17 @@
 //! This module contains the service state, internal events, and helper types
 //! used by the main loop and handlers.
 
-use std::sync::Arc;
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
 
 use ahash::HashMap;
 use kanal::AsyncSender;
 use quinn::Endpoint;
 
-use crate::api::{OpenStreamError, Stream};
-use crate::config::NetServiceConfig;
-use crate::tls::PeerId;
+use crate::{
+    api::{OpenStreamError, Stream},
+    config::NetServiceConfig,
+    tls::PeerId,
+};
 
 /// Direction metadata for a stored connection.
 ///

crates/net/svc/src/svc/stream.rs

@@ -8,8 +8,10 @@ use std::sync::{Arc, Mutex};
 use kanal::{AsyncReceiver, AsyncSender, bounded_async};
 use quinn::{RecvStream, SendStream};
 
-use crate::api::{PayloadBuf, Stream, StreamClosed, StreamRequest};
-use crate::tls::PeerId;
+use crate::{
+    api::{PayloadBuf, Stream, StreamClosed, StreamRequest},
+    tls::PeerId,
+};
 
 /// Channel buffer sizes for stream communication.
 const PAYLOAD_CHANNEL_SIZE: usize = 16;
@@ -94,7 +96,9 @@ async fn write_task(
                     StreamRequest::Write { buf } => {
                         // Encode frame with length prefix
                         frame_buf.clear();
-                        if let Err(e) = mosaic_net_wire::encode_frame_unchecked(&buf, &mut frame_buf) {
+                        if let Err(e) =
+                            mosaic_net_wire::encode_frame_unchecked(&buf, &mut frame_buf)
+                        {
                             tracing::warn!(error = %e, "failed to encode frame");
                             // Return buffer anyway
                             let mut buf = buf;

crates/net/svc/src/svc/tasks.rs

@@ -13,12 +13,15 @@ use std::{collections::HashSet, sync::Arc};
 use kanal::AsyncSender;
 use quinn::Endpoint;
 
-use crate::api::{OpenStreamError, Stream};
-use crate::tls::PeerId;
-
-use super::conn;
-use super::state::{CONNECTION_TIMEOUT, HEADER_READ_TIMEOUT, ServiceEvent};
-use super::stream;
+use super::{
+    conn,
+    state::{CONNECTION_TIMEOUT, HEADER_READ_TIMEOUT, ServiceEvent},
+    stream,
+};
+use crate::{
+    api::{OpenStreamError, Stream},
+    tls::PeerId,
+};
 
 /// Spawn a task to handle an incoming connection's TLS handshake.
 ///
@@ -216,8 +219,8 @@ pub fn spawn_stream_header_reader(
             }
 
             // Decode header
-            let (header, _) =
-                mosaic_net_wire::StreamHeader::decode(&buf[..1 + remaining]).map_err(|e| e.to_string())?;
+            let (header, _) = mosaic_net_wire::StreamHeader::decode(&buf[..1 + remaining])
+                .map_err(|e| e.to_string())?;
 
             Ok(header.stream_type)
         }

crates/net/svc/tests/integration.rs

@@ -7,10 +7,14 @@
 //! That is inherently flaky in CI. Prefer waiting for an actual successful
 //! operation with a timeout.
 
-use std::net::SocketAddr;
-use std::sync::Once;
-use std::sync::atomic::{AtomicU16, Ordering};
-use std::time::Duration;
+use std::{
+    net::SocketAddr,
+    sync::{
+        Once,
+        atomic::{AtomicU16, Ordering},
+    },
+    time::Duration,
+};
 
 use ed25519_dalek::SigningKey;
 use mosaic_net_svc::{
@@ -168,8 +172,8 @@ where
 /// Receive a value with a timeout.
 ///
 /// This is intentionally *not* a retry loop:
-/// - If the channel is open but no value arrives, `recv().await` may wait indefinitely,
-///   so we bound it with a timeout.
+/// - If the channel is open but no value arrives, `recv().await` may wait indefinitely, so we bound
+///   it with a timeout.
 /// - If the channel is closed, `recv().await` should return promptly with an error.
 /// - If the value is merely delayed, increasing the timeout is the right fix (not retries).
 async fn recv_with_timeout<Fut, T>(timeout: Duration, fut: Fut) -> T