feat(vm): Use the one interface for all vms

core/bin/system-constants-generator/src/utils.rs

@@ -1,8 +1,12 @@
-use multivm::interface::{L1BatchEnv, L2BlockEnv, SystemEnv, TxExecutionMode, VmExecutionMode};
+use multivm::interface::dyn_tracers::vm_1_3_3::DynTracer;
+use multivm::interface::tracer::VmExecutionStopReason;
+use multivm::interface::{
+    L1BatchEnv, L2BlockEnv, SystemEnv, TxExecutionMode, VmExecutionMode, VmInterface,
+};
 use multivm::vm_latest::{
     constants::{BLOCK_GAS_LIMIT, BOOTLOADER_HEAP_PAGE},
-    BootloaderState, BoxedTracer, DynTracer, HistoryEnabled, HistoryMode, Vm,
-    VmExecutionStopReason, VmTracer, ZkSyncVmState,
+    BootloaderState, HistoryEnabled, HistoryMode, SimpleMemory, ToTracerPointer, Vm, VmTracer,
+    ZkSyncVmState,
 };
 use once_cell::sync::Lazy;
 use std::cell::RefCell;
@@ -31,7 +35,7 @@ struct SpecialBootloaderTracer {
     output: Rc<RefCell<u32>>,
 }
 
