ran cargo +nightly fmt

Author: Roee-87

rustfmt.toml

@@ -0,0 +1,16 @@
+# https://github.com/rust-lang/rustfmt/blob/master/Configurations.md
+
+# Stable configurations
+edition = "2024"
+max_width = 120
+merge_derives = true
+use_field_init_shorthand = true
+use_small_heuristics = "Max"
+use_try_shorthand = true
+imports_layout = "HorizontalVertical"
+imports_granularity = "Crate"
+overflow_delimited_expr = true
+
+# Nightly configurations
+reorder_impl_items = true
+style_edition = "2024"

src/rest/mod.rs

@@ -35,8 +35,8 @@ use axum::{
     response::Response,
     routing::{get, post},
 };
-use std::path::PathBuf;
 use axum_extra::response::ErasedJson;
+use std::path::PathBuf;
 
 use parking_lot::Mutex;
 use std::{

src/restore.rs

@@ -43,20 +43,15 @@ impl Restore {
         let snapshot_path = snapshots_dir.join(&self.snapshot);
 
         if !snapshot_path.exists() {
-            return Err(anyhow!(
-                "Snapshot '{}' not found at '{}'",
-                self.snapshot,
-                snapshot_path.display()
-            ));
+            return Err(anyhow!("Snapshot '{}' not found at '{}'", self.snapshot, snapshot_path.display()));
         }
 
         // Clear the current storage directory, preserving the directory itself.
         if self.storage.exists() {
             println!("Clearing storage directory: {}", self.storage.display());
             clear_dir(&self.storage)?;
         } else {
-            std::fs::create_dir_all(&self.storage)
-                .map_err(|e| anyhow!("Failed to create storage directory: {e}"))?;
+            std::fs::create_dir_all(&self.storage).map_err(|e| anyhow!("Failed to create storage directory: {e}"))?;
         }
 
         // Copy the snapshot into the storage directory.
@@ -65,12 +60,15 @@ impl Restore {
         println!("Restore complete.");
 
         if self.restart {
-            relaunch_as_start(&self.storage, self.private_key.as_deref(), &self.socket_addr, self.verbosity, self.manual_block_creation)?;
+            relaunch_as_start(
+                &self.storage,
+                self.private_key.as_deref(),
+                &self.socket_addr,
+                self.verbosity,
+                self.manual_block_creation,
+            )?;
         } else {
-            println!(
-                "Restart the devnode with:\n  aleo-devnode start --storage {}",
-                self.storage.display()
-            );
+            println!("Restart the devnode with:\n  aleo-devnode start --storage {}", self.storage.display());
         }
 
         Ok(())
@@ -130,10 +128,7 @@ fn relaunch_as_start(
 /// Returns the snapshots directory that sits alongside the given storage directory.
 /// e.g. `devnode` → `devnode-snapshots`
 pub(crate) fn snapshots_sibling_dir(storage: &Path) -> PathBuf {
-    let dir_name = format!(
-        "{}-snapshots",
-        storage.file_name().unwrap_or_default().to_string_lossy()
-    );
+    let dir_name = format!("{}-snapshots", storage.file_name().unwrap_or_default().to_string_lossy());
     let mut p = storage.to_path_buf();
     p.pop();
     p.join(dir_name)
@@ -144,11 +139,9 @@ fn clear_dir(dir: &Path) -> Result<()> {
         let entry = entry.map_err(|e| anyhow!("Failed to read entry: {e}"))?;
         let path = entry.path();
         if path.is_dir() {
-            std::fs::remove_dir_all(&path)
-                .map_err(|e| anyhow!("Failed to remove '{}': {e}", path.display()))?;
+            std::fs::remove_dir_all(&path).map_err(|e| anyhow!("Failed to remove '{}': {e}", path.display()))?;
         } else {
-            std::fs::remove_file(&path)
-                .map_err(|e| anyhow!("Failed to remove '{}': {e}", path.display()))?;
+            std::fs::remove_file(&path).map_err(|e| anyhow!("Failed to remove '{}': {e}", path.display()))?;
         }
     }
     Ok(())
@@ -163,8 +156,7 @@ fn copy_dir_all(src: &Path, dst: &Path) -> Result<()> {
         if src_path.is_dir() {
             copy_dir_all(&src_path, &dst_path)?;
         } else {
-            std::fs::copy(&src_path, &dst_path)
-                .map_err(|e| anyhow!("Failed to copy '{}': {e}", src_path.display()))?;
+            std::fs::copy(&src_path, &dst_path).map_err(|e| anyhow!("Failed to copy '{}': {e}", src_path.display()))?;
         }
     }
     Ok(())

src/start.rs

@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::logger::initialize_terminal_logger;
-use crate::rest::Rest;
+use crate::{logger::initialize_terminal_logger, rest::Rest};
 
 use anyhow::Result;
 use clap::Parser;
@@ -82,9 +81,10 @@ async fn start_devnode(command: Start, private_key: Option<String>) -> Result<()
         .map_err(|e| anyhow::anyhow!("Failed to parse listener address '{}': {}", command.socket_addr, e))?;
     // Load the genesis block.
     let genesis_block: Block<TestnetV0> = if command.genesis_path != "blank" {
-        Block::from_bytes_le(&std::fs::read(&command.genesis_path).map_err(|e| {
-            anyhow::anyhow!("Failed to read genesis block file '{}': {}", command.genesis_path, e)
-        })?)?
+        Block::from_bytes_le(
+            &std::fs::read(&command.genesis_path)
+                .map_err(|e| anyhow::anyhow!("Failed to read genesis block file '{}': {}", command.genesis_path, e))?,
+        )?
     } else {
         // This genesis block is stored in $TMPDIR when running snarkos start --dev 0 --dev-num-validators N
         Block::from_bytes_le(include_bytes!(concat!(
@@ -95,19 +95,17 @@ async fn start_devnode(command: Start, private_key: Option<String>) -> Result<()
     match command.storage {
         Some(path) => {
             if command.clear_storage && path.exists() {
-                for entry in std::fs::read_dir(&path)
-                    .map_err(|e| anyhow::anyhow!("Failed to read ledger directory: {e}"))?
+                for entry in
+                    std::fs::read_dir(&path).map_err(|e| anyhow::anyhow!("Failed to read ledger directory: {e}"))?
                 {
                     let entry = entry.map_err(|e| anyhow::anyhow!("Failed to read entry: {e}"))?;
                     let entry_path = entry.path();
                     if entry_path.is_dir() {
-                        std::fs::remove_dir_all(&entry_path).map_err(|e| {
-                            anyhow::anyhow!("Failed to remove '{}': {e}", entry_path.display())
-                        })?;
+                        std::fs::remove_dir_all(&entry_path)
+                            .map_err(|e| anyhow::anyhow!("Failed to remove '{}': {e}", entry_path.display()))?;
                     } else {
-                        std::fs::remove_file(&entry_path).map_err(|e| {
-                            anyhow::anyhow!("Failed to remove '{}': {e}", entry_path.display())
-                        })?;
+                        std::fs::remove_file(&entry_path)
+                            .map_err(|e| anyhow::anyhow!("Failed to remove '{}': {e}", entry_path.display()))?;
                     }
                 }
                 println!("Cleaned ledger directory: {}", path.display());
@@ -173,10 +171,7 @@ async fn run_devnode<C: 'static + ConsensusStorage<TestnetV0>>(
 
 fn resolve_private_key(private_key: &Option<String>) -> Result<PrivateKey<TestnetV0>> {
     match private_key {
-        Some(pk) => {
-            Ok(PrivateKey::<TestnetV0>::from_str(pk)
-                .map_err(|e| anyhow::anyhow!("Invalid private key: {e}"))?)
-        }
+        Some(pk) => Ok(PrivateKey::<TestnetV0>::from_str(pk).map_err(|e| anyhow::anyhow!("Invalid private key: {e}"))?),
         None => {
             let pk = std::env::var("PRIVATE_KEY").map_err(|e| {
                 anyhow::anyhow!(
@@ -187,8 +182,7 @@ Please either:
 2. Set the PRIVATE_KEY environment variable"
                 )
             })?;
-            Ok(PrivateKey::<TestnetV0>::from_str(&pk)
-                .map_err(|e| anyhow::anyhow!("Invalid private key: {e}"))?)
+            Ok(PrivateKey::<TestnetV0>::from_str(&pk).map_err(|e| anyhow::anyhow!("Invalid private key: {e}"))?)
         }
     }
 }

tests/integration.rs

@@ -3,10 +3,12 @@
 // Each test spawns the binary directly, mirroring the shell-based devnode tests
 // in the leo repo (tests/tests/cli/test_devnode*, leo_devnode_missing_private_key).
 
-use std::path::Path;
-use std::process::{Child, Command, Stdio};
-use std::sync::atomic::{AtomicU16, Ordering};
-use std::time::{Duration, Instant};
+use std::{
+    path::Path,
+    process::{Child, Command, Stdio},
+    sync::atomic::{AtomicU16, Ordering},
+    time::{Duration, Instant},
+};
 
 const PRIVATE_KEY: &str = "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH";
 const DEVNODE_BIN: &str = env!("CARGO_BIN_EXE_aleo-devnode");