+ update openvm

+ fmt
+ trivial updates

Signed-off-by: noelwei <[email protected]>

Author: noel2004

Cargo.lock

@@ -23,9 +23,9 @@ version = "4.5.8"
 [workspace.dependencies]
 scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", package = "scroll-zkvm-prover"}
 
-openvm = { git = "https://github.com/openvm-org/openvm.git", rev = "3c35e9f", default-features = false }
-openvm-custom-insn = { git = "https://github.com/openvm-org/openvm.git", rev = "3c35e9f", default-features = false }
-openvm-rv32im-guest = { git = "https://github.com/openvm-org/openvm.git", rev = "3c35e9f", default-features = false }
+openvm = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-custom-insn = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
+openvm-rv32im-guest = { git = "https://github.com/openvm-org/openvm.git", rev = "a0ae88f", default-features = false }
 
 sbv-core = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade", features = ["scroll"] }
 sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade", features = ["scroll"] }

Cargo.toml

@@ -2,9 +2,10 @@ pub mod io;
 pub use io::read_witnesses;
 
 use alloy_primitives::B256;
-use types_base::public_inputs::PublicInputs;
-use types_agg::{ProofCarryingWitness, ProgramCommitment, AggregationInput, verify_proof};
 use itertools::Itertools;
+use types_agg::{AggregationInput, ProgramCommitment, ProofCarryingWitness, verify_proof};
+
+pub use types_base::public_inputs::PublicInputs;
 
 /// Reveal the public-input values as openvm public values.
 pub fn reveal_pi_hash(pi_hash: B256) {
@@ -38,7 +39,6 @@ pub trait Circuit {
     }
 }
 
-
 /// Circuit that additional aggregates proofs from other [`Circuits`][Circuit].
 pub trait AggCircuit: Circuit
 where
@@ -93,4 +93,4 @@ where
             );
         }
     }
-}
+}

common/types-rs/circuit/src/lib.rs

@@ -0,0 +1,21 @@
+// re-export for a compatible interface with old circuit/types for prover
+
+pub mod bundle {
+    pub use types_base::public_inputs::bundle::{BundleInfo, BundleInfoV1, BundleInfoV2};
+    pub use types_bundle::*;
+}
+
+pub mod batch {
+    pub use types_base::public_inputs::batch::{ArchivedBatchInfo, BatchInfo, VersionedBatchInfo};
+    pub use types_batch::*;
+}
+
+pub mod chunk {
+    pub use types_base::public_inputs::chunk::{
+        ArchivedChunkInfo, BlockContextV2, ChunkInfo, SIZE_BLOCK_CTX, VersionedChunkInfo,
+    };
+    pub use types_chunk::*;
+}
+
+pub use types_agg;
+pub use types_base::{public_inputs, utils};

common/types-rs/src/lib.rs

@@ -1,7 +1,5 @@
 use crate::zk_circuits_handler::{
-    euclid::EuclidHandler, euclidV2::EuclidV2Handler, CircuitsHandler,
-    RequestPreHandler,
-    RpcConfig,
+    euclid::EuclidHandler, euclidV2::EuclidV2Handler, CircuitsHandler, RequestPreHandler, RpcConfig,
 };
 use anyhow::{anyhow, Result};
 use async_trait::async_trait;
