fix: run fmt on whole project

SupernaviX · SupernaviX · commit b0c5fc7fd165 · 2025-11-04T20:25:53.000-05:00
diff --git a/common/src/upstream_cache.rs b/common/src/upstream_cache.rs
@@ -124,7 +124,9 @@ impl<S: Storage> UpstreamCacheImpl<S> {
 
     pub fn write_record(&mut self, record: &UpstreamCacheRecord) -> Result<()> {
         self.chunk_cached.push(record.clone());
-        self.storage.write_chunk(self.current_chunk, &self.chunk_cached).context("could not write cache record")?;
+        self.storage
+            .write_chunk(self.current_chunk, &self.chunk_cached)
+            .context("could not write cache record")?;
 
         self.current_record += 1;
         if self.current_record >= self.density {
@@ -155,7 +157,8 @@ impl Storage for FileStorage {
     }
 
     fn write_chunk(&mut self, chunk_no: usize, data: &[UpstreamCacheRecord]) -> Result<()> {
-        let mut file = File::create(self.get_file_name(chunk_no)).context("could not write chunk")?;
+        let mut file =
+            File::create(self.get_file_name(chunk_no)).context("could not write chunk")?;
         file.write_all(&serde_json::to_vec(data)?)?;
         Ok(())
     }
diff --git a/modules/peer_network_interface/src/chain_state.rs b/modules/peer_network_interface/src/chain_state.rs
@@ -21,7 +21,11 @@ impl SlotBlockData {
         if let Some(block) = self.blocks.iter_mut().find(|b| b.header.hash == header.hash) {
             block.announced_by.push(id);
         } else {
-            self.blocks.push(BlockData { header, announced_by: vec![id], body: None });
+            self.blocks.push(BlockData {
+                header,
+                announced_by: vec![id],
+                body: None,
+            });
         }
     }
 
@@ -50,7 +54,7 @@ impl SlotBlockData {
     fn announcers(&self, hash: BlockHash) -> Vec<PeerId> {
         match self.blocks.iter().find(|b| b.header.hash == hash) {
             Some(b) => b.announced_by.clone(),
-            None => vec![]
+            None => vec![],
         }
     }
 
@@ -180,7 +184,7 @@ impl ChainState {
         // queue them to be published as soon as we have their bodies
         let head_slot = self.published_blocks.back().map(|(s, _)| *s);
         if let Some(slot) = head_slot {
-            for (slot, blocks) in self.blocks.range(slot+1..) {
+            for (slot, blocks) in self.blocks.range(slot + 1..) {
                 if let Some(hash) = blocks.find_announced_hash(id) {
                     self.unpublished_blocks.push_back((*slot, hash));
                 }
@@ -251,7 +255,7 @@ impl ChainState {
     pub fn block_announcers(&self, slot: u64, hash: BlockHash) -> Vec<PeerId> {
         match self.blocks.get(&slot) {
             Some(slot_blocks) => slot_blocks.announcers(hash),
-            None => vec![]
+            None => vec![],
         }
     }
 }
@@ -298,7 +302,10 @@ mod tests {
         state.handle_body_fetched(header.slot, header.hash, body.clone());
 
         // NOW we have a new block to report
-        assert_eq!(state.next_unpublished_block(), Some((&header, body.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&header, body.as_slice(), false))
+        );
         state.handle_block_published();
         assert_eq!(state.next_unpublished_block(), None);
     }
@@ -329,9 +336,15 @@ mod tests {
         state.handle_body_fetched(h1.slot, h1.hash, b1.clone());
 
         // NOW we have TWO new blocks to report
-        assert_eq!(state.next_unpublished_block(), Some((&h1, b1.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h1, b1.as_slice(), false))
+        );
         state.handle_block_published();
-        assert_eq!(state.next_unpublished_block(), Some((&h2, b2.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h2, b2.as_slice(), false))
+        );
         state.handle_block_published();
         assert_eq!(state.next_unpublished_block(), None);
     }
@@ -350,13 +363,19 @@ mod tests {
         // publish the first block
         assert_eq!(state.handle_roll_forward(p1, h1.clone()), vec![p1]);
         state.handle_body_fetched(h1.slot, h1.hash, b1.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&h1, b1.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h1, b1.as_slice(), false))
+        );
         state.handle_block_published();
 
         // publish the second block
         assert_eq!(state.handle_roll_forward(p1, h2.clone()), vec![p1]);
         state.handle_body_fetched(h2.slot, h2.hash, b2.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&h2, b2.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h2, b2.as_slice(), false))
+        );
         state.handle_block_published();
         assert_eq!(state.next_unpublished_block(), None);
 
@@ -367,13 +386,19 @@ mod tests {
         // and when we advance to the new second block, the system should report it as a rollback
         assert_eq!(state.handle_roll_forward(p1, h3.clone()), vec![p1]);
         state.handle_body_fetched(h3.slot, h3.hash, b3.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&h3, b3.as_slice(), true)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h3, b3.as_slice(), true))
+        );
         state.handle_block_published();
 
         // and the new third block should not be a rollback
         assert_eq!(state.handle_roll_forward(p1, h4.clone()), vec![p1]);
         state.handle_body_fetched(h4.slot, h4.hash, b4.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&h4, b4.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h4, b4.as_slice(), false))
+        );
         state.handle_block_published();
     }
 
