Prefetch JUMPDESTs through RPC with progressive proving

.cargo/config.toml

@@ -1,7 +1,18 @@
 [build]
 # https://github.com/rust-lang/rust/pull/124129
 # https://github.com/dtolnay/linkme/pull/88
-rustflags = ["-Z", "linker-features=-lld"]
+
+[env]
+RUST_BACKTRACE = "1"
+RUST_TEST_NOCAPTURE = "1"
+
+[term]
+verbose = true
+color = 'auto'
+
+[target.x86_64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-Z", "linker-features=-lld", "-C", "target-cpu=native"] #, "-C", "link-arg=-fuse-ld=/usr/bin/mold", "-C", "debuginfo=2"]
 
 [alias]
 xtask = ["run", "--package=xtask", "--"]

Cargo.toml

@@ -36,6 +36,8 @@ alloy = { version = '0.3.0', default-features = false, features = [
   "transport-http",
   "rpc-types-debug",
 ] }
+alloy-primitives = "0.8.0"
+alloy-serde = "0.3.0"
 anyhow = "1.0.86"
 async-stream = "0.3.5"
 axum = "0.7.5"
@@ -47,6 +49,7 @@ ciborium-io = "0.2.2"
 clap = { version = "4.5.7", features = ["derive", "env"] }
 compat = { path = "compat" }
 criterion = "0.5.1"
+derive_more = "1.0.0"
 dotenvy = "0.15.7"
 either = "1.12.0"
 enum-as-inner = "0.6.0"
@@ -86,6 +89,7 @@ ruint = "1.12.3"
 serde = "1.0.203"
 serde_json = "1.0.118"
 serde_path_to_error = "0.1.16"
+serde_with = "3.8.1"
 serde-big-array = "0.5.1"
 sha2 = "0.10.8"
 static_assertions = "1.1.0"
@@ -94,8 +98,8 @@ thiserror = "1.0.61"
 tiny-keccak = "2.0.2"
 tokio = { version = "1.38.0", features = ["full"] }
 tower = "0.4"
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing = { version = "0.1", features = ["attributes"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 trybuild = "1.0"
 u4 = "0.1.0"
 uint = "0.9.5"
@@ -119,3 +123,27 @@ starky = { git = "https://github.com/0xPolygonZero/plonky2.git", rev = "2488cdac
 
 [workspace.lints.clippy]
 too_long_first_doc_paragraph = "allow"
+
+[profile.release]
+opt-level = 3
+debug = true
+incremental = true
+debug-assertions = true
+lto = false
+overflow-checks = false
+
+[profile.test]
+opt-level = 3
+debug = true
+incremental = true
+debug-assertions = true
+lto = false
+overflow-checks = false
+
+[profile.dev]
+opt-level = 3
+debug = true
+incremental = true
+debug-assertions = true
+lto = false
+overflow-checks = false

evm_arithmetization/Cargo.toml

@@ -17,6 +17,7 @@ keywords.workspace = true
 [dependencies]
 anyhow.workspace = true
 bytes.workspace = true
+derive_more.workspace = true
 env_logger.workspace = true
 ethereum-types.workspace = true
 hashbrown.workspace = true

evm_arithmetization/benches/fibonacci_25m_gas.rs

@@ -192,6 +192,7 @@ fn prepare_setup() -> anyhow::Result<GenerationInputs<F>> {
             prev_hashes: vec![H256::default(); 256],
             cur_hash: H256::default(),
         },
+        jumpdest_table: None,
     })
 }
 

evm_arithmetization/src/cpu/kernel/interpreter.rs

@@ -5,11 +5,13 @@
 //! the future execution and generate nondeterministically the corresponding
 //! jumpdest table, before the actual CPU carries on with contract execution.
 
+use core::option::Option::None;
 use std::collections::{BTreeSet, HashMap};
 
 use anyhow::anyhow;
 use ethereum_types::{BigEndianHash, U256};
-use log::Level;
+use keccak_hash::H256;
+use log::{trace, Level};
 use mpt_trie::partial_trie::PartialTrie;
 use plonky2::hash::hash_types::RichField;
 use serde::{Deserialize, Serialize};
@@ -19,8 +21,10 @@
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::constants::global_metadata::GlobalMetadata;
 use crate::generation::debug_inputs;
+use crate::generation::jumpdest::{JumpDestTableProcessed, JumpDestTableWitness};
 use crate::generation::linked_list::LinkedListsPtrs;
 use crate::generation::mpt::{load_linked_lists_and_txn_and_receipt_mpts, TrieRootPtrs};
+use crate::generation::prover_input::get_proofs_and_jumpdests;
 use crate::generation::rlp::all_rlp_prover_inputs_reversed;
 use crate::generation::state::{
     all_ger_prover_inputs, all_withdrawals_prover_inputs_reversed, GenerationState,
@@ -54,6 +58,7 @@
     /// The interpreter will halt only if the current context matches
     /// halt_context
     pub(crate) halt_context: Option<usize>,
+    /// A table of call contexts and the JUMPDEST offsets that they jumped to.
     jumpdest_table: HashMap<usize, BTreeSet<usize>>,
     /// `true` if the we are currently carrying out a jumpdest analysis.
     pub(crate) is_jumpdest_analysis: bool,
@@ -73,9 +78,9 @@
 pub(crate) fn simulate_cpu_and_get_user_jumps<F: RichField>(
     final_label: &str,
     state: &GenerationState<F>,
-) -> Option<HashMap<usize, Vec<usize>>> {
+) -> Option<(JumpDestTableProcessed, JumpDestTableWitness)> {
     match state.jumpdest_table {
-        Some(_) => None,
+        Some(_) => Default::default(),
         None => {
             let halt_pc = KERNEL.global_labels[final_label];
             let initial_context = state.registers.context;
@@ -94,16 +99,22 @@
 
             let clock = interpreter.get_clock();
 
-            interpreter
+            let (jdtp, jdtw) = interpreter
                 .generation_state
-                .set_jumpdest_analysis_inputs(interpreter.jumpdest_table);
+                .get_jumpdest_analysis_inputs(interpreter.jumpdest_table.clone());
 
             log::debug!(
                 "Simulated CPU for jumpdest analysis halted after {:?} cycles.",
                 clock
             );
 
-            interpreter.generation_state.jumpdest_table
+            // if let Some(cc) = interpreter.generation_state.jumpdest_table {
+            //     interpreter.generation_state.jumpdest_table =
+            //         Some(JumpDestTableProcessed::merge([&cc, &jdtp]));
+            // } else {
+            //     interpreter.generation_state.jumpdest_table = Some(jdtp.clone());
+            // }
+            Some((jdtp, jdtw))
         }
     }
 }
@@ -116,7 +127,7 @@
     pub(crate) withdrawal_prover_inputs: Vec<U256>,
     pub(crate) ger_prover_inputs: Vec<U256>,
     pub(crate) trie_root_ptrs: TrieRootPtrs,
-    pub(crate) jumpdest_table: Option<HashMap<usize, Vec<usize>>>,
+    pub(crate) jumpdest_table: Option<JumpDestTableProcessed>,
     pub(crate) access_lists_ptrs: LinkedListsPtrs,
     pub(crate) state_ptrs: LinkedListsPtrs,
     pub(crate) next_txn_index: usize,
@@ -152,6 +163,49 @@
     interpreter.run()
 }
 
+/// Computes the JUMPDEST proofs for each context.
+///
+/// # Arguments
+///
+/// - `jumpdest_table_rpc`:  The raw table received from RPC.
+/// - `code_db`: The corresponding database of contract code used in the trace.
+///
+/// # Output
+///
+/// Returns a [`JumpDestTableProccessed`].
+pub(crate) fn get_jumpdest_analysis_inputs_rpc_progressive<F: RichField>(
+    jumpdest_table_rpc: &JumpDestTableWitness,
+    generation_state: &GenerationState<F>,
+) -> JumpDestTableProcessed {
+    let current_ctx = generation_state.registers.context;
+    let current_code = generation_state.get_current_code().unwrap();
+    let current_code_hash = generation_state.get_current_code_hash().unwrap();
+    let code_map: &HashMap<H256, Vec<u8>> = &generation_state.inputs.contract_code;
+
+    trace!(
+        "current_code: {:?}, current_code_hash: {:?}, {:?} <============",
+        &current_code,
+        &current_code_hash,
+        code_map.contains_key(&current_code_hash),
+    );
+    trace!("code_map: {:?}", &code_map);
+    dbg!(current_ctx, current_code_hash, jumpdest_table_rpc.clone());
+    let mut ctx_proof = HashMap::<usize, Vec<_>>::new();
+    if jumpdest_table_rpc.contains_key(&current_code_hash) {
+        let cc = &(*jumpdest_table_rpc)[&current_code_hash].0;
+        if cc.contains_key(&current_ctx) {
+            let current_offsets = cc[&current_ctx].clone();
+            //let ctx_proof = prove_context_jumpdests(&current_code, &offsets);
+            let largest_address = current_offsets.last().unwrap().clone();
+            let offset_proofs =
+                get_proofs_and_jumpdests(&current_code, largest_address, current_offsets);
+            ctx_proof.insert(current_ctx, offset_proofs);
+        }
+    }
+
+    JumpDestTableProcessed::new(ctx_proof)
+}
+
 impl<F: RichField> Interpreter<F> {
     /// Returns an instance of `Interpreter` given `GenerationInputs`, and
     /// assuming we are initializing with the `KERNEL` code.

evm_arithmetization/src/cpu/kernel/tests/add11.rs

@@ -193,6 +193,7 @@ fn test_add11_yml() {
             prev_hashes: vec![H256::default(); 256],
             cur_hash: H256::default(),
         },
+        jumpdest_table: None,
     };
 
     let initial_stack = vec![];
@@ -370,6 +371,7 @@ fn test_add11_yml_with_exception() {
             prev_hashes: vec![H256::default(); 256],
             cur_hash: H256::default(),
         },
+        jumpdest_table: None,
     };
 
     let initial_stack = vec![];

