fmt

Author: noel2004

crates/l2geth/src/rpc_client.rs

@@ -75,15 +75,13 @@ impl RpcClientCore {
         let retry_layer = RetryBackoffLayer::new(config.max_retry, config.backoff, config.cups);
         let client = ClientBuilder::default().layer(retry_layer).http(rpc);
 
-        Ok(Self {
-            client,
-            rt,
-        })
+        Ok(Self { client, rt })
     }
 
     pub fn get_client(&self) -> RpcClient<'_, impl Provider<Network>> {
         RpcClient {
-            provider: ProviderBuilder::<_, _, Network>::default().connect_client(self.client.clone()),
+            provider: ProviderBuilder::<_, _, Network>::default()
+                .connect_client(self.client.clone()),
             handle: self.rt.handle(),
         }
     }
@@ -103,11 +101,7 @@ impl<T: Provider<Network>> ChunkInterpreter for RpcClient<'_, T> {
             use sbv_utils::rpc::ProviderExt;
 
             let (chain_id, block_num, prev_state_root) = if let Some(w) = prev_witness {
-                (
-                    w.chain_id,
-                    w.header.number + 1,
-                    w.prev_state_root,
-                )
+                (w.chain_id, w.header.number + 1, w.prev_state_root)
             } else {
                 let chain_id = provider.get_chain_id().await?;
                 let block = provider
@@ -119,25 +113,40 @@ impl<T: Provider<Network>> ChunkInterpreter for RpcClient<'_, T> {
                 let parent_block = provider
                     .get_block_by_hash(block.header.parent_hash)
                     .await?
-                    .unwrap_or_else(||panic!("parent block for block {} should exist", block.header.number));
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "parent block for block {} should exist",
+                            block.header.number
+                        )
+                    });
 
-                (chain_id, block.header.number, parent_block.header.state_root)
+                (
+                    chain_id,
+                    block.header.number,
+                    parent_block.header.state_root,
+                )
             };
 
-            let req = provider.dump_block_witness(block_num)
+            let req = provider
+                .dump_block_witness(block_num)
                 .with_chain_id(chain_id)
                 .with_prev_state_root(prev_state_root);
 
-            let witness = req.send().await.transpose()
+            let witness = req
+                .send()
+                .await
+                .transpose()
                 .ok_or_else(|| eyre::eyre!("Block witness {block_num} not avaliable"))??;
 
             Ok(witness)
-
         }
 
         tracing::debug!("fetch witness for {block_hash}");
-        self.handle
-            .block_on(fetch_witness_async(&self.provider, block_hash, prev_witness))
+        self.handle.block_on(fetch_witness_async(
+            &self.provider,
+            block_hash,
+            prev_witness,
+        ))
     }
 
     fn try_fetch_storage_node(
@@ -209,5 +218,4 @@ mod tests {
 
         println!("{}", serde_json::to_string_pretty(&wit2).unwrap());
     }
-
 }

crates/libzkp/src/lib.rs

@@ -13,12 +13,12 @@ use tasks::chunk_interpreter::{ChunkInterpreter, TryFromWithInterpreter};
 
 /// global features: use legacy encoding for witness
 static mut LEGACY_WITNESS_ENCODING: bool = false;
-pub(crate) fn witness_use_legacy_mode() -> bool {unsafe{LEGACY_WITNESS_ENCODING}}
-
+pub(crate) fn witness_use_legacy_mode() -> bool {
+    unsafe { LEGACY_WITNESS_ENCODING }
+}
 
