Fix trailing whitespace in audit_modular.rs

Co-authored-by: 0xrinegade <[email protected]>

Author: Copilot

benches/deployment_benchmarks.rs

@@ -1,7 +1,5 @@
-use criterion::{criterion_group, criterion_main, Criterion, BenchmarkId};
-use osvm::utils::ebpf_deploy::{
-    load_program, load_program_id, DeployConfig, RpcClientCache,
-};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use osvm::utils::ebpf_deploy::{load_program, load_program_id, DeployConfig, RpcClientCache};
 use std::fs::File;
 use std::io::Write;
 use std::time::{Duration, Instant};
@@ -10,65 +8,61 @@ use tempfile::tempdir;
 /// Benchmark program loading performance
 fn benchmark_load_program(c: &mut Criterion) {
     let dir = tempdir().unwrap();
-    
+
     // Create test programs of different sizes
     let sizes = vec![
-        ("small", 10_000),    // 10KB
-        ("medium", 100_000),  // 100KB  
-        ("large", 1_000_000), // 1MB
+        ("small", 10_000),     // 10KB
+        ("medium", 100_000),   // 100KB
+        ("large", 1_000_000),  // 1MB
         ("xlarge", 2_000_000), // 2MB
     ];
-    
+
     let mut group = c.benchmark_group("load_program");
-    
+
     for (name, size) in sizes {
         let program_path = dir.path().join(format!("program_{}.so", name));
         let program_data = vec![0u8; size];
         let mut file = File::create(&program_path).unwrap();
         file.write_all(&program_data).unwrap();
-        
+
         group.benchmark_with_input(
             BenchmarkId::new("load_program", name),
             &program_path.to_string_lossy().to_string(),
             |b, path| {
-                b.iter(|| {
-                    load_program(path).unwrap()
-                });
+                b.iter(|| load_program(path).unwrap());
             },
         );
     }
-    
+
     group.finish();
 }
 
 /// Benchmark program ID loading performance
 fn benchmark_load_program_id(c: &mut Criterion) {
     let dir = tempdir().unwrap();
     let program_id_file = dir.path().join("program_id.json");
-    
+
     // Create test program ID file
     let program_id_content = r#"{"programId": "HN4tEEGheziD9dqcWg4xZd29htcerjXKGoGiQXM5hxiS"}"#;
     let mut file = File::create(&program_id_file).unwrap();
     file.write_all(program_id_content.as_bytes()).unwrap();
-    
+
     c.bench_function("load_program_id", |b| {
-        b.iter(|| {
-            load_program_id(program_id_file.to_str().unwrap()).unwrap()
-        });
+        b.iter(|| load_program_id(program_id_file.to_str().unwrap()).unwrap());
     });
 }
 
 /// Benchmark RPC client cache performance
 fn benchmark_rpc_client_cache(c: &mut Criterion) {
     let mut group = c.benchmark_group("rpc_client_cache");
-    
+
     // Test cache performance with multiple URLs
     let urls = vec![
         "https://api.devnet.solana.com",
-        "https://api.testnet.solana.com", 
+        "https://api.testnet.solana.com",
         "https://api.mainnet-beta.solana.com",
     ];
-    
+
     group.bench_function("cache_miss", |b| {
         b.iter(|| {
             let mut cache = RpcClientCache::new();
@@ -77,40 +71,38 @@ fn benchmark_rpc_client_cache(c: &mut Criterion) {
             }
         });
     });
-    
+
     group.bench_function("cache_hit", |b| {
         let mut cache = RpcClientCache::new();
         // Pre-populate cache
         for url in &urls {
             cache.get_client(url);
         }
-        
+
         b.iter(|| {
             for url in &urls {
                 cache.get_client(url);
             }
         });
     });
-    
+
     group.finish();
 }
 
 /// Benchmark deployment configuration creation
 fn benchmark_deploy_config_creation(c: &mut Criterion) {
     c.bench_function("deploy_config_creation", |b| {
-        b.iter(|| {
-            DeployConfig {
-                binary_path: "program.so".to_string(),
-                program_id_path: "program_id.json".to_string(),
-                owner_path: "owner.json".to_string(),
-                fee_payer_path: "fee_payer.json".to_string(),
-                publish_idl: true,
-                idl_file_path: Some("idl.json".to_string()),
-                network_selection: "all".to_string(),
-                json_output: false,
-                retry_attempts: 3,
-                confirm_large_binaries: false,
-            }
+        b.iter(|| DeployConfig {
+            binary_path: "program.so".to_string(),
+            program_id_path: "program_id.json".to_string(),
+            owner_path: "owner.json".to_string(),
+            fee_payer_path: "fee_payer.json".to_string(),
+            publish_idl: true,
+            idl_file_path: Some("idl.json".to_string()),
+            network_selection: "all".to_string(),
+            json_output: false,
+            retry_attempts: 3,
+            confirm_large_binaries: false,
         });
     });
 }
@@ -119,7 +111,7 @@ fn benchmark_deploy_config_creation(c: &mut Criterion) {
 fn benchmark_json_operations(c: &mut Criterion) {
     use osvm::utils::ebpf_deploy::DeploymentResult;
     use solana_sdk::pubkey::Pubkey;
-    
+
     let result = DeploymentResult {
         network: "devnet".to_string(),
         program_id: Pubkey::new_unique(),
@@ -129,65 +121,61 @@ fn benchmark_json_operations(c: &mut Criterion) {
         retries_attempted: 3,
         duration_ms: 5000,
     };
-    
+
     let mut group = c.benchmark_group("json_operations");
-    
+
     group.bench_function("serialize", |b| {
-        b.iter(|| {
-            serde_json::to_string(&result).unwrap()
-        });
+        b.iter(|| serde_json::to_string(&result).unwrap());
     });
-    
+
     let json_str = serde_json::to_string(&result).unwrap();
     group.bench_function("deserialize", |b| {
         b.iter(|| {
             let _: DeploymentResult = serde_json::from_str(&json_str).unwrap();
         });
     });
-    
+
     group.finish();
 }
 
 /// Benchmark file operations for deployment
 fn benchmark_file_operations(c: &mut Criterion) {
     let dir = tempdir().unwrap();
-    
+
     // Create test files of various sizes
     let file_sizes = vec![1_000, 10_000, 100_000, 1_000_000];
     let mut test_files = Vec::new();
-    
+
     for size in file_sizes {
         let file_path = dir.path().join(format!("test_{}.dat", size));
         let data = vec![0u8; size];
         let mut file = File::create(&file_path).unwrap();
         file.write_all(&data).unwrap();
         test_files.push((size, file_path));
     }
-    
+
     let mut group = c.benchmark_group("file_operations");
-    
+
     for (size, file_path) in test_files {
         group.benchmark_with_input(
             BenchmarkId::new("read_file", size),
             &file_path,
             |b, path| {
-                b.iter(|| {
-                    std::fs::read(path).unwrap()
-                });
+                b.iter(|| std::fs::read(path).unwrap());
             },
         );
     }
-    
+
     group.finish();
 }
 
 /// Benchmark memory usage and allocation patterns
 fn benchmark_memory_allocation(c: &mut Criterion) {
     let mut group = c.benchmark_group("memory_allocation");
-    
+
     // Test vector allocation for different program sizes
     let sizes = vec![10_000, 100_000, 1_000_000, 5_000_000];
-    
+
     for size in sizes {
         group.benchmark_with_input(
             BenchmarkId::new("vec_allocation", size),
@@ -199,7 +187,7 @@ fn benchmark_memory_allocation(c: &mut Criterion) {
             },
         );
     }
-    
+
     group.finish();
 }
 
@@ -214,4 +202,4 @@ criterion_group!(
     benchmark_memory_allocation
 );
 
-criterion_main!(benches);
+criterion_main!(benches);

src/main.rs

@@ -32,23 +32,39 @@ pub mod utils;
 
 /// Check if a command is a known OSVM command
 fn is_known_command(sub_command: &str) -> bool {
-    matches!(sub_command, 
-        "balance" | "svm" | "nodes" | "examples" | "rpc-manager" | "deploy" | 
-        "solana" | "doctor" | "audit" | "new_feature_command" | "v" | "ver" | "version"
+    matches!(
+        sub_command,
+        "balance"
+            | "svm"
+            | "nodes"
+            | "examples"
+            | "rpc-manager"
+            | "deploy"
+            | "solana"
+            | "doctor"
+            | "audit"
+            | "new_feature_command"
+            | "v"
+            | "ver"
+            | "version"
     )
 }
 
 /// Handle AI query command
-async fn handle_ai_query(sub_command: &str, sub_matches: &clap::ArgMatches) -> Result<(), Box<dyn std::error::Error>> {
+async fn handle_ai_query(
+    sub_command: &str,
+    sub_matches: &clap::ArgMatches,
+) -> Result<(), Box<dyn std::error::Error>> {
     // For external subcommands, clap provides the additional arguments differently
     // We need to collect them from the raw args since clap doesn't know about them
     let args: Vec<String> = std::env::args().collect();
-    
+
     // Find where our subcommand starts and collect everything after osvm
     let mut query_parts = Vec::new();
     let mut found_osvm = false;
-    
-    for arg in args.iter().skip(1) { // Skip the binary name
+
+    for arg in args.iter().skip(1) {
+        // Skip the binary name
         if !found_osvm {
             found_osvm = true;
         }
@@ -57,12 +73,12 @@ async fn handle_ai_query(sub_command: &str, sub_matches: &clap::ArgMatches) -> R
             query_parts.push(arg.clone());
         }
     }
-    
+
     let query = query_parts.join(" ");
-    
+
     // Make AI request
     println!("🔍 Interpreting as AI query: \"{}\"", query);
-    
+
     let ai_service = crate::services::ai_service::AiService::new();
     match ai_service.query(&query).await {
         Ok(response) => {
@@ -74,7 +90,7 @@ async fn handle_ai_query(sub_command: &str, sub_matches: &clap::ArgMatches) -> R
             eprintln!("💡 Use 'osvm --help' to see available commands");
         }
     }
-    
+
     Ok(())
 }
 
@@ -178,14 +194,14 @@ async fn handle_audit_command(
 
     let no_commit = matches.get_flag("no-commit");
     let default_output_dir = matches.get_one::<String>("output").unwrap().to_string();
-    
+
     // If --no-commit is used and output directory is the default, use current directory
     let output_dir = if no_commit && default_output_dir == "audit_reports" {
         ".".to_string()
     } else {
         default_output_dir
     };
-    
+
     let format = matches.get_one::<String>("format").unwrap().to_string();
     let verbose = matches.get_count("verbose");
     let test_mode = matches.get_flag("test");