Replace EnvProver with NetworkProver

Plus: set skip_simulation(true) to save ~1minute of proving time.

Author: imikushin

src/cli/mod.rs

@@ -16,14 +16,14 @@ use crate::{
     utils,
     utils::{BoxedSP1Prover, Shared},
 };
-use bitcoin::{address::NetworkUnchecked, Address};
+use bitcoin::{Address, address::NetworkUnchecked};
 use charms_app_runner::AppRunner;
 use clap::{Args, CommandFactory, Parser, Subcommand};
-use clap_complete::{generate, Shell};
+use clap_complete::{Shell, generate};
 #[cfg(not(feature = "prover"))]
 use reqwest::Client;
 use serde::Serialize;
-use sp1_sdk::{install::try_install_circuit_artifacts, CpuProver, ProverClient};
+use sp1_sdk::{CpuProver, NetworkProver, ProverClient, install::try_install_circuit_artifacts};
 use std::{io, net::IpAddr, path::PathBuf, str::FromStr, sync::Arc};
 use utils::AsyncShared;
 
@@ -414,14 +414,14 @@ fn spell_sp1_client(app_sp1_client: &Arc<Shared<BoxedSP1Prover>>) -> Arc<Shared<
     let name = std::env::var("SPELL_SP1_PROVER").unwrap_or_default();
     match name.as_str() {
         "app" => app_sp1_client.clone(),
-        "env" | "" => Arc::new(Shared::new(sp1_env_client)),
-        _ => unreachable!("Only 'app' or 'env' are supported as SPELL_SP1_PROVER values"),
+        "network" => Arc::new(Shared::new(sp1_network_client)),
+        _ => unreachable!("Only 'app' or 'network' are supported as SPELL_SP1_PROVER values"),
     }
 }
 
 #[tracing::instrument(level = "info")]
 #[cfg(feature = "prover")]
-fn charms_sp1_cuda_client() -> utils::sp1::CudaProver {
+fn charms_sp1_cuda_prover() -> utils::sp1::CudaProver {
     utils::sp1::CudaProver::new(
         sp1_prover::SP1Prover::new(),
         SP1CudaProver::new(gpu_service_url()).unwrap(),
@@ -434,13 +434,18 @@ fn gpu_service_url() -> String {
 }
 
 #[tracing::instrument(level = "info")]
-pub fn sp1_cpu_client() -> CpuProver {
+pub fn sp1_cpu_prover() -> CpuProver {
     ProverClient::builder().cpu().build()
 }
 
-#[tracing::instrument(level = "debug")]
-fn sp1_env_client() -> BoxedSP1Prover {
-    sp1_named_env_client("env")
+#[tracing::instrument(level = "info")]
+pub fn sp1_network_prover() -> NetworkProver {
+    ProverClient::builder().network().build()
+}
+
+#[tracing::instrument(level = "info")]
+pub fn sp1_network_client() -> BoxedSP1Prover {
+    sp1_named_env_client("network")
 }
 
 #[tracing::instrument(level = "debug")]
@@ -452,9 +457,10 @@ fn sp1_named_env_client(name: &str) -> BoxedSP1Prover {
     };
     match name {
         #[cfg(feature = "prover")]
-        "cuda" => Box::new(charms_sp1_cuda_client()),
-        "cpu" => Box::new(sp1_cpu_client()),
-        _ => Box::new(ProverClient::from_env()),
+        "cuda" => Box::new(charms_sp1_cuda_prover()),
+        "cpu" => Box::new(sp1_cpu_prover()),
+        "network" => Box::new(sp1_network_prover()),
+        _ => unimplemented!("only 'cuda', 'cpu' and 'network' are supported as prover values"),
     }
 }
 

src/utils/prover.rs

@@ -1,6 +1,9 @@
 use sp1_core_machine::io::SP1Stdin;
-use sp1_prover::{components::CpuProverComponents, SP1ProvingKey, SP1VerifyingKey};
-use sp1_sdk::{CpuProver, EnvProver, Prover, SP1ProofMode, SP1ProofWithPublicValues};
+use sp1_prover::{SP1ProvingKey, SP1VerifyingKey, components::CpuProverComponents};
+use sp1_sdk::{
+    CpuProver, NetworkProver, Prover, SP1ProofMode, SP1ProofWithPublicValues,
+    network::FulfillmentStrategy,
+};
 
 pub trait CharmsSP1Prover: Send + Sync {
     fn setup(&self, elf: &[u8]) -> (SP1ProvingKey, SP1VerifyingKey);
@@ -29,7 +32,7 @@ impl CharmsSP1Prover for CpuProver {
     }
 }
 
-impl CharmsSP1Prover for EnvProver {
+impl CharmsSP1Prover for NetworkProver {
     fn setup(&self, elf: &[u8]) -> (SP1ProvingKey, SP1VerifyingKey) {
         let (pk, _, _, vk) = <Self as Prover<CpuProverComponents>>::inner(self).setup(elf);
         (pk, vk)
@@ -41,7 +44,13 @@ impl CharmsSP1Prover for EnvProver {
         stdin: &SP1Stdin,
         kind: SP1ProofMode,
     ) -> anyhow::Result<(SP1ProofWithPublicValues, u64)> {
-        let proof = self.prove(pk, stdin).mode(kind).run()?;
+        let proof = self
+            .prove(pk, stdin)
+            .mode(kind)
+            .cycle_limit(32000000)
+            .skip_simulation(true)
+            .strategy(FulfillmentStrategy::Hosted)
+            .run()?;
         Ok((proof, 0))
     }
 }