feat: add the execute path to the Prover trait and sp1 prover

Author: Sahilgill24

crates/prover/core/src/lib.rs

@@ -38,6 +38,9 @@ pub trait StfProver {
 
     /// Verify a proof and return the public values it commits to.
     async fn verify(&self, proof: &Proof) -> Result<StfPublicValues, ProverError>;
+
+    /// Execute the guest program, without generating the proof.
+    async fn execute(&self, input: &StfInput) -> Result<StfPublicValues, ProverError>;
 }
 
 /// Errors raised while proving or verifying a state transition.
@@ -52,4 +55,7 @@ pub enum ProverError {
     /// A proof or its public values could not be (de)serialized.
     #[error("proof (de)serialization failed: {0}")]
     Serialization(String),
+    /// The execution of the guest program failed.
+    #[error("execution failed: {0}")]
+    Execute(String),
 }

crates/prover/sp1/Cargo.toml

@@ -18,3 +18,9 @@ bincode = "1.3"
 
 [build-dependencies]
 sp1-build = "6.3.1"
+
+[dev-dependencies]
+# Build valid `(state, block)` inputs for tests and cross-check the guest's
+# committed roots against a host-side run of the same transition.
+ethlambda-state-transition = { path = "../../blockchain/state_transition" }
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

crates/prover/sp1/build.rs

@@ -1,5 +1,14 @@
+use sp1_build::{BuildArgs, build_program_with_args};
+
 fn main() {
     // Compile the RISC-V guest program so `include_elf!("zkvm_guest_sp1")` can
     // embed its ELF. Path is relative to this crate's manifest directory.
-    sp1_build::build_program("../../guest-program/sp1");
+    //
+    // `ignore_rust_version` removes the compatibility issues with the toolchain
+    // being used for ethlambda and the sp1 toolchain
+    let args = BuildArgs {
+        ignore_rust_version: true,
+        ..Default::default()
+    };
+    build_program_with_args("../../guest-program/sp1", args);
 }

crates/prover/sp1/src/lib.rs

@@ -1,11 +1,10 @@
 use ethlambda_prover_core::{Proof, ProverError, StfInput, StfProver, StfPublicValues};
 use sp1_sdk::{
-    MockProver, Prover, SP1ProofWithPublicValues, SP1ProvingKey, SP1Stdin, SP1VerifyingKey,
-    include_elf,
+    Elf, MockProver, ProveRequest, Prover, ProvingKey, SP1ProofWithPublicValues, SP1ProvingKey,
+    SP1Stdin, SP1VerifyingKey, include_elf,
 };
 
-
-const STATE_TRANSITION_ELF: &[u8] = include_elf!("zkvm_guest_sp1");
+const STATE_TRANSITION_ELF: Elf = include_elf!("zkvm_guest_sp1");
 const CYCLE_LIMIT: u64 = 10_000_000;
 
 /// SP1 prover: proves the STF guest and verifies its proofs.
@@ -25,7 +24,13 @@ impl Sp1Prover {
     pub async fn new() -> Self {
         let client = MockProver::new().await;
         // let client = ProverClient::builder().cpu().await;
-        let (pk, vk) = client.setup(STATE_TRANSITION_ELF).await;
+        // `setup` returns only the proving key (fallible); the verifying key is
+        // derived from it.
+        let pk = client
+            .setup(STATE_TRANSITION_ELF)
+            .await
+            .expect("failed to set up SP1 proving key");
+        let vk = pk.verifying_key().clone();
         Self { client, pk, vk }
     }
 }
@@ -56,12 +61,29 @@ impl StfProver for Sp1Prover {
         let mut sp1_proof: SP1ProofWithPublicValues = bincode::deserialize(proof.as_bytes())
             .map_err(|err| ProverError::Serialization(err.to_string()))?;
 
+        // `verify` is synchronous in this SDK and takes an optional status code.
         self.client
-            .verify(&sp1_proof, &self.vk)
-            .await
+            .verify(&sp1_proof, &self.vk, None)
             .map_err(|err| ProverError::Verify(err.to_string()))?;
 
         // The guest committed `StfPublicValues` via `io::commit`; read it back.
         Ok(sp1_proof.public_values.read::<StfPublicValues>())
     }
+
+    async fn execute(&self, input: &StfInput) -> Result<StfPublicValues, ProverError> {
+        let mut stdin = SP1Stdin::new();
+        stdin.write(input);
+
+        // Runs the guest in the SP1 executor without proving; the future yields
+        // `(SP1PublicValues, ExecutionReport)`. We ignore the report for now.
+        let (mut public_values, _report) = self
+            .client
+            .execute(STATE_TRANSITION_ELF, stdin)
+            .cycle_limit(CYCLE_LIMIT)
+            .await
+            .map_err(|err| ProverError::Execute(err.to_string()))?;
+
+        // The guest committed `StfPublicValues` via `io::commit`; read it back.
+        Ok(public_values.read::<StfPublicValues>())
+    }
 }