-impl<S: WriteStorage, H: HistoryMode> DynTracer<S, H> for SpecialBootloaderTracer {}
+impl<S: WriteStorage, H: HistoryMode> DynTracer<S, SimpleMemory<H>> for SpecialBootloaderTracer {}
 
 impl<S: WriteStorage, H: HistoryMode> VmTracer<S, H> for SpecialBootloaderTracer {
     fn initialize_tracer(&mut self, state: &mut ZkSyncVmState<S, H>) {
@@ -247,14 +251,11 @@ pub(super) fn execute_internal_transfer_test() -> u32 {
     let tracer = SpecialBootloaderTracer {
         input,
         output: tracer_result.clone(),
-    };
-    let mut vm = Vm::new(
-        l1_batch,
-        system_env,
-        Rc::new(RefCell::new(storage_view)),
-        HistoryEnabled,
-    );
-    let result = vm.inspect(vec![tracer.into_boxed()], VmExecutionMode::Bootloader);
+    }
+    .into_tracer_pointer();
+    let mut vm: Vm<_, HistoryEnabled> =
+        Vm::new(l1_batch, system_env, Rc::new(RefCell::new(storage_view)));
+    let result = vm.inspect(tracer.into(), VmExecutionMode::Bootloader);
 
     assert!(!result.result.is_failed(), "The internal call has reverted");
     tracer_result.take()
@@ -307,12 +308,8 @@ pub(super) fn execute_user_txs_in_test_gas_vm(
         chain_id: L2ChainId::default(),
     };
 
-    let mut vm = Vm::new(
-        l1_batch,
-        system_env,
-        Rc::new(RefCell::new(storage_view)),
-        HistoryEnabled,
-    );
+    let mut vm: Vm<_, HistoryEnabled> =
+        Vm::new(l1_batch, system_env, Rc::new(RefCell::new(storage_view)));
 
     let mut total_gas_refunded = 0;
     for tx in txs {

core/lib/multivm/src/glue/init_vm.rs

@@ -1,6 +1,6 @@
 use super::GlueInto;
 use crate::glue::history_mode::HistoryMode;
-use crate::interface::{L1BatchEnv, SystemEnv};
+use crate::interface::{L1BatchEnv, SystemEnv, VmInterface};
 use crate::vm_instance::VmInstanceVersion;
 use crate::VmInstance;
 use zksync_state::{ReadStorage, StoragePtr, StorageView};
@@ -154,7 +154,6 @@ impl<S: ReadStorage, H: HistoryMode> VmInstance<S, H> {
                     l1_batch_env.glue_into(),
                     system_env.clone().glue_into(),
                     storage_view.clone(),
-                    H::VmVirtualBlocksMode::default(),
                 );
                 let vm = VmInstanceVersion::VmVirtualBlocks(Box::new(vm));
                 Self {
@@ -168,7 +167,6 @@ impl<S: ReadStorage, H: HistoryMode> VmInstance<S, H> {
                     l1_batch_env.glue_into(),
                     system_env.clone(),
                     storage_view.clone(),
-                    H::VmVirtualBlocksRefundsEnhancement::default(),
                 );
                 let vm = VmInstanceVersion::VmVirtualBlocksRefundsEnhancement(Box::new(vm));
                 Self {

core/lib/multivm/src/glue/mod.rs

@@ -11,7 +11,7 @@ pub(crate) mod block_properties;
 pub(crate) mod history_mode;
 pub(crate) mod init_vm;
 pub(crate) mod oracle_tools;
-pub(crate) mod tracer;
+pub mod tracers;
 mod types;
 
 /// This trait is a workaround on the Rust'c [orphan rule](orphan_rule).

core/lib/multivm/src/glue/tracer.rs → core/lib/multivm/src/glue/tracers/mod.rs

@@ -1,50 +1,44 @@
 //! # Multivm Tracing
 //!
-//! The MultiVM tracing module enables Tracers support for different versions of virtual machines
+//! The MultiVM tracing module enables support for Tracers in different versions of virtual machines.
 //!
 //! ## Overview
 //!
 //! Different VM versions may have distinct requirements and types for Tracers. To accommodate these differences,
 //! this module defines one primary trait:
 //!
 //! - `MultivmTracer<S, H>`: This trait represents a tracer that can be converted into a tracer for
-//! specific VM version.
+//! a specific VM version.
 //!
-//! Specific traits for each VM version, which supports Custom Tracers
+//! Specific traits for each VM version, which support Custom Tracers:
 //! - `IntoLatestTracer<S, H>`: This trait is responsible for converting a tracer
 //! into a form compatible with the latest VM version.
 //! It defines a method `latest` for obtaining a boxed tracer.
 //!
-//! - `IntoVmVirtualBlocksTracer<S, H>`:This trait is responsible for converting a tracer
+//! - `IntoVmVirtualBlocksTracer<S, H>`: This trait is responsible for converting a tracer
 //! into a form compatible with the vm_virtual_blocks version.
 //! It defines a method `vm_virtual_blocks` for obtaining a boxed tracer.
 //!
-//! For `MultivmTracer` to be implemented, Tracer must implement all N currently
+//! For `MultivmTracer` to be implemented, the Tracer must implement all N currently
 //! existing sub-traits.
 //!
-//! Any tracer compatible with the current VM automatically
-//! supports conversion into the latest VM,
-//! but the remaining traits required by the MultivmTracer should be implemented manually.
-//! If a certain tracer is not intended to be used with VMs other than the latest one,
-//! these traits should still be implemented, but one may just write a panicking implementation.
-//!
 //! ## Adding a new VM version
 //!
 //! To add support for one more VM version to MultivmTracer, one needs to:
-//! - Create a new trait performing conversion to the specified VM tracer, e.g. `Into<VmVersion>Tracer`.
-//! - Provide implementations of this trait for all the structures that currently implement `MultivmTracer`.
+//! - Create a new trait performing conversion to the specified VM tracer, e.g., `Into<VmVersion>Tracer`.
 //! - Add this trait as a trait bound to the `MultivmTracer`.
 //! - Add this trait as a trait bound for `T` in `MultivmTracer` implementation.
-//! - Integrate the newly added method to the MultiVM itself (e.g. add required tracer conversions where applicable).
-mod implementations;
-
+//! — Implement the trait for `T` with a bound to `VmTracer` for a specific version.
+//!
 use crate::HistoryMode;
 use zksync_state::WriteStorage;
 
+pub type MultiVmTracerPointer<S, H> = Box<dyn MultivmTracer<S, H>>;
+
 pub trait MultivmTracer<S: WriteStorage, H: HistoryMode>:
     IntoLatestTracer<S, H> + IntoVmVirtualBlocksTracer<S, H>
 {
-    fn into_boxed(self) -> Box<dyn MultivmTracer<S, H>>
+    fn into_tracer_pointer(self) -> MultiVmTracerPointer<S, H>
     where
         Self: Sized + 'static,
     {
@@ -53,15 +47,13 @@ pub trait MultivmTracer<S: WriteStorage, H: HistoryMode>:
 }
 
 pub trait IntoLatestTracer<S: WriteStorage, H: HistoryMode> {
-    fn latest(
-        &self,
-    ) -> Box<dyn crate::vm_latest::VmTracer<S, H::VmVirtualBlocksRefundsEnhancement>>;
+    fn latest(&self) -> crate::vm_latest::TracerPointer<S, H::VmVirtualBlocksRefundsEnhancement>;
 }
 
 pub trait IntoVmVirtualBlocksTracer<S: WriteStorage, H: HistoryMode> {
     fn vm_virtual_blocks(
         &self,
-    ) -> Box<dyn crate::vm_virtual_blocks::VmTracer<S, H::VmVirtualBlocksMode>>;
+    ) -> crate::vm_virtual_blocks::TracerPointer<S, H::VmVirtualBlocksMode>;
 }
 
 impl<S, T, H> IntoLatestTracer<S, H> for T
@@ -70,9 +62,20 @@ where
     H: HistoryMode,
     T: crate::vm_latest::VmTracer<S, H::VmVirtualBlocksRefundsEnhancement> + Clone + 'static,
 {
-    fn latest(
+    fn latest(&self) -> crate::vm_latest::TracerPointer<S, H::VmVirtualBlocksRefundsEnhancement> {
+        Box::new(self.clone())
+    }
+}
+
+impl<S, T, H> IntoVmVirtualBlocksTracer<S, H> for T
+where
+    S: WriteStorage,
+    H: HistoryMode,
+    T: crate::vm_virtual_blocks::VmTracer<S, H::VmVirtualBlocksMode> + Clone + 'static,
+{
+    fn vm_virtual_blocks(
         &self,
-    ) -> Box<dyn crate::vm_latest::VmTracer<S, H::VmVirtualBlocksRefundsEnhancement>> {
+    ) -> crate::vm_virtual_blocks::TracerPointer<S, H::VmVirtualBlocksMode> {
         Box::new(self.clone())
     }
 }
@@ -81,10 +84,6 @@ impl<S, H, T> MultivmTracer<S, H> for T
 where
     S: WriteStorage,
     H: HistoryMode,
-    T: crate::vm_latest::VmTracer<S, H::VmVirtualBlocksRefundsEnhancement>
-        + IntoLatestTracer<S, H>
-        + IntoVmVirtualBlocksTracer<S, H>
-        + Clone
-        + 'static,
+    T: IntoLatestTracer<S, H> + IntoVmVirtualBlocksTracer<S, H>,
 {
 }

core/lib/multivm/src/interface/mod.rs

@@ -1,3 +1,9 @@
+pub(crate) mod traits;
+
+pub use traits::{
+    tracers::dyn_tracers,
+    vm::{VmInterface, VmInterfaceHistoryEnabled},
+};
 pub mod types;
 
 pub use types::{
@@ -9,4 +15,5 @@ pub use types::{
         BootloaderMemory, CurrentExecutionState, ExecutionResult, FinishedL1Batch, L2Block,
         Refunds, VmExecutionResultAndLogs, VmExecutionStatistics, VmMemoryMetrics,
     },
+    tracer,
 };

core/lib/multivm/src/interface/traits/mod.rs

@@ -0,0 +1,2 @@
+pub mod tracers;
+pub mod vm;

core/lib/multivm/src/interface/traits/tracers/dyn_tracers/mod.rs

@@ -0,0 +1 @@
+pub mod vm_1_3_3;

core/lib/multivm/src/interface/traits/tracers/dyn_tracers/vm_1_3_3.rs

@@ -0,0 +1,33 @@
+use zk_evm_1_3_3::abstractions::Memory;
+use zk_evm_1_3_3::tracing::{
+    AfterDecodingData, AfterExecutionData, BeforeExecutionData, VmLocalStateData,
+};
+use zksync_state::StoragePtr;
+
+/// Version of zk_evm_1_3_3::Tracer suitable for dynamic dispatch.
+pub trait DynTracer<S, M: Memory> {
+    fn before_decoding(&mut self, _state: VmLocalStateData<'_>, _memory: &M) {}
+    fn after_decoding(
+        &mut self,
+        _state: VmLocalStateData<'_>,
+        _data: AfterDecodingData,
+        _memory: &M,
+    ) {
+    }
+    fn before_execution(
+        &mut self,
+        _state: VmLocalStateData<'_>,
+        _data: BeforeExecutionData,
+        _memory: &M,
+        _storage: StoragePtr<S>,
+    ) {
+    }
+    fn after_execution(
+        &mut self,
+        _state: VmLocalStateData<'_>,
+        _data: AfterExecutionData,
+        _memory: &M,
+        _storage: StoragePtr<S>,
+    ) {
+    }
+}

core/lib/multivm/src/interface/traits/tracers/mod.rs

@@ -0,0 +1 @@
+pub mod dyn_tracers;