Merge pull request #67 from xqcxx/feat/multisig-gas-plugins-testing

Add multisig, gas analyzer, plugin registry, and contract test command

Author: Nanle-code

Cargo.lock

@@ -36,6 +36,7 @@ libloading = "0.8.1"
 uuid = { version = "1.6.1", features = ["v4"] }
 hidapi = { version = "2.6.5", optional = true }
 hex = "0.4.3"
+sha2 = "0.10"
 
 [features]
 hardware-wallet = ["dep:hidapi"]

Cargo.toml

@@ -0,0 +1,83 @@
+use crate::utils::{config, optimizer, print as p, profiler};
+use anyhow::Result;
+use clap::Subcommand;
+use std::path::PathBuf;
+
+#[derive(Subcommand)]
+pub enum GasCommands {
+    /// Analyze a compiled Soroban contract for gas/cpu opportunities
+    Analyze {
+        /// Path to the compiled wasm
+        wasm: PathBuf,
+        /// Network context (used for fee heuristics)
+        #[arg(long)]
+        network: Option<String>,
+    },
+    /// Emit an "optimized" wasm (lightweight, heuristic-based)
+    Optimize {
+        /// Path to the input wasm
+        #[arg(long)]
+        target: PathBuf,
+        /// Output path for optimized wasm
+        #[arg(long)]
+        output: PathBuf,
+    },
+}
+
+pub fn handle(cmd: GasCommands) -> Result<()> {
+    match cmd {
+        GasCommands::Analyze { wasm, network } => analyze(wasm, network),
+        GasCommands::Optimize { target, output } => optimize(target, output),
+    }
+}
+
+fn analyze(wasm: PathBuf, network: Option<String>) -> Result<()> {
+    config::validate_file_path(&wasm, Some("wasm"))?;
+
+    let cfg = config::load()?;
+    let network = network.unwrap_or(cfg.network);
+    config::validate_network(&network)?;
+
+    p::header("Gas Analyzer");
+    p::kv("Network", &network);
+    p::kv("Wasm", &wasm.display().to_string());
+
+    let t = profiler::Timer::start();
+    let report = optimizer::analyze_wasm(&wasm)?;
+    let elapsed = t.elapsed();
+
+    println!();
+    p::separator();
+    p::kv_accent("Size (bytes)", &report.size_bytes.to_string());
+    p::kv("SHA256", &report.sha256);
+    p::kv("Heuristic score", &report.score.to_string());
+    if !report.suggestions.is_empty() {
+        println!();
+        p::info("Suggestions:");
+        for s in &report.suggestions {
+            println!("  - {}", s);
+        }
+    }
+    p::separator();
+    p::kv("Duration", &format!("{:?}", elapsed));
+    Ok(())
+}
+
+fn optimize(target: PathBuf, output: PathBuf) -> Result<()> {
+    config::validate_file_path(&target, Some("wasm"))?;
+
+    p::header("Gas Optimizer");
+    p::kv("Input", &target.display().to_string());
+    p::kv("Output", &output.display().to_string());
+
+    let t = profiler::Timer::start();
+    let result = optimizer::optimize_wasm(&target, &output)?;
+    let elapsed = t.elapsed();
+
+    println!();
+    p::success("Optimization output written");
+    p::kv("Bytes in", &result.input_size_bytes.to_string());
+    p::kv("Bytes out", &result.output_size_bytes.to_string());
+    p::kv("Duration", &format!("{:?}", elapsed));
+    Ok(())
+}

src/commands/gas.rs

@@ -1,12 +1,15 @@
 pub mod completions;
 pub mod contract;
 pub mod deploy;
+pub mod gas;
 pub mod info;
 pub mod invoke;
 pub mod monitor;
 pub mod network;
 pub mod new;
+pub mod plugin;
 pub mod shell;
+pub mod test;
 pub mod tx;
 pub mod wallet;
 pub mod tutorial;

src/commands/mod.rs

