add feature switch

Author: lightsing

bus-mapping/Cargo.toml

@@ -41,8 +41,12 @@ mock = { path = "../mock" }
 rand.workspace = true
 
 [features]
-default = ["test"]
+default = ["test", "enable-stack", "enable-storage"]
 test = ["mock", "rand"]
 scroll = ["eth-types/scroll", "mock?/scroll"]
 # Enable shanghai feature of mock only if mock is enabled (by test).
 shanghai = ["eth-types/shanghai", "mock?/shanghai"]
+tracer-tests = ["enable-memory"]
+enable-stack = ["eth-types/enable-stack"]
+enable-memory = ["eth-types/enable-memory"]
+enable-storage = ["eth-types/enable-storage"]

bus-mapping/src/circuit_input_builder.rs

@@ -8,7 +8,7 @@ mod execution;
 mod input_state_ref;
 #[cfg(feature = "scroll")]
 mod l2;
-#[cfg(test)]
+#[cfg(all(feature = "tracer-tests", test))]
 mod tracer_tests;
 mod transaction;
 

bus-mapping/src/evm/opcodes.rs

@@ -12,7 +12,8 @@ use crate::{
 use core::fmt::Debug;
 use eth_types::{evm_unimplemented, GethExecStep, ToAddress, ToWord, Word};
 
-use crate::util::CHECK_MEM_STRICT;
+#[cfg(feature = "enable-memory")]
+use crate::util::GETH_TRACE_CHECK_LEVEL;
 
 #[cfg(any(feature = "test", test))]
 pub use self::sha3::sha3_tests::{gen_sha3_code, MemoryKind};
@@ -383,8 +384,8 @@ 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
-    if check_level >= 1 {
+    #[cfg(feature = "enable-memory")]
+    if GETH_TRACE_CHECK_LEVEL.should_check() {
         let memory_enabled = !geth_steps.iter().all(|s| s.memory.is_empty());
         assert!(memory_enabled);
         if memory_enabled {
@@ -414,7 +415,7 @@ pub fn gen_associated_ops(
                         );
                     }
                 }
-                if check_level >= 2 {
+                if GETH_TRACE_CHECK_LEVEL.should_panic() {
                     panic!("mem wrong");
                 }
                 state.call_ctx_mut()?.memory = geth_steps[0].memory.clone();

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::GETH_TRACE_CHECK_LEVEL;
 
 /// Serialize a type.
 ///
@@ -42,9 +42,9 @@ pub(crate) struct GethLoggerConfig {
 impl Default for GethLoggerConfig {
     fn default() -> Self {
         Self {
-            enable_memory: false,
-            disable_stack: false,
-            disable_storage: false,
+            enable_memory: cfg!(feature = "enable-memory"),
+            disable_stack: !cfg!(feature = "enable-stack"),
+            disable_storage: !cfg!(feature = "enable-storage"),
             enable_return_data: true,
         }
     }
@@ -149,7 +149,7 @@ 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: cfg!(feature = "enable-memory") && GETH_TRACE_CHECK_LEVEL.should_check(),
             ..Default::default()
         };
         let cfg = serialize(&cfg);

bus-mapping/src/util.rs

@@ -3,6 +3,7 @@ use eth_types::{Hash, U256};
 pub use eth_types::{KECCAK_CODE_HASH_EMPTY, POSEIDON_CODE_HASH_EMPTY};
 use halo2_proofs::halo2curves::{bn256::Fr, group::ff::PrimeField};
 use once_cell::sync::Lazy;
+use std::convert::Infallible;
 
 use std::str::FromStr;
 
@@ -12,8 +13,44 @@ pub fn read_env_var<T: Clone + FromStr>(var_name: &'static str, default: T) -> T
         .map(|s| s.parse::<T>().unwrap_or_else(|_| default.clone()))
         .unwrap_or(default)
 }
-/// ..
-pub static CHECK_MEM_STRICT: Lazy<bool> = Lazy::new(|| read_env_var("CHECK_MEM_STRICT", false));
+/// env var for Geth trace sanity check level
+pub static GETH_TRACE_CHECK_LEVEL: Lazy<GethTraceSanityCheckLevel> =
+    Lazy::new(|| read_env_var("GETH_TRACE_CHECK_LEVEL", GethTraceSanityCheckLevel::None));
+
+/// Geth trace sanity check level
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GethTraceSanityCheckLevel {
+    /// No sanity check
+    None,
+    /// Check sanity and log error
+    Check,
+    /// Panic on error
+    Strict,
+}
+
+impl GethTraceSanityCheckLevel {
+    /// Whether to do sanity check
+    pub fn should_check(&self) -> bool {
+        *self != GethTraceSanityCheckLevel::None
+    }
+
+    /// Whether to panic on error
+    pub fn should_panic(&self) -> bool {
+        *self == GethTraceSanityCheckLevel::Strict
+    }
+}
+
+impl FromStr for GethTraceSanityCheckLevel {
+    type Err = Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "strict" => Ok(GethTraceSanityCheckLevel::Strict),
+            _ if !s.is_empty() => Ok(GethTraceSanityCheckLevel::Check),
+            _ => Ok(GethTraceSanityCheckLevel::None),
+        }
+    }
+}
 
 /// Default number of bytes to pack into a field element.
 pub const POSEIDON_HASH_BYTES_IN_FIELD: usize = 31;

eth-types/Cargo.toml

@@ -30,3 +30,8 @@ default = ["warn-unimplemented"]
 warn-unimplemented = []
 shanghai = []
 scroll = []
+
+# trace heap allocation related feature switches
+enable-stack = []
+enable-memory = []
+enable-storage = []

eth-types/src/l2_types.rs

@@ -1,13 +1,20 @@
 //! L2 types used to deserialize traces for l2geth.
 
 use crate::{
-    evm_types::{Gas, GasCost, Memory, OpcodeId, ProgramCounter, Stack, Storage},
+    evm_types::{Gas, GasCost, OpcodeId, ProgramCounter},
     Block, GethExecStep, GethExecTrace, Hash, Transaction, Word, H256,
 };
 use ethers_core::types::{Address, Bytes, U256, U64};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
+#[cfg(feature = "enable-memory")]
+use crate::evm_types::Memory;
+#[cfg(feature = "enable-stack")]
+use crate::evm_types::Stack;
+#[cfg(feature = "enable-storage")]
+use crate::evm_types::Storage;
+
 /// l2 block full trace
 #[derive(Deserialize, Serialize, Default, Debug, Clone)]
 pub struct BlockTrace {
@@ -226,19 +233,18 @@ pub struct ExecStep {
     pub refund: u64,
     pub depth: isize,
     pub error: Option<String>,
+    #[cfg(feature = "enable-stack")]
     pub stack: Option<Vec<Word>>,
+    #[cfg(feature = "enable-memory")]
     pub memory: Option<Vec<Word>>,
+    #[cfg(feature = "enable-storage")]
     pub storage: Option<HashMap<Word, Word>>,
     #[serde(rename = "extraData")]
     pub extra_data: Option<ExtraData>,
 }
 
 impl From<ExecStep> for GethExecStep {
     fn from(e: ExecStep) -> Self {
-        let stack = e.stack.map_or_else(Stack::new, Stack::from);
-        let storage = e.storage.map_or_else(Storage::empty, Storage::from);
-        let memory = e.memory.map_or_else(Memory::default, Memory::from);
-
         GethExecStep {
             pc: ProgramCounter(e.pc as usize),
             // FIXME
@@ -248,9 +254,12 @@ impl From<ExecStep> for GethExecStep {
             refund: Gas(e.refund),
             depth: e.depth as u16,
             error: e.error,
-            stack,
-            memory,
-            storage,
+            #[cfg(feature = "enable-stack")]
+            stack: e.stack.map_or_else(Stack::new, Stack::from),
+            #[cfg(feature = "enable-memory")]
+            memory: e.memory.map_or_else(Memory::default, Memory::from),
+            #[cfg(feature = "enable-storage")]
+            storage: e.storage.map_or_else(Storage::empty, Storage::from),
         }
     }
 }

eth-types/src/lib.rs

@@ -30,9 +30,7 @@ use halo2_proofs::{
     halo2curves::{bn256::Fr, group::ff::PrimeField},
 };
 
-use crate::evm_types::{
-    memory::Memory, stack::Stack, storage::Storage, Gas, GasCost, OpcodeId, ProgramCounter,
-};
+use crate::evm_types::{Gas, GasCost, OpcodeId, ProgramCounter};
 use ethers_core::types;
 pub use ethers_core::{
     abi::ethereum_types::{BigEndianHash, U512},
@@ -41,11 +39,17 @@ pub use ethers_core::{
         Address, Block, Bytes, Signature, H160, H256, H64, U256, U64,
     },
 };
-
 use once_cell::sync::Lazy;
 use serde::{de, Deserialize, Serialize};
 use std::{collections::HashMap, fmt, str::FromStr};
 
+#[cfg(feature = "enable-memory")]
+use crate::evm_types::Memory;
+#[cfg(feature = "enable-stack")]
+use crate::evm_types::Stack;
+#[cfg(feature = "enable-storage")]
+use crate::evm_types::Storage;
+
 /// Trait used to reduce verbosity with the declaration of the [`FieldExt`]
 /// trait and its repr.
 pub trait Field:
@@ -352,12 +356,15 @@ struct GethExecStepInternal {
     depth: u16,
     error: Option<String>,
     // stack is in hex 0x prefixed
+    #[cfg(feature = "enable-stack")]
     #[serde(default)]
     stack: Vec<DebugU256>,
     // memory is in chunks of 32 bytes, in hex
+    #[cfg(feature = "enable-memory")]
     #[serde(default)]
     memory: Vec<DebugU256>,
     // storage is hex -> hex
+    #[cfg(feature = "enable-storage")]
     #[serde(default)]
     storage: HashMap<DebugU256, DebugU256>,
 }
@@ -375,10 +382,13 @@ pub struct GethExecStep {
     pub depth: u16,
     pub error: Option<String>,
     // stack is in hex 0x prefixed
+    #[cfg(feature = "enable-stack")]
     pub stack: Stack,
     // memory is in chunks of 32 bytes, in hex
+    #[cfg(feature = "enable-memory")]
     pub memory: Memory,
     // storage is hex -> hex
+    #[cfg(feature = "enable-storage")]
     pub storage: Storage,
 }
 
@@ -403,18 +413,21 @@ impl<'a> fmt::Debug for DebugWord<'a> {
 
 impl fmt::Debug for GethExecStep {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Step")
-            .field("pc", &format_args!("0x{:04x}", self.pc.0))
+        let mut f = f.debug_struct("Step");
+        f.field("pc", &format_args!("0x{:04x}", self.pc.0))
             .field("op", &self.op)
             .field("gas", &format_args!("{}", self.gas.0))
             .field("gas_cost", &format_args!("{}", self.gas_cost.0))
             .field("refund", &format_args!("{}", self.refund.0))
             .field("depth", &self.depth)
-            .field("error", &self.error)
-            .field("stack", &self.stack)
-            // .field("memory", &self.memory)
-            .field("storage", &self.storage)
-            .finish()
+            .field("error", &self.error);
+        #[cfg(feature = "enable-stack")]
+        f.field("stack", &self.stack);
+        #[cfg(feature = "enable-memory")]
+        f.field("memory", &self.memory);
+        #[cfg(feature = "enable-storage")]
+        f.field("storage", &self.storage);
+        f.finish()
     }
 }
 
@@ -432,13 +445,16 @@ impl<'de> Deserialize<'de> for GethExecStep {
             gas_cost: s.gas_cost,
             depth: s.depth,
             error: s.error,
+            #[cfg(feature = "enable-stack")]
             stack: Stack(s.stack.iter().map(|dw| dw.to_word()).collect::<Vec<Word>>()),
+            #[cfg(feature = "enable-memory")]
             memory: Memory::from(
                 s.memory
                     .iter()
                     .map(|dw| dw.to_word())
                     .collect::<Vec<Word>>(),
             ),
+            #[cfg(feature = "enable-storage")]
             storage: Storage(
                 s.storage
                     .iter()
@@ -552,7 +568,10 @@ macro_rules! word_map {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::evm_types::{memory::Memory, opcode_ids::OpcodeId, stack::Stack};
+    use crate::evm_types::{opcode_ids::OpcodeId, stack::Stack};
+
+    #[cfg(feature = "enable-memory")]
+    use crate::evm_types::memory::Memory;
 
     #[test]
     fn test_to_u16_array() {
@@ -648,8 +667,11 @@ mod tests {
                         gas_cost: GasCost(3),
                         depth: 1,
                         error: None,
+                        #[cfg(feature = "enable-stack")]
                         stack: Stack::new(),
+                        #[cfg(feature = "enable-storage")]
                         storage: Storage(word_map!()),
+                        #[cfg(feature = "enable-memory")]
                         memory: Memory::new(),
                     },
                     GethExecStep {
@@ -660,8 +682,11 @@ mod tests {
                         gas_cost: GasCost(2100),
                         depth: 1,
                         error: None,
+                        #[cfg(feature = "enable-stack")]
                         stack: Stack(vec![word!("0x1003e2d2"), word!("0x2a"), word!("0x0")]),
+                        #[cfg(feature = "enable-storage")]
                         storage: Storage(word_map!("0x0" => "0x6f")),
+                        #[cfg(feature = "enable-memory")]
                         memory: Memory::from(vec![word!("0x0"), word!("0x0"), word!("0x080")]),
                     },
                     GethExecStep {
@@ -672,12 +697,15 @@ mod tests {
                         gas_cost: GasCost(42),
                         depth: 1,
                         error: None,
+                        #[cfg(feature = "enable-stack")]
                         stack: Stack(vec![
                             word!("0x3635c9adc5dea00000"),
                             word!("0x40"),
                             word!("0x0")
                         ]),
+                        #[cfg(feature = "enable-storage")]
                         storage: Storage(word_map!()),
+                        #[cfg(feature = "enable-memory")]
                         memory: Memory::from(vec![
                             word!(
                                 "000000000000000000000000b8f67472dcc25589672a61905f7fd63f09e5d470"

external-tracer/src/lib.rs

@@ -58,6 +58,7 @@ impl Default for LoggerConfig {
 }
 
 impl LoggerConfig {
+    #[cfg(feature = "enable-memory")]
     pub fn enable_memory() -> Self {
         Self {
             enable_memory: true,

testool/Cargo.toml

@@ -50,3 +50,7 @@ scroll = ["bus-mapping/scroll", "eth-types/scroll", "external-tracer/scroll", "m
 parallel_syn = ["halo2_proofs/parallel_syn", "zkevm-circuits/parallel_syn", "prover?/parallel_syn"]
 inner-prove = ["prover/test", "parallel_syn", "scroll", "shanghai"]
 chunk-prove = ["prover/test", "parallel_syn", "scroll", "shanghai"]
+
+enable-stack = ["zkevm-circuits/enable-stack"]
+enable-memory = ["zkevm-circuits/enable-memory"]
+enable-storage = ["zkevm-circuits/enable-storage"]