Enables optional verification of Keccak tables

evm_arithmetization/src/all_stark.rs

@@ -126,6 +126,10 @@ pub const NUM_TABLES: usize = if cfg!(feature = "cdk_erigon") {
     Table::MemAfter as usize + 1
 };
 
+/// Indices of Keccak Tables
+pub const KECCAK_TABLES_INDICES: [usize; 2] =
+    [Table::Keccak as usize, Table::KeccakSponge as usize];
+
 impl Table {
     /// Returns all STARK table indices.
     pub(crate) const fn all() -> [Self; NUM_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)?;