[WIP] [Do Not Merge] feat: Upgrade sdk to v6

Cargo.toml

@@ -28,10 +28,9 @@ csv = "1.3.1"
 sha2 = "0.10"
 
 # sp1
-sp1-sdk = { version = "5.2.1", default-features = false, features = [
-    "network",
-] }
-sp1-zkvm = "5.0.0"
+sp1-sdk = { git = "https://github.com/succinctlabs/sp1-wip.git", branch = "multilinear_v6" }
+sp1-zkvm = { package = "sp1-zkvm", git = "https://github.com/succinctlabs/sp1-wip.git", branch = "multilinear_v6" }
+sp1-build = { git = "https://github.com/succinctlabs/sp1-wip.git", branch = "multilinear_v6" }
 
 [patch.crates-io]
 sha2-v0-9-9 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", package = "sha2", tag = "patch-sha2-0.9.9-sp1-4.0.0" }

script/Cargo.toml

@@ -56,4 +56,4 @@ tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 
 [build-dependencies]
-sp1-build = "5.0.0"
+sp1-build = { workspace = true }

script/bin/genesis.rs

@@ -10,7 +10,7 @@
 use clap::Parser;
 use sp1_blobstream_script::util::*;
 use sp1_blobstream_script::TendermintRPCClient;
-use sp1_sdk::{HashableKey, Prover, ProverClient};
+use sp1_sdk::{HashableKey, MockProver, Prover, ProvingKey};
 use std::env;
 use tracing::info;
 use tracing_subscriber::EnvFilter;
