Merge branch 'dev' of github.com:succinctlabs/sp1 into dev

Author: yuwen01

crates/build/src/lib.rs

@@ -8,7 +8,7 @@ pub use build::{execute_build_program, generate_elf_paths};
 pub use command::TOOLCHAIN_NAME;
 
 use clap::{Parser, ValueEnum};
-use sp1_prover::{components::CpuProverComponents, HashableKey, SP1Prover};
+use sp1_prover::{components::CpuProverComponents, HashableKey, SP1Prover, SP1VerifyingKey};
 
 const DEFAULT_DOCKER_TAG: &str = concat!("v", env!("CARGO_PKG_VERSION"));
 const BUILD_TARGET: &str = "riscv32im-succinct-zkvm-elf";
@@ -156,7 +156,7 @@ pub fn build_program_with_args(path: &str, args: BuildArgs) {
 ///
 /// Note: If used in a script `build.rs`, this function should be called *after* [`build_program`]
 /// to returns the vkey corresponding to the latest program version which has just been compiled.
-pub fn vkey(path: &str, target_name: &str) -> String {
+pub fn verifying_key(path: &str, target_name: &str) -> SP1VerifyingKey {
     let program_dir = std::path::Path::new(path);
     let metadata_file = program_dir.join("Cargo.toml");
     let mut metadata_cmd = cargo_metadata::MetadataCommand::new();
@@ -171,6 +171,20 @@ pub fn vkey(path: &str, target_name: &str) -> String {
 
     file.read_to_end(&mut elf).unwrap();
     let (_, _, _, vk) = prover.setup(&elf);
+    vk
+}
+
+/// Returns the verification key hash for the provided program.
+///
+/// # Arguments
+///
+/// * `path` - A string slice that holds the path to the program directory.
+/// * `target_name` - A string slice that holds the binary target.
+///
+/// Note: If used in a script `build.rs`, this function should be called *after* [`build_program`]
+/// to returns the vkey corresponding to the latest program version which has just been compiled.
+pub fn vkey(path: &str, target_name: &str) -> String {
+    let vk = verifying_key(path, target_name);
     vk.bytes32()
 }
 

crates/sdk/src/network/prove.rs

@@ -7,7 +7,7 @@ use std::time::Duration;
 use alloy_primitives::{Address, B256};
 use anyhow::Result;
 use sp1_core_machine::io::SP1Stdin;
-use sp1_prover::SP1ProvingKey;
+use sp1_prover::SP1VerifyingKey;
 
 use crate::{
     utils::{block_on, sp1_dump},
@@ -25,7 +25,8 @@ use std::{
 pub struct NetworkProveBuilder<'a> {
     pub(crate) prover: &'a NetworkProver,
     pub(crate) mode: SP1ProofMode,
-    pub(crate) pk: &'a SP1ProvingKey,
+    pub(crate) vk: &'a SP1VerifyingKey,
+    pub(crate) elf: &'a [u8],
     pub(crate) stdin: SP1Stdin,
     pub(crate) timeout: Option<Duration>,
     pub(crate) strategy: FulfillmentStrategy,
@@ -590,7 +591,8 @@ impl NetworkProveBuilder<'_> {
     pub async fn request_async(self) -> Result<B256> {
         self.prover
             .request_proof_impl(
-                self.pk,
+                self.vk,
+                self.elf,
                 &self.stdin,
                 self.mode,
                 self.strategy,
@@ -659,11 +661,12 @@ impl NetworkProveBuilder<'_> {
             self.skip_simulation = matches!(val.to_lowercase().as_str(), "true" | "1");
         }
 
-        sp1_dump(&self.pk.elf, &self.stdin);
+        sp1_dump(self.elf, &self.stdin);
 
         self.prover
             .prove_impl(
-                self.pk,
+                self.vk,
+                self.elf,
                 &self.stdin,
                 self.mode,
                 self.strategy,

crates/sdk/src/network/prover.rs

@@ -167,7 +167,60 @@ impl NetworkProver {
         NetworkProveBuilder {
             prover: self,
             mode: SP1ProofMode::Core,
-            pk,
+            vk: &pk.vk,
+            elf: &pk.elf,
+            stdin: stdin.clone(),
+            timeout: None,
+            strategy: self.default_fulfillment_strategy(),
+            skip_simulation: false,
+            cycle_limit: None,
+            gas_limit: None,
+            tee_2fa: false,
+            min_auction_period: 1,
+            whitelist: None,
+            auctioneer: None,
+            executor: None,
+            verifier: None,
+            treasury: None,
+            max_price_per_pgu: None,
+            auction_timeout: None,
+        }
+    }
+
+    /// A request to generate a proof for a given verifying key, ELF and input.
+    ///
+    /// This allow to send proof requests to the network without having to run
+    /// `setup()`. You just need the verifying key that is cheap to
+    /// deserialize.
+    ///
+    /// # Details
+    /// * `vk`: The verifying key to use for the proof.
+    /// * `elf`: The ELF to use for the proof.
+    /// * `stdin`: The input to use for the proof.
+    ///
+    /// # Example
+    /// ```rust,no_run
+    /// use sp1_sdk::{Prover, ProverClient, SP1Stdin};
+    ///
+    /// let elf = &[1, 2, 3];
+    /// let vk_bytes = &[4, 5, 6];
+    /// let stdin = SP1Stdin::new();
+    ///
+    /// let client = ProverClient::builder().network().build();
+    /// let vk = bincode::deserialize(vk_bytes).unwrap();
+    /// let proof = client.prove_from_vk(&vk, elf, &stdin).run();
+    /// ```
+    pub fn prove_from_vk<'a>(
+        &'a self,
+        vk: &'a SP1VerifyingKey,
+        elf: &'a [u8],
+        stdin: &'a SP1Stdin,
+    ) -> NetworkProveBuilder<'a> {
+        NetworkProveBuilder {
+            prover: self,
+            mode: SP1ProofMode::Core,
+            vk,
+            elf,
             stdin: stdin.clone(),
             timeout: None,
             strategy: self.default_fulfillment_strategy(),
@@ -555,7 +608,8 @@ impl NetworkProver {
     #[allow(clippy::too_many_arguments)]
     pub(crate) async fn request_proof_impl(
         &self,
-        pk: &SP1ProvingKey,
+        vk: &SP1VerifyingKey,
+        elf: &[u8],
         stdin: &SP1Stdin,
         mode: SP1ProofMode,
         strategy: FulfillmentStrategy,
@@ -571,9 +625,9 @@ impl NetworkProver {
         treasury: Option<Address>,
         max_price_per_pgu: Option<u64>,
     ) -> Result<B256> {
-        let vk_hash = self.register_program(&pk.vk, &pk.elf).await?;
+        let vk_hash = self.register_program(vk, elf).await?;
         let (cycle_limit, gas_limit, public_values_hash) =
-            self.get_execution_limits(cycle_limit, gas_limit, &pk.elf, stdin, skip_simulation)?;
+            self.get_execution_limits(cycle_limit, gas_limit, elf, stdin, skip_simulation)?;
         let (auctioneer, executor, verifier, treasury, max_price_per_pgu, base_fee, domain) = self
             .get_auction_request_params(
                 mode,
@@ -610,7 +664,8 @@ impl NetworkProver {
     #[allow(clippy::too_many_arguments)]
     pub(crate) async fn prove_impl(
         &self,
-        pk: &SP1ProvingKey,
+        vk: &SP1VerifyingKey,
+        elf: &[u8],
         stdin: &SP1Stdin,
         mode: SP1ProofMode,
         strategy: FulfillmentStrategy,
@@ -636,7 +691,8 @@ impl NetworkProver {
         loop {
             let request_id = self
                 .request_proof_impl(
-                    pk,
+                    vk,
+                    elf,
                     stdin,
                     mode,
                     strategy,
@@ -660,7 +716,7 @@ impl NetworkProver {
                 let request = super::tee::api::TEERequest::new(
                     &self.client.signer,
                     *request_id,
-                    pk.elf.clone(),
+                    elf.to_vec(),
                     stdin.clone(),
                     cycle_limit.unwrap_or_else(|| {
                         super::utils::get_default_cycle_limit_for_mode(self.network_mode)
@@ -899,7 +955,8 @@ impl Prover<CpuProverComponents> for NetworkProver {
         mode: SP1ProofMode,
     ) -> Result<SP1ProofWithPublicValues> {
         block_on(self.prove_impl(
-            pk,
+            &pk.vk,
+            &pk.elf,
             stdin,
             mode,
             self.default_fulfillment_strategy(),