Add SP1 hash-based signature benchmark (#14)

This PR adds an SP1 benchmark suite for hashed-based signature aggregation benchmark using the same structure as the risc0 benchmarks.

The `sp1/guest` crate contains the SP1 program that verifies the aggregated signature. 

The `sp1/host` crate contains the benchmark that generates the test, and drives the SP1 guest program.

Scripts `benchmark-sp1-{cpu, cuda}.sh` are added to run the benchmarks.

NB: The existing `benchmark-{cpu, coda}.sh` scripts are renamed to `benchmark-risc0-{cpu, cuda}.sh`.

Author: lockedloop

Cargo.toml

@@ -1,6 +1,13 @@
 [workspace]
 resolver = "2"
-members = ["crates/risc0/host", "crates/risc0/methods", "crates/shared", "crates/core"]
+members = [
+    "crates/shared",
+    "crates/core",
+    "crates/risc0/host",
+    "crates/risc0/methods",
+    "crates/sp1/host",
+    "crates/sp1/guest"
+]
 
 # Always optimize; building and running the guest takes much longer without optimization.
 [profile.dev]

benchmark-cpu.sh benchmark-risc0-cpu.shbenchmark-cpu.sh renamed to benchmark-risc0-cpu.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# SP1 XMSS Benchmark Script (CPU Only)
+# This script runs benchmarks without CUDA acceleration
+
+set -e
+
+echo "╔══════════════════════════════════════════════════════╗"
+echo "║       SP1 XMSS Aggregate Benchmark Suite (CPU)      ║"
+echo "╚══════════════════════════════════════════════════════╝"
+echo
+
+# Set environment variables for optimal SP1 performance
+export RUST_LOG=info
+
+echo "🔨 Building SP1 guest program..."
+cd crates/sp1/guest
+cargo prove build
+cd ../../..
+
+echo "📦 Building SP1 host..."
+cargo build --release -p sp1-host
+
+echo
+echo "💻 Running benchmarks on CPU..."
+echo "   Sample size: 10 iterations per benchmark"
+echo
+
+# Run the Criterion benchmark
+cargo bench -p sp1-host
+
+echo
+echo "📊 Benchmark results saved to:"
+echo "   target/criterion/index.html"
+echo
+echo "✅ Benchmark complete!"

benchmark-cuda.sh benchmark-risc0-cuda.shbenchmark-cuda.sh renamed to benchmark-risc0-cuda.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# SP1 XMSS Benchmark Script with CUDA Support
+# This script runs benchmarks with CUDA acceleration if available
+
+set -e
+
+echo "╔══════════════════════════════════════════════════════╗"
+echo "║      SP1 XMSS Aggregate Benchmark Suite (CUDA)      ║"
+echo "╚══════════════════════════════════════════════════════╝"
+echo
+
+# Check if CUDA is available
+if command -v nvidia-smi &> /dev/null; then
+    echo "✅ NVIDIA GPU detected:"
+    nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
+    echo
+else
+    echo "⚠️  No NVIDIA GPU detected. Will run on CPU."
+    echo
+fi
+
+# Set environment variables for optimal SP1 performance
+export RUST_LOG=info
+
+echo "🔨 Building SP1 guest program..."
+cd crates/sp1/guest
+cargo prove build
+cd ../../..
+
+echo "📦 Building SP1 host with CUDA support..."
+cargo build --release --features cuda -p sp1-host
+
+echo
+echo "🚀 Running benchmarks with CUDA acceleration..."
+echo "   Sample size: 10 iterations per benchmark"
+echo
+
+# Run the Criterion benchmark
+cargo bench --features cuda -p sp1-host
+
+echo
+echo "📊 Benchmark results saved to:"
+echo "   target/criterion/index.html"
+echo
+echo "✅ Benchmark complete!"

benchmark-sp1-cpu.sh

@@ -0,0 +1,9 @@
+[package]
+name = "sp1-guest"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sp1-zkvm = "4.0.0"
+leansig-core = { path = "../../core" }
+leansig-shared = { path = "../../shared" }

benchmark-sp1-cuda.sh

@@ -0,0 +1,33 @@
+#![no_main]
+sp1_zkvm::entrypoint!(main);
+
+use leansig_core::AggregatedVerifier;
+use leansig_shared::XmssTestData;
+
+pub fn main() {
+    // Read the test data containing both public inputs and aggregated signature
+    let test_data = sp1_zkvm::io::read::<XmssTestData>();
+    
+    // Extract the components
+    let public_inputs = test_data.public_inputs;
+    let aggregated_signature = test_data.aggregated_signature;
+
+    // Create the aggregated verifier with the validator roots
+    let verifier = AggregatedVerifier::new(
+        public_inputs.validator_roots.clone(),
+        public_inputs.spec.clone(),
+    );
+
+    // Verify the aggregated signature
+    let verification_result = verifier.verify(&public_inputs.message, &aggregated_signature);
+
+    // The verification must succeed, otherwise the proof generation will fail
+    assert!(verification_result, "XMSS signature verification failed");
+
+    // Commit the public inputs to the journal for the host to verify
+    // This ensures the proof is bound to specific inputs
+    sp1_zkvm::io::commit(&public_inputs);
+
+    // Optionally commit a success flag
+    sp1_zkvm::io::commit(&verification_result);
+}

crates/sp1/guest/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "sp1-host"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sp1-sdk = "4.0.0"
+leansig-shared = { path = "../../shared" }
+leansig-core = { path = "../../core" }
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+serde = "1.0"
+bincode = "1.3"
+rand = "0.9"
+
+[dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }
+leansig-shared = { path = "../../shared" }
+
+[[bench]]
+name = "xmss_benchmark"
+harness = false

crates/sp1/guest/src/main.rs

@@ -0,0 +1,194 @@
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
+use leansig_core::spec::{SPEC_1, SPEC_2, Spec};
+use sp1_sdk::{ProverClient, SP1Stdin, SP1ProofWithPublicValues};
+use leansig_shared::{create_test_data, XmssTestData};
+use std::time::{Duration, Instant};
+
+const ELF: &[u8] = include_bytes!("../../../../target/elf-compilation/riscv32im-succinct-zkvm-elf/release/sp1-guest");
+
+/// Configuration parameters for benchmarking
+struct BenchmarkConfig {
+    num_validators: usize,
+    tree_height: usize,
+    spec: Spec,
+}
+
+impl Default for BenchmarkConfig {
+    fn default() -> Self {
+        Self {
+            num_validators: 16,
+            tree_height: 13,
+            spec: SPEC_2,
+        }
+    }
+}
+
+impl BenchmarkConfig {
+    fn from_env() -> Self {
+        let mut config = Self::default();
+
+        if let Ok(val) = std::env::var("BENCH_VALIDATORS") {
+            if let Ok(n) = val.parse() {
+                config.num_validators = n;
+            }
+        }
+
+        if let Ok(val) = std::env::var("BENCH_TREE_HEIGHT") {
+            if let Ok(h) = val.parse() {
+                config.tree_height = h;
+            }
+        }
+
+        if let Ok(val) = std::env::var("BENCH_SPEC") {
+            config.spec = match val.as_str() {
+                "1" | "SPEC_1" => SPEC_1,
+                "2" | "SPEC_2" => SPEC_2,
+                _ => SPEC_2,
+            };
+        }
+
+        config
+    }
+}
+
+/// Job structure for benchmarking XMSS signatures with SP1
+struct Job {
+    test_data: XmssTestData,
+}
+
+impl Job {
+    fn new(config: BenchmarkConfig) -> Self {
+        // Create test data with specified parameters
+        let test_data = create_test_data(
+            config.num_validators,
+            config.spec.clone(),
+            config.tree_height,
+            10000,  // max_retries for nonce grinding
+            None,   // use default message [42; 32]
+            None,   // use default epoch 0
+        );
+
+        Self {
+            test_data,
+        }
+    }
+
+    /// Execute witness generation phase (SP1 setup + stdin preparation)
+    fn exec_compute(&self) -> (SP1Stdin, Duration) {
+        let start = Instant::now();
+        
+        let mut stdin = SP1Stdin::new();
+        stdin.write(&self.test_data);
+        
+        let elapsed = start.elapsed();
+
+        (stdin, elapsed)
+    }
+
+    /// Execute proving phase
+    fn prove_stdin(
+        &self,
+        stdin: &SP1Stdin,
+    ) -> (SP1ProofWithPublicValues, Duration) {
+        let client = ProverClient::from_env();
+        let (pk, _vk) = client.setup(ELF);
+        
+        let start = Instant::now();
+        let proof = client.prove(&pk, stdin).run().unwrap();
+        let elapsed = start.elapsed();
+        
+        (proof, elapsed)
+    }
+}
+
+/// Main benchmarking function
+fn xmss_benchmarks(c: &mut Criterion) {
+    let config = BenchmarkConfig::from_env();
+
+    println!("\n════════════════════════════════════════════════");
+    println!("SP1 XMSS Signature Benchmark Configuration:");
+    println!("  Validators: {}", config.num_validators);
+    println!(
+        "  Tree Height: {} (max {} signatures)",
+        config.tree_height,
+        1 << config.tree_height
+    );
+    println!(
+        "  Spec: {}",
+        if config.spec.target_sum == SPEC_1.target_sum {
+            "SPEC_1"
+        } else {
+            "SPEC_2"
+        }
+    );
+    println!("════════════════════════════════════════════════\n");
+
+    let mut group = c.benchmark_group("sp1_xmss_signature");
+
+    // Configure the benchmark group
+    group.sample_size(10);
+    group.measurement_time(Duration::from_secs(10));
+
+    let job = Job::new(config);
+
+    // Benchmark 1: Witness Generation (setup + stdin preparation)
+    group.bench_function("witness_generation", |b| {
+        b.iter(|| {
+            let (stdin, _duration) = job.exec_compute();
+            black_box(stdin);
+        });
+    });
+
+    // Pre-compute stdin for proving/verification benchmarks
+    let (stdin, _) = job.exec_compute();
+
+    // Reset group configuration for proof generation
+    group.finish();
+
+    // Create new group for proof generation benchmarks
+    let mut group = c.benchmark_group("sp1_xmss_signature_proving");
+    group.sample_size(10);
+
+    // Benchmark 2: Proof Generation
+    group.bench_function("proof_generation", |b| {
+        b.iter(|| {
+            // We need to recreate stdin for each iteration since it gets consumed
+            let mut fresh_stdin = SP1Stdin::new();
+            fresh_stdin.write(&job.test_data);
+            
+            let (proof, _duration) = job.prove_stdin(&fresh_stdin);
+            black_box(proof);
+        });
+    });
+
+    // Generate proof for verification benchmark
+    let mut fresh_stdin = SP1Stdin::new();
+    fresh_stdin.write(&job.test_data);
+    let (proof, _) = job.prove_stdin(&fresh_stdin);
+
+    group.finish();
+
+    // Create new group for verification benchmarks
+    let mut group = c.benchmark_group("sp1_xmss_signature_verification");
+    group.sample_size(100); // Many samples for quick operation
+    group.measurement_time(Duration::from_secs(5));
+
+    group.bench_function("proof_verification", |b| {
+        let client = ProverClient::from_env();
+        let (_pk, vk) = client.setup(ELF);
+        
+        b.iter(|| {
+            client.verify(&proof, &vk).unwrap();
+        });
+    });
+
+    // Print additional metrics
+    println!("\nSP1 Additional Metrics:");
+    let proof_size_bytes = bincode::serialize(&proof).unwrap().len();
+    println!("  Proof Size: {:.2} KiB ({} bytes)", proof_size_bytes as f64 / 1024.0, proof_size_bytes);
+
+    group.finish();
+}
+
+criterion_group!(sp1_xmss_signature, xmss_benchmarks);
+criterion_main!(sp1_xmss_signature);