add strict check

Author: lightsing

bus-mapping/src/evm/opcodes.rs

@@ -12,7 +12,7 @@ use crate::{
 use core::fmt::Debug;
 use eth_types::{evm_unimplemented, GethExecStep, ToAddress, ToWord, Word};
 
-use crate::util::CHECK_MEM_STRICT;
+use crate::util::CHECK_MEM_STACK_STRICT;
 
 #[cfg(any(feature = "test", test))]
 pub use self::sha3::sha3_tests::{gen_sha3_code, MemoryKind};
@@ -401,7 +401,7 @@ pub fn gen_associated_ops(
     state: &mut CircuitInputStateRef,
     geth_steps: &[GethExecStep],
 ) -> Result<Vec<ExecStep>, Error> {
-    let check_level = if *CHECK_MEM_STRICT { 2 } else { 0 }; // 0: no check, 1: check and log error and fix, 2: check and assert_eq
+    let check_level = if *CHECK_MEM_STACK_STRICT { 2 } else { 0 }; // 0: no check, 1: check and log error and fix, 2: check and assert_eq
     if check_level >= 1 {
         let memory_enabled = !geth_steps.iter().all(|s| s.memory.is_empty());
         if memory_enabled {
@@ -437,6 +437,38 @@ pub fn gen_associated_ops(
                 state.call_ctx_mut()?.memory = geth_steps[0].memory.clone();
             }
         }
+        let stack_enabled = !geth_steps.iter().all(|s| s.stack.is_empty());
+        if stack_enabled {
+            if state.call_ctx()?.stack != geth_steps[0].stack {
+                log::error!(
+                    "wrong stack before {:?}. len in state {}, len in step {}",
+                    opcode_id,
+                    &state.call_ctx()?.stack.len(),
+                    &geth_steps[0].stack.len(),
+                );
+                log::error!("state stack {:?}", &state.call_ctx()?.stack);
+                log::error!("step  stack {:?}", &geth_steps[0].stack);
+
+                for i in
+                    0..std::cmp::min(state.call_ctx()?.stack.0.len(), geth_steps[0].stack.0.len())
+                {
+                    let state_stack = state.call_ctx()?.stack.0[i];
+                    let step_stack = geth_steps[0].stack.0[i];
+                    if state_stack != step_stack {
+                        log::error!(
+                            "diff at {}: state {:?} != step {:?}",
+                            i,
+                            state_stack,
+                            step_stack
+                        );
+                    }
+                }
+                if check_level >= 2 {
+                    panic!("stack wrong");
+                }
+                state.call_ctx_mut()?.stack = geth_steps[0].stack.clone();
+            }
+        }
     }
 
     // check if have error

bus-mapping/src/rpc.rs

@@ -11,7 +11,7 @@ use ethers_providers::JsonRpcClient;
 use serde::Serialize;
 use std::collections::HashMap;
 
-use crate::util::CHECK_MEM_STRICT;
+use crate::util::CHECK_MEM_STACK_STRICT;
 
 /// Serialize a type.
 ///
@@ -149,7 +149,8 @@ impl<P: JsonRpcClient> GethClient<P> {
     pub async fn trace_tx_by_hash(&self, hash: H256) -> Result<Vec<GethExecTrace>, Error> {
         let hash = serialize(&hash);
         let cfg = GethLoggerConfig {
-            enable_memory: *CHECK_MEM_STRICT,
+            enable_memory: *CHECK_MEM_STACK_STRICT,
+            // TODO: disable_stack: !*CHECK_MEM_STACK_STRICT,
             ..Default::default()
         };
         let cfg = serialize(&cfg);

bus-mapping/src/util.rs

@@ -13,7 +13,8 @@ pub fn read_env_var<T: Clone + FromStr>(var_name: &'static str, default: T) -> T
         .unwrap_or(default)
 }
 /// ..
-pub static CHECK_MEM_STRICT: Lazy<bool> = Lazy::new(|| read_env_var("CHECK_MEM_STRICT", false));
+pub static CHECK_MEM_STACK_STRICT: Lazy<bool> =
+    Lazy::new(|| read_env_var("CHECK_MEM_STACK_STRICT", false));
 
 /// Default number of bytes to pack into a field element.
 pub const POSEIDON_HASH_BYTES_IN_FIELD: usize = 31;

eth-types/src/evm_types/stack.rs

@@ -110,6 +110,16 @@ impl Stack {
         Stack(words)
     }
 
+    /// Returns the length of the stack.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Returns if the stack is empty.
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
     /// Returns the first available/free `StackAddress`.
     pub fn stack_pointer(&self) -> StackAddress {
         // Stack has 1024 slots.

testool/src/statetest/executor.rs

@@ -204,7 +204,8 @@ fn into_traceconfig(st: StateTest) -> (String, TraceConfig, StateTestResult) {
             }],
             accounts,
             logger_config: LoggerConfig {
-                enable_memory: *bus_mapping::util::CHECK_MEM_STRICT,
+                enable_memory: *bus_mapping::util::CHECK_MEM_STACK_STRICT,
+                // TODO: disable_stack: !*bus_mapping::util::CHECK_MEM_STACK_STRICT,
                 ..Default::default()
             },
             #[cfg(feature = "shanghai")]