Add Tests for Segment Proving Without Keccak Tables

evm_arithmetization/src/arithmetic/mod.rs

@@ -1,5 +1,6 @@
 use ethereum_types::U256;
 use plonky2::field::types::PrimeField64;
+use serde::{Deserialize, Serialize};
 
 use self::columns::{
  INPUT_REGISTER_0, INPUT_REGISTER_1, INPUT_REGISTER_2, OPCODE_COL, OUTPUT_REGISTER,
@@ -24,7 +25,7 @@ pub(crate) mod columns;
 ///
 /// `Shl` and `Shr` are handled differently, by leveraging `Mul` and `Div`
 /// respectively.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub(crate) enum BinaryOperator {
  Add,
  Mul,
@@ -114,7 +115,7 @@ impl BinaryOperator {
 
 /// An enum representing different ternary operations.
 #[allow(clippy::enum_variant_names)]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub(crate) enum TernaryOperator {
  AddMod,
  MulMod,

evm_arithmetization/src/cpu/kernel/interpreter.rs

@@ -55,8 +55,7 @@ pub(crate) struct Interpreter<F: RichField> {
  /// halt_context
  pub(crate) halt_context: Option<usize>,
  /// Counts the number of appearances of each opcode. For debugging purposes.
- #[allow(unused)]
- pub(crate) opcode_count: [usize; 0x100],
+ pub(crate) opcode_count: HashMap<Operation, usize>,
  jumpdest_table: HashMap<usize, BTreeSet<usize>>,
  /// `true` if the we are currently carrying out a jumpdest analysis.
  pub(crate) is_jumpdest_analysis: bool,
@@ -179,7 +178,7 @@ impl<F: RichField> Interpreter<F> {
  // while the label `halt` is the halting label in the kernel.
  halt_offsets: vec![DEFAULT_HALT_OFFSET, KERNEL.global_labels["halt_final"]],
  halt_context: None,
- opcode_count: [0; 256],
+ opcode_count: HashMap::new(),
  jumpdest_table: HashMap::new(),
  is_jumpdest_analysis: false,
  clock: 0,
@@ -210,7 +209,7 @@ impl<F: RichField> Interpreter<F> {
  generation_state: state.soft_clone(),
  halt_offsets: vec![halt_offset],
  halt_context: Some(halt_context),
- opcode_count: [0; 256],
+ opcode_count: HashMap::new(),
  jumpdest_table: HashMap::new(),
  is_jumpdest_analysis: true,
  clock: 0,
@@ -429,6 +428,10 @@ impl<F: RichField> Interpreter<F> {
  self.max_cpu_len_log
  }
 
+ pub(crate) fn reset_opcode_counts(&mut self) {
+ self.opcode_count = HashMap::new();
+ }
+
  pub(crate) fn code(&self) -> &MemorySegmentState {
  // The context is 0 if we are in kernel mode.
  &self.generation_state.memory.contexts[(1 - self.is_kernel() as usize) * self.context()]
@@ -662,6 +665,9 @@ impl<F: RichField> State<F> for Interpreter<F> {
 
  let op = decode(registers, opcode)?;
 
+ // Increment the opcode count
+ *self.opcode_count.entry(op).or_insert(0) += 1;
+
  fill_op_flag(op, &mut row);
 
  self.fill_stack_fields(&mut row)?;

evm_arithmetization/src/fixed_recursive_verifier.rs

@@ -2997,3 +2997,80 @@ where
  circuit.verifier_only.circuit_digest.elements.len()
  + (1 << circuit.common.config.fri_config.cap_height) * NUM_HASH_OUT_ELTS
 }
+
+#[cfg(test)]
+#[cfg(not(feature = "cdk_erigon"))]
+mod tests {
+ use plonky2::field::goldilocks_field::GoldilocksField;
+ use plonky2::plonk::config::PoseidonGoldilocksConfig;
+ use plonky2::timed;
+
+ use super::*;
+ use crate::testing_utils::{empty_payload, init_logger};
+ use crate::witness::operation::Operation;
+
+ type F = GoldilocksField;
+ const D: usize = 2;
+ type C = PoseidonGoldilocksConfig;
+
+ #[test]
+ #[ignore]
+ fn test_segment_proof_generation_without_keccak() -> anyhow::Result<()> {
+ init_logger();
+
+ let all_stark = AllStark::<F, D>::default();
+ let config = StarkConfig::standard_fast_config();
+
+ // Generate a dummy payload for testing
+ let payload = empty_payload()?;
+ let max_cpu_len_log = Some(7);
+ let mut segment_iterator = SegmentDataIterator::<F>::new(&payload, max_cpu_len_log);
+ let (_, mut segment_data) = segment_iterator.next().unwrap()?;
+
+ let opcode_counts = &segment_data.opcode_counts;
+ assert!(!opcode_counts.contains_key(&Operation::KeccakGeneral));
+
+ let timing = &mut TimingTree::new(
+ "Segment Proof Generation Without Keccak Test",
+ log::Level::Info,
+ );
+ // Process and prove segment
+ let all_circuits = timed!(
+ timing,
+ log::Level::Info,
+ "Create all recursive circuits",
+ AllRecursiveCircuits::<F, C, D>::new(
+ &all_stark,
+ &[16..17, 8..9, 7..8, 4..9, 8..9, 4..7, 17..18, 17..18, 17..18],
+ &config,
+ )
+ );
+
+ let segment_proof = timed!(
+ timing,
+ log::Level::Info,
+ "Prove segment",
+ all_circuits.prove_segment(
+ &all_stark,
+ &config,
+ payload.trim(),
+ &mut segment_data,
+ timing,
+ None,
+ )?
+ );
+
+ // Verify the generated segment proof
+ timed!(
+ timing,
+ log::Level::Info,
+ "Verify segment proof",
+ all_circuits.verify_root(segment_proof.proof_with_pvs.intern.clone())?
+ );
+
+ // Print timing details
+ timing.print();
+
+ Ok(())
+ }
+}

evm_arithmetization/src/generation/segments.rs

@@ -1,6 +1,8 @@
 //! Module defining the logic around proof segmentation into chunks,
 //! which allows what is commonly known as zk-continuations.
 
+use std::collections::HashMap;
+
 use anyhow::Result;
 use plonky2::hash::hash_types::RichField;
 use serde::{Deserialize, Serialize};
@@ -11,6 +13,7 @@ use crate::cpu::kernel::interpreter::{set_registers_and_run, ExtraSegmentData, I
 use crate::generation::state::State;
 use crate::generation::{collect_debug_tries, debug_inputs, ErrorWithTries, GenerationInputs};
 use crate::witness::memory::MemoryState;
+use crate::witness::operation::Operation;
 use crate::witness::state::RegistersState;
 
 /// Structure holding the data needed to initialize a segment.
@@ -29,6 +32,8 @@ pub struct GenerationSegmentData {
  pub(crate) extra_data: ExtraSegmentData,
  /// Log of the maximal cpu length.
  pub(crate) max_cpu_len_log: Option<usize>,
+ /// Counts the number of appearances of each opcode. For debugging purposes.
+ pub(crate) opcode_counts: HashMap<Operation, usize>,
 }
 
 impl GenerationSegmentData {
@@ -77,6 +82,7 @@ fn build_segment_data<F: RichField>(
  access_lists_ptrs: interpreter.generation_state.access_lists_ptrs.clone(),
  state_ptrs: interpreter.generation_state.state_ptrs.clone(),
  },
+ opcode_counts: interpreter.opcode_count.clone(),
  }
 }
 
@@ -133,6 +139,9 @@ impl<F: RichField> SegmentDataIterator<F> {
 
  let segment_index = segment_data.segment_index;
 
+ // Reset opcode counts before executing the segment
+ self.interpreter.reset_opcode_counts();
+
  // Run the interpreter to get `registers_after` and the partial data for the
  // next segment.
  let execution_result =
@@ -147,6 +156,8 @@ impl<F: RichField> SegmentDataIterator<F> {
  ));
 
  segment_data.registers_after = updated_registers;
+ segment_data.opcode_counts = self.interpreter.opcode_count.clone();
+
  Ok(Some(Box::new((segment_data, partial_segment_data))))
  } else {
  let inputs = &self.interpreter.get_generation_state().inputs;

evm_arithmetization/src/logic.rs

@@ -11,6 +11,7 @@ use plonky2::hash::hash_types::RichField;
 use plonky2::iop::ext_target::ExtensionTarget;
 use plonky2::timed;
 use plonky2::util::timing::TimingTree;
+use serde::{Deserialize, Serialize};
 use starky::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 use starky::evaluation_frame::StarkEvaluationFrame;
 use starky::lookup::{Column, Filter};
@@ -118,7 +119,7 @@ pub(crate) struct LogicStark<F, const D: usize> {
 }
 
 /// Logic operations.
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub(crate) enum Op {
  And,
  Or,

evm_arithmetization/src/testing_utils.rs

@@ -1,8 +1,9 @@
 //! A set of utility functions and constants to be used by `evm_arithmetization`
 //! unit and integration tests.
 
+use anyhow::Result;
 use env_logger::{try_init_from_env, Env, DEFAULT_FILTER_ENV};
-use ethereum_types::{BigEndianHash, H256, U256};
+use ethereum_types::{Address, BigEndianHash, H256, U256};
 use hex_literal::hex;
 use keccak_hash::keccak;
 use mpt_trie::{
@@ -12,7 +13,9 @@ use mpt_trie::{
 
 pub use crate::cpu::kernel::cancun_constants::*;
 pub use crate::cpu::kernel::constants::global_exit_root::*;
-use crate::{generation::mpt::AccountRlp, proof::BlockMetadata, util::h2u};
+use crate::generation::TrieInputs;
+use crate::proof::TrieRoots;
+use crate::{generation::mpt::AccountRlp, proof::BlockMetadata, util::h2u, GenerationInputs};
 
 pub const EMPTY_NODE_HASH: H256 = H256(hex!(
  "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"
@@ -161,3 +164,52 @@ pub fn scalable_contract_from_storage(storage_trie: &HashedPartialTrie) -> Accou
  ..Default::default()
  }
 }
+
+pub fn empty_payload() -> Result<GenerationInputs> {
+ // Set up default block metadata
+ let block_metadata = BlockMetadata {
+ block_beneficiary: Address::zero(),
+ block_timestamp: U256::zero(),
+ block_number: U256::one(),
+ block_difficulty: U256::zero(),
+ block_random: H256::zero(),
+ block_gaslimit: U256::zero(),
+ block_chain_id: U256::one(),
+ block_base_fee: U256::zero(),
+ ..Default::default()
+ };
+
+ // Initialize an empty state trie and storage tries
+ let state_trie_before = HashedPartialTrie::from(crate::Node::Empty);
+ let storage_tries = Vec::new();
+ let checkpoint_state_trie_root = state_trie_before.hash();
+
+ // Prepare the tries without any transactions or receipts
+ let tries_before = TrieInputs {
+ state_trie: state_trie_before.clone(),
+ storage_tries: storage_tries.clone(),
+ transactions_trie: HashedPartialTrie::from(crate::Node::Empty),
+ receipts_trie: HashedPartialTrie::from(crate::Node::Empty),
+ };
+
+ // The expected state trie after execution remains the same as before
+ let expected_state_trie_after = state_trie_before;
+
+ // Compute the trie roots after execution
+ let trie_roots_after = TrieRoots {
+ state_root: expected_state_trie_after.hash(),
+ transactions_root: tries_before.transactions_trie.hash(),
+ receipts_root: tries_before.receipts_trie.hash(),
+ };
+
+ // Construct the GenerationInputs without any transactions or state changes
+ let inputs = GenerationInputs {
+ tries: tries_before,
+ trie_roots_after,
+ checkpoint_state_trie_root,
+ block_metadata,
+ ..Default::default()
+ };
+
+ Ok(inputs)
+}

evm_arithmetization/src/witness/operation.rs

@@ -2,6 +2,7 @@ use ethereum_types::{BigEndianHash, U256};
 use itertools::Itertools;
 use keccak_hash::keccak;
 use plonky2::hash::hash_types::RichField;
+use serde::{Deserialize, Serialize};
 
 use super::state::KERNEL_CONTEXT;
 use super::transition::Transition;
@@ -29,7 +30,7 @@ use crate::witness::util::{
 };
 use crate::{arithmetic, logic};
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub(crate) enum Operation {
  Iszero,
  Not,