-pub fn set_dynamic_feature(feats: &str){
+pub fn set_dynamic_feature(feats: &str) {
     for feat_s in feats.split(':') {
-
         match feat_s.trim().to_lowercase().as_str() {
             "legacy_witness" => {
                 tracing::info!("set witness encoding for legacy mode");
@@ -32,7 +32,6 @@ pub fn set_dynamic_feature(feats: &str){
     }
 }
 
-
 /// Turn the coordinator's chunk task into a json string for formal chunk proving
 /// task (with full witnesses)
 pub fn checkout_chunk_task(
@@ -77,10 +76,9 @@ pub fn gen_universal_task(
             if fork_name_str != task.fork_name.as_str() {
                 eyre::bail!("fork name in chunk task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
             }
-            let (pi_hash, metadata, u_task) = utils::panic_catch(move || {
-                gen_universal_chunk_task(task, fork_name_str.into())
-            })
-            .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
+            let (pi_hash, metadata, u_task) =
+                utils::panic_catch(move || gen_universal_chunk_task(task, fork_name_str.into()))
+                    .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
             (pi_hash, AnyMetaData::Chunk(metadata), u_task)
         }
         x if x == TaskType::Batch as i32 => {

crates/libzkp/src/proofs.rs

@@ -10,7 +10,7 @@ use scroll_zkvm_types::{
     proof::{EvmProof, OpenVmEvmProof, ProofEnum, StarkProof},
     public_inputs::{ForkName, MultiVersionPublicInputs},
     types_agg::AggregationInput,
-    utils::{vec_as_base64, serialize_vk}
+    utils::{serialize_vk, vec_as_base64},
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 

crates/libzkp/src/tasks/batch.rs

@@ -4,9 +4,9 @@ use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
     batch::{
-        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderV8, BatchInfo, BatchWitness,
-        Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, ReferenceHeader,
-        build_point_eval_witness, N_BLOB_BYTES, LegacyBatchWitness,
+        build_point_eval_witness, BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderV8,
+        BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, LegacyBatchWitness,
+        ReferenceHeader, N_BLOB_BYTES,
     },
     public_inputs::ForkName,
     task::ProvingTask,
@@ -167,7 +167,7 @@ impl BatchProvingTask {
             assert_eq!(p, kzg_proof);
         }
 
-        let point_eval_witness = Some(build_point_eval_witness (
+        let point_eval_witness = Some(build_point_eval_witness(
             kzg_commitment.into_inner(),
             kzg_proof.into_inner(),
         ));

crates/libzkp/src/tasks/chunk.rs

@@ -1,7 +1,7 @@
 use super::chunk_interpreter::*;
 use eyre::Result;
-use sbv_primitives::B256;
 use sbv_core::BlockWitness;
+use sbv_primitives::B256;
 use scroll_zkvm_types::{
     chunk::{execute, ChunkInfo, ChunkWitness, LegacyChunkWitness},
     task::ProvingTask,

crates/libzkp/src/tasks/chunk_interpreter.rs

@@ -1,6 +1,6 @@
 use eyre::Result;
-use sbv_primitives::{Bytes, B256};
 use sbv_core::BlockWitness;
+use sbv_primitives::{Bytes, B256};
 
 /// An interpreter which is cirtical in translating chunk data
 /// since we need to grep block witness and storage node data

crates/libzkp_c/src/lib.rs

@@ -157,7 +157,7 @@ pub unsafe extern "C" fn gen_universal_task(
         let pre_task_str = c_char_to_str(task);
         let cli = l2geth::get_client();
         match libzkp::checkout_chunk_task(pre_task_str, cli) {
-            Ok(str) => str,            
+            Ok(str) => str,
             Err(e) => {
                 tracing::error!("gen_universal_task failed at pre interpret step, error: {e}");
                 return failed_handling_result();
@@ -173,12 +173,8 @@ pub unsafe extern "C" fn gen_universal_task(
         &[]
     };
 
-    let ret = libzkp::gen_universal_task(
-        task_type,
-        &task_json,
-        c_char_to_str(fork_name),
-        expected_vk,
-    );
+    let ret =
+        libzkp::gen_universal_task(task_type, &task_json, c_char_to_str(fork_name), expected_vk);
 
     if let Ok((pi_hash, meta_json, task_json)) = ret {
         let expected_pi_hash = pi_hash.0.map(|byte| byte as c_char);