feat: upgrade zkvm-prover to feynman fork

Cargo.toml

@@ -17,22 +17,22 @@ repository = "https://github.com/scroll-tech/scroll"
 version = "4.5.8"
 
 [workspace.dependencies]
-scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "6078604", package = "scroll-zkvm-prover" }
-scroll-zkvm-verifier-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "6078604", package = "scroll-zkvm-verifier" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "6078604" }
+scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "09e998f", package = "scroll-zkvm-prover" }
+scroll-zkvm-verifier-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "09e998f", package = "scroll-zkvm-verifier" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "09e998f" }
 
-sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade", features = ["scroll"] }
-sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade" }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/upgrade", features = ["scroll"] }
+sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/upgrade" }
 
 metrics = "0.23.0"
 metrics-util = "0.17"
 metrics-tracing-context = "0.16.0"
 
 anyhow = "1.0"
-alloy = { version = "0.11", default-features = false }
-alloy-primitives = { version = "0.8", default-features = false }
+alloy = { version = "1", default-features = false }
+alloy-primitives = { version = "1.2", default-features = false, features = ["tiny-keccak"] }
 # also use this to trigger "serde" feature for primitives
-alloy-serde = { version = "0.8", default-features = false }
+alloy-serde = { version = "1", default-features = false }
 
 rkyv = "0.8"
 serde = { version = "1", default-features = false, features = ["derive"] }
@@ -43,22 +43,25 @@ itertools = "0.14"
 tiny-keccak = "2.0"
 tracing = "0.1"
 eyre = "0.6"
-bincode_v1 = { version = "1.3", package = "bincode"}
-snark-verifier-sdk = { version = "0.2.0", default-features = false, features = [
-    "loader_halo2",
-    "halo2-axiom",
-    "display",
-] }
 once_cell = "1.20"
 base64 = "0.22"
 
-#TODO: upgrade when Feynman
-vm-zstd = { git = "https://github.com/scroll-tech/rust-zstd-decompressor.git", tag = "v0.1.1" }
-
 [patch.crates-io]
-alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.18-euclid-upgrade" }
-ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
-tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-euclid-upgrade" }
+revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-bytecode = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-context = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-context-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-database = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-database-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-handler = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-inspector = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-interpreter = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-precompile = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-state = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.15.0" }
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v1.2.0" }
 
 [profile.maxperf]
 inherits = "release"

coordinator/conf/config.json

