prune storage fetch in execution

Author: noel2004

crates/l2geth/src/rpc_client.rs

@@ -1,5 +1,5 @@
 use alloy::{
-    providers::{Provider, ProviderBuilder, RootProvider},
+    providers::{Provider, ProviderBuilder},
     rpc::client::ClientBuilder,
     transports::layers::RetryBackoffLayer,
 };
@@ -81,7 +81,7 @@ impl RpcClientCore {
         })
     }
 
-    pub fn get_client(&self) -> RpcClient<impl Provider<Network>> {
+    pub fn get_client(&self) -> RpcClient<'_, impl Provider<Network>> {
         RpcClient {
             provider: ProviderBuilder::<_, _, Network>::default().connect_client(self.client.clone()),
             handle: self.rt.handle(),
@@ -100,7 +100,7 @@ impl<T: Provider<Network>> ChunkInterpreter for RpcClient<'_, T> {
             block_hash: sbv_primitives::B256,
             prev_witness: Option<&sbv_core::BlockWitness>,
         ) -> Result<sbv_core::BlockWitness> {
-            use sbv_utils::{rpc::ProviderExt, witness::WitnessBuilder};
+            use sbv_utils::rpc::ProviderExt;
 
             let (chain_id, block_num, prev_state_root) = if let Some(w) = prev_witness {
                 (
@@ -119,7 +119,7 @@ impl<T: Provider<Network>> ChunkInterpreter for RpcClient<'_, T> {
                 let parent_block = provider
                     .get_block_by_hash(block.header.parent_hash)
                     .await?
-                    .expect(&format!("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)
             };
@@ -183,10 +183,10 @@ mod tests {
         let client_core = RpcClientCore::create(&config).expect("Failed to create RPC client");
         let client = client_core.get_client();
 
-        // latest - 1 block in 2025.6.15
+        // latest - 1 block in 2025.9.11
         let block_hash = B256::from(
             hex::const_decode_to_array(
-                b"0x9535a6970bc4db9031749331a214e35ed8c8a3f585f6f456d590a0bc780a1368",
+                b"0x093fb6bf2e556a659b35428ac447cd9f0635382fc40ffad417b5910824f9e932",
             )
             .unwrap(),
         );
@@ -196,10 +196,10 @@ mod tests {
             .try_fetch_block_witness(block_hash, None)
             .expect("should success");
 
-        // latest block in 2025.6.15
+        // block selected in 2025.9.11
         let block_hash = B256::from(
             hex::const_decode_to_array(
-                b"0xd47088cdb6afc68aa082e633bb7da9340d29c73841668afacfb9c1e66e557af0",
+                b"0x77cc84dd7a4dedf6fe5fb9b443aeb5a4fb0623ad088a365d3232b7b23fc848e5",
             )
             .unwrap(),
         );
@@ -210,25 +210,4 @@ mod tests {
         println!("{}", serde_json::to_string_pretty(&wit2).unwrap());
     }
 
-    #[test]
-    #[ignore = "Requires L2GETH_ENDPOINT environment variable"]
-    fn test_try_fetch_storage_node() {
-        let config = create_config_from_env();
-        let client_core = RpcClientCore::create(&config).expect("Failed to create RPC client");
-        let client = client_core.get_client();
-
-        // the root node (state root) of the block in unittest above
-        let node_hash = B256::from(
-            hex::const_decode_to_array(
-                b"0xb9e67403a2eb35afbb0475fe942918cf9a330a1d7532704c24554506be62b27c",
-            )
-            .unwrap(),
-        );
-
-        // This is expected to fail since we're using a dummy hash, but it tests the code path
-        let node = client
-            .try_fetch_storage_node(node_hash)
-            .expect("should success");
-        println!("{}", serde_json::to_string_pretty(&node).unwrap());
-    }
 }

crates/libzkp/src/lib.rs

@@ -35,7 +35,6 @@ pub fn gen_universal_task(
     task_json: &str,
     fork_name_str: &str,
     expected_vk: &[u8],
-    interpreter: Option<impl ChunkInterpreter>,
 ) -> eyre::Result<(B256, String, String)> {
     use proofs::*;
     use tasks::*;
@@ -60,7 +59,7 @@ pub fn gen_universal_task(
                 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(), interpreter)
+                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)

crates/libzkp/src/proofs.rs

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

crates/libzkp/src/tasks.rs

@@ -42,13 +42,9 @@ where
 
 /// Generate required staff for chunk proving
 pub fn gen_universal_chunk_task(
-    mut task: ChunkProvingTask,
+    task: ChunkProvingTask,
     fork_name: ForkName,
-    interpreter: Option<impl ChunkInterpreter>,
 ) -> eyre::Result<(B256, ChunkProofMetadata, ProvingTask)> {
-    if let Some(interpreter) = interpreter {
-        task.prepare_task_via_interpret(interpreter)?;
-    }
     let chunk_total_gas = task.stats().total_gas_used;
     let chunk_info = task.precheck_and_build_metadata()?;
     let proving_task = task.try_into()?;

crates/libzkp_c/src/lib.rs

@@ -153,17 +153,12 @@ pub unsafe extern "C" fn gen_universal_task(
     expected_vk: *const u8,
     expected_vk_len: usize,
 ) -> HandlingResult {
-    let mut interpreter = None;
     let task_json = if task_type == TaskType::Chunk as i32 {
         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) => {
-                interpreter.replace(cli);
-                str
-            }
+            Ok(str) => 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();
             }
@@ -183,7 +178,6 @@ pub unsafe extern "C" fn gen_universal_task(
         &task_json,
         c_char_to_str(fork_name),
         expected_vk,
-        interpreter,
     );
 
     if let Ok((pi_hash, meta_json, task_json)) = ret {