feat: add simulation function

sdk/src/lib.rs

@@ -370,6 +370,32 @@ impl ProverClient {
     pub fn verify_plonk(&self, proof: &SP1PlonkBn254Proof, vkey: &SP1VerifyingKey) -> Result<()> {
         self.prover.verify_plonk(proof, vkey)
     }
+
+    /// Simulates the execution of a program with the given input, and return the number of cycles.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// use sp1_sdk::{ProverClient, SP1Stdin};
+    ///
+    /// // Load the program.
+    /// let elf = include_bytes!("../../examples/fibonacci/program/elf/riscv32im-succinct-zkvm-elf");
+    ///
+    /// // Initialize the prover client.
+    /// let client = ProverClient::new();
+    ///
+    /// // Setup the program.
+    /// let (pk, vk) = client.setup(elf);
+    ///
+    /// // Setup the inputs.
+    /// let mut stdin = SP1Stdin::new();
+    /// stdin.write(&10usize);
+    ///
+    /// // Simulate the execution of the program.
+    /// let cycles = client.simulate(elf, stdin).unwrap();
+    /// ```
+    pub fn simulate(&self, elf: &[u8], stdin: SP1Stdin) -> Result<u64> {
+        self.prover.simulate(elf, stdin)
+    }
 }
 
 impl Default for ProverClient {
@@ -450,4 +476,15 @@ mod tests {
         let proof = client.prove_plonk(&pk, stdin).unwrap();
         client.verify_plonk(&proof, &vk).unwrap();
     }
+
+    #[test]
+    fn test_simulate() {
+        utils::setup_logger();
+        let client = ProverClient::local();
+        let elf =
+            include_bytes!("../../examples/fibonacci/program/elf/riscv32im-succinct-zkvm-elf");
+        let mut stdin = SP1Stdin::new();
+        stdin.write(&10usize);
+        let _ = client.simulate(elf, stdin).unwrap();
+    }
 }

sdk/src/provers/mod.rs

@@ -7,7 +7,9 @@ use anyhow::Result;
 pub use local::LocalProver;
 pub use mock::MockProver;
 pub use network::NetworkProver;
+use sp1_core::runtime::{Program, Runtime};
 use sp1_core::stark::MachineVerificationError;
+use sp1_core::utils::SP1CoreOpts;
 use sp1_prover::CoreSC;
 use sp1_prover::SP1CoreProofData;
 use sp1_prover::SP1Prover;
@@ -72,4 +74,27 @@ pub trait Prover: Send + Sync {
 
         Ok(())
     }
+
+    // Simulates the execution of a program with the given input, and return the number of cycles.
+    fn simulate(&self, elf: &[u8], stdin: SP1Stdin) -> Result<u64> {
+        let program = Program::from(elf);
+        let mut runtime = Runtime::new(program, SP1CoreOpts::default());
+
+        runtime.write_vecs(&stdin.buffer);
+        for (proof, vkey) in stdin.proofs.iter() {
+            runtime.write_proof(proof.clone(), vkey.clone());
+        }
+
+        match runtime.run_untraced() {
+            Ok(_) => {
+                let cycles = runtime.state.global_clk;
+                log::info!("Simulation complete, cycles: {}", cycles);
+                Ok(cycles)
+            }
+            Err(e) => {
+                log::error!("Failed to simulate program: {}", e);
+                Err(e.into())
+            }
+        }
+    }
 }

sdk/src/provers/network.rs

@@ -9,8 +9,6 @@ use crate::{
 use crate::{SP1CompressedProof, SP1PlonkBn254Proof, SP1Proof, SP1ProvingKey, SP1VerifyingKey};
 use anyhow::{Context, Result};
 use serde::de::DeserializeOwned;
-use sp1_core::runtime::{Program, Runtime};
-use sp1_core::utils::SP1CoreOpts;
 use sp1_prover::utils::block_on;
 use sp1_prover::{SP1Prover, SP1Stdin};
 use tokio::{runtime, time::sleep};
@@ -42,18 +40,6 @@ impl NetworkProver {
         mode: ProofMode,
     ) -> Result<P> {
         let client = &self.client;
-        // Execute the runtime before creating the proof request.
-        let program = Program::from(elf);
-        let opts = SP1CoreOpts::default();
-        let mut runtime = Runtime::new(program, opts);
-        runtime.write_vecs(&stdin.buffer);
-        for (proof, vkey) in stdin.proofs.iter() {
-            runtime.write_proof(proof.clone(), vkey.clone());
-        }
-        runtime
-            .run_untraced()
-            .context("Failed to execute program")?;
-        log::info!("Simulation complete, cycles: {}", runtime.state.global_clk);
 
         let proof_id = client.create_proof(elf, &stdin, mode).await?;
         log::info!("Created {}", proof_id);
@@ -164,14 +150,17 @@ impl Prover for NetworkProver {
     }
 
     fn prove(&self, pk: &SP1ProvingKey, stdin: SP1Stdin) -> Result<SP1Proof> {
+        let _ = self.simulate(&pk.elf, stdin.clone());
         block_on(self.prove_async(&pk.elf, stdin, ProofMode::Core))
     }
 
     fn prove_compressed(&self, pk: &SP1ProvingKey, stdin: SP1Stdin) -> Result<SP1CompressedProof> {
+        let _ = self.simulate(&pk.elf, stdin.clone());
         block_on(self.prove_async(&pk.elf, stdin, ProofMode::Compressed))
     }
 
     fn prove_plonk(&self, pk: &SP1ProvingKey, stdin: SP1Stdin) -> Result<SP1PlonkBn254Proof> {
+        let _ = self.simulate(&pk.elf, stdin.clone());
         block_on(self.prove_async(&pk.elf, stdin, ProofMode::Plonk))
     }
 }