@@ -11,7 +11,12 @@
       "verifiers": [{
         "assets_path": "assets",
         "fork_name": "euclidV2"
-      }]
+      }
+      ,{
+        "assets_path": "assets",
+        "fork_name": "feynman"
+      }
+      ]
     }
   },
   "db": {

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -197,7 +197,7 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		taskMsg, metadata, err = bp.applyUniversal(taskMsg)
 		if err != nil {
 			bp.recoverActiveAttempts(ctx, batchTask)
-			log.Error("Generate universal prover task failure", "task_id", batchTask.Hash, "type", "batch")
+			log.Error("Generate universal prover task failure", "task_id", batchTask.Hash, "type", "batch", "err", err)
 			return nil, ErrCoordinatorInternalFailure
 		}
 		proverTask.Metadata = metadata

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -193,7 +193,7 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		taskMsg, metadata, err = bp.applyUniversal(taskMsg)
 		if err != nil {
 			bp.recoverActiveAttempts(ctx, bundleTask)
-			log.Error("Generate universal prover task failure", "task_id", bundleTask.Hash, "type", "bundle")
+			log.Error("Generate universal prover task failure", "task_id", bundleTask.Hash, "type", "bundle", "err", err)
 			return nil, ErrCoordinatorInternalFailure
 		}
 		// bundle proof require snark

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -191,7 +191,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		taskMsg, metadata, err = cp.applyUniversal(taskMsg)
 		if err != nil {
 			cp.recoverActiveAttempts(ctx, chunkTask)
-			log.Error("Generate universal prover task failure", "task_id", chunkTask.Hash, "type", "chunk")
+			log.Error("Generate universal prover task failure", "task_id", chunkTask.Hash, "type", "chunk", "err", err)
 			return nil, ErrCoordinatorInternalFailure
 		}
 		proverTask.Metadata = metadata

crates/l2geth/src/rpc_client.rs

@@ -76,7 +76,7 @@ impl RpcClientCore {
         let client = ClientBuilder::default().layer(retry_layer).http(rpc);
 
         Ok(Self {
-            provider: ProviderBuilder::<_, _, Network>::default().on_client(client),
+            provider: ProviderBuilder::<_, _, Network>::default().connect_client(client),
             rt,
         })
     }
@@ -100,13 +100,13 @@ impl ChunkInterpreter for RpcClient<'_> {
             block_hash: sbv_primitives::B256,
             prev_witness: Option<&sbv_primitives::types::BlockWitness>,
         ) -> Result<sbv_primitives::types::BlockWitness> {
-            use alloy::network::primitives::BlockTransactionsKind;
             use sbv_utils::{rpc::ProviderExt, witness::WitnessBuilder};
 
             let chain_id = provider.get_chain_id().await?;
 
             let block = provider
-                .get_block_by_hash(block_hash, BlockTransactionsKind::Full)
+                .get_block_by_hash(block_hash)
+                .full()
                 .await?
                 .ok_or_else(|| eyre::eyre!("Block not found"))?;
 

crates/libzkp/Cargo.toml

@@ -8,6 +8,7 @@ edition.workspace = true
 scroll-zkvm-types.workspace = true
 scroll-zkvm-verifier-euclid.workspace = true
 
+alloy-primitives.workspace = true #depress the effect of "native-keccak"
 sbv-primitives.workspace = true
 base64.workspace = true
 serde.workspace = true
@@ -19,5 +20,5 @@ eyre.workspace = true
 git-version = "0.3.5"
 serde_stacker = "0.1"
 regex = "1.11"
-c-kzg = { version = "1.0", features = ["serde"] }
+c-kzg = { version = "2.0", features = ["serde"] }
 

crates/libzkp/src/proofs.rs

@@ -214,11 +214,7 @@ impl<Metadata: ProofMetadata> PersistableProof for WrappedProof<Metadata> {
 mod tests {
     use base64::{prelude::BASE64_STANDARD, Engine};
     use sbv_primitives::B256;
-    use scroll_zkvm_types::{
-        bundle::{BundleInfo, BundleInfoV1},
-        proof::EvmProof,
-        public_inputs::PublicInputs,
-    };
+    use scroll_zkvm_types::{bundle::BundleInfo, proof::EvmProof, public_inputs::ForkName};
 
     use super::*;
 
@@ -245,7 +241,7 @@ mod tests {
     fn test_dummy_proof() -> eyre::Result<()> {
         // 1. Metadata
         let metadata = {
-            let bundle_info: BundleInfoV1 = BundleInfo {
+            let bundle_info = BundleInfo {
                 chain_id: 12345,
                 num_batches: 12,
                 prev_state_root: B256::repeat_byte(1),
@@ -254,11 +250,10 @@ mod tests {
                 batch_hash: B256::repeat_byte(4),
                 withdraw_root: B256::repeat_byte(5),
                 msg_queue_hash: B256::repeat_byte(6),
-            }
-            .into();
-            let bundle_pi_hash = bundle_info.pi_hash();
+            };
+            let bundle_pi_hash = bundle_info.pi_hash(ForkName::EuclidV1);
             BundleProofMetadata {
-                bundle_info: bundle_info.0,
+                bundle_info,
                 bundle_pi_hash,
             }
         };

crates/libzkp/src/tasks/batch.rs

@@ -4,8 +4,8 @@ use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
     batch::{
-        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchInfo, BatchWitness, EnvelopeV6, EnvelopeV7,
-        PointEvalWitness, ReferenceHeader, ToArchievedWitness, N_BLOB_BYTES,
+        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchInfo, BatchWitness, Envelope, EnvelopeV6,
+        EnvelopeV7, PointEvalWitness, ReferenceHeader, ToArchievedWitness, N_BLOB_BYTES,
     },
     public_inputs::ForkName,
     task::ProvingTask,
@@ -117,7 +117,8 @@ impl BatchProvingTask {
                         "hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
                         ForkName::EuclidV1,
                     );
-                    EnvelopeV6::from(self.blob_bytes.as_slice()).challenge_digest(versioned_hash)
+                    EnvelopeV6::from_slice(self.blob_bytes.as_slice())
+                        .challenge_digest(versioned_hash)
                 }
                 BatchHeaderV::V7(_) => {
                     match fork_name {
@@ -131,7 +132,8 @@ impl BatchProvingTask {
                         padded_blob_bytes.resize(N_BLOB_BYTES, 0);
                         padded_blob_bytes
                     };
-                    EnvelopeV7::from(padded_blob_bytes.as_slice()).challenge_digest(versioned_hash)
+                    EnvelopeV7::from_slice(padded_blob_bytes.as_slice())
+                        .challenge_digest(versioned_hash)
                 }
             };
 

crates/libzkp/src/tasks/batch/utils.rs

@@ -42,7 +42,8 @@ pub mod point_eval {
 
     /// Get the KZG commitment from an EIP-4844 blob.
     pub fn blob_to_kzg_commitment(blob: &c_kzg::Blob) -> c_kzg::KzgCommitment {
-        c_kzg::KzgCommitment::blob_to_kzg_commitment(blob, c_kzg::ethereum_kzg_settings())
+        c_kzg::ethereum_kzg_settings(0)
+            .blob_to_kzg_commitment(blob)
             .expect("blob to kzg commitment should succeed")
     }
 
@@ -65,12 +66,9 @@ pub mod point_eval {
     pub fn get_kzg_proof(blob: &c_kzg::Blob, challenge: H256) -> (c_kzg::KzgProof, U256) {
         let challenge = get_x_from_challenge(challenge);
 
-        let (proof, y) = c_kzg::KzgProof::compute_kzg_proof(
-            blob,
-            &c_kzg::Bytes32::new(challenge.to_be_bytes()),
-            c_kzg::ethereum_kzg_settings(),
-        )
-        .expect("kzg proof should succeed");
+        let (proof, y) = c_kzg::ethereum_kzg_settings(0)
+            .compute_kzg_proof(blob, &c_kzg::Bytes32::new(challenge.to_be_bytes()))
+            .expect("kzg proof should succeed");
 
         (proof, U256::from_be_slice(y.as_slice()))
     }

crates/libzkp/src/tasks/bundle.rs

@@ -4,7 +4,6 @@ use scroll_zkvm_types::{
     bundle::{BundleInfo, BundleWitness, ToArchievedWitness},
     public_inputs::ForkName,
     task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
 };
 
 /// Message indicating a sanity check failure.
@@ -47,6 +46,7 @@ impl BundleProvingTask {
                 .iter()
                 .map(|wrapped_proof| wrapped_proof.metadata.batch_info.clone())
                 .collect(),
+            fork_name: self.fork_name.to_lowercase().as_str().into(),
         }
     }
 
@@ -83,7 +83,7 @@ impl TryFrom<BundleProvingTask> for ProvingTask {
                 .into_iter()
                 .map(|w_proof| w_proof.proof.into_root_proof().expect("expect root proof"))
                 .collect(),
-            serialized_witness: vec![to_rkyv_bytes::<RancorError>(&witness)?.to_vec()],
+            serialized_witness: vec![witness.rkyv_serialize(None)?.to_vec()],
             vk: Vec::new(),
         })
     }

crates/libzkp/src/tasks/chunk.rs

@@ -4,7 +4,6 @@ use sbv_primitives::{types::BlockWitness, B256};
 use scroll_zkvm_types::{
     chunk::{execute, ChunkInfo, ChunkWitness, ToArchievedWitness},
     task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
 };
 
 /// The type aligned with coordinator's defination
@@ -72,7 +71,7 @@ impl TryFrom<ChunkProvingTask> for ProvingTask {
             identifier: value.identifier(),
             fork_name: value.fork_name,
             aggregated_proofs: Vec::new(),
-            serialized_witness: vec![to_rkyv_bytes::<RancorError>(&witness)?.to_vec()],
+            serialized_witness: vec![witness.rkyv_serialize(None)?.to_vec()],
             vk: Vec::new(),
         })
     }
@@ -119,11 +118,11 @@ impl ChunkProvingTask {
     }
 
     fn build_guest_input(&self) -> ChunkWitness {
-        ChunkWitness {
-            blocks: self.block_witnesses.to_vec(),
-            prev_msg_queue_hash: self.prev_msg_queue_hash,
-            fork_name: self.fork_name.to_lowercase().as_str().into(),
-        }
+        ChunkWitness::new(
+            &self.block_witnesses,
+            self.prev_msg_queue_hash,
+            self.fork_name.to_lowercase().as_str().into(),
+        )
     }
 
     fn insert_state(&mut self, node: sbv_primitives::Bytes) {

crates/libzkp_c/src/lib.rs

@@ -104,6 +104,7 @@ pub unsafe extern "C" fn gen_universal_task(
                 str
             }
             Err(e) => {
+                println!("gen_universal_task failed at pre interpret step, error: {e}");
                 tracing::error!("gen_universal_task failed at pre interpret step, error: {e}");
                 return failed_handling_result();
             }
@@ -135,7 +136,8 @@ pub unsafe extern "C" fn gen_universal_task(
             expected_pi_hash,
         }
     } else {
-        tracing::error!("gen_universal_task failed, error: {:#}", ret.unwrap_err());
+        println!("gen_universal_task, error: {:#}", ret.unwrap_err());
+        //tracing::error!("gen_universal_task failed, error: {:#}", ret.unwrap_err());
         failed_handling_result()
     }
 }

crates/prover-bin/src/main.rs

@@ -5,10 +5,9 @@ mod zk_circuits_handler;
 use clap::{ArgAction, Parser, Subcommand};
 use prover::{LocalProver, LocalProverConfig};
 use scroll_proving_sdk::{
-    prover::{types::ProofType, ProverBuilder},
+    prover::ProverBuilder,
     utils::{get_version, init_tracing},
 };
-use std::{fs::File, path::Path};
 
 #[derive(Parser, Debug)]
 #[command(disable_version_flag = true)]
@@ -36,33 +35,11 @@ struct Args {
 enum Commands {
     /// Dump vk of this prover
     Dump {
-        /// File to save the vks
-        file_name: String,
+        /// path to save the verifier's asset
+        asset_path: String,
     },
 }
 
-fn dump_vk(file: &Path, prover: &LocalProver, fork_name: &str) -> eyre::Result<()> {
-    let f = File::create(file)?;
-
-    #[derive(Debug, serde::Serialize)]
-    struct VKDump {
-        pub chunk_vk: String,
-        pub batch_vk: String,
-        pub bundle_vk: String,
-    }
-
-    let handler = prover.new_handler(fork_name);
-
-    let dump = VKDump {
-        chunk_vk: handler.get_vk(ProofType::Chunk),
-        batch_vk: handler.get_vk(ProofType::Batch),
-        bundle_vk: handler.get_vk(ProofType::Bundle),
-    };
-    serde_json::to_writer(f, &dump)?;
-
-    Ok(())
-}
-
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
     init_tracing();
@@ -80,10 +57,10 @@ async fn main() -> eyre::Result<()> {
     let local_prover = LocalProver::new(cfg.clone());
 
     match args.command {
-        Some(Commands::Dump { file_name }) => {
+        Some(Commands::Dump { asset_path }) => {
             let fork_name = args.fork_name.unwrap_or(default_fork_name);
-            println!("dump vk for {fork_name}");
-            dump_vk(Path::new(&file_name), &local_prover, &fork_name)?;
+            println!("dump assets for {fork_name} into {asset_path}");
+            local_prover.dump_verifier_assets(&fork_name, asset_path.as_ref())?;
         }
         None => {
             let prover = ProverBuilder::new(sdk_config, local_prover)