@@ -0,0 +1,92 @@
+use crate::plugins::{registry, PluginManager};
+use crate::utils::print as p;
+use anyhow::{Context, Result};
+use clap::Subcommand;
+use std::path::PathBuf;
+
+#[derive(Subcommand)]
+pub enum PluginCommands {
+    /// Register a plugin shared library for StarForge to load
+    Install {
+        /// Plugin name (used as the command name)
+        name: String,
+        /// Path to the plugin shared library (.so/.dylib/.dll)
+        #[arg(long)]
+        path: Option<PathBuf>,
+    },
+    /// List installed plugins from the local registry
+    List,
+    /// Load installed plugins and show those successfully loaded
+    Load,
+}
+
+pub fn handle(cmd: PluginCommands) -> Result<()> {
+    match cmd {
+        PluginCommands::Install { name, path } => install(name, path),
+        PluginCommands::List => list(),
+        PluginCommands::Load => load(),
+    }
+}
+
+fn install(name: String, path: Option<PathBuf>) -> Result<()> {
+    let lib_path = registry::resolve_plugin_library_path(&name, path)?;
+    registry::install_plugin(&name, &lib_path)?;
+
+    p::header("Plugin Install");
+    p::success("Plugin registered");
+    p::kv_accent("Name", &name);
+    p::kv("Library", &lib_path.display().to_string());
+    p::info("Load plugins with: starforge plugin load");
+    Ok(())
+}
+
+fn list() -> Result<()> {
+    p::header("Installed Plugins");
+    let reg = registry::load_registry().unwrap_or_default();
+    if reg.plugins.is_empty() {
+        p::info("No plugins installed. Use: starforge plugin install <name> --path <lib>");
+        return Ok(());
+    }
+
+    p::separator();
+    for (i, pl) in reg.plugins.iter().enumerate() {
+        println!("  {:>2}. {}", i + 1, pl.name);
+        p::kv("Path", &pl.path);
+        if i < reg.plugins.len() - 1 {
+            println!();
+        }
+    }
+    p::separator();
+    Ok(())
+}
+
+fn load() -> Result<()> {
+    p::header("Plugin Loader");
+
+    let reg = registry::load_registry().unwrap_or_default();
+    if reg.plugins.is_empty() {
+        p::info("No plugins installed. Use: starforge plugin install <name> --path <lib>");
+        return Ok(());
+    }
+
+    let mut pm = PluginManager::new();
+    for pl in &reg.plugins {
+        unsafe {
+            pm.load_plugin(&pl.path)
+                .with_context(|| format!("Failed to load plugin '{}' from {}", pl.name, pl.path))?;
+        }
+    }
+
+    let loaded = pm.list_plugins();
+    if loaded.is_empty() {
+        p::warn("No plugins loaded.");
+        return Ok(());
+    }
+
+    p::separator();
+    for (name, desc) in loaded {
+        p::kv_accent(name, desc);
+    }
+    p::separator();
+    Ok(())
+}

src/commands/plugin.rs

@@ -0,0 +1,54 @@
+use crate::utils::{config, print as p, test_runner};
+use anyhow::Result;
+use clap::Args;
+use std::path::PathBuf;
+
+#[derive(Args)]
+pub struct TestArgs {
+    /// Path to the compiled wasm
+    #[arg(long)]
+    pub wasm: PathBuf,
+
+    /// Collect a lightweight coverage report (heuristic)
+    #[arg(long, default_value = "false")]
+    pub coverage: bool,
+
+    /// Output report format (e.g. html, json)
+    #[arg(long)]
+    pub report: Option<String>,
+}
+
+pub fn handle(args: TestArgs) -> Result<()> {
+    config::validate_file_path(&args.wasm, Some("wasm"))?;
+
+    p::header("Contract Test Runner");
+    p::kv("Wasm", &args.wasm.display().to_string());
+    p::kv("Coverage", if args.coverage { "yes" } else { "no" });
+    if let Some(r) = &args.report {
+        p::kv("Report", r);
+    }
+
+    let result = test_runner::run_contract_tests(&args.wasm, test_runner::TestOptions {
+        coverage: args.coverage,
+        report_format: args.report.clone(),
+    })?;
+
+    println!();
+    p::separator();
+    p::kv_accent("SHA256", &result.sha256);
+    p::kv("Wasm bytes", &result.size_bytes.to_string());
+    p::kv("Cases executed", &result.cases_executed.to_string());
+    p::kv("Failures", &result.failures.to_string());
+    if let Some(path) = &result.report_path {
+        p::kv("Report path", &path.display().to_string());
+    }
+    p::separator();
+
+    if result.failures > 0 {
+        anyhow::bail!("Some contract tests failed");
+    }
+
+    p::success("All contract tests passed");
+    Ok(())
+}
+