feat(provers/sp1): support pacaya

Author: keroro520

lib/src/builder.rs

@@ -13,7 +13,7 @@ use crate::{
 };
 use anyhow::{bail, ensure, Result};
 use reth_chainspec::{
-    ChainSpecBuilder, Hardfork, HOLESKY, MAINNET, TAIKO_A7, TAIKO_DEV, TAIKO_MAINNET,
+    ChainSpecBuilder, ForkCondition, Hardfork, HOLESKY, MAINNET, TAIKO_A7, TAIKO_DEV, TAIKO_MAINNET,
 };
 use reth_evm::execute::{BlockExecutionOutput, BlockValidationError, Executor, ProviderError};
 use reth_evm_ethereum::execute::{
@@ -169,7 +169,16 @@ impl<DB: Database<Error = ProviderError> + DatabaseCommit + OptimisticDatabase>
                 )
             }
             "holesky" => HOLESKY.clone(),
-            "taiko_dev" => TAIKO_DEV.clone(),
+            "taiko_dev" => {
+                let mut reth_spec = TAIKO_DEV.as_ref().clone();
+                reth_spec
+                    .hardforks
+                    .insert(Hardfork::Ontake, ForkCondition::Block(0));
+                reth_spec
+                    .hardforks
+                    .insert(Hardfork::Pacaya, ForkCondition::Block(50));
+                Arc::new(reth_spec)
+            }
             _ => unimplemented!(),
         };
 

provers/sp1/builder/src/main.rs