evm_arithmetization/src/cpu/kernel/tests/core/jumpdest_analysis.rs

@@ -10,13 +10,15 @@ use plonky2::hash::hash_types::RichField;
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::interpreter::Interpreter;
 use crate::cpu::kernel::opcodes::{get_opcode, get_push_opcode};
+use crate::generation::jumpdest::JumpDestTableProcessed;
 use crate::memory::segments::Segment;
 use crate::witness::memory::MemoryAddress;
 use crate::witness::operation::CONTEXT_SCALING_FACTOR;
 
 impl<F: RichField> Interpreter<F> {
     pub(crate) fn set_jumpdest_analysis_inputs(&mut self, jumps: HashMap<usize, BTreeSet<usize>>) {
-        self.generation_state.set_jumpdest_analysis_inputs(jumps);
+        let (jdtp, _jdtw) = self.generation_state.get_jumpdest_analysis_inputs(jumps);
+        self.generation_state.jumpdest_table = Some(jdtp);
     }
 
     pub(crate) fn get_jumpdest_bit(&self, offset: usize) -> U256 {
@@ -106,7 +108,10 @@ fn test_jumpdest_analysis() -> Result<()> {
         interpreter.generation_state.jumpdest_table,
         // Context 3 has jumpdest 1, 5, 7. All have proof 0 and hence
         // the list [proof_0, jumpdest_0, ... ] is [0, 1, 0, 5, 0, 7, 8, 40]
-        Some(HashMap::from([(3, vec![0, 1, 0, 5, 0, 7, 8, 40])]))
+        Some(JumpDestTableProcessed::new(HashMap::from([(
+            3,
+            vec![0, 1, 0, 5, 0, 7, 8, 40]
+        )])))
     );
 
     // Run jumpdest analysis with context = 3
@@ -175,7 +180,9 @@ fn test_packed_verification() -> Result<()> {
     let mut interpreter: Interpreter<F> =
         Interpreter::new(write_table_if_jumpdest, initial_stack.clone(), None);
     interpreter.set_code(CONTEXT, code.clone());
-    interpreter.generation_state.jumpdest_table = Some(HashMap::from([(3, vec![1, 33])]));
+    interpreter.generation_state.jumpdest_table = Some(JumpDestTableProcessed::new(HashMap::from(
+        [(3, vec![1, 33])],
+    )));
 
     interpreter.run()?;
 
@@ -188,7 +195,9 @@ fn test_packed_verification() -> Result<()> {
         let mut interpreter: Interpreter<F> =
             Interpreter::new(write_table_if_jumpdest, initial_stack.clone(), None);
         interpreter.set_code(CONTEXT, code.clone());
-        interpreter.generation_state.jumpdest_table = Some(HashMap::from([(3, vec![1, 33])]));
+        interpreter.generation_state.jumpdest_table = Some(JumpDestTableProcessed::new(
+            HashMap::from([(3, vec![1, 33])]),
+        ));
 
         assert!(interpreter.run().is_err());
 

evm_arithmetization/src/cpu/kernel/tests/init_exc_stop.rs

@@ -101,6 +101,7 @@ fn test_init_exc_stop() {
             cur_hash: H256::default(),
         },
         ger_data: None,
+        jumpdest_table: None,
     };
     let initial_stack = vec![];
     let initial_offset = KERNEL.global_labels["init"];