Merge pull request #60 from 0xVida/main

feat: add gas optimization checker

Author: Timi16

src/cli/args.rs

@@ -20,6 +20,9 @@ pub enum Commands {
 
     /// Inspect contract information without executing
     Inspect(InspectArgs),
+
+    /// Analyze contract and generate gas optimization suggestions
+    Optimize(OptimizeArgs),
 }
 
 #[derive(Parser)]
@@ -74,3 +77,26 @@ pub struct InspectArgs {
     #[arg(long)]
     pub metadata: bool,
 }
+
+#[derive(Parser)]
+pub struct OptimizeArgs {
+    /// Path to the contract WASM file
+    #[arg(short, long)]
+    pub contract: PathBuf,
+
+    /// Function name to analyze (can be specified multiple times)
+    #[arg(short, long)]
+    pub function: Vec<String>,
+
+    /// Function arguments as JSON array (e.g., '["arg1", "arg2"]')
+    #[arg(short, long)]
+    pub args: Option<String>,
+
+    /// Output file for the optimization report (default: stdout)
+    #[arg(short, long)]
+    pub output: Option<PathBuf>,
+
+    /// Initial storage state as JSON object
+    #[arg(short, long)]
+    pub storage: Option<String>,
+}

src/cli/commands.rs

@@ -1,4 +1,4 @@
-use crate::cli::args::{InspectArgs, InteractiveArgs, RunArgs};
+use crate::cli::args::{InspectArgs, InteractiveArgs, OptimizeArgs, RunArgs};
 use crate::debugger::engine::DebuggerEngine;
 use crate::runtime::executor::ContractExecutor;
 use crate::ui::tui::DebuggerUI;
@@ -125,3 +125,59 @@ fn parse_storage(json: &str) -> Result<String> {
         .with_context(|| format!("Invalid JSON storage: {}", json))?;
     Ok(json.to_string())
 }
+
+/// Execute the optimize command
+pub fn optimize(args: OptimizeArgs) -> Result<()> {
+    println!("Analyzing contract for gas optimization: {:?}", args.contract);
+
+    let wasm_bytes = fs::read(&args.contract)
+        .with_context(|| format!("Failed to read WASM file: {:?}", args.contract))?;
+
+    println!("Contract loaded successfully ({} bytes)", wasm_bytes.len());
+
+    let mut executor = ContractExecutor::new(wasm_bytes)?;
+
+    if let Some(storage_json) = &args.storage {
+        let storage = parse_storage(storage_json)?;
+        executor.set_initial_storage(storage)?;
+    }
+
+    let functions_to_analyze = if args.function.is_empty() {
+        println!("No functions specified, analyzing all exported functions...");
+        crate::utils::wasm::parse_functions(&wasm_bytes)?
+    } else {
+        args.function.clone()
+    };
+
+    let mut optimizer = crate::profiler::analyzer::GasOptimizer::new(executor);
+
+    println!("\nAnalyzing {} function(s)...", functions_to_analyze.len());
+
+    for function_name in &functions_to_analyze {
+        println!("  Analyzing function: {}", function_name);
+        match optimizer.analyze_function(function_name, args.args.as_deref()) {
+            Ok(profile) => {
+                println!("    CPU: {} instructions, Memory: {} bytes", 
+                    profile.total_cpu, profile.total_memory);
+            }
+            Err(e) => {
+                eprintln!("    Warning: Failed to analyze function {}: {}", function_name, e);
+            }
+        }
+    }
+
+    let contract_path_str = args.contract.to_string_lossy().to_string();
+    let report = optimizer.generate_report(&contract_path_str);
+
+    let markdown = optimizer.generate_markdown_report(&report);
+
+    if let Some(output_path) = &args.output {
+        fs::write(output_path, &markdown)
+            .with_context(|| format!("Failed to write report to: {:?}", output_path))?;
+        println!("\nOptimization report written to: {:?}", output_path);
+    } else {
+        println!("\n{}", markdown);
+    }
+
+    Ok(())
+}

src/cli/mod.rs

@@ -1,4 +1,4 @@
 pub mod args;
 pub mod commands;
 
-pub use args::{Cli, Commands, InspectArgs, InteractiveArgs, RunArgs};
+pub use args::{Cli, Commands, InspectArgs, InteractiveArgs, OptimizeArgs, RunArgs};

src/lib.rs

@@ -4,6 +4,7 @@ pub mod inspector;
 pub mod runtime;
 pub mod ui;
 pub mod utils;
+pub mod profiler;
 
 pub use debugger::engine::DebuggerEngine;
 pub use runtime::executor::ContractExecutor;

src/main.rs

@@ -27,6 +27,9 @@ fn main() -> Result<()> {
         Commands::Inspect(args) => {
             soroban_debugger::cli::commands::inspect(args)?;
         }
+        Commands::Optimize(args) => {
+            soroban_debugger::cli::commands::optimize(args)?;
+        }
     }
 
     Ok(())