refactor(api): Refactor VM-invoking API server methods to be less VM-specific (#3564)

## What ❔

- Refactors VM-invoking methods in the API server (e.g., gas estimation)
to use less VM-specific logic.
- Simplifies some VM interfaces along the way. E.g., unifies batch and
oneshot VM executor results.

## Why ❔

Should somewhat simplify ZK OS integration into the API server.

## Checklist

- [x] PR title corresponds to the body of PR (we generate changelog
entries from PRs).
- [x] Tests for the changes have been added / updated.
- [x] Documentation comments have been added / updated.
- [x] Code has been formatted via `zkstack dev fmt` and `zkstack dev
lint`.

Author: slowli

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

@@ -340,7 +340,7 @@ pub(super) fn execute_user_txs_in_test_gas_vm(
     }
 
     let result = vm.execute(InspectExecutionMode::Bootloader);
-    let metrics = result.get_execution_metrics(None);
+    let metrics = result.get_execution_metrics();
 
     VmSpentResourcesResult {
         // It is assumed that the entire `gas_used` was spent on computation and so it safe to convert to u32

core/lib/dal/src/tests/mod.rs

@@ -162,8 +162,6 @@ pub(crate) fn mock_execution_result(transaction: L2Tx) -> TransactionExecutionRe
         execution_info: VmExecutionMetrics::default(),
         execution_status: TxExecutionStatus::Success,
         refunded_gas: 0,
-        operator_suggested_refund: 0,
-        compressed_bytecodes: vec![],
         call_traces: vec![],
         revert_reason: None,
     }

core/lib/dal/src/transactions_dal.rs

@@ -482,9 +482,10 @@ impl TransactionsDal<'_, '_> {
             value,
             &paymaster,
             &paymaster_input,
-            exec_info.gas_used as i64,
-            (exec_info.initial_storage_writes + exec_info.repeated_storage_writes) as i32,
-            exec_info.contracts_used as i32,
+            exec_info.vm.gas_used as i64,
+            (exec_info.writes.initial_storage_writes + exec_info.writes.repeated_storage_writes)
+                as i32,
+            exec_info.vm.contracts_used as i32,
             received_at,
             timestamp_asserter_range_start,
             timestamp_asserter_range_end,

core/lib/multivm/src/versions/testonly/block_tip.rs

@@ -185,7 +185,7 @@ fn execute_test<VM: TestedVm>(test_data: L1MessengerTestData) -> TestStatistics
     TestStatistics {
         max_used_gas: gas_before - gas_after,
         circuit_statistics: result.statistics.circuit_statistic.total() as u64,
-        execution_metrics_size: result.get_execution_metrics(None).size() as u64,
+        execution_metrics_size: result.get_execution_metrics().size() as u64,
     }
 }
 

core/lib/vm_executor/src/batch/factory.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, fmt, marker::PhantomData, rc::Rc, sync::Arc, time::Duration};
+use std::{fmt, marker::PhantomData, rc::Rc, sync::Arc, time::Duration};
 
 use anyhow::Context as _;
 use once_cell::sync::OnceCell;
@@ -9,9 +9,8 @@ use zksync_multivm::{
         pubdata::PubdataBuilder,
         storage::{ReadStorage, StoragePtr, StorageView, StorageViewStats},
         utils::{DivergenceHandler, ShadowMut},
-        BatchTransactionExecutionResult, BytecodeCompressionError, Call, CompressedBytecodeInfo,
-        ExecutionResult, FinishedL1Batch, Halt, L1BatchEnv, L2BlockEnv, SystemEnv, VmFactory,
-        VmInterface, VmInterfaceHistoryEnabled,
+        BatchTransactionExecutionResult, Call, ExecutionResult, FinishedL1Batch, Halt, L1BatchEnv,
+        L2BlockEnv, SystemEnv, VmFactory, VmInterface, VmInterfaceHistoryEnabled,
     },
     is_supported_by_fast_vm,
     pubdata_builders::pubdata_params_to_builder,
@@ -174,8 +173,6 @@ impl<S: ReadStorage + Send + 'static, Tr: BatchTracer> BatchExecutorFactory<S>
     }
 }
 