@@ -390,7 +415,10 @@ mod tests {
         // publish the first block
         assert_eq!(state.handle_roll_forward(p1, h1.clone()), vec![p1]);
         state.handle_body_fetched(h1.slot, h1.hash, b1.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&h1, b1.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h1, b1.as_slice(), false))
+        );
         state.handle_block_published();
 
         // roll forward to the second block, but pretend the body is taking a while to download
@@ -408,7 +436,10 @@ mod tests {
         // and when we advance to the new second block, the system should not report it as a rollback
         assert_eq!(state.handle_roll_forward(p1, h3.clone()), vec![p1]);
         state.handle_body_fetched(h3.slot, h3.hash, b3.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&h3, b3.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h3, b3.as_slice(), false))
+        );
         state.handle_block_published();
         assert_eq!(state.next_unpublished_block(), None);
     }
@@ -429,17 +460,26 @@ mod tests {
         // publish three blocks on our current chain
         assert_eq!(state.handle_roll_forward(p1, h1.clone()), vec![p1]);
         state.handle_body_fetched(h1.slot, h1.hash, b1.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&h1, b1.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&h1, b1.as_slice(), false))
+        );
         state.handle_block_published();
 
         assert_eq!(state.handle_roll_forward(p1, p1h2.clone()), vec![p1]);
         state.handle_body_fetched(p1h2.slot, p1h2.hash, p1b2.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&p1h2, p1b2.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&p1h2, p1b2.as_slice(), false))
+        );
         state.handle_block_published();
 
         assert_eq!(state.handle_roll_forward(p1, p1h3.clone()), vec![p1]);
         state.handle_body_fetched(p1h3.slot, p1h3.hash, p1b3.clone());
-        assert_eq!(state.next_unpublished_block(), Some((&p1h3, p1b3.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&p1h3, p1b3.as_slice(), false))
+        );
         state.handle_block_published();
 
         // that other chain forked
@@ -454,11 +494,16 @@ mod tests {
         state.handle_new_preferred_upstream(p2);
 
         // now we should publish two blocks, and the first should be marked as "rollback"
-        assert_eq!(state.next_unpublished_block(), Some((&p2h2, p2b2.as_slice(), true)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&p2h2, p2b2.as_slice(), true))
+        );
         state.handle_block_published();
-        assert_eq!(state.next_unpublished_block(), Some((&p2h3, p2b3.as_slice(), false)));
+        assert_eq!(
+            state.next_unpublished_block(),
+            Some((&p2h3, p2b3.as_slice(), false))
+        );
         state.handle_block_published();
         assert_eq!(state.next_unpublished_block(), None);
-
     }
-}
+}
diff --git a/modules/peer_network_interface/src/network.rs b/modules/peer_network_interface/src/network.rs
@@ -1,10 +1,9 @@
-use std::{
-    collections::BTreeMap,
-    time::Duration,
-};
+use std::{collections::BTreeMap, time::Duration};
 
 use crate::{
-    BlockSink, chain_state::ChainState, connection::{PeerChainSyncEvent, PeerConnection, PeerEvent}
+    BlockSink,
+    chain_state::ChainState,
+    connection::{PeerChainSyncEvent, PeerConnection, PeerEvent},
 };
 use acropolis_common::BlockHash;
 use anyhow::{Context as _, Result, bail};
@@ -18,10 +17,7 @@ struct PeerData {
 }
 impl PeerData {
     fn new(conn: PeerConnection) -> Self {
-        Self {
-            conn,
-            reqs: vec![]
-        }
+        Self { conn, reqs: vec![] }
     }
 
     fn find_intersect(&self, points: Vec<Point>) {
@@ -35,7 +31,10 @@ impl PeerData {
             return true;
         }
         if let Err(error) = self.conn.request_block(hash, slot) {
-            warn!("could not request block from {}: {error:#}", self.conn.address);
+            warn!(
+                "could not request block from {}: {error:#}",
+                self.conn.address
+            );
             return false;
         }
         self.reqs.push((hash, slot));
diff --git a/modules/peer_network_interface/src/peer_network_interface.rs b/modules/peer_network_interface/src/peer_network_interface.rs
@@ -4,7 +4,10 @@ mod connection;
 mod network;
 
 use acropolis_common::{
-    BlockInfo, BlockStatus, genesis_values::GenesisValues, messages::{CardanoMessage, Message, RawBlockMessage}, upstream_cache::{UpstreamCache, UpstreamCacheRecord}
+    BlockInfo, BlockStatus,
+    genesis_values::GenesisValues,
+    messages::{CardanoMessage, Message, RawBlockMessage},
+    upstream_cache::{UpstreamCache, UpstreamCacheRecord},
 };
 use anyhow::{Result, bail};
 use caryatid_sdk::{Context, Module, Subscription, module};
@@ -72,8 +75,7 @@ impl PeerNetworkInterface {
                 upstream_cache,
             };
 
-            let mut manager =
-                NetworkManager::new(cfg.magic_number, events, events_sender, sink);
+            let mut manager = NetworkManager::new(cfg.magic_number, events, events_sender, sink);
             for address in cfg.node_addresses {
                 manager.handle_new_connection(address, Duration::ZERO);
             }
@@ -94,7 +96,7 @@ impl PeerNetworkInterface {
                         Ok(point) => manager.sync_to_point(point),
                         Err(error) => {
                             warn!("snapshot restoration never completed: {error:#}");
-                            return;                            
+                            return;
                         }
                     }
                 }
