stuff compiles

crates/sdk/src/client.rs

@@ -1,8 +1,14 @@
 use crate::{
     local::{LocalProver, LocalProverBuilder},
     network::{NetworkProver, NetworkProverBuilder},
+    opts::ProofOpts,
+    proof::SP1ProofWithPublicValues,
     prover::Prover,
 };
+use anyhow::Result;
+use sp1_core_executor::ExecutionReport;
+use sp1_core_machine::io::SP1Stdin;
+use sp1_prover::{SP1ProvingKey, SP1VerifyingKey};
 use std::env;
 
 pub struct None;
@@ -24,6 +30,40 @@ impl ProverClient {
     pub fn new() -> Self {
         Self::builder().from_env()
     }
+
+    pub async fn setup(&self, elf: &[u8]) -> (SP1ProvingKey, SP1VerifyingKey) {
+        self.inner.setup(elf).await
+    }
+
+    pub async fn execute(&self, elf: &[u8], stdin: SP1Stdin) -> Result<ExecutionReport> {
+        self.inner.execute(elf, stdin).await
+    }
+
+    pub async fn prove(
+        &self,
+        pk: &SP1ProvingKey,
+        stdin: &SP1Stdin,
+    ) -> Result<SP1ProofWithPublicValues> {
+        let opts = ProofOpts::default();
+        self.inner.prove_with_options(pk, stdin, &opts).await
+    }
+
+    pub async fn prove_with_options(
+        &self,
+        pk: &SP1ProvingKey,
+        stdin: &SP1Stdin,
+        opts: &ProofOpts,
+    ) -> Result<SP1ProofWithPublicValues> {
+        self.inner.prove_with_options(pk, stdin, opts).await
+    }
+
+    pub async fn verify(
+        &self,
+        proof: &SP1ProofWithPublicValues,
+        vk: &SP1VerifyingKey,
+    ) -> Result<(), crate::provers::SP1VerificationError> {
+        self.inner.verify(proof, vk).await
+    }
 }
 
 impl ProverClientBuilder<None> {

crates/sdk/src/opts.rs

@@ -5,3 +5,10 @@ pub struct ProofOpts {
     pub timeout: u64,
     pub cycle_limit: u64,
 }
+
+impl Default for ProofOpts {
+    fn default() -> Self {
+        // TODO better defaults
+        Self { mode: Mode::default(), timeout: 10000, cycle_limit: 100000000 }
+    }
+}

examples/fibonacci/script/Cargo.toml

@@ -11,6 +11,7 @@ sp1-sdk = { workspace = true, features = ["network-v2"] }
 hex = "0.4.3"
 tokio = { version = "1.0", features = ["full", "macros"] }
 futures = "0.3"
+dotenv = "0.15"
 
 [build-dependencies]
 sp1-build = { workspace = true }

examples/fibonacci/script/bin/network.rs

@@ -1,6 +1,7 @@
 use sp1_sdk::network_v2::{Error, FulfillmentStrategy};
 use sp1_sdk::{include_elf, utils, client::ProverClient, proof::SP1ProofWithPublicValues, SP1Stdin};
 use std::time::Duration;
+use dotenv::dotenv;
 
 /// The ELF we want to execute inside the zkVM.
 const ELF: &[u8] = include_elf!("fibonacci-program");
@@ -18,23 +19,28 @@ async fn main() {
     let mut stdin = SP1Stdin::new();
     stdin.write(&n);
 
+    dotenv().ok();
+
+    let rpc_url = std::env::var("PROVER_NETWORK_RPC").unwrap();
+    let private_key = std::env::var("SP1_PRIVATE_KEY").unwrap();
+
     // Generate the proof, using the specified network configuration.
     let client = ProverClient::builder()
         .network()
-        .with_rpc_url("https://...".to_string())
-        .with_private_key("0x...".to_string())
+        .with_rpc_url(rpc_url)
+        .with_private_key(private_key)
         .build();
 
     // Generate the proving key and verifying key for the given program.
-    let (pk, vk) = client.setup(ELF).await.unwrap();
+    let (pk, vk) = client.setup(ELF).await;
 
     // Generate the proof.
     let proof_result = client
-        .prove(&pk, stdin)
-        .timeout(300)
-        .cycle_limit(1_000_000)
-        .skip_simulation(true)
-        .strategy(FulfillmentStrategy::Hosted)
+        .prove(&pk, &stdin)
+        // .timeout(300)
+        // .cycle_limit(1_000_000)
+        // .skip_simulation(true)
+        // .strategy(FulfillmentStrategy::Hosted)
         .await;
 
     // Example of handling potential errors.
@@ -81,15 +87,15 @@ async fn main() {
     println!("b: {}", b);
 
     // Verify proof and public values
-    client.verify(&proof, &vk).expect("verification failed");
+    // client.verify(&proof, &vk).expect("verification failed");
 
     // Test a round trip of proof serialization and deserialization.
     proof.save("proof-with-pis.bin").expect("saving proof failed");
     let deserialized_proof =
         SP1ProofWithPublicValues::load("proof-with-pis.bin").expect("loading proof failed");
 
     // Verify the deserialized proof.
-    client.verify(&deserialized_proof, &vk).expect("verification failed");
+    // client.verify(&deserialized_proof, &vk).expect("verification failed");
 
     println!("successfully generated and verified proof for the program!")
 }