Add rustfmt formatting policy and reformat codebase

Add rustfmt.toml with stable defaults and apply cargo fmt to all
source files. This establishes a consistent formatting baseline
for CI enforcement.

src/protocol/discovery.rs

@@ -1,9 +1,9 @@
 //! Discovery messages: LookupRequest and LookupResponse.
 
+use crate::NodeAddr;
 use crate::protocol::error::ProtocolError;
 use crate::protocol::session::{decode_coords, encode_coords};
 use crate::tree::TreeCoordinate;
-use crate::NodeAddr;
 use secp256k1::schnorr::Signature;
 
 /// Request to discover a node's coordinates.
@@ -192,7 +192,11 @@ impl LookupResponse {
     /// Get the bytes that should be signed as proof.
     ///
     /// Format: request_id (8) || target (16) || coords_encoding (2 + 16×n)
-    pub fn proof_bytes(request_id: u64, target: &NodeAddr, target_coords: &TreeCoordinate) -> Vec<u8> {
+    pub fn proof_bytes(
+        request_id: u64,
+        target: &NodeAddr,
+        target_coords: &TreeCoordinate,
+    ) -> Vec<u8> {
         let coord_size = 2 + target_coords.entries().len() * 16;
         let mut bytes = Vec::with_capacity(24 + coord_size);
         bytes.extend_from_slice(&request_id.to_le_bytes());

src/protocol/filter.rs

@@ -42,11 +42,7 @@ impl FilterAnnounce {
     }
 
     /// Create with explicit size_class (for testing or future protocol versions).
-    pub fn with_size_class(
-        filter: BloomFilter,
-        sequence: u64,
-        size_class: u8,
-    ) -> Self {
+    pub fn with_size_class(filter: BloomFilter, sequence: u64, size_class: u8) -> Self {
         Self {
             hash_count: filter.hash_count(),
             size_class,
@@ -164,10 +160,8 @@ impl FilterAnnounce {
         }
 
         // Construct BloomFilter from bytes
-        let filter =
-            crate::bloom::BloomFilter::from_slice(&payload[pos..], hash_count).map_err(|e| {
-                ProtocolError::Malformed(format!("invalid bloom filter: {e}"))
-            })?;
+        let filter = crate::bloom::BloomFilter::from_slice(&payload[pos..], hash_count)
+            .map_err(|e| ProtocolError::Malformed(format!("invalid bloom filter: {e}")))?;
 
         let announce = Self {
             filter,
@@ -253,7 +247,12 @@ mod tests {
 
         let result = FilterAnnounce::decode(&encoded[1..]);
         assert!(result.is_err());
-        assert!(result.unwrap_err().to_string().contains("invalid size_class"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("invalid size_class")
+        );
     }
 
     #[test]
@@ -265,10 +264,12 @@ mod tests {
 
         let result = FilterAnnounce::decode(&encoded[1..]);
         assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("unsupported size_class"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("unsupported size_class")
+        );
     }
 
     #[test]

src/protocol/link.rs

@@ -533,8 +533,7 @@ mod tests {
         let src = make_node_addr(0xAA);
         let dest = make_node_addr(0xBB);
         let payload = vec![0x10, 0x00, 0x05, 0x00, 1, 2, 3, 4, 5]; // session payload
-        let dg = SessionDatagram::new(src, dest, payload.clone())
-            .with_ttl(32);
+        let dg = SessionDatagram::new(src, dest, payload.clone()).with_ttl(32);
 
         let encoded = dg.encode();
         assert_eq!(encoded[0], 0x00); // msg_type (SessionDatagram)

src/protocol/mod.rs

@@ -28,21 +28,21 @@ mod session;
 mod tree;
 
 // Re-export all public types at protocol:: level
-pub use error::ProtocolError;
-pub use link::{
-    Disconnect, DisconnectReason, HandshakeMessageType, LinkMessageType, SessionDatagram,
-    SESSION_DATAGRAM_HEADER_SIZE,
-};
-pub use tree::TreeAnnounce;
-pub use filter::FilterAnnounce;
 pub use discovery::{LookupRequest, LookupResponse};
+pub use error::ProtocolError;
+pub use filter::FilterAnnounce;
+pub use link::{
+    Disconnect, DisconnectReason, HandshakeMessageType, LinkMessageType,
+    SESSION_DATAGRAM_HEADER_SIZE, SessionDatagram,
+};
 pub use session::{
-    CoordsRequired, FspFlags, FspInnerFlags, MtuExceeded, PathBroken, PathMtuNotification,
-    SessionAck, SessionFlags, SessionMessageType, SessionMsg3, SessionReceiverReport,
-    SessionSenderReport, SessionSetup, COORDS_REQUIRED_SIZE, MTU_EXCEEDED_SIZE,
-    PATH_MTU_NOTIFICATION_SIZE, SESSION_RECEIVER_REPORT_SIZE, SESSION_SENDER_REPORT_SIZE,
+    COORDS_REQUIRED_SIZE, CoordsRequired, FspFlags, FspInnerFlags, MTU_EXCEEDED_SIZE, MtuExceeded,
+    PATH_MTU_NOTIFICATION_SIZE, PathBroken, PathMtuNotification, SESSION_RECEIVER_REPORT_SIZE,
+    SESSION_SENDER_REPORT_SIZE, SessionAck, SessionFlags, SessionMessageType, SessionMsg3,
+    SessionReceiverReport, SessionSenderReport, SessionSetup,
 };
 pub(crate) use session::{coords_wire_size, decode_optional_coords, encode_coords};
+pub use tree::TreeAnnounce;
 
 /// Protocol version for message compatibility.
 pub const PROTOCOL_VERSION: u8 = 1;

src/protocol/session.rs

@@ -1,8 +1,8 @@
 //! Session-layer message types: setup, ack, data, and error messages.
 
 use super::ProtocolError;
-use crate::tree::TreeCoordinate;
 use crate::NodeAddr;
+use crate::tree::TreeCoordinate;
 use std::fmt;
 
 // ============================================================================
@@ -141,15 +141,17 @@ pub(crate) fn decode_coords(data: &[u8]) -> Result<(TreeCoordinate, usize), Prot
         bytes.copy_from_slice(&data[offset..offset + 16]);
         addrs.push(NodeAddr::from_bytes(bytes));
     }
-    let coord = TreeCoordinate::from_addrs(addrs)
-        .map_err(|e| ProtocolError::Malformed(e.to_string()))?;
+    let coord =
+        TreeCoordinate::from_addrs(addrs).map_err(|e| ProtocolError::Malformed(e.to_string()))?;
     Ok((coord, needed))
 }
 
 /// Decode an optional coordinate field (count may be 0).
 ///
 /// Returns None if count is 0, Some(coord) otherwise, plus bytes consumed.
-pub(crate) fn decode_optional_coords(data: &[u8]) -> Result<(Option<TreeCoordinate>, usize), ProtocolError> {
+pub(crate) fn decode_optional_coords(
+    data: &[u8],
+) -> Result<(Option<TreeCoordinate>, usize), ProtocolError> {
     if data.len() < 2 {
         return Err(ProtocolError::MessageTooShort {
             expected: 2,
@@ -174,8 +176,8 @@ pub(crate) fn decode_optional_coords(data: &[u8]) -> Result<(Option<TreeCoordina
         bytes.copy_from_slice(&data[offset..offset + 16]);
         addrs.push(NodeAddr::from_bytes(bytes));
     }
-    let coord = TreeCoordinate::from_addrs(addrs)
-        .map_err(|e| ProtocolError::Malformed(e.to_string()))?;
+    let coord =
+        TreeCoordinate::from_addrs(addrs).map_err(|e| ProtocolError::Malformed(e.to_string()))?;
     Ok((Some(coord), needed))
 }
 
@@ -909,7 +911,10 @@ pub const COORDS_REQUIRED_SIZE: usize = 34;
 impl CoordsRequired {
     /// Create a new CoordsRequired error.
     pub fn new(dest_addr: NodeAddr, reporter: NodeAddr) -> Self {
-        Self { dest_addr, reporter }
+        Self {
+            dest_addr,
+            reporter,
+        }
     }
 
     /// Encode as wire format (4-byte FSP prefix + msg_type + body).
@@ -1081,7 +1086,11 @@ pub const MTU_EXCEEDED_SIZE: usize = 36;
 impl MtuExceeded {
     /// Create a new MtuExceeded error.
     pub fn new(dest_addr: NodeAddr, reporter: NodeAddr, mtu: u16) -> Self {
-        Self { dest_addr, reporter, mtu }
+        Self {
+            dest_addr,
+            reporter,
+            mtu,
+        }
     }
 
     /// Encode as wire format (4-byte FSP prefix + msg_type + body).
@@ -1359,8 +1368,7 @@ mod tests {
         let addrs: Vec<u8> = (0..11).collect();
         let src = make_coords(&addrs);
         let dest = make_coords(&[20, 21, 22, 23, 24]);
-        let setup = SessionSetup::new(src.clone(), dest.clone())
-            .with_handshake(vec![0x55; 82]);
+        let setup = SessionSetup::new(src.clone(), dest.clone()).with_handshake(vec![0x55; 82]);
 
         let encoded = setup.encode();
         let decoded = SessionSetup::decode(&encoded[4..]).unwrap();
@@ -1459,9 +1467,18 @@ mod tests {
 
     #[test]
     fn test_session_message_type_display() {
-        assert_eq!(format!("{}", SessionMessageType::SenderReport), "SenderReport");
-        assert_eq!(format!("{}", SessionMessageType::ReceiverReport), "ReceiverReport");
-        assert_eq!(format!("{}", SessionMessageType::PathMtuNotification), "PathMtuNotification");
+        assert_eq!(
+            format!("{}", SessionMessageType::SenderReport),
+            "SenderReport"
+        );
+        assert_eq!(
+            format!("{}", SessionMessageType::ReceiverReport),
+            "ReceiverReport"
+        );
+        assert_eq!(
+            format!("{}", SessionMessageType::PathMtuNotification),
+            "PathMtuNotification"
+        );
     }
 
     // ===== SessionSenderReport Tests =====
@@ -1639,7 +1656,10 @@ mod tests {
 
     #[test]
     fn test_mtu_exceeded_display() {
-        assert_eq!(format!("{}", SessionMessageType::MtuExceeded), "MtuExceeded");
+        assert_eq!(
+            format!("{}", SessionMessageType::MtuExceeded),
+            "MtuExceeded"
+        );
     }
 
     // ===== SessionMsg3 Tests =====

src/protocol/tree.rs

@@ -2,8 +2,8 @@
 
 use super::error::ProtocolError;
 use super::link::LinkMessageType;
-use crate::tree::{CoordEntry, ParentDeclaration, TreeCoordinate};
 use crate::NodeAddr;
+use crate::tree::{CoordEntry, ParentDeclaration, TreeCoordinate};
 use secp256k1::schnorr::Signature;
 
 /// Spanning tree announcement carrying parent declaration and ancestry.
@@ -166,8 +166,8 @@ impl TreeAnnounce {
         let sig_bytes: [u8; 64] = payload[pos..pos + 64]
             .try_into()
             .map_err(|_| ProtocolError::Malformed("bad signature".into()))?;
-        let signature = Signature::from_slice(&sig_bytes)
-            .map_err(|_| ProtocolError::InvalidSignature)?;
+        let signature =
+            Signature::from_slice(&sig_bytes).map_err(|_| ProtocolError::InvalidSignature)?;
 
         // The first entry's node_addr is the declaring node
         if entries.is_empty() {
@@ -324,7 +324,10 @@ mod tests {
         encoded[1] = 0xFF;
 
         let result = TreeAnnounce::decode(&encoded[1..]);
-        assert!(matches!(result, Err(ProtocolError::UnsupportedVersion(0xFF))));
+        assert!(matches!(
+            result,
+            Err(ProtocolError::UnsupportedVersion(0xFF))
+        ));
     }
 
     #[test]
@@ -365,10 +368,7 @@ mod tests {
         encoded[35] = 0;
 
         let result = TreeAnnounce::decode(&encoded[1..]);
-        assert!(matches!(
-            result,
-            Err(ProtocolError::MessageTooShort { .. })
-        ));
+        assert!(matches!(result, Err(ProtocolError::MessageTooShort { .. })));
     }
 
     #[test]