@@ -36,8 +36,12 @@ pub async fn main() {
     let data_fetcher = TendermintRPCClient::default();
     let args = GenesisArgs::parse();
 
-    let client = ProverClient::builder().mock().build();
-    let (_pk, vk) = client.setup(BLOBSTREAMX_ELF);
+    let client = MockProver::new().await;
+    let pk = client
+        .setup(sp1_sdk::Elf::Static(BLOBSTREAMX_ELF))
+        .await
+        .expect("Failed to setup prover");
+    let vk = pk.verifying_key().clone();
 
     if let Some(block) = args.block {
         let header_hash = fetch_header_hash(&data_fetcher, block)

script/bin/operator.rs

@@ -12,8 +12,8 @@ use sp1_blobstream_script::util::{fetch_input_for_blobstream_proof, find_block_t
 use sp1_blobstream_script::TendermintRPCClient;
 use sp1_blobstream_script::{relay, TENDERMINT_ELF};
 use sp1_sdk::{
-    network::FulfillmentStrategy, HashableKey, NetworkProver, Prover, ProverClient,
-    SP1ProofWithPublicValues, SP1ProvingKey, SP1Stdin, SP1VerifyingKey,
+    network::FulfillmentStrategy, HashableKey, NetworkProver, ProveRequest, Prover, ProverClient,
+    ProvingKey, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey,
 };
 use std::time::Duration;
 use std::{collections::HashMap, env, sync::Arc};
@@ -82,7 +82,7 @@ impl std::str::FromStr for SignerMode {
 /////// Operator ///////
 
 struct SP1BlobstreamOperator<P, N> {
-    pk: Arc<SP1ProvingKey>,
+    pk: Arc<<NetworkProver as Prover>::ProvingKey>,
     vk: SP1VerifyingKey,
     client: TendermintRPCClient,
     contracts: HashMap<u64, SP1BlobstreamContract<P, N>>,
@@ -103,7 +103,7 @@ where
     /// - `vk`: the SP1 Verifying key of the blobstream program.
     /// - `use_kms_relayer`: whether to use the KMS relayer to relay the proof.
     pub fn new(
-        pk: SP1ProvingKey,
+        pk: <NetworkProver as Prover>::ProvingKey,
         vk: SP1VerifyingKey,
         client: TendermintRPCClient,
         signer_mode: SignerMode,
@@ -479,14 +479,14 @@ where
         // If the SP1_PROVER environment variable is set to "cpu", use the CPU prover.
         if let Ok(prover_type) = env::var("SP1_PROVER") {
             if prover_type == "cpu" {
-                let prover_client = ProverClient::builder().cpu().build();
-                let proof = prover_client.prove(&self.pk, &stdin).plonk().run()?;
+                let prover_client = ProverClient::builder().cpu().build().await;
+                let proof = prover_client.prove(&self.pk, stdin).plonk().await?;
                 return Ok(proof);
             }
         }
 
         self.network_prover
-            .prove(&self.pk, &stdin)
+            .prove(&self.pk, stdin)
             .strategy(FulfillmentStrategy::Auction)
             .skip_simulation(true)
             .cycle_limit(10_000_000_000)
@@ -639,8 +639,12 @@ async fn run_with_wallet(config: Vec<ChainConfig>) {
     let key = env::var("PRIVATE_KEY").expect("PRIVATE_KEY not set");
     let signer: PrivateKeySigner = key.parse().expect("Failed to parse PRIVATE_KEY");
 
-    let prover = ProverClient::builder().network().build();
-    let (pk, vk) = prover.setup(TENDERMINT_ELF);
+    let prover = ProverClient::builder().network().build().await;
+    let pk = prover
+        .setup(sp1_sdk::Elf::Static(TENDERMINT_ELF))
+        .await
+        .expect("Failed to setup prover");
+    let vk = pk.verifying_key().clone();
 
     let client = TendermintRPCClient::default();
 
@@ -662,8 +666,12 @@ async fn run_with_wallet(config: Vec<ChainConfig>) {
 }
 
 async fn run_with_kms_relayer(config: Vec<ChainConfig>) {
-    let prover = ProverClient::builder().network().build();
-    let (pk, vk) = prover.setup(TENDERMINT_ELF);
+    let prover = ProverClient::builder().network().build().await;
+    let pk = prover
+        .setup(sp1_sdk::Elf::Static(TENDERMINT_ELF))
+        .await
+        .expect("Failed to setup prover");
+    let vk = pk.verifying_key().clone();
 
     let client = TendermintRPCClient::default();
 

script/bin/test.rs

@@ -1,7 +1,7 @@
 use clap::Parser;
 use sp1_blobstream_script::util::fetch_input_for_blobstream_proof;
 use sp1_blobstream_script::{TendermintRPCClient, TENDERMINT_ELF};
-use sp1_sdk::{ProverClient, SP1Stdin};
+use sp1_sdk::{include_elf, ProveRequest, Prover, ProverClient, ProvingKey, SP1Stdin};
 use tokio::runtime;
 
 #[derive(Parser, Debug)]
@@ -21,34 +21,36 @@ struct ScriptArgs {
 /// ```
 /// RUST_LOG=info cargo run --bin test --release -- --trusted-block=1 --target-block=5
 /// ```
-fn main() -> anyhow::Result<()> {
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
     dotenv::dotenv().ok();
     sp1_sdk::utils::setup_logger();
 
     let args = ScriptArgs::parse();
 
-    let rt = runtime::Runtime::new()?;
-
     let mut stdin = SP1Stdin::new();
     let tendermint_rpc_client = TendermintRPCClient::default();
 
     // Fetch the inputs for the proof.
-    let inputs = rt.block_on(async {
-        fetch_input_for_blobstream_proof(
-            &tendermint_rpc_client,
-            args.trusted_block,
-            args.target_block,
-        )
-        .await
-        .expect("Failed to fetch proof inputs")
-    });
+    let inputs = fetch_input_for_blobstream_proof(
+        &tendermint_rpc_client,
+        args.trusted_block,
+        args.target_block,
+    )
+    .await
+    .expect("Failed to fetch proof inputs");
     let encoded_proof_inputs = serde_cbor::to_vec(&inputs).unwrap();
     stdin.write_vec(encoded_proof_inputs);
 
-    let prover_client = ProverClient::from_env();
-    let (pk, vk) = prover_client.setup(TENDERMINT_ELF);
-    let proof = prover_client.prove(&pk, &stdin).groth16().run()?;
-    prover_client.verify(&proof, &vk)?;
+    let prover_client = ProverClient::from_env().await;
+    let new_elf = include_elf!("sp1-blobstream-program").to_vec();
+    let pk = prover_client
+        .setup(new_elf.into())
+        .await
+        .expect("Failed to setup prover");
+    let vk = pk.verifying_key().clone();
+    let proof = prover_client.prove(&pk, stdin).groth16().await?;
+    prover_client.verify(&proof, &vk, None)?;
 
     Ok(())
 }

script/bin/vkey.rs

@@ -1,9 +1,13 @@
-use sp1_sdk::{HashableKey, Prover, ProverClient};
+use sp1_sdk::{HashableKey, MockProver, Prover, ProvingKey};
 const BLOBSTREAMX_ELF: &[u8] = include_bytes!("../../elf/blobstream-elf");
 
 #[tokio::main]
 pub async fn main() {
-    let client = ProverClient::builder().mock().build();
-    let (_pk, vk) = client.setup(BLOBSTREAMX_ELF);
+    let client = MockProver::new().await;
+    let pk = client
+        .setup(sp1_sdk::Elf::Static(BLOBSTREAMX_ELF))
+        .await
+        .unwrap();
+    let vk = pk.verifying_key().clone();
     println!("VK: {}", vk.bytes32());
 }

script/build.rs

@@ -1,15 +1,6 @@
 #[allow(unused_imports)]
-use sp1_build::{build_program_with_args, BuildArgs};
+use sp1_build::build_program;
 
 fn main() {
-    // build_program_with_args(
-    //     "../program",
-    //     BuildArgs {
-    //         docker: true,
-    //         elf_name: Some("blobstream-elf".to_string()),
-    //         output_directory: Some("../elf".to_string()),
-    //         tag: "v5.0.0".to_string(),
-    //         ..Default::default()
-    //     },
-    // )
+    build_program("../program")
 }

script/src/tendermint.rs

@@ -160,7 +160,7 @@ impl TendermintRPCClient {
         ) -> anyhow::Result<CommitResponse> {
             let url = format!("{}/commit", client.url);
 
-            client
+            let raw = client
                 .client
                 .get(url)
                 .query(&[
@@ -169,8 +169,11 @@ impl TendermintRPCClient {
                 ])
                 .send()
                 .await
-                .context("Failed to fetch commit")?
-                .json::<CommitResponse>()
+                .context("Failed to fetch commit")?;
+
+            tracing::info!("raw: {:?}", raw);
+
+            raw.json::<CommitResponse>()
                 .await
                 .context("Failed to parse commit response")
         }