Benchmarking

./benchmark
├── Cargo.lock
├── Cargo.tom
├── rust-toolchain.toml
└── src
    ├── main.rs
    └── guest
        ├── Cargo.toml
        ├── rust-toolchain.toml
        └── src
            └── main.rs

use nexus_sdk::{
    ByGuestCompilation, Local, Prover, Verifiable, Viewable,
    compile::{Compile, Compiler, cargo::CargoPackager},
    stwo::seq::Stwo,
};
use std::env;
use std::time::Instant;

const PACKAGE: &str = "guest";

fn main() {
    println!("=== Nexus zkVM Host Program Execution ===");

    let start_time = Instant::now();

    print!("1. Compiling guest program...");
    let compile_start = Instant::now();
    let mut prover_compiler = Compiler::<CargoPackager>::new(PACKAGE);
    let prover: Stwo<Local> =
        Stwo::compile(&mut prover_compiler).expect("failed to compile guest program");
    let compile_duration = compile_start.elapsed();
    println!(" {} ms", compile_duration.as_millis());

    let elf = prover.elf.clone(); // save elf for use with verification

    // Read public_input from environment variable, default to 10 if not set
    let public_input: u32 = env::var("PUBLIC_INPUT")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(10);

    // Read public_output from environment variable, default to 89 if not set
    let public_output: u128 = env::var("PUBLIC_OUTPUT")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(89);

    println!("Using public_input: {}", public_input);
    println!("Using public_output: {}", public_output);

    print!("\n2. Proving execution of VM...");
    let prove_start = Instant::now();
    let (view, proof) = prover
        .prove_with_input::<(), u32>(&(), &public_input)
        .expect("failed to prove program");
    let prove_duration = prove_start.elapsed();
    println!(" {} ms", prove_duration.as_millis());

    println!("\n3. Execution Logs:");
    println!("-------------------");
    match view.logs() {
        Ok(logs) => println!("{}", logs.join("")),
        Err(e) => eprintln!("Error: Failed to retrieve debug logs - {}", e),
    }
    println!("-------------------");

    match view.exit_code() {
        Ok(code) => {
            if code == nexus_sdk::KnownErrorCodes::ExitSuccess as u32 {
                println!(
                    "\n4. Execution completed successfully (Exit code: {})",
                    code
                );
            } else {
                eprintln!("\n4. Execution failed (Exit code: {})", code);
                return;
            }
        }
        Err(e) => {
            eprintln!("\nError: Failed to retrieve exit code - {}", e);
            return;
        }
    }

    print!("\n5. Verifying execution... ");
    let verify_start = Instant::now();
    proof
        .verify_expected::<u32, u128>(
            &public_input, // no public input
            nexus_sdk::KnownErrorCodes::ExitSuccess as u32,
            &public_output, // no public output
            &elf,           // expected elf (program binary)
            &[],            // no associated data,
        )
        .expect("failed to verify proof");
    let verify_duration = verify_start.elapsed();

    println!("Succeeded!");
    println!("   Verification time: {} ms", verify_duration.as_millis());
    println!("   Proofsize: {} bytes", proof.size_estimate());

    let total_duration = start_time.elapsed();
    println!("\n=== Execution and Verification Complete ===");
    println!("Total execution time: {} ms", total_duration.as_millis());
}

#![cfg_attr(target_arch = "riscv32", no_std, no_main)]
#[cfg(target_arch = "riscv32")]
use nexus_rt::println;
#[cfg(not(target_arch = "riscv32"))]
use std::println;

use core::ops::Add;

#[derive(Copy, Clone)]
struct BN([u128; 6]);

const ONE: BN = BN([1, 0, 0, 0, 0, 0]);

// carrying_add is unstable, so we define it here
fn adc(x: u128, y: u128, c: bool) -> (u128, bool) {
    let (z1, c1) = x.overflowing_add(y);
    let (z2, c2) = z1.overflowing_add(if c { 1 } else { 0 });
    (z2, c1 || c2)
}

impl Add for BN {
    type Output = BN;
    fn add(self, rhs: Self) -> Self::Output {
        let (a, o) = adc(self.0[0], rhs.0[0], false);
        let (b, o) = adc(self.0[1], rhs.0[1], o);
        let (c, o) = adc(self.0[2], rhs.0[2], o);
        let (d, o) = adc(self.0[3], rhs.0[3], o);
        let (e, o) = adc(self.0[4], rhs.0[4], o);
        let (f, _) = adc(self.0[5], rhs.0[5], o);
        Self([a, b, c, d, e, f])
    }
}

fn fib_iter(n: u32) -> BN {
    let mut a = ONE;
    let mut b = ONE;

    for n in 0..n + 1 {
        if n > 1 {
            let c = a + b;
            a = b;
            b = c;
        }
    }
    b
}

#[nexus_rt::main]
#[cfg_attr(target_arch = "riscv32", nexus_rt::public_input(x))]
fn main(x: u32) -> u128 {
    let b = fib_iter(x);

    // We print the result, this will show in the host program execution log.
    println!("{}", b.0[0]);
    b.0[0]
}

#!/bin/bash

# Arrays for input and output
public_inputs=(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
public_outputs=(1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765)

# Loop through the arrays
for i in "${!public_inputs[@]}"; do
    public_input="${public_inputs[$i]}"
    public_output="${public_outputs[$i]}"

    echo "Running with PUBLIC_INPUT=$public_input and PUBLIC_OUTPUT=$public_output"

    # Run the Rust program with environment variables set
    # Ensure the Rust program is built in release mode
    PUBLIC_INPUT=$public_input PUBLIC_OUTPUT=$public_output cargo run --release

    echo "----------------------------------------"
done