@@ -5,7 +5,10 @@ use std::path::PathBuf;
 
 fn main() {
     let pipeline = Sp1Pipeline::new("provers/sp1/guest", "release");
-    pipeline.bins(&["sp1-guest", "sp1-aggregation"], "provers/sp1/guest/elf");
+    pipeline.bins(
+        &["sp1-guest", "sp1-aggregation", "sp1-batch"],
+        "provers/sp1/guest/elf",
+    );
     #[cfg(feature = "test")]
     pipeline.tests(&["sp1-guest"], "provers/sp1/guest/elf");
     #[cfg(feature = "bench")]

provers/sp1/driver/src/lib.rs

@@ -21,13 +21,14 @@ use sp1_sdk::{
 };
 use sp1_sdk::{HashableKey, ProverClient, SP1Stdin};
 use std::{borrow::BorrowMut, env, sync::Arc, time::Duration};
-use tracing::{debug, error, info};
+use tracing::{debug, info};
 
 mod proof_verify;
 use proof_verify::remote_contract_verify::verify_sol_by_contract_call;
 
 pub const ELF: &[u8] = include_bytes!("../../guest/elf/sp1-guest");
 pub const AGGREGATION_ELF: &[u8] = include_bytes!("../../guest/elf/sp1-aggregation");
+pub const BATCH_ELF: &[u8] = include_bytes!("../../guest/elf/sp1-batch");
 
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -110,6 +111,7 @@ struct Sp1ProverClient {
 //TODO: use prover object to save such local storage members.
 static BLOCK_PROOF_CLIENT: Lazy<DashMap<ProverMode, Sp1ProverClient>> = Lazy::new(DashMap::new);
 static AGGREGATION_CLIENT: Lazy<DashMap<ProverMode, Sp1ProverClient>> = Lazy::new(DashMap::new);
+static BATCH_PROOF_CLIENT: Lazy<DashMap<ProverMode, Sp1ProverClient>> = Lazy::new(DashMap::new);
 
 impl Prover for Sp1Prover {
     async fn run(
@@ -197,8 +199,8 @@ impl Prover for Sp1Prover {
                     .await?;
             }
             info!(
-                "Sp1 Prover: block {:?} - proof id {proof_id:?}",
-                output.header.number
+                "Sp1: network proof id: {:?} for block {:?}",
+                proof_id, output.header.number
             );
             network_client
                 .wait_proof(proof_id.clone(), Some(Duration::from_secs(3600)))
@@ -319,7 +321,7 @@ impl Prover for Sp1Prover {
                     stdin.write_proof(*block_proof, stark_vk.clone());
                 }
                 _ => {
-                    error!("unsupported proof type for aggregation: {sp1_proof:?}");
+                    panic!("unsupported proof type for aggregation: {sp1_proof:?}");
                 }
             }
         }
@@ -387,6 +389,7 @@ impl Prover for Sp1Prover {
                 .map_err(|e| {
                     ProverError::GuestError(format!("Sp1: network proving failed: {e}"))
                 })?;
+            info!("Sp1: network proof id: {proof_id:?} for aggregation");
             network_client
                 .wait_proof(proof_id.clone(), Some(Duration::from_secs(3600)))
                 .await
@@ -429,12 +432,146 @@ impl Prover for Sp1Prover {
     }
 
     async fn batch_run(
-        _input: GuestBatchInput,
-        _output: &GuestBatchOutput,
-        _config: &ProverConfig,
-        _store: Option<&mut dyn IdWrite>,
+        input: GuestBatchInput,
+        output: &GuestBatchOutput,
+        config: &ProverConfig,
+        id_store: Option<&mut dyn IdWrite>,
     ) -> ProverResult<Proof> {
-        unimplemented!();
+        let param = Sp1Param::deserialize(config.get("sp1").unwrap()).unwrap();
+        let mode = param.prover.clone().unwrap_or_else(get_env_mock);
+
+        println!("batch_run param: {param:?}");
+        let mut stdin = SP1Stdin::new();
+        stdin.write(&input);
+
+        let Sp1ProverClient {
+            client,
+            pk,
+            vk,
+            network_client,
+        } = BATCH_PROOF_CLIENT
+            .entry(mode.clone())
+            .or_insert_with(|| {
+                let network_client = Arc::new(ProverClient::builder().network().build());
+                let base_client: Box<dyn SP1ProverTrait<CpuProverComponents>> = match mode {
+                    ProverMode::Mock => Box::new(ProverClient::builder().mock().build()),
+                    ProverMode::Local => Box::new(ProverClient::builder().cpu().build()),
+                    ProverMode::Network => Box::new(ProverClient::builder().network().build()),
+                };
+
+                let client = Arc::new(base_client);
+                let (pk, vk) = client.setup(BATCH_ELF);
+                info!(
+                    "new client and setup() for batch {:?}.",
+                    input.taiko.batch_id
+                );
+                Sp1ProverClient {
+                    client,
+                    network_client,
+                    pk,
+                    vk,
+                }
+            })
+            .clone();
+
+        info!(
+            "Sp1 Prover: batch {:?} with vk {:?}, output.hash: {}",
+            input.taiko.batch_id,
+            vk.bytes32(),
+            output.hash
+        );
+
+        let prove_result = if !matches!(mode, ProverMode::Network) {
+            debug!("Proving locally with recursion mode: {:?}", param.recursion);
+            let prove_mode = match param.recursion {
+                RecursionMode::Core => SP1ProofMode::Core,
+                RecursionMode::Compressed => SP1ProofMode::Compressed,
+                RecursionMode::Plonk => SP1ProofMode::Plonk,
+            };
+            client
+                .prove(&pk, &stdin, prove_mode)
+                .map_err(|e| ProverError::GuestError(format!("Sp1: local proving failed: {e}")))?
+        } else {
+            let proof_id = network_client
+                .prove(&pk, &stdin)
+                .mode(param.recursion.clone().into())
+                .cycle_limit(1_000_000_000_000)
+                .skip_simulation(true)
+                .strategy(FulfillmentStrategy::Reserved)
+                .request_async()
+                .await
+                .map_err(|e| {
+                    ProverError::GuestError(format!("Sp1: requesting proof failed: {e}"))
+                })?;
+            if let Some(id_store) = id_store {
+                id_store
+                    .store_id(
+                        (
+                            input.taiko.chain_spec.chain_id,
+                            input.taiko.batch_id,
+                            output.hash,
+                            ProofType::Sp1 as u8,
+                        ),
+                        proof_id.clone().to_string(),
+                    )
+                    .await?;
+            }
+            info!(
+                "Sp1 Prover: batch {:?} - proof id {proof_id:?}",
+                input.taiko.batch_id
+            );
+            network_client
+                .wait_proof(proof_id.clone(), Some(Duration::from_secs(3600)))
+                .await
+                .map_err(|e| ProverError::GuestError(format!("Sp1: network proof failed {e:?}")))?
+        };
+
+        let proof_bytes = match param.recursion {
+            RecursionMode::Compressed => {
+                info!("Compressed proof is used in aggregation mode only");
+                vec![]
+            }
+            _ => prove_result.bytes(),
+        };
+        if param.verify && !proof_bytes.is_empty() {
+            let time = Measurement::start("verify", false);
+            let pi_hash = prove_result
+                .clone()
+                .borrow_mut()
+                .public_values
+                .read::<[u8; 32]>();
+            let fixture = RaikoProofFixture {
+                vkey: vk.bytes32(),
+                public_values: B256::from_slice(&pi_hash).to_string(),
+                proof: proof_bytes.clone(),
+            };
+
+            verify_sol_by_contract_call(&fixture).await?;
+            time.stop_with("==> Verification complete");
+        }
+
+        let proof_string = (!proof_bytes.is_empty()).then_some(
+            // 0x + 64 bytes of the vkey + the proof
+            // vkey itself contains 0x prefix
+            format!(
+                "{}{}",
+                vk.bytes32(),
+                reth_primitives::hex::encode(proof_bytes)
+            ),
+        );
+
+        info!(
+            "Sp1 Prover: batch {:?} completed! proof: {proof_string:?}",
+            input.taiko.batch_id,
+        );
+        Ok::<_, ProverError>(
+            Sp1Response {
+                proof: proof_string,
+                sp1_proof: Some(prove_result),
+                vkey: Some(vk.clone()),
+            }
+            .into(),
+        )
     }
 }
 

provers/sp1/guest/Cargo.toml

@@ -13,6 +13,10 @@ path = "src/zk_op.rs"
 name = "sp1-aggregation"
 path = "src/aggregation.rs"
 
+[[bin]]
+name = "sp1-batch"
+path = "src/batch.rs"
+
 [[bin]]
 name = "sha256"
 path = "src/benchmark/sha256.rs"

provers/sp1/guest/src/batch.rs

@@ -0,0 +1,59 @@
+#![no_main]
+sp1_zkvm::entrypoint!(main);
+
+use raiko_lib::{
+    builder::calculate_batch_blocks_final_header, input::GuestBatchInput, proof_type::ProofType,
+    protocol_instance::ProtocolInstance, CycleTracker,
+};
+
+pub mod sys;
+pub use sys::*;
+
+pub fn main() {
+    let mut ct = CycleTracker::start("input");
+    let input = sp1_zkvm::io::read_vec();
+    let batch_input = bincode::deserialize::<GuestBatchInput>(&input).unwrap();
+    ct.end();
+
+    ct = CycleTracker::start("calculate_batch_blocks_final_header");
+    let final_blocks = calculate_batch_blocks_final_header(&batch_input);
+    ct.end();
+
+    ct = CycleTracker::start("batch_instance_hash");
+    let pi = ProtocolInstance::new_batch(&batch_input, final_blocks, ProofType::Sp1)
+        .unwrap()
+        .instance_hash();
+    ct.end();
+
+    sp1_zkvm::io::commit(&pi.0);
+}
+
+harness::zk_suits!(
+    pub mod tests {
+        use reth_primitives::U256;
+        use std::str::FromStr;
+        #[test]
+        pub fn test_build_from_mock_input() {
+            // Todo: impl mock input for static unit test
+            assert_eq!(1, 1);
+        }
+        pub fn test_signature() {
+            let signature = reth_primitives::Signature {
+                r: U256::from_str(
+                    "18515461264373351373200002665853028612451056578545711640558177340181847433846",
+                )
+                .unwrap(),
+                s: U256::from_str(
+                    "46948507304638947509940763649030358759909902576025900602547168820602576006531",
+                )
+                .unwrap(),
+                odd_y_parity: false,
+            };
+            let hash = reth_primitives::B256::from_str(
+                "daf5a779ae972f972197303d7b574746c7ef83eadac0f2791ad23db92e4c8e53",
+            )
+            .unwrap();
+            signature.recover_signer(hash).unwrap();
+        }
+    }
+);

script/build.sh

@@ -2,9 +2,10 @@
 
 # Any error will result in failure
 set -e
+set -x
 
 TOOLCHAIN_RISC0=+nightly-2024-12-20
-TOOLCHAIN_SP1=+nightly-2024-12-20
+TOOLCHAIN_SP1="+1.82.0"
 TOOLCHAIN_SGX=+nightly-2024-12-20
 
 check_toolchain() {

script/install.sh

@@ -70,25 +70,25 @@ if [ -z "$1" ] || [ "$1" == "risc0" ]; then
 fi
 # SP1
 if [ -z "$1" ] || [ "$1" == "sp1" ]; then
-	curl -L https://sp1.succinct.xyz | bash
-	echo "SP1 installed"
-	# if [ -z "${CI}" ] || [ ! command -v sp1up &> /dev/null ]; then
-	# echo "Non-CI environment"
-		# Need to add sp1up to the path here
-		PROFILE=$HOME/.profile
-		echo ${PROFILE}
-		source ${PROFILE}
-		if command -v sp1up >/dev/null 2>&1; then
-			echo "sp1 found in path"
-			sp1up -v v4.0.0-rc.1
-		else
-			echo "sp1 not found in path"
-			"$HOME/.sp1/bin/sp1up" -v v4.0.0-rc.1
-		fi
-	# else
-	# 	echo "CI environment"
-	# 	source /home/runner/.bashrc
-	# 	echo "/home/runner/.sp1/bin" >> $GITHUB_PATH
-	# 	/home/runner/.sp1/bin/sp1up
-	# fi
+    curl -L https://sp1.succinct.xyz | bash
+    echo "SP1 installed"
+    # if [ -z "${CI}" ] || [ ! command -v sp1up &> /dev/null ]; then
+    # echo "Non-CI environment"
+        # Need to add sp1up to the path here
+        PROFILE=$HOME/.profile
+        echo ${PROFILE}
+        source ${PROFILE}
+        if command -v sp1up >/dev/null 2>&1; then
+            echo "sp1 found in path"
+            sp1up -v v4.0.0-rc.1
+        else
+            echo "sp1 not found in path"
+            "$HOME/.sp1/bin/sp1up" -v v4.0.0-rc.1
+        fi
+    # else
+    #   echo "CI environment"
+    #   source /home/runner/.bashrc
+    #   echo "/home/runner/.sp1/bin" >> $GITHUB_PATH
+    #   /home/runner/.sp1/bin/sp1up
+    # fi
 fi

script/prove-block.sh

@@ -72,7 +72,17 @@ elif [ "$proof" == "sp1" ]; then
 	"sp1": {
 		"recursion": "plonk",
 		"prover": "network",
-		"verify": true
+		"verify": false
+	}
+  '
+elif [ "$proof" == "sp1-mock" ]; then
+	proofParam='
+    "proof_type": "sp1",
+    "blob_proof_type": "proof_of_equivalence",
+	"sp1": {
+		"recursion": "plonk",
+		"prover": "mock",
+		"verify": false
 	}
   '
 elif [ "$proof" == "sp1-aggregation" ]; then