@@ -153,7 +151,8 @@ impl LocalProver {
         handler: Arc<dyn CircuitsHandler>,
     ) -> Result<ProveResponse> {
         if self.pre_handler.is_none() {
-            self.pre_handler.replace(RequestPreHandler::create(&self.config.rpc_config)?);
+            self.pre_handler
+                .replace(RequestPreHandler::create(&self.config.rpc_config)?);
         }
 
         self.next_task_id += 1;

zkvm-prover/src/prover.rs

@@ -1,5 +1,5 @@
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use alloy::primitives::B256;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[derive(Serialize, Deserialize, Default)]
 pub struct Task {

zkvm-prover/src/types.rs

@@ -13,13 +13,12 @@ pub trait CircuitsHandler: Sync + Send {
     async fn get_proof_data(&self, prove_request: ProveRequest) -> Result<String>;
 }
 
-
 use alloy::{
-    providers::{ProviderBuilder, RootProvider, Provider},
+    providers::{Provider, ProviderBuilder, RootProvider},
     rpc::client::ClientBuilder,
     transports::layers::RetryBackoffLayer,
 };
-use sbv_primitives::{ChainId, types::Network};
+use sbv_primitives::{types::Network, ChainId};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -35,7 +34,6 @@ pub struct RpcConfig {
     pub cups: u64,
 }
 
-
 pub struct RequestPreHandler {
     provider: RootProvider<Network>,
 }
@@ -44,47 +42,40 @@ impl RequestPreHandler {
     pub fn create(config: &RpcConfig) -> Result<Self> {
         let rpc = url::Url::parse(&config.rpc_url)?;
         tracing::info!("Using RPC: {}", rpc);
-        let retry_layer = RetryBackoffLayer::new(
-            config.max_retry,
-            config.backoff,
-            config.cups,
-        );
-        let client = ClientBuilder::default()
-            .layer(retry_layer)
-            .http(rpc);
+        let retry_layer = RetryBackoffLayer::new(config.max_retry, config.backoff, config.cups);
+        let client = ClientBuilder::default().layer(retry_layer).http(rpc);
 
         Ok(Self {
-            provider: ProviderBuilder::<_, _, Network>::default().on_client(client)
+            provider: ProviderBuilder::<_, _, Network>::default().on_client(client),
         })
-        
     }
 
     async fn on_chunk_request(&self, input: String) -> Result<String> {
-        use sbv_utils::{rpc::ProviderExt, witness::WitnessBuilder};
-        use alloy::network::primitives::BlockTransactionsKind;
         use crate::types::ChunkTaskDetail;
+        use alloy::network::primitives::BlockTransactionsKind;
+        use sbv_utils::{rpc::ProviderExt, witness::WitnessBuilder};
         use scroll_zkvm_prover_euclid::task::chunk::ChunkProvingTask;
 
-        let chunk_task : ChunkTaskDetail = serde_json::from_str(&input)?;
+        let chunk_task: ChunkTaskDetail = serde_json::from_str(&input)?;
 
         let chain_id = self.provider.get_chain_id().await?;
 
-        // we need block number but only get hashes, which cause much extra cost for query the block number from hash
-        // according to https://github.com/scroll-tech/scroll/blob/932be72b88ba2ebb6f9457e8480ee08d612d35a7/coordinator/internal/orm/l2_block.go#L53
+        // we need block number but only get hashes, which cause much extra cost for query the block
+        // number from hash according to https://github.com/scroll-tech/scroll/blob/932be72b88ba2ebb6f9457e8480ee08d612d35a7/coordinator/internal/orm/l2_block.go#L53
         // the hashes is ordered by ascending in block number so a heuristic way is applied
 
         let mut block_witnesses = Vec::new();
 
         for block_hash in chunk_task.block_hashes {
-            // grep `dump_block_witness` in sbv here, 
+            // grep `dump_block_witness` in sbv here,
             // TODO: we do not need to do that
             // if we have block number or `dump_block_witness` support block hashes
-            let block = self.provider.get_block_by_hash(
-                block_hash,
-                BlockTransactionsKind::Full,
-            ).await?
-            .ok_or_else(|| anyhow::anyhow!("Block not found"))?;
-            
+            let block = self
+                .provider
+                .get_block_by_hash(block_hash, BlockTransactionsKind::Full)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("Block not found"))?;
+
             let number = block.header.number;
 
             let builder = WitnessBuilder::new()
@@ -93,10 +84,20 @@ impl RequestPreHandler {
                 .execution_witness(self.provider.debug_execution_witness(number.into()).await?);
 
             let builder = builder
-                .state_root(self.provider.scroll_disk_root(number.into()).await?.disk_root)
+                .state_root(
+                    self.provider
+                        .scroll_disk_root(number.into())
+                        .await?
+                        .disk_root,
+                )
                 .unwrap()
-                .prev_state_root(self.provider.scroll_disk_root((number - 1).into()).await?.disk_root);
-    
+                .prev_state_root(
+                    self.provider
+                        .scroll_disk_root((number - 1).into())
+                        .await?
+                        .disk_root,
+                );
+
             block_witnesses.push(builder.build()?);
         }
 
@@ -108,17 +109,15 @@ impl RequestPreHandler {
         //self.provider.dump_block_witness(number)
 
         Ok(serde_json::to_string(&input_repack)?)
-
     }
 
     pub async fn on_request(&self, mut prove_request: ProveRequest) -> Result<ProveRequest> {
-
         match prove_request.proof_type {
             ProofType::Chunk => {
                 prove_request.input = self.on_chunk_request(prove_request.input).await?;
             }
-            _ => ()
+            _ => (),
         }
         Ok(prove_request)
     }
-}
+}