-type BytecodeResult = Result<Vec<CompressedBytecodeInfo>, BytecodeCompressionError>;
-
 #[derive(Debug)]
 enum BatchVm<S: ReadStorage, Tr: BatchTracer> {
     Legacy(LegacyVmInstance<S, HistoryEnabled>),
@@ -241,7 +238,7 @@ impl<S: ReadStorage, Tr: BatchTracer> BatchVm<S, Tr> {
         &mut self,
         tx: Transaction,
         with_compression: bool,
-    ) -> BatchTransactionExecutionResult<BytecodeResult> {
+    ) -> BatchTransactionExecutionResult {
         let legacy_tracer_result = Arc::new(OnceCell::default());
         let legacy_tracer = if Tr::TRACE_CALLS {
             vec![CallTracer::new(legacy_tracer_result.clone()).into_tracer_pointer()]
@@ -270,7 +267,7 @@ impl<S: ReadStorage, Tr: BatchTracer> BatchVm<S, Tr> {
             }
         };
 
-        let compressed_bytecodes = compression_result.map(Cow::into_owned);
+        let compressed_bytecodes = compression_result.map(drop);
         let legacy_traces = Arc::try_unwrap(legacy_tracer_result)
             .expect("failed extracting call traces")
             .take()
@@ -289,7 +286,7 @@ impl<S: ReadStorage, Tr: BatchTracer> BatchVm<S, Tr> {
 
         BatchTransactionExecutionResult {
             tx_result: Box::new(tx_result),
-            compressed_bytecodes,
+            compression_result: compressed_bytecodes,
             call_traces,
         }
     }
@@ -466,10 +463,10 @@ impl<S: ReadStorage + 'static, Tr: BatchTracer> CommandReceiver<S, Tr> {
         // and so we re-execute the transaction, but without compression.
 
         let res = vm.inspect_transaction(tx.clone(), true);
-        if let Ok(compressed_bytecodes) = res.compressed_bytecodes {
+        if res.compression_result.is_ok() {
             return Ok(BatchTransactionExecutionResult {
                 tx_result: res.tx_result,
-                compressed_bytecodes,
+                compression_result: Ok(()),
                 call_traces: res.call_traces,
             });
         }
@@ -480,12 +477,11 @@ impl<S: ReadStorage + 'static, Tr: BatchTracer> CommandReceiver<S, Tr> {
         vm.make_snapshot();
 
         let res = vm.inspect_transaction(tx.clone(), false);
-        let compressed_bytecodes = res
-            .compressed_bytecodes
+        res.compression_result
             .context("compression failed when it wasn't applied")?;
         Ok(BatchTransactionExecutionResult {
             tx_result: res.tx_result,
-            compressed_bytecodes,
+            compression_result: Ok(()),
             call_traces: res.call_traces,
         })
     }
@@ -498,10 +494,10 @@ impl<S: ReadStorage + 'static, Tr: BatchTracer> CommandReceiver<S, Tr> {
         vm: &mut BatchVm<S, Tr>,
     ) -> anyhow::Result<BatchTransactionExecutionResult> {
         let res = vm.inspect_transaction(tx.clone(), true);
-        if let Ok(compressed_bytecodes) = res.compressed_bytecodes {
+        if res.compression_result.is_ok() {
             Ok(BatchTransactionExecutionResult {
                 tx_result: res.tx_result,
-                compressed_bytecodes,
+                compression_result: Ok(()),
                 call_traces: res.call_traces,
             })
         } else {
@@ -512,7 +508,7 @@ impl<S: ReadStorage + 'static, Tr: BatchTracer> CommandReceiver<S, Tr> {
             };
             Ok(BatchTransactionExecutionResult {
                 tx_result,
-                compressed_bytecodes: vec![],
+                compression_result: Ok(()),
                 call_traces: vec![],
             })
         }

core/lib/vm_executor/src/batch/metrics.rs

@@ -92,7 +92,7 @@ impl BatchTipMetrics {
         self.circuit_statistic
             .observe(execution_result.statistics.circuit_statistic.total());
         self.execution_metrics_size
-            .observe(execution_result.get_execution_metrics(None).size());
+            .observe(execution_result.get_execution_metrics().size());
     }
 }
 

core/lib/vm_interface/src/executor.rs

@@ -61,7 +61,7 @@ pub trait OneshotExecutor<S: ReadStorage> {
 
 /// VM executor capable of validating transactions.
 #[async_trait]
-pub trait TransactionValidator<S: ReadStorage>: OneshotExecutor<S> {
+pub trait TransactionValidator<S: ReadStorage> {
     /// Validates the provided transaction.
     async fn validate_transaction(
         &self,

core/lib/vm_interface/src/types/outputs/execution_result.rs

@@ -6,26 +6,17 @@ use zksync_system_constants::{
     PUBLISH_BYTECODE_OVERHEAD,
 };
 use zksync_types::{
+    bytecode::BytecodeHash,
     ethabi,
     l2_to_l1_log::{SystemL2ToL1Log, UserL2ToL1Log},
     zk_evm_types::FarCallOpcode,
     Address, L1BatchNumber, StorageLogWithPreviousValue, Transaction, H256, U256,
 };
 
 use crate::{
-    BytecodeCompressionError, CompressedBytecodeInfo, Halt, VmExecutionMetrics,
-    VmExecutionStatistics, VmRevertReason,
+    BytecodeCompressionError, Halt, VmExecutionMetrics, VmExecutionStatistics, VmRevertReason,
 };
 
-const L1_MESSAGE_EVENT_SIGNATURE: H256 = H256([
-    58, 54, 228, 114, 145, 244, 32, 31, 175, 19, 127, 171, 8, 29, 146, 41, 91, 206, 45, 83, 190,
-    44, 108, 166, 139, 168, 44, 127, 170, 156, 226, 65,
-]);
-
-pub fn bytecode_len_in_bytes(bytecodehash: H256) -> usize {
-    usize::from(u16::from_be_bytes([bytecodehash[2], bytecodehash[3]])) * 32
-}
-
 /// Event generated by the VM.
 #[derive(Default, Debug, Clone, PartialEq)]
 pub struct VmEvent {
@@ -51,6 +42,11 @@ impl VmEvent {
         201, 71, 34, 255, 19, 234, 207, 83, 84, 124, 71, 65, 218, 181, 34, 131, 83, 160, 89, 56,
         255, 205, 213, 212, 162, 213, 51, 174, 14, 97, 130, 135,
     ]);
+    /// Long signature of the L1 messenger publication event (`L1MessageSent`).
+    pub const L1_MESSAGE_EVENT_SIGNATURE: H256 = H256([
+        58, 54, 228, 114, 145, 244, 32, 31, 175, 19, 127, 171, 8, 29, 146, 41, 91, 206, 45, 83,
+        190, 44, 108, 166, 139, 168, 44, 127, 170, 156, 226, 65,
+    ]);
 
     /// Extracts all the "long" L2->L1 messages that were submitted by the L1Messenger contract.
     pub fn extract_long_l2_to_l1_messages(events: &[Self]) -> Vec<Vec<u8>> {
@@ -60,7 +56,7 @@ impl VmEvent {
                 // Filter events from the l1 messenger contract that match the expected signature.
                 event.address == L1_MESSENGER_ADDRESS
                     && event.indexed_topics.len() == 3
-                    && event.indexed_topics[0] == L1_MESSAGE_EVENT_SIGNATURE
+                    && event.indexed_topics[0] == Self::L1_MESSAGE_EVENT_SIGNATURE
             })
             .map(|event| {
                 let decoded_tokens = ethabi::decode(&[ethabi::ParamType::Bytes], &event.value)
@@ -174,11 +170,7 @@ impl VmExecutionResultAndLogs {
         Self::mock(ExecutionResult::Success { output: vec![] })
     }
 
-    pub fn get_execution_metrics(&self, tx: Option<&Transaction>) -> VmExecutionMetrics {
-        let contracts_deployed = tx
-            .map(|tx| tx.execute.factory_deps.len() as u16)
-            .unwrap_or(0);
-
+    pub fn get_execution_metrics(&self) -> VmExecutionMetrics {
         // We published the data as ABI-encoded `bytes`, so the total length is:
         // - message length in bytes, rounded up to a multiple of 32
         // - 32 bytes of encoded offset
@@ -190,8 +182,11 @@ impl VmExecutionResultAndLogs {
 
         let published_bytecode_bytes = VmEvent::extract_published_bytecodes(&self.logs.events)
             .iter()
-            .map(|bytecodehash| {
-                bytecode_len_in_bytes(*bytecodehash) + PUBLISH_BYTECODE_OVERHEAD as usize
+            .map(|&bytecode_hash| {
+                let len_in_bytes = BytecodeHash::try_from(bytecode_hash)
+                    .expect("published unparseable bytecode hash")
+                    .len_in_bytes();
+                len_in_bytes + PUBLISH_BYTECODE_OVERHEAD as usize
             })
             .sum();
 
@@ -202,7 +197,6 @@ impl VmExecutionResultAndLogs {
             l2_to_l1_logs: self.logs.total_l2_to_l1_logs_count(),
             user_l2_to_l1_logs: self.logs.user_l2_to_l1_logs.len(),
             contracts_used: self.statistics.contracts_used,
-            contracts_deployed,
             vm_events: self.logs.events.len(),
             storage_logs: self.logs.storage_logs.len(),
             total_log_queries: self.statistics.total_log_queries,
@@ -336,43 +330,33 @@ impl Call {
 }
 
 /// Mid-level transaction execution output returned by a [batch executor](crate::executor::BatchExecutor).
-#[derive(Debug, Clone)]
-pub struct BatchTransactionExecutionResult<C = Vec<CompressedBytecodeInfo>> {
+#[derive(Debug)]
+pub struct BatchTransactionExecutionResult {
     /// VM result.
     pub tx_result: Box<VmExecutionResultAndLogs>,
     /// Compressed bytecodes used by the transaction.
-    pub compressed_bytecodes: C,
+    pub compression_result: Result<(), BytecodeCompressionError>,
     /// Call traces (if requested; otherwise, empty).
     pub call_traces: Vec<Call>,
 }
 
-impl<C> BatchTransactionExecutionResult<C> {
+impl BatchTransactionExecutionResult {
     pub fn was_halted(&self) -> bool {
         matches!(self.tx_result.result, ExecutionResult::Halt { .. })
     }
 }
 
 /// Mid-level transaction execution output returned by a [oneshot executor](crate::executor::OneshotExecutor).
-#[derive(Debug)]
-pub struct OneshotTransactionExecutionResult {
-    /// VM result.
-    pub tx_result: Box<VmExecutionResultAndLogs>,
-    /// Result of compressing bytecodes used by the transaction.
-    pub compression_result: Result<(), BytecodeCompressionError>,
-    /// Call traces (if requested; otherwise, empty).
-    pub call_traces: Vec<Call>,
-}
+pub type OneshotTransactionExecutionResult = BatchTransactionExecutionResult;
 
-/// High-level transaction execution result used by the API server sandbox etc.
+/// High-level transaction execution result used by the state keeper etc.
 #[derive(Debug, Clone, PartialEq)]
 pub struct TransactionExecutionResult {
     pub transaction: Transaction,
     pub hash: H256,
     pub execution_info: VmExecutionMetrics,
     pub execution_status: TxExecutionStatus,
     pub refunded_gas: u64,
-    pub operator_suggested_refund: u64,
-    pub compressed_bytecodes: Vec<CompressedBytecodeInfo>,
     pub call_traces: Vec<Call>,
     pub revert_reason: Option<String>,
 }
@@ -436,7 +420,7 @@ mod tests {
                 ethabi::ParamType::Bytes,
             ],
         );
-        assert_eq!(L1_MESSAGE_EVENT_SIGNATURE, expected_signature);
+        assert_eq!(VmEvent::L1_MESSAGE_EVENT_SIGNATURE, expected_signature);
     }
 
     #[test]