diff --git a/core/lib/multivm/src/glue/tracers/mod.rs b/core/lib/multivm/src/glue/tracers/mod.rs
index bf2f67cae501..f5a854ecbaaf 100644
--- a/core/lib/multivm/src/glue/tracers/mod.rs
+++ b/core/lib/multivm/src/glue/tracers/mod.rs
@@ -7,7 +7,7 @@
//! 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
+//! - `MultiVmTracer<S, H>`: This trait represents a tracer that can be converted into a tracer for
//! a specific VM version.
//!
//! Specific traits for each VM version, which support Custom Tracers:
@@ -19,22 +19,22 @@
//! 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, the Tracer must implement all N currently
+//! For `MultiVmTracer` to be implemented, the Tracer must implement all N currently
//! existing sub-traits.
//!
//! ## Adding a new VM version
//!
-//! To add support for one more VM version to MultiVMTracer, one needs to:
+//! 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`.
-//! - Add this trait as a trait bound to the `MultiVMTracer`.
-//! - Add this trait as a trait bound for `T` in `MultiVMTracer` implementation.
+//! - Add this trait as a trait bound to the `MultiVmTracer`.
+//! - Add this trait as a trait bound for `T` in `MultiVmTracer` implementation.
//! - Implement the trait for `T` with a bound to `VmTracer` for a specific version.
use crate::{interface::storage::WriteStorage, tracers::old::OldTracers, HistoryMode};
-pub type MultiVmTracerPointer<S, H> = Box<dyn MultiVMTracer<S, H>>;
+pub type MultiVmTracerPointer<S, H> = Box<dyn MultiVmTracer<S, H>>;
-pub trait MultiVMTracer<S: WriteStorage, H: HistoryMode>:
+pub trait MultiVmTracer<S: WriteStorage, H: HistoryMode>:
IntoLatestTracer<S, H>
+ IntoVmVirtualBlocksTracer<S, H>
+ IntoVmRefundsEnhancementTracer<S, H>
@@ -168,7 +168,7 @@ where
}
}
-impl<S, H, T> MultiVMTracer<S, H> for T
+impl<S, H, T> MultiVmTracer<S, H> for T
where
S: WriteStorage,
H: HistoryMode,
diff --git a/core/lib/multivm/src/lib.rs b/core/lib/multivm/src/lib.rs
index 1cba2c0fb92b..fc4085d9b021 100644
--- a/core/lib/multivm/src/lib.rs
+++ b/core/lib/multivm/src/lib.rs
@@ -10,7 +10,7 @@ pub use zksync_vm_interface as interface;
pub use crate::{
glue::{
history_mode::HistoryMode,
- tracers::{MultiVMTracer, MultiVmTracerPointer},
+ tracers::{MultiVmTracer, MultiVmTracerPointer},
},
versions::{
vm_1_3_2, vm_1_4_1, vm_1_4_2, vm_boojum_integration, vm_fast, vm_latest, vm_m5, vm_m6,
diff --git a/core/lib/multivm/src/utils/mod.rs b/core/lib/multivm/src/utils/mod.rs
index a55adb16c85a..4332c0327ff1 100644
--- a/core/lib/multivm/src/utils/mod.rs
+++ b/core/lib/multivm/src/utils/mod.rs
@@ -239,16 +239,16 @@ pub fn get_bootloader_encoding_space(version: VmVersion) -> u32 {
VmVersion::Vm1_4_2 => crate::vm_1_4_2::constants::BOOTLOADER_TX_ENCODING_SPACE,
VmVersion::Vm1_5_0SmallBootloaderMemory => {
crate::vm_latest::constants::get_bootloader_tx_encoding_space(
- crate::vm_latest::MultiVMSubversion::SmallBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::SmallBootloaderMemory,
)
}
VmVersion::Vm1_5_0IncreasedBootloaderMemory => {
crate::vm_latest::constants::get_bootloader_tx_encoding_space(
- crate::vm_latest::MultiVMSubversion::IncreasedBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::IncreasedBootloaderMemory,
)
}
VmVersion::VmGateway => crate::vm_latest::constants::get_bootloader_tx_encoding_space(
- crate::vm_latest::MultiVMSubversion::Gateway,
+ crate::vm_latest::MultiVmSubversion::Gateway,
),
}
}
@@ -394,16 +394,16 @@ pub fn get_used_bootloader_memory_bytes(version: VmVersion) -> usize {
VmVersion::Vm1_4_2 => crate::vm_1_4_2::constants::USED_BOOTLOADER_MEMORY_BYTES,
VmVersion::Vm1_5_0SmallBootloaderMemory => {
crate::vm_latest::constants::get_used_bootloader_memory_bytes(
- crate::vm_latest::MultiVMSubversion::SmallBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::SmallBootloaderMemory,
)
}
VmVersion::Vm1_5_0IncreasedBootloaderMemory => {
crate::vm_latest::constants::get_used_bootloader_memory_bytes(
- crate::vm_latest::MultiVMSubversion::IncreasedBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::IncreasedBootloaderMemory,
)
}
VmVersion::VmGateway => crate::vm_latest::constants::get_used_bootloader_memory_bytes(
- crate::vm_latest::MultiVMSubversion::Gateway,
+ crate::vm_latest::MultiVmSubversion::Gateway,
),
}
}
@@ -430,16 +430,16 @@ pub fn get_used_bootloader_memory_words(version: VmVersion) -> usize {
VmVersion::Vm1_4_2 => crate::vm_1_4_2::constants::USED_BOOTLOADER_MEMORY_WORDS,
VmVersion::Vm1_5_0SmallBootloaderMemory => {
crate::vm_latest::constants::get_used_bootloader_memory_bytes(
- crate::vm_latest::MultiVMSubversion::SmallBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::SmallBootloaderMemory,
)
}
VmVersion::Vm1_5_0IncreasedBootloaderMemory => {
crate::vm_latest::constants::get_used_bootloader_memory_bytes(
- crate::vm_latest::MultiVMSubversion::IncreasedBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::IncreasedBootloaderMemory,
)
}
VmVersion::VmGateway => crate::vm_latest::constants::get_used_bootloader_memory_bytes(
- crate::vm_latest::MultiVMSubversion::Gateway,
+ crate::vm_latest::MultiVmSubversion::Gateway,
),
}
}
diff --git a/core/lib/multivm/src/versions/vm_fast/bootloader_state/state.rs b/core/lib/multivm/src/versions/vm_fast/bootloader_state/state.rs
index 15b4daf02a77..e104eba6ef4f 100644
--- a/core/lib/multivm/src/versions/vm_fast/bootloader_state/state.rs
+++ b/core/lib/multivm/src/versions/vm_fast/bootloader_state/state.rs
@@ -1,7 +1,7 @@
use std::cmp::Ordering;
use once_cell::sync::OnceCell;
-use zksync_types::{L2ChainId, U256};
+use zksync_types::{L2ChainId, ProtocolVersionId, U256};
use super::{
l2_block::BootloaderL2Block,
@@ -10,8 +10,11 @@ use super::{
BootloaderStateSnapshot,
};
use crate::{
- interface::{BootloaderMemory, CompressedBytecodeInfo, L2BlockEnv, TxExecutionMode},
- versions::vm_fast::{pubdata::PubdataInput, transaction_data::TransactionData},
+ interface::{
+ pubdata::{PubdataBuilder, PubdataInput},
+ BootloaderMemory, CompressedBytecodeInfo, L2BlockEnv, TxExecutionMode,
+ },
+ versions::vm_fast::transaction_data::TransactionData,
vm_latest::{constants::TX_DESCRIPTION_OFFSET, utils::l2_blocks::assert_next_block},
};
@@ -42,6 +45,8 @@ pub struct BootloaderState {
free_tx_offset: usize,
/// Information about the pubdata that will be needed to supply to the L1Messenger
pubdata_information: OnceCell<PubdataInput>,
+ /// Protocol version.
+ protocol_version: ProtocolVersionId,
}
impl BootloaderState {
@@ -49,6 +54,7 @@ impl BootloaderState {
execution_mode: TxExecutionMode,
initial_memory: BootloaderMemory,
first_l2_block: L2BlockEnv,
+ protocol_version: ProtocolVersionId,
) -> Self {
let l2_block = BootloaderL2Block::new(first_l2_block, 0);
Self {
@@ -59,6 +65,7 @@ impl BootloaderState {
execution_mode,
free_tx_offset: 0,
pubdata_information: Default::default(),
+ protocol_version,
}
}
@@ -139,12 +146,23 @@ impl BootloaderState {
.expect("Pubdata information is not set")
}
+ pub(crate) fn settlement_layer_pubdata(&self, pubdata_builder: &dyn PubdataBuilder) -> Vec<u8> {
+ let pubdata_information = self
+ .pubdata_information
+ .get()
+ .expect("Pubdata information is not set");
+ pubdata_builder.settlement_layer_pubdata(pubdata_information, self.protocol_version)
+ }
+
fn last_mut_l2_block(&mut self) -> &mut BootloaderL2Block {
self.l2_blocks.last_mut().unwrap()
}
/// Apply all bootloader transaction to the initial memory
- pub(crate) fn bootloader_memory(&self) -> BootloaderMemory {
+ pub(crate) fn bootloader_memory(
+ &self,
+ pubdata_builder: &dyn PubdataBuilder,
+ ) -> BootloaderMemory {
let mut initial_memory = self.initial_memory.clone();
let mut offset = 0;
let mut compressed_bytecodes_offset = 0;
@@ -172,11 +190,15 @@ impl BootloaderState {
let pubdata_information = self
.pubdata_information
- .clone()
- .into_inner()
+ .get()
.expect("Empty pubdata information");
- apply_pubdata_to_memory(&mut initial_memory, pubdata_information);
+ apply_pubdata_to_memory(
+ &mut initial_memory,
+ pubdata_builder,
+ pubdata_information,
+ self.protocol_version,
+ );
initial_memory
}
diff --git a/core/lib/multivm/src/versions/vm_fast/bootloader_state/utils.rs b/core/lib/multivm/src/versions/vm_fast/bootloader_state/utils.rs
index 838c2d6ba60f..9eb55d794235 100644
--- a/core/lib/multivm/src/versions/vm_fast/bootloader_state/utils.rs
+++ b/core/lib/multivm/src/versions/vm_fast/bootloader_state/utils.rs
@@ -1,10 +1,12 @@
-use zksync_types::{ethabi, h256_to_u256, U256};
+use zksync_types::{ethabi, h256_to_u256, ProtocolVersionId, U256};
use super::{l2_block::BootloaderL2Block, tx::BootloaderTx};
use crate::{
- interface::{BootloaderMemory, CompressedBytecodeInfo, TxExecutionMode},
+ interface::{
+ pubdata::{PubdataBuilder, PubdataInput},
+ BootloaderMemory, CompressedBytecodeInfo, TxExecutionMode,
+ },
utils::bytecode,
- versions::vm_fast::pubdata::PubdataInput,
vm_latest::constants::{
BOOTLOADER_TX_DESCRIPTION_OFFSET, BOOTLOADER_TX_DESCRIPTION_SIZE,
COMPRESSED_BYTECODES_OFFSET, OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_OFFSET,
@@ -118,26 +120,54 @@ fn apply_l2_block_inner(
])
}
+fn bootloader_memory_input(
+ pubdata_builder: &dyn PubdataBuilder,
+ input: &PubdataInput,
+ protocol_version: ProtocolVersionId,
+) -> Vec<u8> {
+ let l2_da_validator_address = pubdata_builder.l2_da_validator();
+ let operator_input = pubdata_builder.l1_messenger_operator_input(input, protocol_version);
+ ethabi::encode(&[
+ ethabi::Token::Address(l2_da_validator_address),
+ ethabi::Token::Bytes(operator_input),
+ ])
+}
+
pub(crate) fn apply_pubdata_to_memory(
memory: &mut BootloaderMemory,
- pubdata_information: PubdataInput,
+ pubdata_builder: &dyn PubdataBuilder,
+ pubdata_information: &PubdataInput,
+ protocol_version: ProtocolVersionId,
) {
- // Skipping two slots as they will be filled by the bootloader itself:
- // - One slot is for the selector of the call to the L1Messenger.
- // - The other slot is for the 0x20 offset for the calldata.
- let l1_messenger_pubdata_start_slot = OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_OFFSET + 2;
-
- // Need to skip first word as it represents array offset
- // while bootloader expects only [len || data]
- let pubdata = ethabi::encode(&[ethabi::Token::Bytes(
- pubdata_information.build_pubdata(true),
- )])[32..]
- .to_vec();
-
- assert!(
- pubdata.len() / 32 <= OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_SLOTS - 2,
- "The encoded pubdata is too big"
- );
+ let (l1_messenger_pubdata_start_slot, pubdata) = if protocol_version.is_pre_gateway() {
+ // Skipping two slots as they will be filled by the bootloader itself:
+ // - One slot is for the selector of the call to the L1Messenger.
+ // - The other slot is for the 0x20 offset for the calldata.
+ let l1_messenger_pubdata_start_slot = OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_OFFSET + 2;
+ // Need to skip first word as it represents array offset
+ // while bootloader expects only [len || data]
+ let pubdata = ethabi::encode(&[ethabi::Token::Bytes(
+ pubdata_builder.l1_messenger_operator_input(pubdata_information, protocol_version),
+ )])[32..]
+ .to_vec();
+ assert!(
+ pubdata.len() / 32 <= OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_SLOTS - 2,
+ "The encoded pubdata is too big"
+ );
+ (l1_messenger_pubdata_start_slot, pubdata)
+ } else {
+ // Skipping the first slot as it will be filled by the bootloader itself:
+ // It is for the selector of the call to the L1Messenger.
+ let l1_messenger_pubdata_start_slot = OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_OFFSET + 1;
+ let pubdata =
+ bootloader_memory_input(pubdata_builder, pubdata_information, protocol_version);
+ assert!(
+ // Note that unlike the previous version, the difference is `1`, since now it also includes the offset
+ pubdata.len() / 32 < OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_SLOTS,
+ "The encoded pubdata is too big"
+ );
+ (l1_messenger_pubdata_start_slot, pubdata)
+ };
pubdata
.chunks(32)
diff --git a/core/lib/multivm/src/versions/vm_fast/mod.rs b/core/lib/multivm/src/versions/vm_fast/mod.rs
index de6e7bd4ef6a..840653b63b08 100644
--- a/core/lib/multivm/src/versions/vm_fast/mod.rs
+++ b/core/lib/multivm/src/versions/vm_fast/mod.rs
@@ -1,5 +1,6 @@
pub use zksync_vm2::interface;
+pub(crate) use self::version::FastVmVersion;
pub use self::vm::Vm;
mod bootloader_state;
@@ -10,10 +11,10 @@ mod evm_deploy_tracer;
mod glue;
mod hook;
mod initial_bootloader_memory;
-mod pubdata;
mod refund;
#[cfg(test)]
mod tests;
mod transaction_data;
mod utils;
+mod version;
mod vm;
diff --git a/core/lib/multivm/src/versions/vm_fast/pubdata.rs b/core/lib/multivm/src/versions/vm_fast/pubdata.rs
deleted file mode 100644
index f938696297b5..000000000000
--- a/core/lib/multivm/src/versions/vm_fast/pubdata.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use zksync_types::writes::{compress_state_diffs, StateDiffRecord};
-
-use crate::interface::pubdata::L1MessengerL2ToL1Log;
-
-/// Struct based on which the pubdata blob is formed
-#[derive(Debug, Clone, Default)]
-pub(crate) struct PubdataInput {
- pub(crate) user_logs: Vec<L1MessengerL2ToL1Log>,
- pub(crate) l2_to_l1_messages: Vec<Vec<u8>>,
- pub(crate) published_bytecodes: Vec<Vec<u8>>,
- pub(crate) state_diffs: Vec<StateDiffRecord>,
-}
-
-impl PubdataInput {
- pub(crate) fn build_pubdata(self, with_uncompressed_state_diffs: bool) -> Vec<u8> {
- let mut l1_messenger_pubdata = vec![];
-
- let PubdataInput {
- user_logs,
- l2_to_l1_messages,
- published_bytecodes,
- state_diffs,
- } = self;
-
- // Encoding user L2->L1 logs.
- // Format: `[(numberOfL2ToL1Logs as u32) || l2tol1logs[1] || ... || l2tol1logs[n]]`
- l1_messenger_pubdata.extend((user_logs.len() as u32).to_be_bytes());
- for l2tol1log in user_logs {
- l1_messenger_pubdata.extend(l2tol1log.packed_encoding());
- }
-
- // Encoding L2->L1 messages
- // Format: `[(numberOfMessages as u32) || (messages[1].len() as u32) || messages[1] || ... || (messages[n].len() as u32) || messages[n]]`
- l1_messenger_pubdata.extend((l2_to_l1_messages.len() as u32).to_be_bytes());
- for message in l2_to_l1_messages {
- l1_messenger_pubdata.extend((message.len() as u32).to_be_bytes());
- l1_messenger_pubdata.extend(message);
- }
-
- // Encoding bytecodes
- // Format: `[(numberOfBytecodes as u32) || (bytecodes[1].len() as u32) || bytecodes[1] || ... || (bytecodes[n].len() as u32) || bytecodes[n]]`
- l1_messenger_pubdata.extend((published_bytecodes.len() as u32).to_be_bytes());
- for bytecode in published_bytecodes {
- l1_messenger_pubdata.extend((bytecode.len() as u32).to_be_bytes());
- l1_messenger_pubdata.extend(bytecode);
- }
-
- // Encoding state diffs
- // Format: `[size of compressed state diffs u32 || compressed state diffs || (# state diffs: intial + repeated) as u32 || sorted state diffs by <index, address, key>]`
- let state_diffs_compressed = compress_state_diffs(state_diffs.clone());
- l1_messenger_pubdata.extend(state_diffs_compressed);
-
- if with_uncompressed_state_diffs {
- l1_messenger_pubdata.extend((state_diffs.len() as u32).to_be_bytes());
- for state_diff in state_diffs {
- l1_messenger_pubdata.extend(state_diff.encode_padded());
- }
- }
-
- l1_messenger_pubdata
- }
-}
-
-#[cfg(test)]
-mod tests {
- use zksync_system_constants::{ACCOUNT_CODE_STORAGE_ADDRESS, BOOTLOADER_ADDRESS};
- use zksync_types::u256_to_h256;
-
- use super::*;
-
- #[test]
- fn test_basic_pubdata_building() {
- // Just using some constant addresses for tests
- let addr1 = BOOTLOADER_ADDRESS;
- let addr2 = ACCOUNT_CODE_STORAGE_ADDRESS;
-
- let user_logs = vec![L1MessengerL2ToL1Log {
- l2_shard_id: 0,
- is_service: false,
- tx_number_in_block: 0,
- sender: addr1,
- key: 1.into(),
- value: 128.into(),
- }];
-
- let l2_to_l1_messages = vec![hex::decode("deadbeef").unwrap()];
-
- let published_bytecodes = vec![hex::decode("aaaabbbb").unwrap()];
-
- // For covering more cases, we have two state diffs:
- // One with enumeration index present (and so it is a repeated write) and the one without it.
- let state_diffs = vec![
- StateDiffRecord {
- address: addr2,
- key: 155.into(),
- derived_key: u256_to_h256(125.into()).0,
- enumeration_index: 12,
- initial_value: 11.into(),
- final_value: 12.into(),
- },
- StateDiffRecord {
- address: addr2,
- key: 156.into(),
- derived_key: u256_to_h256(126.into()).0,
- enumeration_index: 0,
- initial_value: 0.into(),
- final_value: 14.into(),
- },
- ];
-
- let input = PubdataInput {
- user_logs,
- l2_to_l1_messages,
- published_bytecodes,
- state_diffs,
- };
-
- let pubdata =
- ethabi::encode(&[ethabi::Token::Bytes(input.build_pubdata(true))])[32..].to_vec();
-
- assert_eq!(hex::encode(pubdata), "00000000000000000000000000000000000000000000000000000000000002c700000001000000000000000000000000000000000000000000008001000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000100000004deadbeef0000000100000004aaaabbbb0100002a040001000000000000000000000000000000000000000000000000000000000000007e090e0000000c0901000000020000000000000000000000000000000000008002000000000000000000000000000000000000000000000000000000000000009b000000000000000000000000000000000000000000000000000000000000007d000000000000000c000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008002000000000000000000000000000000000000000000000000000000000000009c000000000000000000000000000000000000000000000000000000000000007e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
- }
-}
diff --git a/core/lib/multivm/src/versions/vm_fast/tests/mod.rs b/core/lib/multivm/src/versions/vm_fast/tests/mod.rs
index e00a71a43c36..0a26e895b5a7 100644
--- a/core/lib/multivm/src/versions/vm_fast/tests/mod.rs
+++ b/core/lib/multivm/src/versions/vm_fast/tests/mod.rs
@@ -112,7 +112,7 @@ impl TestedVm for Vm<ImmutableStorageView<InMemoryStorage>> {
}
fn finish_batch_without_pubdata(&mut self) -> VmExecutionResultAndLogs {
- self.inspect_inner(&mut Default::default(), VmExecutionMode::Batch)
+ self.inspect_inner(&mut Default::default(), VmExecutionMode::Batch, None)
}
fn insert_bytecodes(&mut self, bytecodes: &[&[u8]]) {
diff --git a/core/lib/multivm/src/versions/vm_fast/version.rs b/core/lib/multivm/src/versions/vm_fast/version.rs
new file mode 100644
index 000000000000..8da180d8ba59
--- /dev/null
+++ b/core/lib/multivm/src/versions/vm_fast/version.rs
@@ -0,0 +1,28 @@
+use crate::{vm_latest::MultiVmSubversion, VmVersion};
+
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum FastVmVersion {
+ IncreasedBootloaderMemory,
+ Gateway,
+}
+
+impl From<FastVmVersion> for MultiVmSubversion {
+ fn from(value: FastVmVersion) -> Self {
+ match value {
+ FastVmVersion::IncreasedBootloaderMemory => Self::IncreasedBootloaderMemory,
+ FastVmVersion::Gateway => Self::Gateway,
+ }
+ }
+}
+
+impl TryFrom<VmVersion> for FastVmVersion {
+ type Error = ();
+
+ fn try_from(value: VmVersion) -> Result<Self, Self::Error> {
+ match value {
+ VmVersion::Vm1_5_0IncreasedBootloaderMemory => Ok(Self::IncreasedBootloaderMemory),
+ VmVersion::VmGateway => Ok(Self::Gateway),
+ _ => Err(()),
+ }
+ }
+}
diff --git a/core/lib/multivm/src/versions/vm_fast/vm.rs b/core/lib/multivm/src/versions/vm_fast/vm.rs
index 2aab2bfc7d96..a91f0831ebbf 100644
--- a/core/lib/multivm/src/versions/vm_fast/vm.rs
+++ b/core/lib/multivm/src/versions/vm_fast/vm.rs
@@ -23,7 +23,6 @@ use zksync_vm2::{
interface::{CallframeInterface, HeapId, StateInterface, Tracer},
ExecutionEnd, FatPointer, Program, Settings, StorageSlot, VirtualMachine,
};
-use zksync_vm_interface::{pubdata::PubdataBuilder, InspectExecutionMode};
use super::{
bootloader_state::{BootloaderState, BootloaderStateSnapshot},
@@ -37,32 +36,28 @@ use super::{
use crate::{
glue::GlueInto,
interface::{
+ pubdata::{PubdataBuilder, PubdataInput},
storage::{ImmutableStorageView, ReadStorage, StoragePtr, StorageView},
BytecodeCompressionError, BytecodeCompressionResult, CurrentExecutionState,
- ExecutionResult, FinishedL1Batch, Halt, L1BatchEnv, L2BlockEnv, PushTransactionResult,
- Refunds, SystemEnv, TxRevertReason, VmEvent, VmExecutionLogs, VmExecutionMode,
- VmExecutionResultAndLogs, VmExecutionStatistics, VmFactory, VmInterface,
+ ExecutionResult, FinishedL1Batch, Halt, InspectExecutionMode, L1BatchEnv, L2BlockEnv,
+ PushTransactionResult, Refunds, SystemEnv, TxRevertReason, VmEvent, VmExecutionLogs,
+ VmExecutionMode, VmExecutionResultAndLogs, VmExecutionStatistics, VmFactory, VmInterface,
VmInterfaceHistoryEnabled, VmRevertReason, VmTrackingContracts,
},
- is_supported_by_fast_vm,
utils::events::extract_l2tol1logs_from_l1_messenger,
vm_fast::{
bootloader_state::utils::{apply_l2_block, apply_pubdata_to_memory},
events::merge_events,
- pubdata::PubdataInput,
refund::compute_refund,
+ version::FastVmVersion,
},
- vm_latest::{
- constants::{
- get_result_success_first_slot, get_vm_hook_params_start_position, get_vm_hook_position,
- OPERATOR_REFUNDS_OFFSET, TX_GAS_LIMIT_OFFSET, VM_HOOK_PARAMS_COUNT,
- },
- MultiVMSubversion,
+ vm_latest::constants::{
+ get_result_success_first_slot, get_vm_hook_params_start_position, get_vm_hook_position,
+ OPERATOR_REFUNDS_OFFSET, TX_GAS_LIMIT_OFFSET, VM_HOOK_PARAMS_COUNT,
},
+ VmVersion,
};
-const VM_VERSION: MultiVMSubversion = MultiVMSubversion::IncreasedBootloaderMemory;
-
type FullTracer<Tr> = ((Tr, CircuitsTracer), EvmDeployTracer);
#[derive(Debug)]
@@ -103,17 +98,21 @@ pub struct Vm<S, Tr = ()> {
pub(super) batch_env: L1BatchEnv,
pub(super) system_env: SystemEnv,
snapshot: Option<VmSnapshot>,
+ vm_version: FastVmVersion,
#[cfg(test)]
enforced_state_diffs: Option<Vec<StateDiffRecord>>,
}
impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
pub fn custom(batch_env: L1BatchEnv, system_env: SystemEnv, storage: S) -> Self {
- assert!(
- is_supported_by_fast_vm(system_env.version),
- "Protocol version {:?} is not supported by fast VM",
- system_env.version
- );
+ let vm_version: FastVmVersion = VmVersion::from(system_env.version)
+ .try_into()
+ .unwrap_or_else(|_| {
+ panic!(
+ "Protocol version {:?} is not supported by fast VM",
+ system_env.version
+ )
+ });
let default_aa_code_hash = system_env.base_system_smart_contracts.default_aa.hash;
let evm_emulator_hash = system_env
@@ -147,7 +146,7 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
Settings {
default_aa_code_hash: default_aa_code_hash.into(),
evm_interpreter_code_hash: evm_emulator_hash.into(),
- hook_address: get_vm_hook_position(VM_VERSION) * 32,
+ hook_address: get_vm_hook_position(vm_version.into()) * 32,
},
);
@@ -167,10 +166,12 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
system_env.execution_mode,
bootloader_memory.clone(),
batch_env.first_l2_block,
+ system_env.version,
),
system_env,
batch_env,
snapshot: None,
+ vm_version,
#[cfg(test)]
enforced_state_diffs: None,
};
@@ -183,6 +184,7 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
execution_mode: VmExecutionMode,
tracer: &mut FullTracer<Tr>,
track_refunds: bool,
+ pubdata_builder: Option<&dyn PubdataBuilder>,
) -> VmRunResult {
let mut refunds = Refunds {
gas_refunded: 0,
@@ -353,15 +355,19 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
state_diffs: self.compute_state_diffs(),
};
- // Save the pubdata for the future initial bootloader memory building
- self.bootloader_state
- .set_pubdata_input(pubdata_input.clone());
-
// Apply the pubdata to the current memory
let mut memory_to_apply = vec![];
- apply_pubdata_to_memory(&mut memory_to_apply, pubdata_input);
+ apply_pubdata_to_memory(
+ &mut memory_to_apply,
+ pubdata_builder.expect("`pubdata_builder` is required to finish batch"),
+ &pubdata_input,
+ self.system_env.version,
+ );
self.write_to_bootloader_heap(memory_to_apply);
+
+ // Save the pubdata for the future initial bootloader memory building
+ self.bootloader_state.set_pubdata_input(pubdata_input);
}
Hook::PaymasterValidationEntered | Hook::ValidationStepEnded => { /* unused */ }
@@ -386,8 +392,8 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
}
fn get_hook_params(&self) -> [U256; 3] {
- (get_vm_hook_params_start_position(VM_VERSION)
- ..get_vm_hook_params_start_position(VM_VERSION) + VM_HOOK_PARAMS_COUNT)
+ (get_vm_hook_params_start_position(self.vm_version.into())
+ ..get_vm_hook_params_start_position(self.vm_version.into()) + VM_HOOK_PARAMS_COUNT)
.map(|word| self.read_word_from_bootloader_heap(word as usize))
.collect::<Vec<_>>()
.try_into()
@@ -396,7 +402,7 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
fn get_tx_result(&self) -> U256 {
let tx_idx = self.bootloader_state.current_tx();
- let slot = get_result_success_first_slot(VM_VERSION) as usize + tx_idx;
+ let slot = get_result_success_first_slot(self.vm_version.into()) as usize + tx_idx;
self.read_word_from_bootloader_heap(slot)
}
@@ -578,6 +584,7 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
&mut self,
tracer: &mut Tr,
execution_mode: VmExecutionMode,
+ pubdata_builder: Option<&dyn PubdataBuilder>,
) -> VmExecutionResultAndLogs {
let mut track_refunds = false;
if matches!(execution_mode, VmExecutionMode::OneTx) {
@@ -593,7 +600,12 @@ impl<S: ReadStorage, Tr: Tracer + Default> Vm<S, Tr> {
(mem::take(tracer), CircuitsTracer::default()),
EvmDeployTracer::new(self.world.dynamic_bytecodes.clone()),
);
- let result = self.run(execution_mode, &mut full_tracer, track_refunds);
+ let result = self.run(
+ execution_mode,
+ &mut full_tracer,
+ track_refunds,
+ pubdata_builder,
+ );
let ((external_tracer, circuits_tracer), _) = full_tracer;
*tracer = external_tracer; // place the tracer back
@@ -712,7 +724,7 @@ impl<S: ReadStorage, Tr: Tracer + Default + 'static> VmInterface for Vm<S, Tr> {
tracer: &mut Self::TracerDispatcher,
execution_mode: InspectExecutionMode,
) -> VmExecutionResultAndLogs {
- self.inspect_inner(tracer, execution_mode.into())
+ self.inspect_inner(tracer, execution_mode.into(), None)
}
fn inspect_transaction_with_bytecode_compression(
@@ -739,19 +751,23 @@ impl<S: ReadStorage, Tr: Tracer + Default + 'static> VmInterface for Vm<S, Tr> {
self.bootloader_state.start_new_l2_block(l2_block_env)
}
- fn finish_batch(&mut self, _pubdata_builder: Rc<dyn PubdataBuilder>) -> FinishedL1Batch {
- let result = self.inspect_inner(&mut Tr::default(), VmExecutionMode::Batch);
+ fn finish_batch(&mut self, pubdata_builder: Rc<dyn PubdataBuilder>) -> FinishedL1Batch {
+ let result = self.inspect_inner(
+ &mut Tr::default(),
+ VmExecutionMode::Batch,
+ Some(pubdata_builder.as_ref()),
+ );
let execution_state = self.get_current_execution_state();
- let bootloader_memory = self.bootloader_state.bootloader_memory();
+ let bootloader_memory = self
+ .bootloader_state
+ .bootloader_memory(pubdata_builder.as_ref());
FinishedL1Batch {
block_tip_execution_result: result,
final_execution_state: execution_state,
final_bootloader_memory: Some(bootloader_memory),
pubdata_input: Some(
self.bootloader_state
- .get_pubdata_information()
- .clone()
- .build_pubdata(false),
+ .settlement_layer_pubdata(pubdata_builder.as_ref()),
),
state_diffs: Some(
self.bootloader_state
diff --git a/core/lib/multivm/src/versions/vm_latest/constants.rs b/core/lib/multivm/src/versions/vm_latest/constants.rs
index c047e6ffa3b0..c95771f9e849 100644
--- a/core/lib/multivm/src/versions/vm_latest/constants.rs
+++ b/core/lib/multivm/src/versions/vm_latest/constants.rs
@@ -5,7 +5,7 @@ pub use zk_evm_1_5_0::zkevm_opcode_defs::system_params::{
};
use zksync_system_constants::MAX_NEW_FACTORY_DEPS;
-use super::vm::MultiVMSubversion;
+use super::vm::MultiVmSubversion;
use crate::vm_latest::old_vm::utils::heap_page_from_base;
/// The amount of ergs to be reserved at the end of the batch to ensure that it has enough ergs to verify compression, etc.
@@ -22,15 +22,15 @@ pub(crate) const MAX_BASE_LAYER_CIRCUITS: usize = 34100;
/// the requirements on RAM.
/// In this version of the VM the used bootloader memory bytes has increased from `30_000_000` to `59_000_000`,
/// and then to `63_800_000` in a subsequent upgrade.
-pub(crate) const fn get_used_bootloader_memory_bytes(subversion: MultiVMSubversion) -> usize {
+pub(crate) const fn get_used_bootloader_memory_bytes(subversion: MultiVmSubversion) -> usize {
match subversion {
- MultiVMSubversion::SmallBootloaderMemory => 59_000_000,
- MultiVMSubversion::IncreasedBootloaderMemory => 63_800_000,
- MultiVMSubversion::Gateway => 63_800_000,
+ MultiVmSubversion::SmallBootloaderMemory => 59_000_000,
+ MultiVmSubversion::IncreasedBootloaderMemory => 63_800_000,
+ MultiVmSubversion::Gateway => 63_800_000,
}
}
-pub(crate) const fn get_used_bootloader_memory_words(subversion: MultiVMSubversion) -> usize {
+pub(crate) const fn get_used_bootloader_memory_words(subversion: MultiVmSubversion) -> usize {
get_used_bootloader_memory_bytes(subversion) / 32
}
@@ -105,7 +105,7 @@ pub(crate) const BOOTLOADER_TX_DESCRIPTION_OFFSET: usize =
OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_OFFSET + OPERATOR_PROVIDED_L1_MESSENGER_PUBDATA_SLOTS;
/// The size of the bootloader memory dedicated to the encodings of transactions
-pub(crate) const fn get_bootloader_tx_encoding_space(subversion: MultiVMSubversion) -> u32 {
+pub(crate) const fn get_bootloader_tx_encoding_space(subversion: MultiVmSubversion) -> u32 {
(get_used_bootloader_memory_words(subversion) - TX_DESCRIPTION_OFFSET - MAX_TXS_IN_BATCH) as u32
}
@@ -129,21 +129,21 @@ pub const BOOTLOADER_HEAP_PAGE: u32 = heap_page_from_base(MemoryPage(INITIAL_BAS
/// So the layout looks like this:
/// `[param 0][param 1][param 2][vmhook opcode]`
pub const VM_HOOK_PARAMS_COUNT: u32 = 3;
-pub(crate) const fn get_vm_hook_position(subversion: MultiVMSubversion) -> u32 {
+pub(crate) const fn get_vm_hook_position(subversion: MultiVmSubversion) -> u32 {
get_result_success_first_slot(subversion) - 1
}
-pub(crate) const fn get_vm_hook_params_start_position(subversion: MultiVMSubversion) -> u32 {
+pub(crate) const fn get_vm_hook_params_start_position(subversion: MultiVmSubversion) -> u32 {
get_vm_hook_position(subversion) - VM_HOOK_PARAMS_COUNT
}
/// Method that provides the start position of the vm hook in the memory for the latest version of v1.5.0.
/// This method is used only in `test_infra` in the bootloader tests and that's why it should be exposed.
pub const fn get_vm_hook_start_position_latest() -> u32 {
- get_vm_hook_params_start_position(MultiVMSubversion::IncreasedBootloaderMemory)
+ get_vm_hook_params_start_position(MultiVmSubversion::IncreasedBootloaderMemory)
}
/// Arbitrary space in memory closer to the end of the page
-pub(crate) const fn get_result_success_first_slot(subversion: MultiVMSubversion) -> u32 {
+pub(crate) const fn get_result_success_first_slot(subversion: MultiVmSubversion) -> u32 {
((get_used_bootloader_memory_bytes(subversion) as u32) - (MAX_TXS_IN_BATCH as u32) * 32) / 32
}
diff --git a/core/lib/multivm/src/versions/vm_latest/mod.rs b/core/lib/multivm/src/versions/vm_latest/mod.rs
index 211c527c3816..46f8db789ddc 100644
--- a/core/lib/multivm/src/versions/vm_latest/mod.rs
+++ b/core/lib/multivm/src/versions/vm_latest/mod.rs
@@ -1,4 +1,4 @@
-pub(crate) use self::vm::MultiVMSubversion;
+pub(crate) use self::vm::MultiVmSubversion;
pub use self::{
bootloader_state::BootloaderState,
old_vm::{
diff --git a/core/lib/multivm/src/versions/vm_latest/tests/constants.rs b/core/lib/multivm/src/versions/vm_latest/tests/constants.rs
index 3b75bfd6d36b..8ee62650ca77 100644
--- a/core/lib/multivm/src/versions/vm_latest/tests/constants.rs
+++ b/core/lib/multivm/src/versions/vm_latest/tests/constants.rs
@@ -3,7 +3,7 @@
#[test]
fn test_that_bootloader_encoding_space_is_large_enoguh() {
let encoding_space = crate::vm_latest::constants::get_bootloader_tx_encoding_space(
- crate::vm_latest::MultiVMSubversion::latest(),
+ crate::vm_latest::MultiVmSubversion::latest(),
);
assert!(encoding_space >= 330000, "Bootloader tx space is too small");
}
diff --git a/core/lib/multivm/src/versions/vm_latest/tests/mod.rs b/core/lib/multivm/src/versions/vm_latest/tests/mod.rs
index 51c9dde0dd56..fc226f03ecea 100644
--- a/core/lib/multivm/src/versions/vm_latest/tests/mod.rs
+++ b/core/lib/multivm/src/versions/vm_latest/tests/mod.rs
@@ -91,7 +91,7 @@ impl TestedVm for TestedLatestVm {
self.batch_env.clone(),
VmExecutionMode::Batch,
diffs,
- crate::vm_latest::MultiVMSubversion::latest(),
+ crate::vm_latest::MultiVmSubversion::latest(),
Some(pubdata_builder),
);
self.inspect_inner(
diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/default_tracers.rs b/core/lib/multivm/src/versions/vm_latest/tracers/default_tracers.rs
index 7156acce152e..8755b98ddb8c 100755
--- a/core/lib/multivm/src/versions/vm_latest/tracers/default_tracers.rs
+++ b/core/lib/multivm/src/versions/vm_latest/tracers/default_tracers.rs
@@ -32,7 +32,7 @@ use crate::{
CircuitsTracer, RefundsTracer, ResultTracer,
},
types::internals::ZkSyncVmState,
- vm::MultiVMSubversion,
+ vm::MultiVmSubversion,
VmTracer,
},
};
@@ -65,7 +65,7 @@ pub struct DefaultExecutionTracer<S: WriteStorage, H: HistoryMode> {
pub(crate) circuits_tracer: CircuitsTracer<S, H>,
// This tracer is responsible for handling EVM deployments and providing the data to the code decommitter.
pub(crate) evm_deploy_tracer: Option<EvmDeployTracer<S>>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
storage: StoragePtr<S>,
_phantom: PhantomData<H>,
}
@@ -80,7 +80,7 @@ impl<S: WriteStorage, H: HistoryMode> DefaultExecutionTracer<S, H> {
storage: StoragePtr<S>,
refund_tracer: Option<RefundsTracer<S>>,
pubdata_tracer: Option<PubdataTracer<S>>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
) -> Self {
Self {
tx_has_been_processed: false,
diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/pubdata_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/pubdata_tracer.rs
index 4c71c3b2fc49..3698914630dd 100644
--- a/core/lib/multivm/src/versions/vm_latest/tracers/pubdata_tracer.rs
+++ b/core/lib/multivm/src/versions/vm_latest/tracers/pubdata_tracer.rs
@@ -33,7 +33,7 @@ use crate::{
tracers::{traits::VmTracer, utils::VmHook},
types::internals::ZkSyncVmState,
utils::logs::collect_events_and_l1_system_logs_after_timestamp,
- vm::MultiVMSubversion,
+ vm::MultiVmSubversion,
StorageOracle,
},
};
@@ -47,7 +47,7 @@ pub(crate) struct PubdataTracer<S> {
// For testing purposes it might be helpful to supply an exact set of state diffs to be provided
// to the L1Messenger.
enforced_state_diffs: Option<Vec<StateDiffRecord>>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
pubdata_builder: Option<Rc<dyn PubdataBuilder>>,
_phantom_data: PhantomData<S>,
}
@@ -56,7 +56,7 @@ impl<S: WriteStorage> PubdataTracer<S> {
pub(crate) fn new(
l1_batch_env: L1BatchEnv,
execution_mode: VmExecutionMode,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
pubdata_builder: Option<Rc<dyn PubdataBuilder>>,
) -> Self {
Self {
@@ -77,7 +77,7 @@ impl<S: WriteStorage> PubdataTracer<S> {
l1_batch_env: L1BatchEnv,
execution_mode: VmExecutionMode,
forced_state_diffs: Vec<StateDiffRecord>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
pubdata_builder: Option<Rc<dyn PubdataBuilder>>,
) -> Self {
Self {
diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/refunds.rs b/core/lib/multivm/src/versions/vm_latest/tracers/refunds.rs
index f3fc1b167b45..6ef251c2db98 100644
--- a/core/lib/multivm/src/versions/vm_latest/tracers/refunds.rs
+++ b/core/lib/multivm/src/versions/vm_latest/tracers/refunds.rs
@@ -24,7 +24,7 @@ use crate::{
},
types::internals::ZkSyncVmState,
utils::fee::get_batch_base_fee,
- vm::MultiVMSubversion,
+ vm::MultiVmSubversion,
},
};
@@ -50,12 +50,12 @@ pub(crate) struct RefundsTracer<S> {
spent_pubdata_counter_before: u32,
l1_batch: L1BatchEnv,
pubdata_published: u32,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
_phantom: PhantomData<S>,
}
impl<S> RefundsTracer<S> {
- pub(crate) fn new(l1_batch: L1BatchEnv, subversion: MultiVMSubversion) -> Self {
+ pub(crate) fn new(l1_batch: L1BatchEnv, subversion: MultiVmSubversion) -> Self {
Self {
pending_refund_request: None,
refund_gas: 0,
diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/result_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/result_tracer.rs
index 0687c8393c62..80a3147f65d2 100644
--- a/core/lib/multivm/src/versions/vm_latest/tracers/result_tracer.rs
+++ b/core/lib/multivm/src/versions/vm_latest/tracers/result_tracer.rs
@@ -23,7 +23,7 @@ use crate::{
utils::{get_vm_hook_params, read_pointer, VmHook},
},
types::internals::ZkSyncVmState,
- vm::MultiVMSubversion,
+ vm::MultiVmSubversion,
BootloaderState, HistoryMode, SimpleMemory,
},
};
@@ -102,7 +102,7 @@ pub(crate) struct ResultTracer<S> {
execution_mode: VmExecutionMode,
far_call_tracker: FarCallTracker,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
pub(crate) tx_finished_in_one_tx_mode: bool,
@@ -110,7 +110,7 @@ pub(crate) struct ResultTracer<S> {
}
impl<S> ResultTracer<S> {
- pub(crate) fn new(execution_mode: VmExecutionMode, subversion: MultiVMSubversion) -> Self {
+ pub(crate) fn new(execution_mode: VmExecutionMode, subversion: MultiVmSubversion) -> Self {
Self {
result: None,
bootloader_out_of_gas: false,
@@ -336,7 +336,7 @@ impl<S: WriteStorage> ResultTracer<S> {
pub(crate) fn tx_has_failed<S: WriteStorage, H: HistoryMode>(
state: &ZkSyncVmState<S, H>,
tx_id: u32,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
) -> bool {
let mem_slot = get_result_success_first_slot(subversion) + tx_id;
let mem_value = state
diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/utils.rs b/core/lib/multivm/src/versions/vm_latest/tracers/utils.rs
index 50901dca62fc..6f81a3ac8de5 100644
--- a/core/lib/multivm/src/versions/vm_latest/tracers/utils.rs
+++ b/core/lib/multivm/src/versions/vm_latest/tracers/utils.rs
@@ -21,7 +21,7 @@ use crate::vm_latest::{
memory::SimpleMemory,
utils::{aux_heap_page_from_base, heap_page_from_base},
},
- vm::MultiVMSubversion,
+ vm::MultiVmSubversion,
};
#[derive(Clone, Debug, Copy)]
@@ -47,7 +47,7 @@ impl VmHook {
pub(crate) fn from_opcode_memory(
state: &VmLocalStateData<'_>,
data: &BeforeExecutionData,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
) -> Self {
let opcode_variant = data.opcode.variant;
let heap_page =
@@ -89,7 +89,7 @@ impl VmHook {
pub(crate) fn get_debug_log<H: HistoryMode>(
state: &VmLocalStateData<'_>,
memory: &SimpleMemory<H>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
) -> String {
let vm_hook_params: Vec<_> = get_vm_hook_params(memory, subversion)
.into_iter()
@@ -161,7 +161,7 @@ pub(crate) fn print_debug_if_needed<H: HistoryMode>(
state: &VmLocalStateData<'_>,
memory: &SimpleMemory<H>,
latest_returndata_ptr: Option<FatPointer>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
) {
let log = match hook {
VmHook::DebugLog => get_debug_log(state, memory, subversion),
@@ -210,7 +210,7 @@ pub(crate) fn get_calldata_page_via_abi(far_call_abi: &FarCallABI, base_page: Me
}
pub(crate) fn get_vm_hook_params<H: HistoryMode>(
memory: &SimpleMemory<H>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
) -> Vec<U256> {
let start_position = get_vm_hook_params_start_position(subversion);
memory.dump_page_content_as_u256_words(
diff --git a/core/lib/multivm/src/versions/vm_latest/vm.rs b/core/lib/multivm/src/versions/vm_latest/vm.rs
index 5a0e77023a5e..ada20af9fa3c 100644
--- a/core/lib/multivm/src/versions/vm_latest/vm.rs
+++ b/core/lib/multivm/src/versions/vm_latest/vm.rs
@@ -35,7 +35,7 @@ use crate::{
/// version was released with increased bootloader memory. The version with the small bootloader memory
/// is available only on internal staging environments.
#[derive(Debug, Copy, Clone)]
-pub(crate) enum MultiVMSubversion {
+pub(crate) enum MultiVmSubversion {
/// The initial version of v1.5.0, available only on staging environments.
SmallBootloaderMemory,
/// The final correct version of v1.5.0
@@ -44,7 +44,7 @@ pub(crate) enum MultiVMSubversion {
Gateway,
}
-impl MultiVMSubversion {
+impl MultiVmSubversion {
#[cfg(test)]
pub(crate) fn latest() -> Self {
Self::IncreasedBootloaderMemory
@@ -53,7 +53,7 @@ impl MultiVMSubversion {
#[derive(Debug)]
pub(crate) struct VmVersionIsNotVm150Error;
-impl TryFrom<VmVersion> for MultiVMSubversion {
+impl TryFrom<VmVersion> for MultiVmSubversion {
type Error = VmVersionIsNotVm150Error;
fn try_from(value: VmVersion) -> Result<Self, Self::Error> {
match value {
@@ -77,7 +77,7 @@ pub struct Vm<S: WriteStorage, H: HistoryMode> {
pub(crate) batch_env: L1BatchEnv,
// Snapshots for the current run
pub(crate) snapshots: Vec<VmSnapshot>,
- pub(crate) subversion: MultiVMSubversion,
+ pub(crate) subversion: MultiVmSubversion,
_phantom: std::marker::PhantomData<H>,
}
@@ -247,7 +247,7 @@ impl<S: WriteStorage, H: HistoryMode> Vm<S, H> {
batch_env: L1BatchEnv,
system_env: SystemEnv,
storage: StoragePtr<S>,
- subversion: MultiVMSubversion,
+ subversion: MultiVmSubversion,
) -> Self {
let (state, bootloader_state) = new_vm_state(storage.clone(), &system_env, &batch_env);
Self {
diff --git a/core/lib/multivm/src/versions/vm_m5/oracle_tools.rs b/core/lib/multivm/src/versions/vm_m5/oracle_tools.rs
index 32930f31cd71..f430ad346387 100644
--- a/core/lib/multivm/src/versions/vm_m5/oracle_tools.rs
+++ b/core/lib/multivm/src/versions/vm_m5/oracle_tools.rs
@@ -10,7 +10,7 @@ use crate::vm_m5::{
storage::StorageOracle,
},
storage::{Storage, StoragePtr},
- vm_instance::MultiVMSubversion,
+ vm_instance::MultiVmSubversion,
};
#[derive(Debug)]
@@ -25,7 +25,7 @@ pub struct OracleTools<const B: bool, S: Storage> {
}
impl<S: Storage> OracleTools<false, S> {
- pub fn new(storage_pointer: StoragePtr<S>, refund_state: MultiVMSubversion) -> Self {
+ pub fn new(storage_pointer: StoragePtr<S>, refund_state: MultiVmSubversion) -> Self {
Self {
storage: StorageOracle::new(storage_pointer.clone(), refund_state),
memory: SimpleMemory::default(),
diff --git a/core/lib/multivm/src/versions/vm_m5/oracles/storage.rs b/core/lib/multivm/src/versions/vm_m5/oracles/storage.rs
index ab373e9e7696..90bd9cfaab69 100644
--- a/core/lib/multivm/src/versions/vm_m5/oracles/storage.rs
+++ b/core/lib/multivm/src/versions/vm_m5/oracles/storage.rs
@@ -18,7 +18,7 @@ use crate::vm_m5::{
},
storage::{Storage, StoragePtr},
utils::StorageLogQuery,
- vm_instance::MultiVMSubversion,
+ vm_instance::MultiVmSubversion,
};
// While the storage does not support different shards, it was decided to write the
@@ -45,7 +45,7 @@ pub struct StorageOracle<S: Storage> {
// to cover this slot.
pub paid_changes: HistoryRecorder<HashMap<StorageKey, u32>>,
- pub refund_state: MultiVMSubversion,
+ pub refund_state: MultiVmSubversion,
}
impl<S: Storage> OracleWithHistory for StorageOracle<S> {
@@ -63,7 +63,7 @@ impl<S: Storage> OracleWithHistory for StorageOracle<S> {
}
impl<S: Storage> StorageOracle<S> {
- pub fn new(storage: StoragePtr<S>, refund_state: MultiVMSubversion) -> Self {
+ pub fn new(storage: StoragePtr<S>, refund_state: MultiVmSubversion) -> Self {
Self {
storage: HistoryRecorder::from_inner(StorageWrapper::new(storage)),
frames_stack: Default::default(),
@@ -74,10 +74,10 @@ impl<S: Storage> StorageOracle<S> {
fn is_storage_key_free(&self, key: &StorageKey) -> bool {
match self.refund_state {
- MultiVMSubversion::V1 => {
+ MultiVmSubversion::V1 => {
key.address() == &zksync_system_constants::SYSTEM_CONTEXT_ADDRESS
}
- MultiVMSubversion::V2 => {
+ MultiVmSubversion::V2 => {
key.address() == &zksync_system_constants::SYSTEM_CONTEXT_ADDRESS
|| *key == storage_key_for_eth_balance(&BOOTLOADER_ADDRESS)
}
diff --git a/core/lib/multivm/src/versions/vm_m5/vm.rs b/core/lib/multivm/src/versions/vm_m5/vm.rs
index 266a0a437e5e..bd104b868401 100644
--- a/core/lib/multivm/src/versions/vm_m5/vm.rs
+++ b/core/lib/multivm/src/versions/vm_m5/vm.rs
@@ -12,7 +12,7 @@ use crate::{
},
vm_m5::{
storage::Storage,
- vm_instance::{MultiVMSubversion, VmInstance},
+ vm_instance::{MultiVmSubversion, VmInstance},
},
};
@@ -28,7 +28,7 @@ impl<S: Storage, H: HistoryMode> Vm<S, H> {
batch_env: L1BatchEnv,
system_env: SystemEnv,
storage: StoragePtr<S>,
- vm_sub_version: MultiVMSubversion,
+ vm_sub_version: MultiVmSubversion,
) -> Self {
let oracle_tools = crate::vm_m5::OracleTools::new(storage.clone(), vm_sub_version);
let block_properties = zk_evm_1_3_1::block_properties::BlockProperties {
@@ -127,8 +127,8 @@ impl<S: Storage, H: HistoryMode> VmFactory<S> for Vm<S, H> {
fn new(batch_env: L1BatchEnv, system_env: SystemEnv, storage: StoragePtr<S>) -> Self {
let vm_version: VmVersion = system_env.version.into();
let vm_sub_version = match vm_version {
- VmVersion::M5WithoutRefunds => MultiVMSubversion::V1,
- VmVersion::M5WithRefunds => MultiVMSubversion::V2,
+ VmVersion::M5WithoutRefunds => MultiVmSubversion::V1,
+ VmVersion::M5WithRefunds => MultiVmSubversion::V2,
_ => panic!("Unsupported protocol version for vm_m5: {:?}", vm_version),
};
Self::new_with_subversion(batch_env, system_env, storage, vm_sub_version)
diff --git a/core/lib/multivm/src/versions/vm_m5/vm_instance.rs b/core/lib/multivm/src/versions/vm_m5/vm_instance.rs
index 4a96c4a750cc..94b86bce7ea7 100644
--- a/core/lib/multivm/src/versions/vm_m5/vm_instance.rs
+++ b/core/lib/multivm/src/versions/vm_m5/vm_instance.rs
@@ -81,7 +81,7 @@ pub(crate) fn get_vm_hook_params(memory: &SimpleMemory) -> Vec<U256> {
///
/// This enum allows to execute blocks with the same VM but different support for refunds.
#[derive(Debug, Copy, Clone)]
-pub enum MultiVMSubversion {
+pub enum MultiVmSubversion {
/// Initial VM M5 version, refunds are fully disabled.
V1,
/// Refunds were enabled. ETH balance for bootloader address was marked as a free slot.
@@ -99,7 +99,7 @@ pub struct VmInstance<S: Storage> {
pub snapshots: Vec<VmSnapshot>,
/// MultiVM-specific addition. See enum doc-comment for details.
- pub(crate) refund_state: MultiVMSubversion,
+ pub(crate) refund_state: MultiVmSubversion,
}
/// This structure stores data that accumulates during the VM run.
@@ -560,12 +560,12 @@ impl<S: Storage> VmInstance<S> {
let refund_to_propose;
let refund_slot;
match self.refund_state {
- MultiVMSubversion::V1 => {
+ MultiVmSubversion::V1 => {
refund_to_propose = bootloader_refund;
refund_slot =
OPERATOR_REFUNDS_OFFSET + self.bootloader_state.tx_to_execute() - 1;
}
- MultiVMSubversion::V2 => {
+ MultiVmSubversion::V2 => {
let gas_spent_on_pubdata = tracer
.gas_spent_on_pubdata(&self.state.local_state)
- spent_pubdata_counter_before;
diff --git a/core/lib/multivm/src/versions/vm_m5/vm_with_bootloader.rs b/core/lib/multivm/src/versions/vm_m5/vm_with_bootloader.rs
index 653169cd7ff0..706c0fbc717c 100644
--- a/core/lib/multivm/src/versions/vm_m5/vm_with_bootloader.rs
+++ b/core/lib/multivm/src/versions/vm_m5/vm_with_bootloader.rs
@@ -30,7 +30,7 @@ use crate::{
utils::{
code_page_candidate_from_base, heap_page_from_base, BLOCK_GAS_LIMIT, INITIAL_BASE_PAGE,
},
- vm_instance::{MultiVMSubversion, VmInstance, ZkSyncVmState},
+ vm_instance::{MultiVmSubversion, VmInstance, ZkSyncVmState},
OracleTools,
},
};
@@ -222,7 +222,7 @@ impl Default for TxExecutionMode {
}
pub fn init_vm<S: Storage>(
- refund_state: MultiVMSubversion,
+ refund_state: MultiVmSubversion,
oracle_tools: OracleTools<false, S>,
block_context: BlockContextMode,
block_properties: BlockProperties,
@@ -241,7 +241,7 @@ pub fn init_vm<S: Storage>(
}
pub fn init_vm_with_gas_limit<S: Storage>(
- refund_state: MultiVMSubversion,
+ refund_state: MultiVmSubversion,
oracle_tools: OracleTools<false, S>,
block_context: BlockContextMode,
block_properties: BlockProperties,
@@ -338,7 +338,7 @@ impl BlockContextMode {
// This method accepts a custom bootloader code.
// It should be used only in tests.
pub fn init_vm_inner<S: Storage>(
- refund_state: MultiVMSubversion,
+ refund_state: MultiVmSubversion,
mut oracle_tools: OracleTools<false, S>,
block_context: BlockContextMode,
block_properties: BlockProperties,
diff --git a/core/lib/multivm/src/versions/vm_m6/vm.rs b/core/lib/multivm/src/versions/vm_m6/vm.rs
index 0443dc8fb55e..2ed2666b2208 100644
--- a/core/lib/multivm/src/versions/vm_m6/vm.rs
+++ b/core/lib/multivm/src/versions/vm_m6/vm.rs
@@ -14,7 +14,7 @@ use crate::{
},
tracers::old::TracerDispatcher,
utils::bytecode,
- vm_m6::{storage::Storage, vm_instance::MultiVMSubversion, VmInstance},
+ vm_m6::{storage::Storage, vm_instance::MultiVmSubversion, VmInstance},
};
#[derive(Debug)]
@@ -28,7 +28,7 @@ impl<S: Storage, H: HistoryMode> Vm<S, H> {
batch_env: L1BatchEnv,
system_env: SystemEnv,
storage: StoragePtr<S>,
- vm_sub_version: MultiVMSubversion,
+ vm_sub_version: MultiVmSubversion,
) -> Self {
let oracle_tools = crate::vm_m6::OracleTools::new(storage.clone(), H::VmM6Mode::default());
let block_properties = zk_evm_1_3_1::block_properties::BlockProperties {
@@ -220,8 +220,8 @@ impl<S: Storage, H: HistoryMode> VmFactory<S> for Vm<S, H> {
fn new(batch_env: L1BatchEnv, system_env: SystemEnv, storage: StoragePtr<S>) -> Self {
let vm_version: VmVersion = system_env.version.into();
let vm_sub_version = match vm_version {
- VmVersion::M6Initial => MultiVMSubversion::V1,
- VmVersion::M6BugWithCompressionFixed => MultiVMSubversion::V2,
+ VmVersion::M6Initial => MultiVmSubversion::V1,
+ VmVersion::M6BugWithCompressionFixed => MultiVmSubversion::V2,
_ => panic!("Unsupported protocol version for vm_m6: {:?}", vm_version),
};
Self::new_with_subversion(batch_env, system_env, storage, vm_sub_version)
diff --git a/core/lib/multivm/src/versions/vm_m6/vm_instance.rs b/core/lib/multivm/src/versions/vm_m6/vm_instance.rs
index d6c418da4c20..29ef17aa4bc7 100644
--- a/core/lib/multivm/src/versions/vm_m6/vm_instance.rs
+++ b/core/lib/multivm/src/versions/vm_m6/vm_instance.rs
@@ -82,7 +82,7 @@ pub(crate) fn get_vm_hook_params<H: HistoryMode>(memory: &SimpleMemory<H>) -> Ve
///
/// This enum allows to execute blocks with the same VM but different support for refunds.
#[derive(Debug, Copy, Clone)]
-pub enum MultiVMSubversion {
+pub enum MultiVmSubversion {
/// Initial VM M6 version.
V1,
/// Bug with code compression was fixed.
@@ -98,7 +98,7 @@ pub struct VmInstance<S: Storage, H: HistoryMode> {
pub(crate) bootloader_state: BootloaderState,
pub snapshots: Vec<VmSnapshot>,
- pub vm_subversion: MultiVMSubversion,
+ pub vm_subversion: MultiVmSubversion,
}
/// This structure stores data that accumulates during the VM run.
diff --git a/core/lib/multivm/src/versions/vm_m6/vm_with_bootloader.rs b/core/lib/multivm/src/versions/vm_m6/vm_with_bootloader.rs
index a47ffb116364..24cddd5eb5ea 100644
--- a/core/lib/multivm/src/versions/vm_m6/vm_with_bootloader.rs
+++ b/core/lib/multivm/src/versions/vm_m6/vm_with_bootloader.rs
@@ -30,7 +30,7 @@ use crate::{
utils::{
code_page_candidate_from_base, heap_page_from_base, BLOCK_GAS_LIMIT, INITIAL_BASE_PAGE,
},
- vm_instance::{MultiVMSubversion, ZkSyncVmState},
+ vm_instance::{MultiVmSubversion, ZkSyncVmState},
OracleTools, VmInstance,
},
};
@@ -270,7 +270,7 @@ impl Default for TxExecutionMode {
}
pub fn init_vm<S: Storage, H: HistoryMode>(
- vm_subversion: MultiVMSubversion,
+ vm_subversion: MultiVmSubversion,
oracle_tools: OracleTools<false, S, H>,
block_context: BlockContextMode,
block_properties: BlockProperties,
@@ -289,7 +289,7 @@ pub fn init_vm<S: Storage, H: HistoryMode>(
}
pub fn init_vm_with_gas_limit<S: Storage, H: HistoryMode>(
- vm_subversion: MultiVMSubversion,
+ vm_subversion: MultiVmSubversion,
oracle_tools: OracleTools<false, S, H>,
block_context: BlockContextMode,
block_properties: BlockProperties,
@@ -386,7 +386,7 @@ impl BlockContextMode {
// This method accepts a custom bootloader code.
// It should be used only in tests.
pub fn init_vm_inner<S: Storage, H: HistoryMode>(
- vm_subversion: MultiVMSubversion,
+ vm_subversion: MultiVmSubversion,
mut oracle_tools: OracleTools<false, S, H>,
block_context: BlockContextMode,
block_properties: BlockProperties,
@@ -434,7 +434,7 @@ fn bootloader_initial_memory(block_properties: &BlockContextMode) -> Vec<(usize,
}
pub fn get_bootloader_memory(
- vm_subversion: MultiVMSubversion,
+ vm_subversion: MultiVmSubversion,
txs: Vec<TransactionData>,
predefined_refunds: Vec<u32>,
predefined_compressed_bytecodes: Vec<Vec<CompressedBytecodeInfo>>,
@@ -442,14 +442,14 @@ pub fn get_bootloader_memory(
block_context: BlockContextMode,
) -> Vec<(usize, U256)> {
match vm_subversion {
- MultiVMSubversion::V1 => get_bootloader_memory_v1(
+ MultiVmSubversion::V1 => get_bootloader_memory_v1(
txs,
predefined_refunds,
predefined_compressed_bytecodes,
execution_mode,
block_context,
),
- MultiVMSubversion::V2 => get_bootloader_memory_v2(
+ MultiVmSubversion::V2 => get_bootloader_memory_v2(
txs,
predefined_refunds,
predefined_compressed_bytecodes,
@@ -576,14 +576,14 @@ pub fn push_raw_transaction_to_bootloader_memory<S: Storage, H: HistoryMode>(
explicit_compressed_bytecodes: Option<Vec<CompressedBytecodeInfo>>,
) -> Vec<CompressedBytecodeInfo> {
match vm.vm_subversion {
- MultiVMSubversion::V1 => push_raw_transaction_to_bootloader_memory_v1(
+ MultiVmSubversion::V1 => push_raw_transaction_to_bootloader_memory_v1(
vm,
tx,
execution_mode,
predefined_overhead,
explicit_compressed_bytecodes,
),
- MultiVMSubversion::V2 => push_raw_transaction_to_bootloader_memory_v2(
+ MultiVmSubversion::V2 => push_raw_transaction_to_bootloader_memory_v2(
vm,
tx,
execution_mode,
diff --git a/core/lib/multivm/src/vm_instance.rs b/core/lib/multivm/src/vm_instance.rs
index e2f72bd24113..9de99a7eb116 100644
--- a/core/lib/multivm/src/vm_instance.rs
+++ b/core/lib/multivm/src/vm_instance.rs
@@ -14,6 +14,7 @@ use crate::{
VmMemoryMetrics,
},
tracers::TracerDispatcher,
+ vm_fast::FastVmVersion,
vm_latest::HistoryEnabled,
};
@@ -132,7 +133,7 @@ impl<S: ReadStorage, H: HistoryMode> LegacyVmInstance<S, H> {
l1_batch_env,
system_env,
storage_view,
- crate::vm_m5::vm_instance::MultiVMSubversion::V1,
+ crate::vm_m5::vm_instance::MultiVmSubversion::V1,
);
Self::VmM5(vm)
}
@@ -141,7 +142,7 @@ impl<S: ReadStorage, H: HistoryMode> LegacyVmInstance<S, H> {
l1_batch_env,
system_env,
storage_view,
- crate::vm_m5::vm_instance::MultiVMSubversion::V2,
+ crate::vm_m5::vm_instance::MultiVmSubversion::V2,
);
Self::VmM5(vm)
}
@@ -150,7 +151,7 @@ impl<S: ReadStorage, H: HistoryMode> LegacyVmInstance<S, H> {
l1_batch_env,
system_env,
storage_view,
- crate::vm_m6::vm_instance::MultiVMSubversion::V1,
+ crate::vm_m6::vm_instance::MultiVmSubversion::V1,
);
Self::VmM6(vm)
}
@@ -159,7 +160,7 @@ impl<S: ReadStorage, H: HistoryMode> LegacyVmInstance<S, H> {
l1_batch_env,
system_env,
storage_view,
- crate::vm_m6::vm_instance::MultiVMSubversion::V2,
+ crate::vm_m6::vm_instance::MultiVmSubversion::V2,
);
Self::VmM6(vm)
}
@@ -194,7 +195,7 @@ impl<S: ReadStorage, H: HistoryMode> LegacyVmInstance<S, H> {
l1_batch_env,
system_env,
storage_view,
- crate::vm_latest::MultiVMSubversion::SmallBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::SmallBootloaderMemory,
);
Self::Vm1_5_0(vm)
}
@@ -203,7 +204,7 @@ impl<S: ReadStorage, H: HistoryMode> LegacyVmInstance<S, H> {
l1_batch_env,
system_env,
storage_view,
- crate::vm_latest::MultiVMSubversion::IncreasedBootloaderMemory,
+ crate::vm_latest::MultiVmSubversion::IncreasedBootloaderMemory,
);
Self::Vm1_5_0(vm)
}
@@ -212,7 +213,7 @@ impl<S: ReadStorage, H: HistoryMode> LegacyVmInstance<S, H> {
l1_batch_env,
system_env,
storage_view,
- crate::vm_latest::MultiVMSubversion::Gateway,
+ crate::vm_latest::MultiVmSubversion::Gateway,
);
Self::Vm1_5_0(vm)
}
@@ -340,8 +341,5 @@ impl<S: ReadStorage, Tr: Tracer + Default + 'static> FastVmInstance<S, Tr> {
/// Checks whether the protocol version is supported by the fast VM.
pub fn is_supported_by_fast_vm(protocol_version: ProtocolVersionId) -> bool {
- matches!(
- protocol_version.into(),
- VmVersion::Vm1_5_0IncreasedBootloaderMemory
- )
+ FastVmVersion::try_from(VmVersion::from(protocol_version)).is_ok()
}
diff --git a/core/lib/vm_executor/src/batch/factory.rs b/core/lib/vm_executor/src/batch/factory.rs
index de0db5f0bf75..76ef244401bd 100644
--- a/core/lib/vm_executor/src/batch/factory.rs
+++ b/core/lib/vm_executor/src/batch/factory.rs
@@ -18,7 +18,7 @@ use zksync_multivm::{
tracers::CallTracer,
vm_fast,
vm_latest::HistoryEnabled,
- FastVmInstance, LegacyVmInstance, MultiVMTracer,
+ FastVmInstance, LegacyVmInstance, MultiVmTracer,
};
use zksync_types::{commitment::PubdataParams, vm::FastVmMode, Transaction};
diff --git a/core/lib/vm_executor/src/oneshot/contracts.rs b/core/lib/vm_executor/src/oneshot/contracts.rs
index d4e0a94f9178..cacab36cb1c2 100644
--- a/core/lib/vm_executor/src/oneshot/contracts.rs
+++ b/core/lib/vm_executor/src/oneshot/contracts.rs
@@ -26,7 +26,7 @@ impl ContractsKind for CallOrExecute {}
/// Provider of [`BaseSystemContracts`] for oneshot execution.
///
-/// The main implementation of this trait is [`MultiVMBaseSystemContracts`], which selects contracts
+/// The main implementation of this trait is [`MultiVmBaseSystemContracts`], which selects contracts
/// based on [`ProtocolVersionId`].
#[async_trait]
pub trait BaseSystemContractsProvider<C: ContractsKind>: fmt::Debug + Send + Sync {
@@ -46,7 +46,7 @@ pub trait BaseSystemContractsProvider<C: ContractsKind>: fmt::Debug + Send + Syn
/// System contracts (bootloader and default account abstraction) for all supported VM versions.
#[derive(Debug)]
-pub struct MultiVMBaseSystemContracts<C> {
+pub struct MultiVmBaseSystemContracts<C> {
/// Contracts to be used for pre-virtual-blocks protocol versions.
pre_virtual_blocks: BaseSystemContracts,
/// Contracts to be used for post-virtual-blocks protocol versions.
@@ -69,11 +69,11 @@ pub struct MultiVMBaseSystemContracts<C> {
vm_protocol_defense: BaseSystemContracts,
/// Contracts to be used after the gateway upgrade
gateway: BaseSystemContracts,
- // We use `fn() -> C` marker so that the `MultiVMBaseSystemContracts` unconditionally implements `Send + Sync`.
+ // We use `fn() -> C` marker so that the `MultiVmBaseSystemContracts` unconditionally implements `Send + Sync`.
_contracts_kind: PhantomData<fn() -> C>,
}
-impl<C: ContractsKind> MultiVMBaseSystemContracts<C> {
+impl<C: ContractsKind> MultiVmBaseSystemContracts<C> {
fn get_by_protocol_version(
&self,
version: ProtocolVersionId,
@@ -120,7 +120,7 @@ impl<C: ContractsKind> MultiVMBaseSystemContracts<C> {
}
}
-impl MultiVMBaseSystemContracts<EstimateGas> {
+impl MultiVmBaseSystemContracts<EstimateGas> {
/// Returned system contracts (mainly the bootloader) are tuned to provide accurate execution metrics.
pub fn load_estimate_gas_blocking() -> Self {
Self {
@@ -142,7 +142,7 @@ impl MultiVMBaseSystemContracts<EstimateGas> {
}
}
-impl MultiVMBaseSystemContracts<CallOrExecute> {
+impl MultiVmBaseSystemContracts<CallOrExecute> {
/// Returned system contracts (mainly the bootloader) are tuned to provide better UX (e.g. revert messages).
pub fn load_eth_call_blocking() -> Self {
Self {
@@ -165,7 +165,7 @@ impl MultiVMBaseSystemContracts<CallOrExecute> {
}
#[async_trait]
-impl<C: ContractsKind> BaseSystemContractsProvider<C> for MultiVMBaseSystemContracts<C> {
+impl<C: ContractsKind> BaseSystemContractsProvider<C> for MultiVmBaseSystemContracts<C> {
async fn base_system_contracts(
&self,
block_info: &ResolvedBlockInfo,
diff --git a/core/lib/vm_executor/src/oneshot/mod.rs b/core/lib/vm_executor/src/oneshot/mod.rs
index e95164c0fc87..0dfdb67bff52 100644
--- a/core/lib/vm_executor/src/oneshot/mod.rs
+++ b/core/lib/vm_executor/src/oneshot/mod.rs
@@ -29,7 +29,7 @@ use zksync_multivm::{
utils::adjust_pubdata_price_for_tx,
vm_latest::{HistoryDisabled, HistoryEnabled},
zk_evm_latest::ethereum_types::U256,
- FastVmInstance, HistoryMode, LegacyVmInstance, MultiVMTracer,
+ FastVmInstance, HistoryMode, LegacyVmInstance, MultiVmTracer,
};
use zksync_types::{
block::pack_block_info,
@@ -46,7 +46,7 @@ pub use self::{
block::{BlockInfo, ResolvedBlockInfo},
contracts::{
BaseSystemContractsProvider, CallOrExecute, ContractsKind, EstimateGas,
- MultiVMBaseSystemContracts,
+ MultiVmBaseSystemContracts,
},
env::OneshotEnvParameters,
mock::MockOneshotExecutor,
diff --git a/core/node/api_server/src/tx_sender/mod.rs b/core/node/api_server/src/tx_sender/mod.rs
index 180b53492839..91fb84ab8f17 100644
--- a/core/node/api_server/src/tx_sender/mod.rs
+++ b/core/node/api_server/src/tx_sender/mod.rs
@@ -33,7 +33,7 @@ use zksync_types::{
MAX_NEW_FACTORY_DEPS, U256,
};
use zksync_vm_executor::oneshot::{
- CallOrExecute, EstimateGas, MultiVMBaseSystemContracts, OneshotEnvParameters,
+ CallOrExecute, EstimateGas, MultiVmBaseSystemContracts, OneshotEnvParameters,
};
pub(super) use self::{gas_estimation::BinarySearchKind, result::SubmitTxError};
@@ -109,11 +109,11 @@ impl SandboxExecutorOptions {
validation_computational_gas_limit: u32,
) -> anyhow::Result<Self> {
let estimate_gas_contracts =
- tokio::task::spawn_blocking(MultiVMBaseSystemContracts::load_estimate_gas_blocking)
+ tokio::task::spawn_blocking(MultiVmBaseSystemContracts::load_estimate_gas_blocking)
.await
.context("failed loading base contracts for gas estimation")?;
let call_contracts =
- tokio::task::spawn_blocking(MultiVMBaseSystemContracts::load_eth_call_blocking)
+ tokio::task::spawn_blocking(MultiVmBaseSystemContracts::load_eth_call_blocking)
.await
.context("failed loading base contracts for calls / tx execution")?;
diff --git a/core/node/consensus/src/vm.rs b/core/node/consensus/src/vm.rs
index cbd4918dcee1..81d26ebc3758 100644
--- a/core/node/consensus/src/vm.rs
+++ b/core/node/consensus/src/vm.rs
@@ -8,7 +8,7 @@ use zksync_state::PostgresStorage;
use zksync_system_constants::DEFAULT_L2_TX_GAS_PER_PUBDATA_BYTE;
use zksync_types::{ethabi, fee::Fee, l2::L2Tx, AccountTreeId, L2ChainId, Nonce, U256};
use zksync_vm_executor::oneshot::{
- CallOrExecute, MainOneshotExecutor, MultiVMBaseSystemContracts, OneshotEnvParameters,
+ CallOrExecute, MainOneshotExecutor, MultiVmBaseSystemContracts, OneshotEnvParameters,
};
use zksync_vm_interface::{
executor::OneshotExecutor, storage::StorageWithOverrides, ExecutionResult,
@@ -29,7 +29,7 @@ impl VM {
/// Constructs a new `VM` instance.
pub async fn new(pool: ConnectionPool) -> Self {
let base_system_contracts =
- scope::wait_blocking(MultiVMBaseSystemContracts::load_eth_call_blocking).await;
+ scope::wait_blocking(MultiVmBaseSystemContracts::load_eth_call_blocking).await;
Self {
pool,
// L2 chain ID and fee account don't seem to matter for calls, hence the use of default values.
diff --git a/core/node/genesis/src/utils.rs b/core/node/genesis/src/utils.rs
index d89d7475e84b..d8076229fa54 100644
--- a/core/node/genesis/src/utils.rs
+++ b/core/node/genesis/src/utils.rs
@@ -5,7 +5,7 @@ use zksync_contracts::BaseSystemContracts;
use zksync_dal::{Connection, Core, CoreDal};
use zksync_multivm::{
circuit_sequencer_api_latest::sort_storage_access::sort_storage_access_queries,
- zk_evm_latest::aux_structures::{LogQuery as MultiVmLogQuery, Timestamp as MultiVMTimestamp},
+ zk_evm_latest::aux_structures::{LogQuery as MultiVmLogQuery, Timestamp as MultiVmTimestamp},
};
use zksync_system_constants::{DEFAULT_ERA_CHAIN_ID, ETHEREUM_ADDRESS};
use zksync_types::{
@@ -84,7 +84,7 @@ pub(super) fn get_deduped_log_queries(storage_logs: &[StorageLog]) -> Vec<LogQue
MultiVmLogQuery {
// Timestamp and `tx_number` in block don't matter.
// `sort_storage_access_queries` assumes that the queries are in chronological order.
- timestamp: MultiVMTimestamp(0),
+ timestamp: MultiVmTimestamp(0),
tx_number_in_block: 0,
aux_byte: 0,
shard_id: 0,