Merge branch 'implement-tracers' into parallel-execution

core/lib/multivm/src/versions/era_vm/tracers/debug_tracer.rs

@@ -0,0 +1,58 @@
+use zksync_state::ReadStorage;
+use zksync_types::U256;
+use zksync_utils::u256_to_h256;
+
+use super::traits::{Tracer, VmTracer};
+use crate::era_vm::hook::Hook;
+
+pub struct DebugTracer {}
+
+impl Tracer for DebugTracer {}
+
+impl<S: ReadStorage> VmTracer<S> for DebugTracer {
+    fn bootloader_hook_call(
+        &mut self,
+        _vm: &mut super::traits::Vm<S>,
+        hook: crate::era_vm::hook::Hook,
+        hook_params: &[U256; 3],
+    ) {
+        match hook {
+            Hook::DebugLog => {
+                let msg = u256_to_h256(hook_params[0]).as_bytes().to_vec();
+                let data = u256_to_h256(hook_params[1]).as_bytes().to_vec();
+
+                let msg = String::from_utf8(msg).expect("Invalid debug message");
+                let data = U256::from_big_endian(&data);
+
+                // For long data, it is better to use hex-encoding for greater readability
+                let data_str = if data > U256::from(u64::max_value()) {
+                    let mut bytes = [0u8; 32];
+                    data.to_big_endian(&mut bytes);
+                    format!("0x{}", hex::encode(bytes))
+                } else {
+                    data.to_string()
+                };
+
+                println!("======== BOOTLOADER DEBUG LOG ========");
+                println!("MSG: {:?}", msg);
+                println!("DATA: {}", data_str);
+            }
+            Hook::AccountValidationEntered => {
+                // println!("ACCOUNT VALIDATION ENTERED");
+            }
+            Hook::ValidationStepEnded => {
+                // println!("VALIDATION STEP ENDED");
+            }
+            Hook::AccountValidationExited => {
+                // println!("ACCOUNT VALIDATION EXITED");
+            }
+            Hook::DebugReturnData => {
+                // println!("DEBUG RETURN DATA");
+            }
+            Hook::NearCallCatch => {
+                // println!("NOTIFY ABOUT NEAR CALL CATCH");
+            }
+            _ => {}
+        };
+    }
+}

core/lib/multivm/src/versions/era_vm/tracers/manager.rs

@@ -5,8 +5,8 @@ use era_vm::{
 use zksync_state::ReadStorage;
 
 use super::{
-    circuits_tracer::CircuitsTracer, dispatcher::TracerDispatcher, pubdata_tracer::PubdataTracer,
-    refunds_tracer::RefundsTracer, traits::VmTracer,
+    circuits_tracer::CircuitsTracer, debug_tracer::DebugTracer, dispatcher::TracerDispatcher,
+    pubdata_tracer::PubdataTracer, refunds_tracer::RefundsTracer, traits::VmTracer,
 };
 use crate::{era_vm::vm::Vm, interface::tracer::TracerExecutionStatus, vm_1_4_1::VmExecutionMode};
 
@@ -24,6 +24,8 @@ pub struct VmTracerManager<S: ReadStorage> {
     // This tracers keeps track of opcodes calls and collects circuits statistics
     // used later by the prover
     pub circuits_tracer: CircuitsTracer,
+    // Tracer used for debugging purposes
+    pub debug_tracer: Option<DebugTracer>,
 }
 
 impl<S: ReadStorage> VmTracerManager<S> {
@@ -38,6 +40,7 @@ impl<S: ReadStorage> VmTracerManager<S> {
             refund_tracer,
             circuits_tracer: CircuitsTracer::new(),
             pubdata_tracer: pubdata_tracer.unwrap_or(PubdataTracer::new(execution_mode)),
+            debug_tracer: None, // or Some(DebugTracer) to enable debugger
         }
     }
 }
@@ -51,6 +54,9 @@ impl<S: ReadStorage> Tracer for VmTracerManager<S> {
         if let Some(refunds_tracer) = &mut self.refund_tracer {
             refunds_tracer.before_decoding(execution, state);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            debug_tracer.before_decoding(execution, state);
+        }
         self.pubdata_tracer.before_decoding(execution, state);
         self.circuits_tracer.before_decoding(execution, state);
     }
@@ -63,6 +69,9 @@ impl<S: ReadStorage> Tracer for VmTracerManager<S> {
         if let Some(refunds_tracer) = &mut self.refund_tracer {
             refunds_tracer.after_decoding(opcode, execution, state);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            debug_tracer.after_decoding(opcode, execution, state);
+        }
         self.pubdata_tracer.after_decoding(opcode, execution, state);
         self.circuits_tracer
             .after_decoding(opcode, execution, state);
@@ -81,6 +90,9 @@ impl<S: ReadStorage> Tracer for VmTracerManager<S> {
         if let Some(refunds_tracer) = &mut self.refund_tracer {
             refunds_tracer.before_execution(opcode, execution, state);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            debug_tracer.before_execution(opcode, execution, state);
+        }
         self.pubdata_tracer
             .before_execution(opcode, execution, state);
         self.circuits_tracer
@@ -95,6 +107,9 @@ impl<S: ReadStorage> Tracer for VmTracerManager<S> {
         if let Some(refunds_tracer) = &mut self.refund_tracer {
             refunds_tracer.after_execution(opcode, execution, state);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            debug_tracer.after_execution(opcode, execution, state);
+        }
         self.pubdata_tracer
             .after_execution(opcode, execution, state);
         self.circuits_tracer
@@ -111,6 +126,9 @@ impl<S: ReadStorage + 'static> VmTracer<S> for VmTracerManager<S> {
         if let Some(refunds_tracer) = &mut self.refund_tracer {
             refunds_tracer.before_bootloader_execution(state);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            debug_tracer.before_bootloader_execution(state);
+        }
         self.pubdata_tracer.before_bootloader_execution(state);
         self.circuits_tracer.before_bootloader_execution(state);
     }
@@ -123,6 +141,9 @@ impl<S: ReadStorage + 'static> VmTracer<S> for VmTracerManager<S> {
         if let Some(refunds_tracer) = &mut self.refund_tracer {
             refunds_tracer.after_bootloader_execution(state);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            debug_tracer.after_bootloader_execution(state);
+        }
         self.pubdata_tracer.after_bootloader_execution(state);
         self.circuits_tracer.after_bootloader_execution(state);
     }
@@ -141,6 +162,9 @@ impl<S: ReadStorage + 'static> VmTracer<S> for VmTracerManager<S> {
         if let Some(refunds_tracer) = &mut self.refund_tracer {
             refunds_tracer.bootloader_hook_call(state, hook.clone(), hook_params);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            debug_tracer.bootloader_hook_call(state, hook.clone(), hook_params);
+        }
         self.pubdata_tracer
             .bootloader_hook_call(state, hook.clone(), hook_params);
         self.circuits_tracer
@@ -160,6 +184,11 @@ impl<S: ReadStorage + 'static> VmTracer<S> for VmTracerManager<S> {
                 .after_vm_run(vm, output.clone())
                 .stricter(&result);
         }
+        if let Some(debug_tracer) = &mut self.debug_tracer {
+            result = debug_tracer
+                .after_vm_run(vm, output.clone())
+                .stricter(&result);
+        }
         result = self
             .pubdata_tracer
             .after_vm_run(vm, output.clone())

core/lib/multivm/src/versions/era_vm/tracers/mod.rs

@@ -1,4 +1,5 @@
 pub mod circuits_tracer;
+pub mod debug_tracer;
 pub mod dispatcher;
 pub mod manager;
 pub mod pubdata_tracer;