From 1acf89ee01f8b6e30a1d18e9b2b978b4de391957 Mon Sep 17 00:00:00 2001 From: jrigada Date: Tue, 27 Feb 2024 15:48:54 +0000 Subject: [PATCH 01/26] prestate tracer --- .../vm_latest/tests/prestate_tracer.rs | 43 +++++ .../vm_latest/tracers/default_tracers.rs | 5 +- .../src/versions/vm_latest/tracers/mod.rs | 2 + .../vm_latest/tracers/prestate_tracer.rs | 172 ++++++++++++++++++ 4 files changed, 221 insertions(+), 1 deletion(-) create mode 100644 core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs mode change 100644 => 100755 core/lib/multivm/src/versions/vm_latest/tracers/default_tracers.rs mode change 100644 => 100755 core/lib/multivm/src/versions/vm_latest/tracers/mod.rs create mode 100644 core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs new file mode 100644 index 00000000000..408d6e26a84 --- /dev/null +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -0,0 +1,43 @@ +use std::borrow::Borrow; + +use crate::vm_latest::ToTracerPointer; +use crate::{ + interface::{TxExecutionMode, VmExecutionMode, VmInterface}, + vm_latest::{ + constants::BLOCK_GAS_LIMIT, tests::tester::VmTesterBuilder, tracers::PrestateTracer, + HistoryEnabled, + }, +}; +use zksync_test_account::TxType; +use zksync_types::{Address, Execute, U256}; + +#[test] +fn test_prestate_tracer() { + let mut vm = VmTesterBuilder::new(HistoryEnabled) + .with_empty_in_memory_storage() + .with_random_rich_accounts(1) + .with_deployer() + .with_gas_limit(BLOCK_GAS_LIMIT) + .with_execution_mode(TxExecutionMode::VerifyExecute) + .build(); + + vm.deploy_test_contract(); + let account = &mut vm.rich_accounts[0]; + + let tx1 = account.get_test_contract_transaction( + vm.test_contract.unwrap(), + false, + Default::default(), + true, + TxType::L2, + ); + + println!("tx: {:?}", vm.test_contract.unwrap()); + vm.vm.push_transaction(tx1); + + println!("account: {:?}", account); + let prestate_tracer = PrestateTracer::new(); + let tracer_ptr = prestate_tracer.into_tracer_pointer(); + let res = vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); + assert!(1 == 0); +} 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 old mode 100644 new mode 100755 index 0c61bae00a5..2933d6d8192 --- a/core/lib/multivm/src/versions/vm_latest/tracers/default_tracers.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/default_tracers.rs @@ -33,7 +33,7 @@ use crate::{ computational_gas_price, gas_spent_on_bytecodes_and_long_messages_this_opcode, print_debug_if_needed, VmHook, }, - CircuitsTracer, RefundsTracer, ResultTracer, + CircuitsTracer, PrestateTracer, RefundsTracer, ResultTracer, }, types::internals::ZkSyncVmState, VmTracer, @@ -67,6 +67,7 @@ pub(crate) struct DefaultExecutionTracer { // It only takes into account circuits that are generated for actual execution. It doesn't // take into account e.g circuits produced by the initial bootloader memory commitment. pub(crate) circuits_tracer: CircuitsTracer, + pub(crate) prestate_tracer: PrestateTracer, storage: StoragePtr, _phantom: PhantomData, @@ -81,6 +82,7 @@ impl DefaultExecutionTracer { refund_tracer: Option>, pubdata_tracer: Option>, ) -> Self { + println!("NEW DefaultExecutionTracer"); Self { tx_has_been_processed: false, execution_mode, @@ -95,6 +97,7 @@ impl DefaultExecutionTracer { pubdata_tracer, ret_from_the_bootloader: None, circuits_tracer: CircuitsTracer::new(), + prestate_tracer: PrestateTracer::new(), storage, _phantom: PhantomData, } diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs old mode 100644 new mode 100755 index fe916e19e8c..05321aae63b --- a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs @@ -1,11 +1,13 @@ pub(crate) use circuits_tracer::CircuitsTracer; pub(crate) use default_tracers::DefaultExecutionTracer; +pub(crate) use prestate_tracer::PrestateTracer; pub(crate) use pubdata_tracer::PubdataTracer; pub(crate) use refunds::RefundsTracer; pub(crate) use result_tracer::ResultTracer; pub(crate) mod circuits_tracer; pub(crate) mod default_tracers; +pub(crate) mod prestate_tracer; pub(crate) mod pubdata_tracer; pub(crate) mod refunds; pub(crate) mod result_tracer; diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs new file mode 100644 index 00000000000..27c9d2a9f2e --- /dev/null +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -0,0 +1,172 @@ +use std::fmt; +use std::{collections::HashMap, marker::PhantomData}; + +use crate::{ + interface::{ + dyn_tracers::vm_1_4_1::DynTracer, + tracer::{TracerExecutionStatus, TracerExecutionStopReason}, + types::inputs::L1BatchEnv, + VmExecutionMode, + }, + vm_latest::{ + bootloader_state::{utils::apply_pubdata_to_memory, BootloaderState}, + constants::BOOTLOADER_HEAP_PAGE, + old_vm::{history_recorder::HistoryMode, memory::SimpleMemory}, + tracers::{traits::VmTracer, utils::VmHook}, + types::internals::{PubdataInput, ZkSyncVmState}, + utils::logs::collect_events_and_l1_system_logs_after_timestamp, + StorageOracle, + }, +}; +use zk_evm_1_4_1::{ + aux_structures::Timestamp, + tracing::{BeforeExecutionData, VmLocalStateData}, +}; +use zksync_state::{StoragePtr, WriteStorage}; +use zksync_types::{ + get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, Bytes, + StorageKey, StorageValue, H160, H256, L2_ETH_TOKEN_ADDRESS, U256, +}; +use zksync_utils::address_to_h256; + +#[derive(Debug, Clone)] +pub struct Account { + balance: Option, + code: Option, + nonce: Option, + storage: Option>, +} + +impl fmt::Display for Account { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + writeln!(f, "{{")?; + if let Some(balance) = self.balance { + writeln!(f, " balance: \"0x{:x}\",", balance)?; + } + if let Some(code) = &self.code { + writeln!(f, " code: \"{}\",", code)?; + } + if let Some(nonce) = self.nonce { + writeln!(f, " nonce: {},", nonce)?; + } + if let Some(storage) = &self.storage { + writeln!(f, " storage: {{")?; + for (key, value) in storage.iter() { + writeln!(f, " {}: \"{}\",", key, value)?; + } + writeln!(f, " }}")?; + } + writeln!(f, "}}") + } +} + +type State = HashMap; + +#[derive(Debug, Clone)] +pub(crate) struct PrestateTracer { + pub pre: State, + pub post: State, + pub config: PrestateTracerConfig, +} + +impl PrestateTracer { + pub(crate) fn new() -> Self { + println!("NEW"); + Self { + pre: Default::default(), + post: Default::default(), + config: PrestateTracerConfig { diff_mode: false }, + } + } + + pub(crate) fn get_pre(&self) -> &State { + &self.pre + } +} + +#[derive(Debug, Clone)] +pub struct PrestateTracerConfig { + diff_mode: bool, // If true, this tracer will return state modifications +} + +impl DynTracer> for PrestateTracer { + fn before_execution( + &mut self, + state: VmLocalStateData<'_>, + data: BeforeExecutionData, + _memory: &SimpleMemory, + _storage: StoragePtr, + ) { + } +} + +impl VmTracer for PrestateTracer { + fn initialize_tracer(&mut self, _state: &mut ZkSyncVmState) {} + + fn finish_cycle( + &mut self, + _state: &mut ZkSyncVmState, + _bootloader_state: &mut BootloaderState, + ) -> TracerExecutionStatus { + TracerExecutionStatus::Continue + } + + fn after_vm_execution( + &mut self, + state: &mut ZkSyncVmState, + _bootloader_state: &BootloaderState, + _stop_reason: crate::interface::tracer::VmExecutionStopReason, + ) { + let modified_storage_keys = { + let binding = state.storage.storage.inner().storage_ptr.borrow_mut(); + // Clone the keys or derive the needed information here + binding.modified_storage_keys().clone() // Assuming `clone` is possible and inexpensive + }; + + let read_keys = &state.storage.read_keys; + let map = read_keys.inner().clone(); + let storage_keys_read = map.iter().map(|(k, _)| k.clone()).collect::>(); + let pre = storage_keys_read + .iter() + .map(|k| { + let nonce_key = get_nonce_key(k.account().address()); + let code_key = get_code_key(k.account().address()); + let nonce = state.storage.storage.read_from_storage(&nonce_key); + let address_h256 = address_to_h256(k.account().address()); + let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); + let balance_key: H256 = keccak256(&bytes).into(); + let balance_storage_key = + StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key); + let balance = state + .storage + .storage + .read_from_storage(&balance_storage_key); + + let code = state.storage.storage.read_from_storage(&code_key); + let storage = get_storage_if_present(k.account(), &modified_storage_keys); + ( + *(k.account().address()), + Account { + balance: Some(balance), + code: Some(code), + nonce: Some(nonce), + storage: Some(storage), + }, + ) + }) + .collect::(); + self.pre = pre; + } +} + +fn get_storage_if_present( + account: &AccountTreeId, + modified_storage_keys: &HashMap, +) -> HashMap { + //check if there is a StorageKey struct wioth an account field that matches the account and return the key as the key and the StorageValue as the value + modified_storage_keys + .iter() + .filter(|(k, _)| k.account() == account) + .map(|(k, v)| (k.key().clone(), v.clone())) + .collect() +} From 746ebfecff7a4c61aa9a4d047e32afe0de5c6f1c Mon Sep 17 00:00:00 2001 From: jrigada Date: Thu, 29 Feb 2024 14:36:04 +0000 Subject: [PATCH 02/26] prestate tracer with tests first iteration --- .../vm_latest/old_vm/history_recorder.rs | 13 +- .../src/versions/vm_latest/tests/mod.rs | 1 + .../vm_latest/tests/prestate_tracer.rs | 66 ++++- .../vm_latest/tracers/default_tracers.rs | 5 +- .../vm_latest/tracers/prestate_tracer.rs | 234 ++++++++++++------ core/lib/state/src/storage_view.rs | 5 + 6 files changed, 237 insertions(+), 87 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs b/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs index d4c5b6367a9..77640497cd4 100644 --- a/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs +++ b/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs @@ -6,7 +6,7 @@ use zk_evm_1_4_1::{ zkevm_opcode_defs::{self}, }; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{StorageKey, U256}; +use zksync_types::{StorageKey, H256, U256}; use zksync_utils::{h256_to_u256, u256_to_h256}; pub(crate) type MemoryWithHistory = HistoryRecorder; @@ -705,7 +705,7 @@ impl HistoryRecorder { #[derive(Debug)] pub struct StorageWrapper { - storage_ptr: StoragePtr, + pub storage_ptr: StoragePtr, } impl StorageWrapper { @@ -720,6 +720,15 @@ impl StorageWrapper { pub fn read_from_storage(&self, key: &StorageKey) -> U256 { h256_to_u256(self.storage_ptr.borrow_mut().read_value(key)) } + + pub fn get_modified_storage_keys(&self) -> HashMap { + self.storage_ptr + .borrow() + .modified_storage_keys() + .iter() + .map(|(k, v)| (k.clone(), v.clone())) + .collect() + } } #[derive(Debug, Clone)] 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 a07608121bc..f3443f00e68 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/mod.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/mod.rs @@ -13,6 +13,7 @@ mod l1_tx_execution; mod l2_blocks; mod nonce_holder; mod precompiles; +mod prestate_tracer; mod refunds; mod require_eip712; mod rollbacks; diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index 408d6e26a84..c88306b8b96 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -1,4 +1,5 @@ -use std::borrow::Borrow; +use once_cell::sync::OnceCell; +use std::sync::Arc; use crate::vm_latest::ToTracerPointer; use crate::{ @@ -9,7 +10,7 @@ use crate::{ }, }; use zksync_test_account::TxType; -use zksync_types::{Address, Execute, U256}; +use zksync_types::H256; #[test] fn test_prestate_tracer() { @@ -31,13 +32,62 @@ fn test_prestate_tracer() { true, TxType::L2, ); - - println!("tx: {:?}", vm.test_contract.unwrap()); vm.vm.push_transaction(tx1); + let contract_address = vm.test_contract.unwrap(); + let prestate_tracer_result = Arc::new(OnceCell::default()); + let prestate_tracer = PrestateTracer::new(false, prestate_tracer_result.clone()); + let tracer_ptr = prestate_tracer.into_tracer_pointer(); + vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); + + let prestate_result = Arc::try_unwrap(prestate_tracer_result) + .unwrap() + .take() + .unwrap_or_default(); + + // example entry: Account { balance: Some(0), code: Some(452314304036466592745508808605782986981496399793947607959918347501386473656), nonce: Some(0), storage: Some({0x0000000000000000000000000000000000000000000000000000000000000000: 0x0000000000000000000000000000000000000000000000000000000000000007}) } + assert!(prestate_result.1.contains_key(&contract_address)); +} + +#[test] +fn test_prestate_tracer_diff_mode() { + let mut vm = VmTesterBuilder::new(HistoryEnabled) + .with_empty_in_memory_storage() + .with_random_rich_accounts(1) + .with_deployer() + .with_gas_limit(BLOCK_GAS_LIMIT) + .with_execution_mode(TxExecutionMode::VerifyExecute) + .build(); - println!("account: {:?}", account); - let prestate_tracer = PrestateTracer::new(); + vm.deploy_test_contract(); + let account = &mut vm.rich_accounts[0]; + + let tx1 = account.get_test_contract_transaction( + vm.test_contract.unwrap(), + false, + Default::default(), + true, + TxType::L2, + ); + vm.vm.push_transaction(tx1); + let contract_address = vm.test_contract.unwrap(); + let prestate_tracer_result = Arc::new(OnceCell::default()); + let prestate_tracer = PrestateTracer::new(true, prestate_tracer_result.clone()); let tracer_ptr = prestate_tracer.into_tracer_pointer(); - let res = vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); - assert!(1 == 0); + vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); + + let prestate_result = Arc::try_unwrap(prestate_tracer_result) + .unwrap() + .take() + .unwrap_or_default(); + + assert!(prestate_result.0.len() > 0); + assert!(prestate_result.1.len() > 0); + // example entry: Account { balance: Some(0), code: Some(452314304036466592745508808605782986981496399793947607959918347501386473656), nonce: Some(0), storage: Some({0x0000000000000000000000000000000000000000000000000000000000000000: 0x0000000000000000000000000000000000000000000000000000000000000007}) } + let contract_address_account = prestate_result.0.get(&contract_address).unwrap().clone(); + let binding = contract_address_account.storage.unwrap(); + let contract_storage_value_pre_tx = binding.get(&H256::zero()).unwrap(); + let contract_address_account_post = prestate_result.1.get(&contract_address).unwrap().clone(); + let binding = contract_address_account_post.storage.unwrap(); + let contract_storage_value_post_tx = binding.get(&H256::zero()).unwrap(); + assert!(contract_storage_value_pre_tx < contract_storage_value_post_tx); } 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 2933d6d8192..dc902d815a5 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 @@ -1,3 +1,5 @@ +use once_cell::sync::OnceCell; +use std::sync::Arc; use std::{ fmt::{Debug, Formatter}, marker::PhantomData, @@ -82,7 +84,6 @@ impl DefaultExecutionTracer { refund_tracer: Option>, pubdata_tracer: Option>, ) -> Self { - println!("NEW DefaultExecutionTracer"); Self { tx_has_been_processed: false, execution_mode, @@ -97,7 +98,7 @@ impl DefaultExecutionTracer { pubdata_tracer, ret_from_the_bootloader: None, circuits_tracer: CircuitsTracer::new(), - prestate_tracer: PrestateTracer::new(), + prestate_tracer: PrestateTracer::new(false, Arc::new(OnceCell::default())), storage, _phantom: PhantomData, } diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 27c9d2a9f2e..500d5a31293 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -1,40 +1,31 @@ +use once_cell::sync::OnceCell; +use std::collections::HashMap; use std::fmt; -use std::{collections::HashMap, marker::PhantomData}; +use std::sync::Arc; use crate::{ - interface::{ - dyn_tracers::vm_1_4_1::DynTracer, - tracer::{TracerExecutionStatus, TracerExecutionStopReason}, - types::inputs::L1BatchEnv, - VmExecutionMode, - }, + interface::{dyn_tracers::vm_1_4_1::DynTracer, tracer::TracerExecutionStatus}, vm_latest::{ - bootloader_state::{utils::apply_pubdata_to_memory, BootloaderState}, - constants::BOOTLOADER_HEAP_PAGE, + bootloader_state::BootloaderState, old_vm::{history_recorder::HistoryMode, memory::SimpleMemory}, - tracers::{traits::VmTracer, utils::VmHook}, - types::internals::{PubdataInput, ZkSyncVmState}, - utils::logs::collect_events_and_l1_system_logs_after_timestamp, - StorageOracle, + tracers::traits::VmTracer, + types::internals::ZkSyncVmState, }, }; -use zk_evm_1_4_1::{ - aux_structures::Timestamp, - tracing::{BeforeExecutionData, VmLocalStateData}, -}; +use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; use zksync_types::{ - get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, Bytes, - StorageKey, StorageValue, H160, H256, L2_ETH_TOKEN_ADDRESS, U256, + get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, + StorageValue, H256, L2_ETH_TOKEN_ADDRESS, U256, }; use zksync_utils::address_to_h256; -#[derive(Debug, Clone)] +#[derive(Debug, Clone, PartialEq, Eq)] pub struct Account { - balance: Option, - code: Option, - nonce: Option, - storage: Option>, + pub balance: Option, + pub code: Option, + pub nonce: Option, + pub storage: Option>, } impl fmt::Display for Account { @@ -67,33 +58,32 @@ pub(crate) struct PrestateTracer { pub pre: State, pub post: State, pub config: PrestateTracerConfig, + pub result: Arc>, } impl PrestateTracer { - pub(crate) fn new() -> Self { - println!("NEW"); + pub(crate) fn new(diff_mode: bool, result: Arc>) -> Self { Self { pre: Default::default(), post: Default::default(), - config: PrestateTracerConfig { diff_mode: false }, + config: PrestateTracerConfig { + diff_mode: diff_mode, + }, + result, } } - - pub(crate) fn get_pre(&self) -> &State { - &self.pre - } } #[derive(Debug, Clone)] pub struct PrestateTracerConfig { - diff_mode: bool, // If true, this tracer will return state modifications + diff_mode: bool, } impl DynTracer> for PrestateTracer { fn before_execution( &mut self, - state: VmLocalStateData<'_>, - data: BeforeExecutionData, + _state: VmLocalStateData<'_>, + _data: BeforeExecutionData, _memory: &SimpleMemory, _storage: StoragePtr, ) { @@ -101,7 +91,41 @@ impl DynTracer> for PrestateTracer { } impl VmTracer for PrestateTracer { - fn initialize_tracer(&mut self, _state: &mut ZkSyncVmState) {} + fn initialize_tracer(&mut self, state: &mut ZkSyncVmState) { + let initial_storage = state.storage.storage.inner().get_modified_storage_keys(); + let keys = initial_storage.keys().cloned().collect::>(); + + let res = keys + .iter() + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some( + state + .storage + .storage + .read_from_storage(&get_balance_key(k.account())), + ), + code: Some( + state + .storage + .storage + .read_from_storage(&get_code_key(k.account().address())), + ), + nonce: Some( + state + .storage + .storage + .read_from_storage(&get_nonce_key(k.account().address())), + ), + storage: Some(get_storage_if_present(k.account(), &initial_storage)), + }, + ) + }) + .collect::(); + self.pre = res; + } fn finish_cycle( &mut self, @@ -117,56 +141,116 @@ impl VmTracer for PrestateTracer { _bootloader_state: &BootloaderState, _stop_reason: crate::interface::tracer::VmExecutionStopReason, ) { - let modified_storage_keys = { - let binding = state.storage.storage.inner().storage_ptr.borrow_mut(); - // Clone the keys or derive the needed information here - binding.modified_storage_keys().clone() // Assuming `clone` is possible and inexpensive - }; - - let read_keys = &state.storage.read_keys; - let map = read_keys.inner().clone(); - let storage_keys_read = map.iter().map(|(k, _)| k.clone()).collect::>(); - let pre = storage_keys_read - .iter() - .map(|k| { - let nonce_key = get_nonce_key(k.account().address()); - let code_key = get_code_key(k.account().address()); - let nonce = state.storage.storage.read_from_storage(&nonce_key); - let address_h256 = address_to_h256(k.account().address()); - let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); - let balance_key: H256 = keccak256(&bytes).into(); - let balance_storage_key = - StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key); - let balance = state - .storage - .storage - .read_from_storage(&balance_storage_key); - - let code = state.storage.storage.read_from_storage(&code_key); - let storage = get_storage_if_present(k.account(), &modified_storage_keys); - ( - *(k.account().address()), - Account { - balance: Some(balance), - code: Some(code), - nonce: Some(nonce), - storage: Some(storage), - }, - ) - }) - .collect::(); - self.pre = pre; + let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); + if self.config.diff_mode { + let diff = modified_storage_keys + .clone() + .iter() + .map(|(k, _)| k.clone()) + .collect::>(); + + let res = diff + .iter() + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some( + state + .storage + .storage + .read_from_storage(&get_balance_key(k.account())), + ), + code: Some( + state + .storage + .storage + .read_from_storage(&get_code_key(k.account().address())), + ), + nonce: Some( + state + .storage + .storage + .read_from_storage(&get_nonce_key(k.account().address())), + ), + storage: Some(get_storage_if_present( + k.account(), + &modified_storage_keys, + )), + }, + ) + }) + .collect::(); + self.post = res; + } else { + let read_keys = &state.storage.read_keys; + let map = read_keys.inner().clone(); + let storage_keys_read = map.iter().map(|(k, _)| k.clone()).collect::>(); + let res = storage_keys_read + .iter() + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some( + state + .storage + .storage + .read_from_storage(&get_balance_key(k.account())), + ), + code: Some( + state + .storage + .storage + .read_from_storage(&get_code_key(k.account().address())), + ), + nonce: Some( + state + .storage + .storage + .read_from_storage(&get_nonce_key(k.account().address())), + ), + storage: Some(get_storage_if_present( + k.account(), + &modified_storage_keys, + )), + }, + ) + }) + .collect::(); + self.post = res; + } + process_result(&mut self.result, self.pre.clone(), self.post.clone()); } } +fn get_balance_key(account: &AccountTreeId) -> StorageKey { + let address_h256 = address_to_h256(account.address()); + let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); + let balance_key: H256 = keccak256(&bytes).into(); + StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) +} + fn get_storage_if_present( account: &AccountTreeId, modified_storage_keys: &HashMap, ) -> HashMap { - //check if there is a StorageKey struct wioth an account field that matches the account and return the key as the key and the StorageValue as the value + //check if there is a StorageKey struct with an account field that matches the account and return the key as the key and the StorageValue as the value modified_storage_keys .iter() .filter(|(k, _)| k.account() == account) .map(|(k, v)| (k.key().clone(), v.clone())) .collect() } + +fn process_result(result: &mut Arc>, mut pre: State, post: State) { + pre.retain(|k, v| { + if let Some(post_v) = post.get(k) { + if v != post_v { + return true; + } + } + false + }); + result.set((pre, post)).unwrap(); +} diff --git a/core/lib/state/src/storage_view.rs b/core/lib/state/src/storage_view.rs index 543b41bc657..d70f1d6bb8a 100644 --- a/core/lib/state/src/storage_view.rs +++ b/core/lib/state/src/storage_view.rs @@ -60,6 +60,11 @@ impl StorageView { is_write_initial: self.initial_writes_cache.clone(), } } + + // Returns the modified storage keys + pub fn modified_storage_keys(&self) -> &HashMap { + &self.modified_storage_keys + } } impl ReadStorage for Box From 1579b6b39c858f9bb04e29f4cec303e30a68b1d7 Mon Sep 17 00:00:00 2001 From: jrigada Date: Thu, 29 Feb 2024 20:18:01 +0000 Subject: [PATCH 03/26] zk fmt --- .../vm_latest/tests/prestate_tracer.rs | 10 +++++----- .../vm_latest/tracers/default_tracers.rs | 4 ++-- .../vm_latest/tracers/prestate_tracer.rs | 19 +++++++++---------- 3 files changed, 16 insertions(+), 17 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index c88306b8b96..eba5f0719a9 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -1,16 +1,16 @@ -use once_cell::sync::OnceCell; use std::sync::Arc; -use crate::vm_latest::ToTracerPointer; +use once_cell::sync::OnceCell; +use zksync_test_account::TxType; +use zksync_types::H256; + use crate::{ interface::{TxExecutionMode, VmExecutionMode, VmInterface}, vm_latest::{ constants::BLOCK_GAS_LIMIT, tests::tester::VmTesterBuilder, tracers::PrestateTracer, - HistoryEnabled, + HistoryEnabled, ToTracerPointer, }, }; -use zksync_test_account::TxType; -use zksync_types::H256; #[test] fn test_prestate_tracer() { 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 dc902d815a5..e992cae3243 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 @@ -1,10 +1,10 @@ -use once_cell::sync::OnceCell; -use std::sync::Arc; use std::{ fmt::{Debug, Formatter}, marker::PhantomData, + sync::Arc, }; +use once_cell::sync::OnceCell; use zk_evm_1_4_1::{ aux_structures::Timestamp, tracing::{ diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 500d5a31293..e1d51f3e26d 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -1,7 +1,13 @@ +use std::{collections::HashMap, fmt, sync::Arc}; + use once_cell::sync::OnceCell; -use std::collections::HashMap; -use std::fmt; -use std::sync::Arc; +use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; +use zksync_state::{StoragePtr, WriteStorage}; +use zksync_types::{ + get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, + StorageValue, H256, L2_ETH_TOKEN_ADDRESS, U256, +}; +use zksync_utils::address_to_h256; use crate::{ interface::{dyn_tracers::vm_1_4_1::DynTracer, tracer::TracerExecutionStatus}, @@ -12,13 +18,6 @@ use crate::{ types::internals::ZkSyncVmState, }, }; -use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; -use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{ - get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, - StorageValue, H256, L2_ETH_TOKEN_ADDRESS, U256, -}; -use zksync_utils::address_to_h256; #[derive(Debug, Clone, PartialEq, Eq)] pub struct Account { From 7fa2b0df6b05962a906a438002b59107a00a601d Mon Sep 17 00:00:00 2001 From: jrigada Date: Fri, 1 Mar 2024 12:55:34 +0000 Subject: [PATCH 04/26] zk spell --- .../lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs | 2 -- .../multivm/src/versions/vm_latest/tracers/prestate_tracer.rs | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index eba5f0719a9..87932c727bf 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -44,7 +44,6 @@ fn test_prestate_tracer() { .take() .unwrap_or_default(); - // example entry: Account { balance: Some(0), code: Some(452314304036466592745508808605782986981496399793947607959918347501386473656), nonce: Some(0), storage: Some({0x0000000000000000000000000000000000000000000000000000000000000000: 0x0000000000000000000000000000000000000000000000000000000000000007}) } assert!(prestate_result.1.contains_key(&contract_address)); } @@ -82,7 +81,6 @@ fn test_prestate_tracer_diff_mode() { assert!(prestate_result.0.len() > 0); assert!(prestate_result.1.len() > 0); - // example entry: Account { balance: Some(0), code: Some(452314304036466592745508808605782986981496399793947607959918347501386473656), nonce: Some(0), storage: Some({0x0000000000000000000000000000000000000000000000000000000000000000: 0x0000000000000000000000000000000000000000000000000000000000000007}) } let contract_address_account = prestate_result.0.get(&contract_address).unwrap().clone(); let binding = contract_address_account.storage.unwrap(); let contract_storage_value_pre_tx = binding.get(&H256::zero()).unwrap(); diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index e1d51f3e26d..1f2ca0b5bb6 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -234,7 +234,7 @@ fn get_storage_if_present( account: &AccountTreeId, modified_storage_keys: &HashMap, ) -> HashMap { - //check if there is a StorageKey struct with an account field that matches the account and return the key as the key and the StorageValue as the value + //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value modified_storage_keys .iter() .filter(|(k, _)| k.account() == account) From f65bd70d748f246d1117d519f99ad2f109635c1a Mon Sep 17 00:00:00 2001 From: jrigada Date: Fri, 1 Mar 2024 13:23:59 +0000 Subject: [PATCH 05/26] missing docs --- .../src/versions/vm_latest/tests/prestate_tracer.rs | 7 ------- core/lib/state/src/storage_view.rs | 2 +- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index 87932c727bf..dd021b3ef78 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -81,11 +81,4 @@ fn test_prestate_tracer_diff_mode() { assert!(prestate_result.0.len() > 0); assert!(prestate_result.1.len() > 0); - let contract_address_account = prestate_result.0.get(&contract_address).unwrap().clone(); - let binding = contract_address_account.storage.unwrap(); - let contract_storage_value_pre_tx = binding.get(&H256::zero()).unwrap(); - let contract_address_account_post = prestate_result.1.get(&contract_address).unwrap().clone(); - let binding = contract_address_account_post.storage.unwrap(); - let contract_storage_value_post_tx = binding.get(&H256::zero()).unwrap(); - assert!(contract_storage_value_pre_tx < contract_storage_value_post_tx); } diff --git a/core/lib/state/src/storage_view.rs b/core/lib/state/src/storage_view.rs index d70f1d6bb8a..ffc9019bac2 100644 --- a/core/lib/state/src/storage_view.rs +++ b/core/lib/state/src/storage_view.rs @@ -61,7 +61,7 @@ impl StorageView { } } - // Returns the modified storage keys + /// Returns the modified storage keys pub fn modified_storage_keys(&self) -> &HashMap { &self.modified_storage_keys } From 915a7d7f372c50f1474c54091b0d8603252cdb39 Mon Sep 17 00:00:00 2001 From: jrigada Date: Fri, 1 Mar 2024 14:09:17 +0000 Subject: [PATCH 06/26] linter --- .../versions/vm_latest/old_vm/history_recorder.rs | 2 +- .../versions/vm_latest/tests/prestate_tracer.rs | 6 ++---- .../versions/vm_latest/tracers/default_tracers.rs | 3 --- .../versions/vm_latest/tracers/prestate_tracer.rs | 14 ++++++-------- 4 files changed, 9 insertions(+), 16 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs b/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs index 77640497cd4..757213061dc 100644 --- a/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs +++ b/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs @@ -726,7 +726,7 @@ impl StorageWrapper { .borrow() .modified_storage_keys() .iter() - .map(|(k, v)| (k.clone(), v.clone())) + .map(|(k, v)| (*k, *v)) .collect() } } diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index dd021b3ef78..986c1f7368a 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -2,7 +2,6 @@ use std::sync::Arc; use once_cell::sync::OnceCell; use zksync_test_account::TxType; -use zksync_types::H256; use crate::{ interface::{TxExecutionMode, VmExecutionMode, VmInterface}, @@ -68,7 +67,6 @@ fn test_prestate_tracer_diff_mode() { TxType::L2, ); vm.vm.push_transaction(tx1); - let contract_address = vm.test_contract.unwrap(); let prestate_tracer_result = Arc::new(OnceCell::default()); let prestate_tracer = PrestateTracer::new(true, prestate_tracer_result.clone()); let tracer_ptr = prestate_tracer.into_tracer_pointer(); @@ -79,6 +77,6 @@ fn test_prestate_tracer_diff_mode() { .take() .unwrap_or_default(); - assert!(prestate_result.0.len() > 0); - assert!(prestate_result.1.len() > 0); + assert!(!prestate_result.0.is_empty()); + assert!(!prestate_result.1.is_empty()); } 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 e992cae3243..4f4a9ad6f3d 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 @@ -69,8 +69,6 @@ pub(crate) struct DefaultExecutionTracer { // It only takes into account circuits that are generated for actual execution. It doesn't // take into account e.g circuits produced by the initial bootloader memory commitment. pub(crate) circuits_tracer: CircuitsTracer, - pub(crate) prestate_tracer: PrestateTracer, - storage: StoragePtr, _phantom: PhantomData, } @@ -98,7 +96,6 @@ impl DefaultExecutionTracer { pubdata_tracer, ret_from_the_bootloader: None, circuits_tracer: CircuitsTracer::new(), - prestate_tracer: PrestateTracer::new(false, Arc::new(OnceCell::default())), storage, _phantom: PhantomData, } diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 1f2ca0b5bb6..ddf0427a2be 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -65,9 +65,7 @@ impl PrestateTracer { Self { pre: Default::default(), post: Default::default(), - config: PrestateTracerConfig { - diff_mode: diff_mode, - }, + config: PrestateTracerConfig { diff_mode }, result, } } @@ -144,8 +142,8 @@ impl VmTracer for PrestateTracer { if self.config.diff_mode { let diff = modified_storage_keys .clone() - .iter() - .map(|(k, _)| k.clone()) + .keys() + .map(|k| *k) .collect::>(); let res = diff @@ -184,7 +182,7 @@ impl VmTracer for PrestateTracer { } else { let read_keys = &state.storage.read_keys; let map = read_keys.inner().clone(); - let storage_keys_read = map.iter().map(|(k, _)| k.clone()).collect::>(); + let storage_keys_read = map.keys().map(|k| *k).collect::>(); let res = storage_keys_read .iter() .map(|k| { @@ -238,11 +236,11 @@ fn get_storage_if_present( modified_storage_keys .iter() .filter(|(k, _)| k.account() == account) - .map(|(k, v)| (k.key().clone(), v.clone())) + .map(|(k, v)| (*k.key(), *v)) .collect() } -fn process_result(result: &mut Arc>, mut pre: State, post: State) { +fn process_result(result: &Arc>, mut pre: State, post: State) { pre.retain(|k, v| { if let Some(post_v) = post.get(k) { if v != post_v { From 669b66a00c48269c994389d95f95778f19976776 Mon Sep 17 00:00:00 2001 From: jrigada Date: Fri, 1 Mar 2024 14:26:46 +0000 Subject: [PATCH 07/26] remove unused imports --- .../src/versions/vm_latest/tracers/default_tracers.rs | 5 +---- .../src/versions/vm_latest/tracers/prestate_tracer.rs | 8 ++++---- 2 files changed, 5 insertions(+), 8 deletions(-) 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 4f4a9ad6f3d..137a7164e19 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 @@ -1,10 +1,7 @@ use std::{ fmt::{Debug, Formatter}, marker::PhantomData, - sync::Arc, }; - -use once_cell::sync::OnceCell; use zk_evm_1_4_1::{ aux_structures::Timestamp, tracing::{ @@ -35,7 +32,7 @@ use crate::{ computational_gas_price, gas_spent_on_bytecodes_and_long_messages_this_opcode, print_debug_if_needed, VmHook, }, - CircuitsTracer, PrestateTracer, RefundsTracer, ResultTracer, + CircuitsTracer, RefundsTracer, ResultTracer, }, types::internals::ZkSyncVmState, VmTracer, diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index ddf0427a2be..c8e5bfd0dcd 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -61,7 +61,7 @@ pub(crate) struct PrestateTracer { } impl PrestateTracer { - pub(crate) fn new(diff_mode: bool, result: Arc>) -> Self { + pub fn new(diff_mode: bool, result: Arc>) -> Self { Self { pre: Default::default(), post: Default::default(), @@ -143,7 +143,7 @@ impl VmTracer for PrestateTracer { let diff = modified_storage_keys .clone() .keys() - .map(|k| *k) + .copied() .collect::>(); let res = diff @@ -182,7 +182,7 @@ impl VmTracer for PrestateTracer { } else { let read_keys = &state.storage.read_keys; let map = read_keys.inner().clone(); - let storage_keys_read = map.keys().map(|k| *k).collect::>(); + let storage_keys_read = map.keys().copied().collect::>(); let res = storage_keys_read .iter() .map(|k| { @@ -217,7 +217,7 @@ impl VmTracer for PrestateTracer { .collect::(); self.post = res; } - process_result(&mut self.result, self.pre.clone(), self.post.clone()); + process_result(&self.result, self.pre.clone(), self.post.clone()); } } From 5e26988c180fa9abf18f202b4493f6e0a107f9a8 Mon Sep 17 00:00:00 2001 From: jrigada Date: Fri, 1 Mar 2024 14:27:16 +0000 Subject: [PATCH 08/26] fmt --- .../multivm/src/versions/vm_latest/tracers/default_tracers.rs | 1 + 1 file changed, 1 insertion(+) 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 137a7164e19..020e78bbe16 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 @@ -2,6 +2,7 @@ use std::{ fmt::{Debug, Formatter}, marker::PhantomData, }; + use zk_evm_1_4_1::{ aux_structures::Timestamp, tracing::{ From 67ac0b35be9e1a7e7df140e5b5f17faee8f15f0c Mon Sep 17 00:00:00 2001 From: jrigada Date: Fri, 1 Mar 2024 17:50:59 +0000 Subject: [PATCH 09/26] linter --- core/lib/multivm/src/versions/vm_latest/tracers/mod.rs | 1 - .../multivm/src/versions/vm_latest/tracers/prestate_tracer.rs | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs index 05321aae63b..89a5c4f5616 100755 --- a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs @@ -1,6 +1,5 @@ pub(crate) use circuits_tracer::CircuitsTracer; pub(crate) use default_tracers::DefaultExecutionTracer; -pub(crate) use prestate_tracer::PrestateTracer; pub(crate) use pubdata_tracer::PubdataTracer; pub(crate) use refunds::RefundsTracer; pub(crate) use result_tracer::ResultTracer; diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index c8e5bfd0dcd..1650329a3e2 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -61,6 +61,7 @@ pub(crate) struct PrestateTracer { } impl PrestateTracer { + #[allow(dead_code)] pub fn new(diff_mode: bool, result: Arc>) -> Self { Self { pre: Default::default(), From 227c5ce699f5fd423f9185cc0c6896bae4679c77 Mon Sep 17 00:00:00 2001 From: jrigada Date: Mon, 4 Mar 2024 17:37:21 +0000 Subject: [PATCH 10/26] move to before_execution --- .../vm_latest/old_vm/history_recorder.rs | 2 +- .../src/versions/vm_latest/tracers/mod.rs | 1 + .../vm_latest/tracers/prestate_tracer.rs | 145 ++++++++++-------- 3 files changed, 79 insertions(+), 69 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs b/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs index 757213061dc..a8e7d46bba5 100644 --- a/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs +++ b/core/lib/multivm/src/versions/vm_latest/old_vm/history_recorder.rs @@ -705,7 +705,7 @@ impl HistoryRecorder { #[derive(Debug)] pub struct StorageWrapper { - pub storage_ptr: StoragePtr, + storage_ptr: StoragePtr, } impl StorageWrapper { diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs index 89a5c4f5616..05321aae63b 100755 --- a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs @@ -1,5 +1,6 @@ pub(crate) use circuits_tracer::CircuitsTracer; pub(crate) use default_tracers::DefaultExecutionTracer; +pub(crate) use prestate_tracer::PrestateTracer; pub(crate) use pubdata_tracer::PubdataTracer; pub(crate) use refunds::RefundsTracer; pub(crate) use result_tracer::ResultTracer; diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 1650329a3e2..92e722e1f1c 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -1,4 +1,4 @@ -use std::{collections::HashMap, fmt, sync::Arc}; +use std::{collections::HashMap, fmt, rc::Rc, sync::Arc}; use once_cell::sync::OnceCell; use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; @@ -7,11 +7,12 @@ use zksync_types::{ get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, U256, }; -use zksync_utils::address_to_h256; +use zksync_utils::{address_to_h256, h256_to_u256}; use crate::{ interface::{dyn_tracers::vm_1_4_1::DynTracer, tracer::TracerExecutionStatus}, vm_latest::{ + self, bootloader_state::BootloaderState, old_vm::{history_recorder::HistoryMode, memory::SimpleMemory}, tracers::traits::VmTracer, @@ -77,53 +78,55 @@ pub struct PrestateTracerConfig { diff_mode: bool, } -impl DynTracer> for PrestateTracer { +impl DynTracer> for PrestateTracer { fn before_execution( &mut self, _state: VmLocalStateData<'_>, _data: BeforeExecutionData, _memory: &SimpleMemory, - _storage: StoragePtr, + storage: StoragePtr, ) { + if self.config.diff_mode && self.pre.is_empty() { + let cloned_storage = Rc::clone(&storage); + let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); + let keys = initial_storage_ref + .modified_storage_keys() + .keys() + .cloned() + .collect::>(); + + let res = keys + .iter() + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some(h256_to_u256( + initial_storage_ref.read_value(&get_balance_key(k.account())), + )), + code: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_code_key(k.account().address())), + )), + nonce: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_nonce_key(k.account().address())), + )), + storage: Some(get_storage_if_present( + k.account(), + &initial_storage_ref.modified_storage_keys(), + )), + }, + ) + }) + .collect::(); + self.pre = res; + } } } impl VmTracer for PrestateTracer { - fn initialize_tracer(&mut self, state: &mut ZkSyncVmState) { - let initial_storage = state.storage.storage.inner().get_modified_storage_keys(); - let keys = initial_storage.keys().cloned().collect::>(); - - let res = keys - .iter() - .map(|k| { - ( - *(k.account().address()), - Account { - balance: Some( - state - .storage - .storage - .read_from_storage(&get_balance_key(k.account())), - ), - code: Some( - state - .storage - .storage - .read_from_storage(&get_code_key(k.account().address())), - ), - nonce: Some( - state - .storage - .storage - .read_from_storage(&get_nonce_key(k.account().address())), - ), - storage: Some(get_storage_if_present(k.account(), &initial_storage)), - }, - ) - }) - .collect::(); - self.pre = res; - } + fn initialize_tracer(&mut self, _state: &mut ZkSyncVmState) {} fn finish_cycle( &mut self, @@ -186,35 +189,7 @@ impl VmTracer for PrestateTracer { let storage_keys_read = map.keys().copied().collect::>(); let res = storage_keys_read .iter() - .map(|k| { - ( - *(k.account().address()), - Account { - balance: Some( - state - .storage - .storage - .read_from_storage(&get_balance_key(k.account())), - ), - code: Some( - state - .storage - .storage - .read_from_storage(&get_code_key(k.account().address())), - ), - nonce: Some( - state - .storage - .storage - .read_from_storage(&get_nonce_key(k.account().address())), - ), - storage: Some(get_storage_if_present( - k.account(), - &modified_storage_keys, - )), - }, - ) - }) + .map(|k| get_account_data(k, state, &modified_storage_keys)) .collect::(); self.post = res; } @@ -252,3 +227,37 @@ fn process_result(result: &Arc>, mut pre: State, post: }); result.set((pre, post)).unwrap(); } + +fn get_account_data< + S: zksync_state::WriteStorage, + H: vm_latest::old_vm::history_recorder::HistoryMode, +>( + account_key: &StorageKey, + state: &mut ZkSyncVmState, + storage: &HashMap, +) -> (Address, Account) { + let address = *(account_key.account().address()); + let balance = state + .storage + .storage + .read_from_storage(&get_balance_key(account_key.account())); + let code = state + .storage + .storage + .read_from_storage(&get_code_key(account_key.account().address())); + let nonce = state + .storage + .storage + .read_from_storage(&get_nonce_key(account_key.account().address())); + let storage = get_storage_if_present(account_key.account(), storage); + + ( + address, + Account { + balance: Some(balance), + code: Some(code), + nonce: Some(nonce), + storage: Some(storage), + }, + ) +} From 55b4c4b4ae06e2ad11b66627b45934482fdf6ecd Mon Sep 17 00:00:00 2001 From: jrigada Date: Mon, 4 Mar 2024 18:44:05 +0000 Subject: [PATCH 11/26] linter --- .../vm_latest/tests/prestate_tracer.rs | 13 ++++--- .../src/versions/vm_latest/tracers/mod.rs | 1 - .../vm_latest/tracers/prestate_tracer.rs | 34 ++----------------- 3 files changed, 12 insertions(+), 36 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index 986c1f7368a..52aca86f273 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -6,8 +6,7 @@ use zksync_test_account::TxType; use crate::{ interface::{TxExecutionMode, VmExecutionMode, VmInterface}, vm_latest::{ - constants::BLOCK_GAS_LIMIT, tests::tester::VmTesterBuilder, tracers::PrestateTracer, - HistoryEnabled, ToTracerPointer, + constants::BLOCK_GAS_LIMIT, tests::tester::VmTesterBuilder, HistoryEnabled, ToTracerPointer, }, }; @@ -34,7 +33,10 @@ fn test_prestate_tracer() { vm.vm.push_transaction(tx1); let contract_address = vm.test_contract.unwrap(); let prestate_tracer_result = Arc::new(OnceCell::default()); - let prestate_tracer = PrestateTracer::new(false, prestate_tracer_result.clone()); + let prestate_tracer = crate::vm_latest::tracers::prestate_tracer::PrestateTracer::new( + false, + prestate_tracer_result.clone(), + ); let tracer_ptr = prestate_tracer.into_tracer_pointer(); vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); @@ -68,7 +70,10 @@ fn test_prestate_tracer_diff_mode() { ); vm.vm.push_transaction(tx1); let prestate_tracer_result = Arc::new(OnceCell::default()); - let prestate_tracer = PrestateTracer::new(true, prestate_tracer_result.clone()); + let prestate_tracer = crate::vm_latest::tracers::prestate_tracer::PrestateTracer::new( + true, + prestate_tracer_result.clone(), + ); let tracer_ptr = prestate_tracer.into_tracer_pointer(); vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs index 05321aae63b..89a5c4f5616 100755 --- a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs @@ -1,6 +1,5 @@ pub(crate) use circuits_tracer::CircuitsTracer; pub(crate) use default_tracers::DefaultExecutionTracer; -pub(crate) use prestate_tracer::PrestateTracer; pub(crate) use pubdata_tracer::PubdataTracer; pub(crate) use refunds::RefundsTracer; pub(crate) use result_tracer::ResultTracer; diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 92e722e1f1c..6d393ea3a61 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -114,7 +114,7 @@ impl DynTracer> for Prestate )), storage: Some(get_storage_if_present( k.account(), - &initial_storage_ref.modified_storage_keys(), + initial_storage_ref.modified_storage_keys(), )), }, ) @@ -152,35 +152,7 @@ impl VmTracer for PrestateTracer { let res = diff .iter() - .map(|k| { - ( - *(k.account().address()), - Account { - balance: Some( - state - .storage - .storage - .read_from_storage(&get_balance_key(k.account())), - ), - code: Some( - state - .storage - .storage - .read_from_storage(&get_code_key(k.account().address())), - ), - nonce: Some( - state - .storage - .storage - .read_from_storage(&get_nonce_key(k.account().address())), - ), - storage: Some(get_storage_if_present( - k.account(), - &modified_storage_keys, - )), - }, - ) - }) + .map(|k| get_account_data(k, state, &modified_storage_keys)) .collect::(); self.post = res; } else { @@ -233,7 +205,7 @@ fn get_account_data< H: vm_latest::old_vm::history_recorder::HistoryMode, >( account_key: &StorageKey, - state: &mut ZkSyncVmState, + state: &ZkSyncVmState, storage: &HashMap, ) -> (Address, Account) { let address = *(account_key.account().address()); From 55b6a269995d2b299a07edbc458e4e9e3a8da7ce Mon Sep 17 00:00:00 2001 From: jrigada Date: Wed, 6 Mar 2024 15:37:35 +0000 Subject: [PATCH 12/26] fix prestate addition of accounts --- .../vm_latest/tests/prestate_tracer.rs | 87 ++++++++++++++++--- .../src/versions/vm_latest/tests/utils.rs | 6 ++ .../vm_latest/tracers/prestate_tracer.rs | 23 +++-- .../simple-transfer/simple-transfer.sol | 35 ++++++++ .../src/gpu_prover_job_processor.rs | 5 +- 5 files changed, 133 insertions(+), 23 deletions(-) create mode 100644 etc/contracts-test-data/contracts/simple-transfer/simple-transfer.sol diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index 52aca86f273..30532300dac 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -2,11 +2,14 @@ use std::sync::Arc; use once_cell::sync::OnceCell; use zksync_test_account::TxType; +use zksync_types::{utils::deployed_address_create, Execute, U256}; use crate::{ interface::{TxExecutionMode, VmExecutionMode, VmInterface}, vm_latest::{ - constants::BLOCK_GAS_LIMIT, tests::tester::VmTesterBuilder, HistoryEnabled, ToTracerPointer, + constants::BLOCK_GAS_LIMIT, + tests::{tester::VmTesterBuilder, utils::read_simple_transfer_contract}, + HistoryEnabled, ToTracerPointer, }, }; @@ -31,6 +34,7 @@ fn test_prestate_tracer() { TxType::L2, ); vm.vm.push_transaction(tx1); + let contract_address = vm.test_contract.unwrap(); let prestate_tracer_result = Arc::new(OnceCell::default()); let prestate_tracer = crate::vm_latest::tracers::prestate_tracer::PrestateTracer::new( @@ -57,31 +61,88 @@ fn test_prestate_tracer_diff_mode() { .with_gas_limit(BLOCK_GAS_LIMIT) .with_execution_mode(TxExecutionMode::VerifyExecute) .build(); + let contract = read_simple_transfer_contract(); + let tx = vm + .deployer + .as_mut() + .expect("You have to initialize builder with deployer") + .get_deploy_tx(&contract, None, TxType::L2) + .tx; + let nonce = tx.nonce().unwrap().0.into(); + vm.vm.push_transaction(tx); + vm.vm.execute(VmExecutionMode::OneTx); + let deployed_address = deployed_address_create(vm.deployer.as_ref().unwrap().address, nonce); + vm.test_contract = Some(deployed_address); + + // Deploy a second copy of the contract to see its appearance in the prestate + let tx2 = vm + .deployer + .as_mut() + .expect("You have to initialize builder with deployer") + .get_deploy_tx(&contract, None, TxType::L2) + .tx; + let nonce2 = tx2.nonce().unwrap().0.into(); + vm.vm.push_transaction(tx2); + vm.vm.execute(VmExecutionMode::OneTx); + let deployed_address2 = deployed_address_create(vm.deployer.as_ref().unwrap().address, nonce2); - vm.deploy_test_contract(); let account = &mut vm.rich_accounts[0]; - let tx1 = account.get_test_contract_transaction( - vm.test_contract.unwrap(), - false, - Default::default(), - true, - TxType::L2, - ); - vm.vm.push_transaction(tx1); + //enter ether to contract to see difference in the balance post execution + let tx0 = Execute { + contract_address: vm.test_contract.unwrap(), + calldata: Default::default(), + value: U256::from(100000), + factory_deps: None, + }; + + vm.vm + .push_transaction(account.get_l2_tx_for_execute(tx0.clone(), None)); + + let tx1 = Execute { + contract_address: deployed_address2, + calldata: Default::default(), + value: U256::from(200000), + factory_deps: None, + }; + + vm.vm + .push_transaction(account.get_l2_tx_for_execute(tx1, None)); let prestate_tracer_result = Arc::new(OnceCell::default()); let prestate_tracer = crate::vm_latest::tracers::prestate_tracer::PrestateTracer::new( true, prestate_tracer_result.clone(), ); let tracer_ptr = prestate_tracer.into_tracer_pointer(); - vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); + vm.vm + .inspect(tracer_ptr.into(), VmExecutionMode::Bootloader); let prestate_result = Arc::try_unwrap(prestate_tracer_result) .unwrap() .take() .unwrap_or_default(); - assert!(!prestate_result.0.is_empty()); - assert!(!prestate_result.1.is_empty()); + //assert that the prestate contains both deployed contracts with balance zero + assert!(prestate_result.0.contains_key(&deployed_address)); + assert!(prestate_result.0.contains_key(&deployed_address2)); + assert_eq!( + prestate_result.0[&deployed_address].balance, + Some(U256::zero()) + ); + assert_eq!( + prestate_result.0[&deployed_address2].balance, + Some(U256::zero()) + ); + + //assert that the poststate contains both deployed contracts with the correct balance + assert!(prestate_result.1.contains_key(&deployed_address)); + assert!(prestate_result.1.contains_key(&deployed_address2)); + assert_eq!( + prestate_result.1[&deployed_address].balance, + Some(U256::from(100000)) + ); + assert_eq!( + prestate_result.1[&deployed_address2].balance, + Some(U256::from(200000)) + ); } diff --git a/core/lib/multivm/src/versions/vm_latest/tests/utils.rs b/core/lib/multivm/src/versions/vm_latest/tests/utils.rs index 80d59ab709f..eeab7a91f51 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/utils.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/utils.rs @@ -81,6 +81,12 @@ pub(crate) fn read_error_contract() -> Vec { ) } +pub(crate) fn read_simple_transfer_contract() -> Vec { + read_bytecode( + "etc/contracts-test-data/artifacts-zk/contracts/simple-transfer/simple-transfer.sol/SimpleTransfer.json", + ) +} + pub(crate) fn get_execute_error_calldata() -> Vec { let test_contract = load_contract( "etc/contracts-test-data/artifacts-zk/contracts/error/error.sol/SimpleRequire.json", diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 6d393ea3a61..41db72d470a 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -86,7 +86,7 @@ impl DynTracer> for Prestate _memory: &SimpleMemory, storage: StoragePtr, ) { - if self.config.diff_mode && self.pre.is_empty() { + if self.config.diff_mode { let cloned_storage = Rc::clone(&storage); let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); let keys = initial_storage_ref @@ -120,7 +120,14 @@ impl DynTracer> for Prestate ) }) .collect::(); - self.pre = res; + + //Fill the pre-state during execution but keeping only first appearence of the value. + // self.pre = res; + let filtered_res = res + .into_iter() + .filter(|(k, _)| !self.pre.contains_key(k)) + .collect::(); + self.pre.extend(filtered_res); } } } @@ -144,13 +151,11 @@ impl VmTracer for PrestateTracer { ) { let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); if self.config.diff_mode { - let diff = modified_storage_keys + let res = modified_storage_keys .clone() .keys() .copied() - .collect::>(); - - let res = diff + .collect::>() .iter() .map(|k| get_account_data(k, state, &modified_storage_keys)) .collect::(); @@ -158,8 +163,10 @@ impl VmTracer for PrestateTracer { } else { let read_keys = &state.storage.read_keys; let map = read_keys.inner().clone(); - let storage_keys_read = map.keys().copied().collect::>(); - let res = storage_keys_read + let res = map + .keys() + .copied() + .collect::>() .iter() .map(|k| get_account_data(k, state, &modified_storage_keys)) .collect::(); diff --git a/etc/contracts-test-data/contracts/simple-transfer/simple-transfer.sol b/etc/contracts-test-data/contracts/simple-transfer/simple-transfer.sol new file mode 100644 index 00000000000..591e97cc1ae --- /dev/null +++ b/etc/contracts-test-data/contracts/simple-transfer/simple-transfer.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +contract SimpleTransfer { + address public owner; + + constructor() { + owner = msg.sender; // Set the contract creator as the owner + } + + // This function allows the contract to receive Ether with msg.data being empty + receive() external payable {} + + modifier onlyOwner() { + require(msg.sender == owner, "Only the owner can execute this."); + _; + } + + // Function to withdraw Ether to the owner's address + function withdraw(uint _amount) public onlyOwner { + require(address(this).balance >= _amount, "Insufficient balance in contract"); + payable(owner).transfer(_amount); + } + + // Function to transfer Ether from this contract to any address + function transfer(address _to, uint _amount) public onlyOwner { + require(address(this).balance >= _amount, "Insufficient balance in contract"); + payable(_to).transfer(_amount); + } + + // Function to check the contract's balance + function getBalance() public view returns (uint) { + return address(this).balance; + } +} diff --git a/prover/prover_fri/src/gpu_prover_job_processor.rs b/prover/prover_fri/src/gpu_prover_job_processor.rs index 04bfcb580fb..e758a0cbd58 100644 --- a/prover/prover_fri/src/gpu_prover_job_processor.rs +++ b/prover/prover_fri/src/gpu_prover_job_processor.rs @@ -3,8 +3,9 @@ pub mod gpu_prover { use std::{collections::HashMap, sync::Arc, time::Instant}; use anyhow::Context as _; - use shivini::gpu_proof_config::GpuProofConfig; - use shivini::{gpu_prove_from_external_witness_data, ProverContext}; + use shivini::{ + gpu_proof_config::GpuProofConfig, gpu_prove_from_external_witness_data, ProverContext, + }; use tokio::task::JoinHandle; use zksync_config::configs::{fri_prover_group::FriProverGroupConfig, FriProverConfig}; use zksync_dal::{fri_prover_dal::types::SocketAddress, ConnectionPool}; From f6e9ac7512300e1d4467ea0538ebf2415dbb34f6 Mon Sep 17 00:00:00 2001 From: jrigada Date: Wed, 6 Mar 2024 16:16:07 +0000 Subject: [PATCH 13/26] spellcheck --- .../multivm/src/versions/vm_latest/tests/prestate_tracer.rs | 6 +++--- .../src/versions/vm_latest/tracers/prestate_tracer.rs | 3 +-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index 30532300dac..bf1ffdab07a 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -74,7 +74,7 @@ fn test_prestate_tracer_diff_mode() { let deployed_address = deployed_address_create(vm.deployer.as_ref().unwrap().address, nonce); vm.test_contract = Some(deployed_address); - // Deploy a second copy of the contract to see its appearance in the prestate + // Deploy a second copy of the contract to see its appearance in the pre-state let tx2 = vm .deployer .as_mut() @@ -122,7 +122,7 @@ fn test_prestate_tracer_diff_mode() { .take() .unwrap_or_default(); - //assert that the prestate contains both deployed contracts with balance zero + //assert that the pre-state contains both deployed contracts with balance zero assert!(prestate_result.0.contains_key(&deployed_address)); assert!(prestate_result.0.contains_key(&deployed_address2)); assert_eq!( @@ -134,7 +134,7 @@ fn test_prestate_tracer_diff_mode() { Some(U256::zero()) ); - //assert that the poststate contains both deployed contracts with the correct balance + //assert that the post-state contains both deployed contracts with the correct balance assert!(prestate_result.1.contains_key(&deployed_address)); assert!(prestate_result.1.contains_key(&deployed_address2)); assert_eq!( diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 41db72d470a..216e3588801 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -121,8 +121,7 @@ impl DynTracer> for Prestate }) .collect::(); - //Fill the pre-state during execution but keeping only first appearence of the value. - // self.pre = res; + //Fill the pre-state during execution but keeping only first value for each key let filtered_res = res .into_iter() .filter(|(k, _)| !self.pre.contains_key(k)) From 6424eebc5659923df5197532c40bf2232b2c8733 Mon Sep 17 00:00:00 2001 From: jrigada Date: Thu, 7 Mar 2024 19:36:04 +0000 Subject: [PATCH 14/26] fix intermediate variables --- .../vm_latest/tracers/prestate_tracer.rs | 23 ++++--------------- 1 file changed, 4 insertions(+), 19 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs index 216e3588801..4539191cb2b 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs @@ -87,7 +87,7 @@ impl DynTracer> for Prestate storage: StoragePtr, ) { if self.config.diff_mode { - let cloned_storage = Rc::clone(&storage); + let cloned_storage = &storage.clone(); let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); let keys = initial_storage_ref .modified_storage_keys() @@ -97,6 +97,7 @@ impl DynTracer> for Prestate let res = keys .iter() + .filter(|k| !self.pre.contains_key(k.account().address())) .map(|k| { ( *(k.account().address()), @@ -121,27 +122,12 @@ impl DynTracer> for Prestate }) .collect::(); - //Fill the pre-state during execution but keeping only first value for each key - let filtered_res = res - .into_iter() - .filter(|(k, _)| !self.pre.contains_key(k)) - .collect::(); - self.pre.extend(filtered_res); + self.pre.extend(res); } } } impl VmTracer for PrestateTracer { - fn initialize_tracer(&mut self, _state: &mut ZkSyncVmState) {} - - fn finish_cycle( - &mut self, - _state: &mut ZkSyncVmState, - _bootloader_state: &mut BootloaderState, - ) -> TracerExecutionStatus { - TracerExecutionStatus::Continue - } - fn after_vm_execution( &mut self, state: &mut ZkSyncVmState, @@ -150,7 +136,7 @@ impl VmTracer for PrestateTracer { ) { let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); if self.config.diff_mode { - let res = modified_storage_keys + self.post = modified_storage_keys .clone() .keys() .copied() @@ -158,7 +144,6 @@ impl VmTracer for PrestateTracer { .iter() .map(|k| get_account_data(k, state, &modified_storage_keys)) .collect::(); - self.post = res; } else { let read_keys = &state.storage.read_keys; let map = read_keys.inner().clone(); From dc7e35607d8451f37c2320f66ef8f37746c4a6f8 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Mon, 11 Mar 2024 13:56:40 -0300 Subject: [PATCH 15/26] previous vm integration --- core/lib/multivm/src/tracers/mod.rs | 2 + .../src/tracers/prestate_tracer/mod.rs | 68 ++++++++ .../tracers/prestate_tracer/vm_1_4_1/mod.rs | 159 +++++++++++++++++ .../prestate_tracer/vm_latest/mod.rs} | 78 +-------- .../vm_refunds_enhancement/mod.rs | 160 +++++++++++++++++ .../prestate_tracer/vm_virtual_blocks/mod.rs | 165 ++++++++++++++++++ .../vm_1_4_1/old_vm/history_recorder.rs | 11 +- .../vm_latest/tests/prestate_tracer.rs | 11 +- .../src/versions/vm_latest/tracers/mod.rs | 1 - .../old_vm/history_recorder.rs | 11 +- .../old_vm/oracles/storage.rs | 1 + .../vm_refunds_enhancement/oracles/storage.rs | 37 +++- .../old_vm/history_recorder.rs | 11 +- .../old_vm/oracles/storage.rs | 39 ++++- 14 files changed, 656 insertions(+), 98 deletions(-) create mode 100644 core/lib/multivm/src/tracers/prestate_tracer/mod.rs create mode 100644 core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs rename core/lib/multivm/src/{versions/vm_latest/tracers/prestate_tracer.rs => tracers/prestate_tracer/vm_latest/mod.rs} (71%) create mode 100644 core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs create mode 100644 core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs diff --git a/core/lib/multivm/src/tracers/mod.rs b/core/lib/multivm/src/tracers/mod.rs index 8d858ae03ed..3090628fcac 100644 --- a/core/lib/multivm/src/tracers/mod.rs +++ b/core/lib/multivm/src/tracers/mod.rs @@ -1,9 +1,11 @@ pub mod call_tracer; mod multivm_dispatcher; pub mod old_tracers; +pub mod prestate_tracer; pub mod storage_invocation; pub mod validator; pub use call_tracer::CallTracer; pub use multivm_dispatcher::TracerDispatcher; +pub use prestate_tracer::PrestateTracer; pub use storage_invocation::StorageInvocations; diff --git a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs new file mode 100644 index 00000000000..2873f000133 --- /dev/null +++ b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs @@ -0,0 +1,68 @@ +use std::{collections::HashMap, fmt, sync::Arc}; + +use once_cell::sync::OnceCell; +use zksync_types::{Address, H256, U256}; + +pub mod vm_1_4_1; +pub mod vm_latest; +pub mod vm_refunds_enhancement; +pub mod vm_virtual_blocks; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Account { + pub balance: Option, + pub code: Option, + pub nonce: Option, + pub storage: Option>, +} + +impl fmt::Display for Account { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + writeln!(f, "{{")?; + if let Some(balance) = self.balance { + writeln!(f, " balance: \"0x{:x}\",", balance)?; + } + if let Some(code) = &self.code { + writeln!(f, " code: \"{}\",", code)?; + } + if let Some(nonce) = self.nonce { + writeln!(f, " nonce: {},", nonce)?; + } + if let Some(storage) = &self.storage { + writeln!(f, " storage: {{")?; + for (key, value) in storage.iter() { + writeln!(f, " {}: \"{}\",", key, value)?; + } + writeln!(f, " }}")?; + } + writeln!(f, "}}") + } +} + +type State = HashMap; + +#[derive(Debug, Clone)] +pub struct PrestateTracer { + pub pre: State, + pub post: State, + pub config: PrestateTracerConfig, + pub result: Arc>, +} + +impl PrestateTracer { + #[allow(dead_code)] + pub fn new(diff_mode: bool, result: Arc>) -> Self { + Self { + pre: Default::default(), + post: Default::default(), + config: PrestateTracerConfig { diff_mode }, + result, + } + } +} + +#[derive(Debug, Clone)] +pub struct PrestateTracerConfig { + diff_mode: bool, +} + diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs new file mode 100644 index 00000000000..fb9ef53d087 --- /dev/null +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs @@ -0,0 +1,159 @@ +use std::{collections::HashMap, sync::Arc}; + +use once_cell::sync::OnceCell; +use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; +use zksync_state::{StoragePtr, WriteStorage}; +use zksync_types::{ + get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, + StorageValue, H256, L2_ETH_TOKEN_ADDRESS, +}; +use zksync_utils::{address_to_h256, h256_to_u256}; + +use super::{Account, PrestateTracer, State}; +use crate::{ + interface::dyn_tracers::vm_1_4_1::DynTracer, + vm_1_4_1::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, +}; +impl DynTracer> for PrestateTracer { + fn before_execution( + &mut self, + _state: VmLocalStateData<'_>, + _data: BeforeExecutionData, + _memory: &SimpleMemory, + storage: StoragePtr, + ) { + if self.config.diff_mode { + let cloned_storage = &storage.clone(); + let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); + let keys = initial_storage_ref + .modified_storage_keys() + .keys() + .cloned() + .collect::>(); + + let res = keys + .iter() + .filter(|k| !self.pre.contains_key(k.account().address())) + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some(h256_to_u256( + initial_storage_ref.read_value(&get_balance_key(k.account())), + )), + code: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_code_key(k.account().address())), + )), + nonce: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_nonce_key(k.account().address())), + )), + storage: Some(get_storage_if_present( + k.account(), + initial_storage_ref.modified_storage_keys(), + )), + }, + ) + }) + .collect::(); + + self.pre.extend(res); + } + } +} + +impl VmTracer for PrestateTracer { + fn after_vm_execution( + &mut self, + state: &mut ZkSyncVmState, + _bootloader_state: &BootloaderState, + _stop_reason: crate::interface::tracer::VmExecutionStopReason, + ) { + let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); + if self.config.diff_mode { + self.post = modified_storage_keys + .clone() + .keys() + .copied() + .collect::>() + .iter() + .map(|k| get_account_data(k, state, &modified_storage_keys)) + .collect::(); + } else { + let read_keys = &state.storage.read_keys; + let map = read_keys.inner().clone(); + let res = map + .keys() + .copied() + .collect::>() + .iter() + .map(|k| get_account_data(k, state, &modified_storage_keys)) + .collect::(); + self.post = res; + } + process_result(&self.result, self.pre.clone(), self.post.clone()); + } +} + +fn get_balance_key(account: &AccountTreeId) -> StorageKey { + let address_h256 = address_to_h256(account.address()); + let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); + let balance_key: H256 = keccak256(&bytes).into(); + StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) +} + +fn get_storage_if_present( + account: &AccountTreeId, + modified_storage_keys: &HashMap, +) -> HashMap { + //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value + modified_storage_keys + .iter() + .filter(|(k, _)| k.account() == account) + .map(|(k, v)| (*k.key(), *v)) + .collect() +} + +fn process_result(result: &Arc>, mut pre: State, post: State) { + pre.retain(|k, v| { + if let Some(post_v) = post.get(k) { + if v != post_v { + return true; + } + } + false + }); + result.set((pre, post)).unwrap(); +} + +fn get_account_data( + account_key: &StorageKey, + state: &ZkSyncVmState, + storage: &HashMap, +) -> (Address, Account) { + let address = *(account_key.account().address()); + let balance = state + .storage + .storage + .read_from_storage(&get_balance_key(account_key.account())); + let code = state + .storage + .storage + .read_from_storage(&get_code_key(account_key.account().address())); + let nonce = state + .storage + .storage + .read_from_storage(&get_nonce_key(account_key.account().address())); + let storage = get_storage_if_present(account_key.account(), storage); + + ( + address, + Account { + balance: Some(balance), + code: Some(code), + nonce: Some(nonce), + storage: Some(storage), + }, + ) +} diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs similarity index 71% rename from core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs rename to core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs index 4539191cb2b..ed2c9cf5c3b 100644 --- a/core/lib/multivm/src/versions/vm_latest/tracers/prestate_tracer.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs @@ -1,83 +1,20 @@ -use std::{collections::HashMap, fmt, rc::Rc, sync::Arc}; +use std::{collections::HashMap, sync::Arc}; use once_cell::sync::OnceCell; use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; use zksync_types::{ get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, - StorageValue, H256, L2_ETH_TOKEN_ADDRESS, U256, + StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; use zksync_utils::{address_to_h256, h256_to_u256}; +use super::{Account, PrestateTracer, State}; use crate::{ - interface::{dyn_tracers::vm_1_4_1::DynTracer, tracer::TracerExecutionStatus}, - vm_latest::{ - self, - bootloader_state::BootloaderState, - old_vm::{history_recorder::HistoryMode, memory::SimpleMemory}, - tracers::traits::VmTracer, - types::internals::ZkSyncVmState, - }, + interface::dyn_tracers::vm_1_4_1::DynTracer, + vm_latest::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, }; -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct Account { - pub balance: Option, - pub code: Option, - pub nonce: Option, - pub storage: Option>, -} - -impl fmt::Display for Account { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - writeln!(f, "{{")?; - if let Some(balance) = self.balance { - writeln!(f, " balance: \"0x{:x}\",", balance)?; - } - if let Some(code) = &self.code { - writeln!(f, " code: \"{}\",", code)?; - } - if let Some(nonce) = self.nonce { - writeln!(f, " nonce: {},", nonce)?; - } - if let Some(storage) = &self.storage { - writeln!(f, " storage: {{")?; - for (key, value) in storage.iter() { - writeln!(f, " {}: \"{}\",", key, value)?; - } - writeln!(f, " }}")?; - } - writeln!(f, "}}") - } -} - -type State = HashMap; - -#[derive(Debug, Clone)] -pub(crate) struct PrestateTracer { - pub pre: State, - pub post: State, - pub config: PrestateTracerConfig, - pub result: Arc>, -} - -impl PrestateTracer { - #[allow(dead_code)] - pub fn new(diff_mode: bool, result: Arc>) -> Self { - Self { - pre: Default::default(), - post: Default::default(), - config: PrestateTracerConfig { diff_mode }, - result, - } - } -} - -#[derive(Debug, Clone)] -pub struct PrestateTracerConfig { - diff_mode: bool, -} - impl DynTracer> for PrestateTracer { fn before_execution( &mut self, @@ -191,10 +128,7 @@ fn process_result(result: &Arc>, mut pre: State, post: result.set((pre, post)).unwrap(); } -fn get_account_data< - S: zksync_state::WriteStorage, - H: vm_latest::old_vm::history_recorder::HistoryMode, ->( +fn get_account_data( account_key: &StorageKey, state: &ZkSyncVmState, storage: &HashMap, diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs new file mode 100644 index 00000000000..cb82784be81 --- /dev/null +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs @@ -0,0 +1,160 @@ +use std::{collections::HashMap, sync::Arc}; + +use once_cell::sync::OnceCell; +use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; +use zksync_state::{StoragePtr, WriteStorage}; +use zksync_types::{ + get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, + StorageValue, H256, L2_ETH_TOKEN_ADDRESS, +}; +use zksync_utils::{address_to_h256, h256_to_u256}; + +use super::{Account, PrestateTracer, State}; +use crate::{ + interface::dyn_tracers::vm_1_3_3::DynTracer, + vm_refunds_enhancement::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, +}; + +impl DynTracer> for PrestateTracer { + fn before_execution( + &mut self, + _state: VmLocalStateData<'_>, + _data: BeforeExecutionData, + _memory: &SimpleMemory, + storage: StoragePtr, + ) { + if self.config.diff_mode { + let cloned_storage = &storage.clone(); + let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); + let keys = initial_storage_ref + .modified_storage_keys() + .keys() + .cloned() + .collect::>(); + + let res = keys + .iter() + .filter(|k| !self.pre.contains_key(k.account().address())) + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some(h256_to_u256( + initial_storage_ref.read_value(&get_balance_key(k.account())), + )), + code: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_code_key(k.account().address())), + )), + nonce: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_nonce_key(k.account().address())), + )), + storage: Some(get_storage_if_present( + k.account(), + initial_storage_ref.modified_storage_keys(), + )), + }, + ) + }) + .collect::(); + + self.pre.extend(res); + } + } +} + +impl VmTracer for PrestateTracer { + fn after_vm_execution( + &mut self, + state: &mut ZkSyncVmState, + _bootloader_state: &BootloaderState, + _stop_reason: crate::interface::tracer::VmExecutionStopReason, + ) { + let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); + if self.config.diff_mode { + self.post = modified_storage_keys + .clone() + .keys() + .copied() + .collect::>() + .iter() + .map(|k| get_account_data(k, state, &modified_storage_keys)) + .collect::(); + } else { + let read_keys = &state.storage.read_keys; + let map = read_keys.inner().clone(); + let res = map + .keys() + .copied() + .collect::>() + .iter() + .map(|k| get_account_data(k, state, &modified_storage_keys)) + .collect::(); + self.post = res; + } + process_result(&self.result, self.pre.clone(), self.post.clone()); + } +} + +fn get_balance_key(account: &AccountTreeId) -> StorageKey { + let address_h256 = address_to_h256(account.address()); + let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); + let balance_key: H256 = keccak256(&bytes).into(); + StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) +} + +fn get_storage_if_present( + account: &AccountTreeId, + modified_storage_keys: &HashMap, +) -> HashMap { + //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value + modified_storage_keys + .iter() + .filter(|(k, _)| k.account() == account) + .map(|(k, v)| (*k.key(), *v)) + .collect() +} + +fn process_result(result: &Arc>, mut pre: State, post: State) { + pre.retain(|k, v| { + if let Some(post_v) = post.get(k) { + if v != post_v { + return true; + } + } + false + }); + result.set((pre, post)).unwrap(); +} + +fn get_account_data( + account_key: &StorageKey, + state: &ZkSyncVmState, + storage: &HashMap, +) -> (Address, Account) { + let address = *(account_key.account().address()); + let balance = state + .storage + .storage + .read_from_storage(&get_balance_key(account_key.account())); + let code = state + .storage + .storage + .read_from_storage(&get_code_key(account_key.account().address())); + let nonce = state + .storage + .storage + .read_from_storage(&get_nonce_key(account_key.account().address())); + let storage = get_storage_if_present(account_key.account(), storage); + + ( + address, + Account { + balance: Some(balance), + code: Some(code), + nonce: Some(nonce), + storage: Some(storage), + }, + ) +} diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs new file mode 100644 index 00000000000..1c33f7d2dba --- /dev/null +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs @@ -0,0 +1,165 @@ +use std::{collections::HashMap, sync::Arc}; + +use once_cell::sync::OnceCell; +use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; +use zksync_state::{StoragePtr, WriteStorage}; +use zksync_types::{ + get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, + StorageValue, H256, L2_ETH_TOKEN_ADDRESS, +}; +use zksync_utils::{address_to_h256, h256_to_u256}; + +use super::{Account, PrestateTracer, State}; +use crate::{ + interface::dyn_tracers::vm_1_3_3::DynTracer, + vm_virtual_blocks::{ + BootloaderState, ExecutionEndTracer, ExecutionProcessing, HistoryMode, SimpleMemory, + ZkSyncVmState, + }, +}; + +impl DynTracer> for PrestateTracer { + fn before_execution( + &mut self, + _state: VmLocalStateData<'_>, + _data: BeforeExecutionData, + _memory: &SimpleMemory, + storage: StoragePtr, + ) { + if self.config.diff_mode { + let cloned_storage = &storage.clone(); + let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); + let keys = initial_storage_ref + .modified_storage_keys() + .keys() + .cloned() + .collect::>(); + + let res = keys + .iter() + .filter(|k| !self.pre.contains_key(k.account().address())) + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some(h256_to_u256( + initial_storage_ref.read_value(&get_balance_key(k.account())), + )), + code: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_code_key(k.account().address())), + )), + nonce: Some(h256_to_u256( + initial_storage_ref + .read_value(&get_nonce_key(k.account().address())), + )), + storage: Some(get_storage_if_present( + k.account(), + initial_storage_ref.modified_storage_keys(), + )), + }, + ) + }) + .collect::(); + + self.pre.extend(res); + } + } +} + +impl ExecutionEndTracer for PrestateTracer {} + +impl ExecutionProcessing for PrestateTracer { + fn after_vm_execution( + &mut self, + state: &mut ZkSyncVmState, + _bootloader_state: &BootloaderState, + _stop_reason: crate::interface::tracer::VmExecutionStopReason, + ) { + let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); + if self.config.diff_mode { + self.post = modified_storage_keys + .clone() + .keys() + .copied() + .collect::>() + .iter() + .map(|k| get_account_data(k, state, &modified_storage_keys)) + .collect::(); + } else { + let read_keys = &state.storage.read_keys; + let map = read_keys.inner().clone(); + let res = map + .keys() + .copied() + .collect::>() + .iter() + .map(|k| get_account_data(k, state, &modified_storage_keys)) + .collect::(); + self.post = res; + } + process_result(&self.result, self.pre.clone(), self.post.clone()); + } +} + +fn get_balance_key(account: &AccountTreeId) -> StorageKey { + let address_h256 = address_to_h256(account.address()); + let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); + let balance_key: H256 = keccak256(&bytes).into(); + StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) +} + +fn get_storage_if_present( + account: &AccountTreeId, + modified_storage_keys: &HashMap, +) -> HashMap { + //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value + modified_storage_keys + .iter() + .filter(|(k, _)| k.account() == account) + .map(|(k, v)| (*k.key(), *v)) + .collect() +} + +fn process_result(result: &Arc>, mut pre: State, post: State) { + pre.retain(|k, v| { + if let Some(post_v) = post.get(k) { + if v != post_v { + return true; + } + } + false + }); + result.set((pre, post)).unwrap(); +} + +fn get_account_data( + account_key: &StorageKey, + state: &ZkSyncVmState, + storage: &HashMap, +) -> (Address, Account) { + let address = *(account_key.account().address()); + let balance = state + .storage + .storage + .read_from_storage(&get_balance_key(account_key.account())); + let code = state + .storage + .storage + .read_from_storage(&get_code_key(account_key.account().address())); + let nonce = state + .storage + .storage + .read_from_storage(&get_nonce_key(account_key.account().address())); + let storage = get_storage_if_present(account_key.account(), storage); + + ( + address, + Account { + balance: Some(balance), + code: Some(code), + nonce: Some(nonce), + storage: Some(storage), + }, + ) +} diff --git a/core/lib/multivm/src/versions/vm_1_4_1/old_vm/history_recorder.rs b/core/lib/multivm/src/versions/vm_1_4_1/old_vm/history_recorder.rs index 7a0b3f45edf..e9e2d51632d 100644 --- a/core/lib/multivm/src/versions/vm_1_4_1/old_vm/history_recorder.rs +++ b/core/lib/multivm/src/versions/vm_1_4_1/old_vm/history_recorder.rs @@ -6,7 +6,7 @@ use zk_evm_1_4_1::{ zkevm_opcode_defs::{self}, }; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{StorageKey, U256}; +use zksync_types::{StorageKey, H256, U256}; use zksync_utils::{h256_to_u256, u256_to_h256}; pub(crate) type MemoryWithHistory = HistoryRecorder; @@ -720,6 +720,15 @@ impl StorageWrapper { pub fn read_from_storage(&self, key: &StorageKey) -> U256 { h256_to_u256(self.storage_ptr.borrow_mut().read_value(key)) } + + pub fn get_modified_storage_keys(&self) -> HashMap { + self.storage_ptr + .borrow() + .modified_storage_keys() + .iter() + .map(|(k, v)| (*k, *v)) + .collect() + } } #[derive(Debug, Clone)] diff --git a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs index bf1ffdab07a..86ae7f54972 100644 --- a/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs +++ b/core/lib/multivm/src/versions/vm_latest/tests/prestate_tracer.rs @@ -6,6 +6,7 @@ use zksync_types::{utils::deployed_address_create, Execute, U256}; use crate::{ interface::{TxExecutionMode, VmExecutionMode, VmInterface}, + tracers::PrestateTracer, vm_latest::{ constants::BLOCK_GAS_LIMIT, tests::{tester::VmTesterBuilder, utils::read_simple_transfer_contract}, @@ -37,10 +38,7 @@ fn test_prestate_tracer() { let contract_address = vm.test_contract.unwrap(); let prestate_tracer_result = Arc::new(OnceCell::default()); - let prestate_tracer = crate::vm_latest::tracers::prestate_tracer::PrestateTracer::new( - false, - prestate_tracer_result.clone(), - ); + let prestate_tracer = PrestateTracer::new(false, prestate_tracer_result.clone()); let tracer_ptr = prestate_tracer.into_tracer_pointer(); vm.vm.inspect(tracer_ptr.into(), VmExecutionMode::Batch); @@ -109,10 +107,7 @@ fn test_prestate_tracer_diff_mode() { vm.vm .push_transaction(account.get_l2_tx_for_execute(tx1, None)); let prestate_tracer_result = Arc::new(OnceCell::default()); - let prestate_tracer = crate::vm_latest::tracers::prestate_tracer::PrestateTracer::new( - true, - prestate_tracer_result.clone(), - ); + let prestate_tracer = PrestateTracer::new(true, prestate_tracer_result.clone()); let tracer_ptr = prestate_tracer.into_tracer_pointer(); vm.vm .inspect(tracer_ptr.into(), VmExecutionMode::Bootloader); diff --git a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs index 89a5c4f5616..fe916e19e8c 100755 --- a/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs +++ b/core/lib/multivm/src/versions/vm_latest/tracers/mod.rs @@ -6,7 +6,6 @@ pub(crate) use result_tracer::ResultTracer; pub(crate) mod circuits_tracer; pub(crate) mod default_tracers; -pub(crate) mod prestate_tracer; pub(crate) mod pubdata_tracer; pub(crate) mod refunds; pub(crate) mod result_tracer; diff --git a/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/history_recorder.rs b/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/history_recorder.rs index e862f57898a..682a8264fae 100644 --- a/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/history_recorder.rs +++ b/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/history_recorder.rs @@ -6,7 +6,7 @@ use zk_evm_1_3_3::{ zkevm_opcode_defs::{self}, }; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{StorageKey, U256}; +use zksync_types::{StorageKey, H256, U256}; use zksync_utils::{h256_to_u256, u256_to_h256}; pub(crate) type MemoryWithHistory = HistoryRecorder; @@ -720,6 +720,15 @@ impl StorageWrapper { pub fn read_from_storage(&self, key: &StorageKey) -> U256 { h256_to_u256(self.storage_ptr.borrow_mut().read_value(key)) } + + pub fn get_modified_storage_keys(&self) -> HashMap { + self.storage_ptr + .borrow() + .modified_storage_keys() + .iter() + .map(|(k, v)| (*k, *v)) + .collect() + } } #[derive(Debug, Clone)] diff --git a/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs b/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs index bf1871c9b68..86fa391d8c6 100644 --- a/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs @@ -46,6 +46,7 @@ pub struct StorageOracle { // to cover this slot. // `paid_changes` history is necessary pub(crate) paid_changes: HistoryRecorder, HistoryEnabled>, + pub(crate) read_keys: HistoryRecorder, HistoryEnabled>, } impl OracleWithHistory for StorageOracle { diff --git a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs index 40b2d83030a..f3299ba669c 100644 --- a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs @@ -12,15 +12,18 @@ use zksync_types::{ }; use zksync_utils::u256_to_h256; -use crate::vm_refunds_enhancement::{ - old_vm::{ - history_recorder::{ - AppDataFrameManagerWithHistory, HashMapHistoryEvent, HistoryEnabled, HistoryMode, - HistoryRecorder, StorageWrapper, VectorHistoryEvent, WithHistory, +use crate::{ + glue::GlueInto, + vm_refunds_enhancement::{ + old_vm::{ + history_recorder::{ + AppDataFrameManagerWithHistory, HashMapHistoryEvent, HistoryEnabled, HistoryMode, + HistoryRecorder, StorageWrapper, VectorHistoryEvent, WithHistory, + }, + oracles::OracleWithHistory, }, - oracles::OracleWithHistory, + utils::logs::StorageLogQuery, }, - utils::logs::StorageLogQuery, }; // While the storage does not support different shards, it was decided to write the @@ -57,6 +60,9 @@ pub struct StorageOracle { // Storage refunds that oracle has returned in `estimate_refunds_for_write`. pub(crate) returned_refunds: HistoryRecorder, H>, + + // Keeps track of storage keys that were ever read. + pub(crate) read_keys: HistoryRecorder, HistoryEnabled>, } impl OracleWithHistory for StorageOracle { @@ -67,6 +73,7 @@ impl OracleWithHistory for StorageOracle { self.paid_changes.rollback_to_timestamp(timestamp); self.initial_values.rollback_to_timestamp(timestamp); self.returned_refunds.rollback_to_timestamp(timestamp); + self.read_keys.rollback_to_timestamp(timestamp); } } @@ -79,6 +86,7 @@ impl StorageOracle { paid_changes: Default::default(), initial_values: Default::default(), returned_refunds: Default::default(), + read_keys: Default::default(), } } @@ -89,6 +97,7 @@ impl StorageOracle { self.paid_changes.delete_history(); self.initial_values.delete_history(); self.returned_refunds.delete_history(); + self.read_keys.delete_history(); } fn is_storage_key_free(&self, key: &StorageKey) -> bool { @@ -96,15 +105,27 @@ impl StorageOracle { || *key == storage_key_for_eth_balance(&BOOTLOADER_ADDRESS) } + fn set_initial_value(&mut self, storage_key: &StorageKey, value: U256, timestamp: Timestamp) { + if !self.initial_values.inner().contains_key(storage_key) { + self.initial_values.insert(*storage_key, value, timestamp); + } + } + pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); + + if !self.read_keys.inner().contains_key(&key) { + self.read_keys.insert(key, (), query.timestamp); + } let current_value = self.storage.read_from_storage(&key); query.read_value = current_value; + self.set_initial_value(&key, current_value, query.timestamp); + self.frames_stack.push_forward( Box::new(StorageLogQuery { - log_query: query, + log_query: query.glue_into(), log_type: StorageLogQueryType::Read, }), query.timestamp, diff --git a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/history_recorder.rs b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/history_recorder.rs index baed63c14b8..664de3a9003 100644 --- a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/history_recorder.rs +++ b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/history_recorder.rs @@ -6,7 +6,7 @@ use zk_evm_1_3_3::{ zkevm_opcode_defs::{self}, }; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{StorageKey, U256}; +use zksync_types::{StorageKey, H256, U256}; use zksync_utils::{h256_to_u256, u256_to_h256}; pub(crate) type MemoryWithHistory = HistoryRecorder; @@ -716,6 +716,15 @@ impl StorageWrapper { pub fn read_from_storage(&self, key: &StorageKey) -> U256 { h256_to_u256(self.storage_ptr.borrow_mut().read_value(key)) } + + pub fn get_modified_storage_keys(&self) -> HashMap { + self.storage_ptr + .borrow() + .modified_storage_keys() + .iter() + .map(|(k, v)| (*k, *v)) + .collect() + } } #[derive(Debug, Clone)] diff --git a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs index b099930cbed..c8c97ace66e 100644 --- a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs @@ -13,12 +13,15 @@ use zksync_types::{ use zksync_utils::u256_to_h256; use super::OracleWithHistory; -use crate::vm_virtual_blocks::{ - old_vm::history_recorder::{ - AppDataFrameManagerWithHistory, HashMapHistoryEvent, HistoryEnabled, HistoryMode, - HistoryRecorder, StorageWrapper, WithHistory, +use crate::{ + glue::GlueInto, + vm_virtual_blocks::{ + old_vm::history_recorder::{ + AppDataFrameManagerWithHistory, HashMapHistoryEvent, HistoryEnabled, HistoryMode, + HistoryRecorder, StorageWrapper, WithHistory, + }, + utils::logs::StorageLogQuery, }, - utils::logs::StorageLogQuery, }; // While the storage does not support different shards, it was decided to write the @@ -45,6 +48,12 @@ pub struct StorageOracle { // to cover this slot. // `paid_changes` history is necessary pub(crate) paid_changes: HistoryRecorder, HistoryEnabled>, + // The map that contains all the first values read from storage for each slot. + // While formally it does not have to be capable of rolling back, we still do it to avoid memory bloat + // for unused slots. + pub(crate) initial_values: HistoryRecorder, H>, + // Keeps track of storage keys that were ever read. + pub(crate) read_keys: HistoryRecorder, HistoryEnabled>, } impl OracleWithHistory for StorageOracle { @@ -52,6 +61,8 @@ impl OracleWithHistory for StorageOracle { self.frames_stack.rollback_to_timestamp(timestamp); self.storage.rollback_to_timestamp(timestamp); self.paid_changes.rollback_to_timestamp(timestamp); + self.read_keys.rollback_to_timestamp(timestamp); + self.initial_values.rollback_to_timestamp(timestamp); } } @@ -61,6 +72,8 @@ impl StorageOracle { storage: HistoryRecorder::from_inner(StorageWrapper::new(storage)), frames_stack: Default::default(), paid_changes: Default::default(), + read_keys: Default::default(), + initial_values: Default::default(), } } @@ -68,6 +81,8 @@ impl StorageOracle { self.frames_stack.delete_history(); self.storage.delete_history(); self.paid_changes.delete_history(); + self.read_keys.delete_history(); + self.initial_values.delete_history(); } fn is_storage_key_free(&self, key: &StorageKey) -> bool { @@ -75,15 +90,27 @@ impl StorageOracle { || *key == storage_key_for_eth_balance(&BOOTLOADER_ADDRESS) } + fn set_initial_value(&mut self, storage_key: &StorageKey, value: U256, timestamp: Timestamp) { + if !self.initial_values.inner().contains_key(storage_key) { + self.initial_values.insert(*storage_key, value, timestamp); + } + } + pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); + + if !self.read_keys.inner().contains_key(&key) { + self.read_keys.insert(key, (), query.timestamp); + } let current_value = self.storage.read_from_storage(&key); query.read_value = current_value; + self.set_initial_value(&key, current_value, query.timestamp); + self.frames_stack.push_forward( Box::new(StorageLogQuery { - log_query: query, + log_query: query.glue_into(), log_type: StorageLogQueryType::Read, }), query.timestamp, From 3ce1fef00dc6ca654efc3275d179d4c4618951c5 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Mon, 11 Mar 2024 13:56:54 -0300 Subject: [PATCH 16/26] previous vm integration --- core/lib/multivm/src/tracers/prestate_tracer/mod.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs index 2873f000133..b4e75150f51 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs @@ -65,4 +65,3 @@ impl PrestateTracer { pub struct PrestateTracerConfig { diff_mode: bool, } - From 0d1c3825c336199b22485c443db4ad117fecb7c0 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Tue, 12 Mar 2024 16:58:11 -0300 Subject: [PATCH 17/26] move process storage for prestate logic to avoid repetition --- .../src/tracers/prestate_tracer/mod.rs | 66 ++++++++++++++++++- .../tracers/prestate_tracer/vm_1_4_1/mod.rs | 42 ++---------- .../tracers/prestate_tracer/vm_latest/mod.rs | 42 ++---------- .../vm_refunds_enhancement/mod.rs | 42 ++---------- .../prestate_tracer/vm_virtual_blocks/mod.rs | 42 ++---------- 5 files changed, 81 insertions(+), 153 deletions(-) diff --git a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs index b4e75150f51..6bb38e5d2c8 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs @@ -1,7 +1,12 @@ use std::{collections::HashMap, fmt, sync::Arc}; use once_cell::sync::OnceCell; -use zksync_types::{Address, H256, U256}; +use zksync_state::{StoragePtr, WriteStorage}; +use zksync_types::{ + get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, + StorageValue, H160, H256, L2_ETH_TOKEN_ADDRESS, U256, +}; +use zksync_utils::{address_to_h256, h256_to_u256}; pub mod vm_1_4_1; pub mod vm_latest; @@ -65,3 +70,62 @@ impl PrestateTracer { pub struct PrestateTracerConfig { diff_mode: bool, } + +pub fn process_modified_storage_keys( + prestate: State, + storage: &StoragePtr, +) -> HashMap +where + S: WriteStorage, +{ + let cloned_storage = &storage.clone(); + let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); + + initial_storage_ref + .modified_storage_keys() + .keys() + .cloned() + .collect::>() + .iter() + .filter(|k| !prestate.contains_key(k.account().address())) + .map(|k| { + ( + *(k.account().address()), + Account { + balance: Some(h256_to_u256( + initial_storage_ref.read_value(&get_balance_key(k.account())), + )), + code: Some(h256_to_u256( + initial_storage_ref.read_value(&get_code_key(k.account().address())), + )), + nonce: Some(h256_to_u256( + initial_storage_ref.read_value(&get_nonce_key(k.account().address())), + )), + storage: Some(get_storage_if_present( + k.account(), + initial_storage_ref.modified_storage_keys(), + )), + }, + ) + }) + .collect::() +} + +fn get_balance_key(account: &AccountTreeId) -> StorageKey { + let address_h256 = address_to_h256(account.address()); + let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); + let balance_key: H256 = keccak256(&bytes).into(); + StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) +} + +fn get_storage_if_present( + account: &AccountTreeId, + modified_storage_keys: &HashMap, +) -> HashMap { + //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value + modified_storage_keys + .iter() + .filter(|(k, _)| k.account() == account) + .map(|(k, v)| (*k.key(), *v)) + .collect() +} diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs index fb9ef53d087..850672fa192 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs @@ -7,9 +7,9 @@ use zksync_types::{ get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; -use zksync_utils::{address_to_h256, h256_to_u256}; +use zksync_utils::address_to_h256; -use super::{Account, PrestateTracer, State}; +use super::{process_modified_storage_keys, Account, PrestateTracer, State}; use crate::{ interface::dyn_tracers::vm_1_4_1::DynTracer, vm_1_4_1::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, @@ -23,42 +23,8 @@ impl DynTracer> for Prestate storage: StoragePtr, ) { if self.config.diff_mode { - let cloned_storage = &storage.clone(); - let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); - let keys = initial_storage_ref - .modified_storage_keys() - .keys() - .cloned() - .collect::>(); - - let res = keys - .iter() - .filter(|k| !self.pre.contains_key(k.account().address())) - .map(|k| { - ( - *(k.account().address()), - Account { - balance: Some(h256_to_u256( - initial_storage_ref.read_value(&get_balance_key(k.account())), - )), - code: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_code_key(k.account().address())), - )), - nonce: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_nonce_key(k.account().address())), - )), - storage: Some(get_storage_if_present( - k.account(), - initial_storage_ref.modified_storage_keys(), - )), - }, - ) - }) - .collect::(); - - self.pre.extend(res); + self.pre + .extend(process_modified_storage_keys(self.pre.clone(), &storage)); } } } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs index ed2c9cf5c3b..5abd0723b83 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs @@ -7,9 +7,9 @@ use zksync_types::{ get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; -use zksync_utils::{address_to_h256, h256_to_u256}; +use zksync_utils::address_to_h256; -use super::{Account, PrestateTracer, State}; +use super::{process_modified_storage_keys, Account, PrestateTracer, State}; use crate::{ interface::dyn_tracers::vm_1_4_1::DynTracer, vm_latest::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, @@ -24,42 +24,8 @@ impl DynTracer> for Prestate storage: StoragePtr, ) { if self.config.diff_mode { - let cloned_storage = &storage.clone(); - let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); - let keys = initial_storage_ref - .modified_storage_keys() - .keys() - .cloned() - .collect::>(); - - let res = keys - .iter() - .filter(|k| !self.pre.contains_key(k.account().address())) - .map(|k| { - ( - *(k.account().address()), - Account { - balance: Some(h256_to_u256( - initial_storage_ref.read_value(&get_balance_key(k.account())), - )), - code: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_code_key(k.account().address())), - )), - nonce: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_nonce_key(k.account().address())), - )), - storage: Some(get_storage_if_present( - k.account(), - initial_storage_ref.modified_storage_keys(), - )), - }, - ) - }) - .collect::(); - - self.pre.extend(res); + self.pre + .extend(process_modified_storage_keys(self.pre.clone(), &storage)); } } } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs index cb82784be81..812f56dd7a9 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs @@ -7,9 +7,9 @@ use zksync_types::{ get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; -use zksync_utils::{address_to_h256, h256_to_u256}; +use zksync_utils::address_to_h256; -use super::{Account, PrestateTracer, State}; +use super::{process_modified_storage_keys, Account, PrestateTracer, State}; use crate::{ interface::dyn_tracers::vm_1_3_3::DynTracer, vm_refunds_enhancement::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, @@ -24,42 +24,8 @@ impl DynTracer> for Prestate storage: StoragePtr, ) { if self.config.diff_mode { - let cloned_storage = &storage.clone(); - let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); - let keys = initial_storage_ref - .modified_storage_keys() - .keys() - .cloned() - .collect::>(); - - let res = keys - .iter() - .filter(|k| !self.pre.contains_key(k.account().address())) - .map(|k| { - ( - *(k.account().address()), - Account { - balance: Some(h256_to_u256( - initial_storage_ref.read_value(&get_balance_key(k.account())), - )), - code: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_code_key(k.account().address())), - )), - nonce: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_nonce_key(k.account().address())), - )), - storage: Some(get_storage_if_present( - k.account(), - initial_storage_ref.modified_storage_keys(), - )), - }, - ) - }) - .collect::(); - - self.pre.extend(res); + self.pre + .extend(process_modified_storage_keys(self.pre.clone(), &storage)); } } } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs index 1c33f7d2dba..ace5e9eb21e 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs @@ -7,9 +7,9 @@ use zksync_types::{ get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; -use zksync_utils::{address_to_h256, h256_to_u256}; +use zksync_utils::address_to_h256; -use super::{Account, PrestateTracer, State}; +use super::{process_modified_storage_keys, Account, PrestateTracer, State}; use crate::{ interface::dyn_tracers::vm_1_3_3::DynTracer, vm_virtual_blocks::{ @@ -27,42 +27,8 @@ impl DynTracer> for Prestate storage: StoragePtr, ) { if self.config.diff_mode { - let cloned_storage = &storage.clone(); - let mut initial_storage_ref = cloned_storage.as_ref().borrow_mut(); - let keys = initial_storage_ref - .modified_storage_keys() - .keys() - .cloned() - .collect::>(); - - let res = keys - .iter() - .filter(|k| !self.pre.contains_key(k.account().address())) - .map(|k| { - ( - *(k.account().address()), - Account { - balance: Some(h256_to_u256( - initial_storage_ref.read_value(&get_balance_key(k.account())), - )), - code: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_code_key(k.account().address())), - )), - nonce: Some(h256_to_u256( - initial_storage_ref - .read_value(&get_nonce_key(k.account().address())), - )), - storage: Some(get_storage_if_present( - k.account(), - initial_storage_ref.modified_storage_keys(), - )), - }, - ) - }) - .collect::(); - - self.pre.extend(res); + self.pre + .extend(process_modified_storage_keys(self.pre.clone(), &storage)); } } } From d96c470691b79d83cded3e9bbf7ca3ca0e495c4f Mon Sep 17 00:00:00 2001 From: Jrigada Date: Wed, 13 Mar 2024 20:43:26 -0300 Subject: [PATCH 18/26] storageAccess trait --- .../src/tracers/prestate_tracer/mod.rs | 39 ++++++++++ .../tracers/prestate_tracer/vm_1_4_1/mod.rs | 70 +++--------------- .../tracers/prestate_tracer/vm_latest/mod.rs | 73 +++---------------- .../vm_refunds_enhancement/mod.rs | 73 +++---------------- .../prestate_tracer/vm_virtual_blocks/mod.rs | 73 +++---------------- 5 files changed, 78 insertions(+), 250 deletions(-) diff --git a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs index 6bb38e5d2c8..6a4dbaa0de7 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs @@ -129,3 +129,42 @@ fn get_storage_if_present( .map(|(k, v)| (*k.key(), *v)) .collect() } + +fn process_result(result: &Arc>, mut pre: State, post: State) { + pre.retain(|k, v| { + if let Some(post_v) = post.get(k) { + if v != post_v { + return true; + } + } + false + }); + result.set((pre, post)).unwrap(); +} + +fn get_account_data( + account_key: &StorageKey, + state: &T, + storage: &HashMap, +) -> (Address, Account) { + let address = *(account_key.account().address()); + let balance = state.read_from_storage(&get_balance_key(account_key.account())); + let code = state.read_from_storage(&get_code_key(account_key.account().address())); + let nonce = state.read_from_storage(&get_nonce_key(account_key.account().address())); + let storage = get_storage_if_present(account_key.account(), storage); + + ( + address, + Account { + balance: Some(balance), + code: Some(code), + nonce: Some(nonce), + storage: Some(storage), + }, + ) +} + +// Define a trait that abstracts storage access +trait StorageAccess { + fn read_from_storage(&self, key: &StorageKey) -> U256; +} diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs index 850672fa192..40432090f87 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs @@ -9,9 +9,13 @@ use zksync_types::{ }; use zksync_utils::address_to_h256; -use super::{process_modified_storage_keys, Account, PrestateTracer, State}; +use super::{ + get_account_data, process_modified_storage_keys, process_result, Account, PrestateTracer, + State, StorageAccess, +}; use crate::{ interface::dyn_tracers::vm_1_4_1::DynTracer, + tracers::prestate_tracer::U256, vm_1_4_1::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, }; impl DynTracer> for PrestateTracer { @@ -62,64 +66,8 @@ impl VmTracer for PrestateTracer { } } -fn get_balance_key(account: &AccountTreeId) -> StorageKey { - let address_h256 = address_to_h256(account.address()); - let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); - let balance_key: H256 = keccak256(&bytes).into(); - StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) -} - -fn get_storage_if_present( - account: &AccountTreeId, - modified_storage_keys: &HashMap, -) -> HashMap { - //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value - modified_storage_keys - .iter() - .filter(|(k, _)| k.account() == account) - .map(|(k, v)| (*k.key(), *v)) - .collect() -} - -fn process_result(result: &Arc>, mut pre: State, post: State) { - pre.retain(|k, v| { - if let Some(post_v) = post.get(k) { - if v != post_v { - return true; - } - } - false - }); - result.set((pre, post)).unwrap(); -} - -fn get_account_data( - account_key: &StorageKey, - state: &ZkSyncVmState, - storage: &HashMap, -) -> (Address, Account) { - let address = *(account_key.account().address()); - let balance = state - .storage - .storage - .read_from_storage(&get_balance_key(account_key.account())); - let code = state - .storage - .storage - .read_from_storage(&get_code_key(account_key.account().address())); - let nonce = state - .storage - .storage - .read_from_storage(&get_nonce_key(account_key.account().address())); - let storage = get_storage_if_present(account_key.account(), storage); - - ( - address, - Account { - balance: Some(balance), - code: Some(code), - nonce: Some(nonce), - storage: Some(storage), - }, - ) +impl StorageAccess for ZkSyncVmState { + fn read_from_storage(&self, key: &StorageKey) -> U256 { + self.storage.storage.read_from_storage(key) + } } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs index 5abd0723b83..400597b973e 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs @@ -4,14 +4,17 @@ use once_cell::sync::OnceCell; use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; use zksync_types::{ - get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, - StorageValue, H256, L2_ETH_TOKEN_ADDRESS, + web3::signing::keccak256, AccountTreeId, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; use zksync_utils::address_to_h256; -use super::{process_modified_storage_keys, Account, PrestateTracer, State}; +use super::{ + get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, + StorageAccess, +}; use crate::{ interface::dyn_tracers::vm_1_4_1::DynTracer, + tracers::prestate_tracer::U256, vm_latest::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, }; @@ -63,64 +66,8 @@ impl VmTracer for PrestateTracer { } } -fn get_balance_key(account: &AccountTreeId) -> StorageKey { - let address_h256 = address_to_h256(account.address()); - let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); - let balance_key: H256 = keccak256(&bytes).into(); - StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) -} - -fn get_storage_if_present( - account: &AccountTreeId, - modified_storage_keys: &HashMap, -) -> HashMap { - //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value - modified_storage_keys - .iter() - .filter(|(k, _)| k.account() == account) - .map(|(k, v)| (*k.key(), *v)) - .collect() -} - -fn process_result(result: &Arc>, mut pre: State, post: State) { - pre.retain(|k, v| { - if let Some(post_v) = post.get(k) { - if v != post_v { - return true; - } - } - false - }); - result.set((pre, post)).unwrap(); -} - -fn get_account_data( - account_key: &StorageKey, - state: &ZkSyncVmState, - storage: &HashMap, -) -> (Address, Account) { - let address = *(account_key.account().address()); - let balance = state - .storage - .storage - .read_from_storage(&get_balance_key(account_key.account())); - let code = state - .storage - .storage - .read_from_storage(&get_code_key(account_key.account().address())); - let nonce = state - .storage - .storage - .read_from_storage(&get_nonce_key(account_key.account().address())); - let storage = get_storage_if_present(account_key.account(), storage); - - ( - address, - Account { - balance: Some(balance), - code: Some(code), - nonce: Some(nonce), - storage: Some(storage), - }, - ) +impl StorageAccess for ZkSyncVmState { + fn read_from_storage(&self, key: &StorageKey) -> U256 { + self.storage.storage.read_from_storage(key) + } } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs index 812f56dd7a9..120eb2678ef 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs @@ -4,14 +4,17 @@ use once_cell::sync::OnceCell; use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; use zksync_types::{ - get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, - StorageValue, H256, L2_ETH_TOKEN_ADDRESS, + web3::signing::keccak256, AccountTreeId, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; use zksync_utils::address_to_h256; -use super::{process_modified_storage_keys, Account, PrestateTracer, State}; +use super::{ + get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, + StorageAccess, +}; use crate::{ interface::dyn_tracers::vm_1_3_3::DynTracer, + tracers::prestate_tracer::U256, vm_refunds_enhancement::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState}, }; @@ -63,64 +66,8 @@ impl VmTracer for PrestateTracer { } } -fn get_balance_key(account: &AccountTreeId) -> StorageKey { - let address_h256 = address_to_h256(account.address()); - let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); - let balance_key: H256 = keccak256(&bytes).into(); - StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) -} - -fn get_storage_if_present( - account: &AccountTreeId, - modified_storage_keys: &HashMap, -) -> HashMap { - //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value - modified_storage_keys - .iter() - .filter(|(k, _)| k.account() == account) - .map(|(k, v)| (*k.key(), *v)) - .collect() -} - -fn process_result(result: &Arc>, mut pre: State, post: State) { - pre.retain(|k, v| { - if let Some(post_v) = post.get(k) { - if v != post_v { - return true; - } - } - false - }); - result.set((pre, post)).unwrap(); -} - -fn get_account_data( - account_key: &StorageKey, - state: &ZkSyncVmState, - storage: &HashMap, -) -> (Address, Account) { - let address = *(account_key.account().address()); - let balance = state - .storage - .storage - .read_from_storage(&get_balance_key(account_key.account())); - let code = state - .storage - .storage - .read_from_storage(&get_code_key(account_key.account().address())); - let nonce = state - .storage - .storage - .read_from_storage(&get_nonce_key(account_key.account().address())); - let storage = get_storage_if_present(account_key.account(), storage); - - ( - address, - Account { - balance: Some(balance), - code: Some(code), - nonce: Some(nonce), - storage: Some(storage), - }, - ) +impl StorageAccess for ZkSyncVmState { + fn read_from_storage(&self, key: &StorageKey) -> U256 { + self.storage.storage.read_from_storage(key) + } } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs index ace5e9eb21e..bc7c650d782 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs @@ -4,14 +4,17 @@ use once_cell::sync::OnceCell; use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; use zksync_types::{ - get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, - StorageValue, H256, L2_ETH_TOKEN_ADDRESS, + web3::signing::keccak256, AccountTreeId, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, }; use zksync_utils::address_to_h256; -use super::{process_modified_storage_keys, Account, PrestateTracer, State}; +use super::{ + get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, + StorageAccess, +}; use crate::{ interface::dyn_tracers::vm_1_3_3::DynTracer, + tracers::prestate_tracer::U256, vm_virtual_blocks::{ BootloaderState, ExecutionEndTracer, ExecutionProcessing, HistoryMode, SimpleMemory, ZkSyncVmState, @@ -68,64 +71,8 @@ impl ExecutionProcessing for PrestateTrac } } -fn get_balance_key(account: &AccountTreeId) -> StorageKey { - let address_h256 = address_to_h256(account.address()); - let bytes = [address_h256.as_bytes(), &[0; 32]].concat(); - let balance_key: H256 = keccak256(&bytes).into(); - StorageKey::new(AccountTreeId::new(L2_ETH_TOKEN_ADDRESS), balance_key) -} - -fn get_storage_if_present( - account: &AccountTreeId, - modified_storage_keys: &HashMap, -) -> HashMap { - //check if there is a Storage Key struct with an account field that matches the account and return the key as the key and the Storage Value as the value - modified_storage_keys - .iter() - .filter(|(k, _)| k.account() == account) - .map(|(k, v)| (*k.key(), *v)) - .collect() -} - -fn process_result(result: &Arc>, mut pre: State, post: State) { - pre.retain(|k, v| { - if let Some(post_v) = post.get(k) { - if v != post_v { - return true; - } - } - false - }); - result.set((pre, post)).unwrap(); -} - -fn get_account_data( - account_key: &StorageKey, - state: &ZkSyncVmState, - storage: &HashMap, -) -> (Address, Account) { - let address = *(account_key.account().address()); - let balance = state - .storage - .storage - .read_from_storage(&get_balance_key(account_key.account())); - let code = state - .storage - .storage - .read_from_storage(&get_code_key(account_key.account().address())); - let nonce = state - .storage - .storage - .read_from_storage(&get_nonce_key(account_key.account().address())); - let storage = get_storage_if_present(account_key.account(), storage); - - ( - address, - Account { - balance: Some(balance), - code: Some(code), - nonce: Some(nonce), - storage: Some(storage), - }, - ) +impl StorageAccess for ZkSyncVmState { + fn read_from_storage(&self, key: &StorageKey) -> U256 { + self.storage.storage.read_from_storage(key) + } } From 5a176f11cf0466c29dd2909b1300331ba342738f Mon Sep 17 00:00:00 2001 From: Jrigada Date: Wed, 13 Mar 2024 20:51:59 -0300 Subject: [PATCH 19/26] remove unused imports --- .../src/tracers/prestate_tracer/vm_1_4_1/mod.rs | 13 +++---------- .../src/tracers/prestate_tracer/vm_latest/mod.rs | 8 +------- .../prestate_tracer/vm_refunds_enhancement/mod.rs | 8 +------- .../prestate_tracer/vm_virtual_blocks/mod.rs | 8 +------- 4 files changed, 6 insertions(+), 31 deletions(-) diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs index 40432090f87..3da5f77674d 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs @@ -1,17 +1,10 @@ -use std::{collections::HashMap, sync::Arc}; - -use once_cell::sync::OnceCell; use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{ - get_code_key, get_nonce_key, web3::signing::keccak256, AccountTreeId, Address, StorageKey, - StorageValue, H256, L2_ETH_TOKEN_ADDRESS, -}; -use zksync_utils::address_to_h256; +use zksync_types::StorageKey; use super::{ - get_account_data, process_modified_storage_keys, process_result, Account, PrestateTracer, - State, StorageAccess, + get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, + StorageAccess, }; use crate::{ interface::dyn_tracers::vm_1_4_1::DynTracer, diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs index 400597b973e..a7633059b5b 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs @@ -1,12 +1,6 @@ -use std::{collections::HashMap, sync::Arc}; - -use once_cell::sync::OnceCell; use zk_evm_1_4_1::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{ - web3::signing::keccak256, AccountTreeId, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, -}; -use zksync_utils::address_to_h256; +use zksync_types::StorageKey; use super::{ get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs index 120eb2678ef..3ab83eec646 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs @@ -1,12 +1,6 @@ -use std::{collections::HashMap, sync::Arc}; - -use once_cell::sync::OnceCell; use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{ - web3::signing::keccak256, AccountTreeId, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, -}; -use zksync_utils::address_to_h256; +use zksync_types::StorageKey; use super::{ get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs index bc7c650d782..f6b5f8667a0 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs @@ -1,12 +1,6 @@ -use std::{collections::HashMap, sync::Arc}; - -use once_cell::sync::OnceCell; use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::{ - web3::signing::keccak256, AccountTreeId, StorageKey, StorageValue, H256, L2_ETH_TOKEN_ADDRESS, -}; -use zksync_utils::address_to_h256; +use zksync_types::StorageKey; use super::{ get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, From 5283f64b980ef71a67c018b3b00ef613c81e6315 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Thu, 14 Mar 2024 12:23:38 -0300 Subject: [PATCH 20/26] remove unnecesary set_initial_value function --- .../versions/vm_refunds_enhancement/oracles/storage.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs index f3299ba669c..8c08f012442 100644 --- a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs @@ -105,12 +105,6 @@ impl StorageOracle { || *key == storage_key_for_eth_balance(&BOOTLOADER_ADDRESS) } - fn set_initial_value(&mut self, storage_key: &StorageKey, value: U256, timestamp: Timestamp) { - if !self.initial_values.inner().contains_key(storage_key) { - self.initial_values.insert(*storage_key, value, timestamp); - } - } - pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); @@ -121,8 +115,6 @@ impl StorageOracle { query.read_value = current_value; - self.set_initial_value(&key, current_value, query.timestamp); - self.frames_stack.push_forward( Box::new(StorageLogQuery { log_query: query.glue_into(), From 1094d91e9d5579072d3259b715e07eb21b5d085f Mon Sep 17 00:00:00 2001 From: Jrigada Date: Sun, 17 Mar 2024 19:45:17 -0300 Subject: [PATCH 21/26] remove read_keys from the versions of vm that does not need them --- .../vm_refunds_enhancement/mod.rs | 18 ++++++++++++++---- .../prestate_tracer/vm_virtual_blocks/mod.rs | 19 +++++++++++++++---- .../vm_refunds_enhancement/oracles/storage.rs | 9 --------- .../old_vm/oracles/storage.rs | 8 -------- core/lib/state/src/lib.rs | 3 +++ core/lib/state/src/storage_view.rs | 3 +++ 6 files changed, 35 insertions(+), 25 deletions(-) diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs index 3ab83eec646..16c948444d0 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs @@ -1,6 +1,8 @@ +use std::collections::HashMap; + use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::StorageKey; +use zksync_types::{StorageKey, H256}; use super::{ get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, @@ -45,9 +47,17 @@ impl VmTracer for PrestateTracer { .map(|k| get_account_data(k, state, &modified_storage_keys)) .collect::(); } else { - let read_keys = &state.storage.read_keys; - let map = read_keys.inner().clone(); - let res = map + let read_keys: &HashMap = &state + .storage + .storage + .inner() + .get_ptr() + .borrow() + .read_storage_keys() + .iter() + .map(|(k, v)| (*k, *v)) + .collect(); + let res = read_keys .keys() .copied() .collect::>() diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs index f6b5f8667a0..fb950d30c3b 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs @@ -1,6 +1,8 @@ +use std::collections::HashMap; + use zk_evm_1_3_3::tracing::{BeforeExecutionData, VmLocalStateData}; use zksync_state::{StoragePtr, WriteStorage}; -use zksync_types::StorageKey; +use zksync_types::{StorageKey, H256}; use super::{ get_account_data, process_modified_storage_keys, process_result, PrestateTracer, State, @@ -50,9 +52,18 @@ impl ExecutionProcessing for PrestateTrac .map(|k| get_account_data(k, state, &modified_storage_keys)) .collect::(); } else { - let read_keys = &state.storage.read_keys; - let map = read_keys.inner().clone(); - let res = map + let read_keys: &HashMap = &state + .storage + .storage + .inner() + .get_ptr() + .borrow() + .read_storage_keys() + .iter() + .map(|(k, v)| (*k, *v)) + .collect(); + + let res = read_keys .keys() .copied() .collect::>() diff --git a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs index 8c08f012442..9fbd0933e62 100644 --- a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs @@ -60,9 +60,6 @@ pub struct StorageOracle { // Storage refunds that oracle has returned in `estimate_refunds_for_write`. pub(crate) returned_refunds: HistoryRecorder, H>, - - // Keeps track of storage keys that were ever read. - pub(crate) read_keys: HistoryRecorder, HistoryEnabled>, } impl OracleWithHistory for StorageOracle { @@ -73,7 +70,6 @@ impl OracleWithHistory for StorageOracle { self.paid_changes.rollback_to_timestamp(timestamp); self.initial_values.rollback_to_timestamp(timestamp); self.returned_refunds.rollback_to_timestamp(timestamp); - self.read_keys.rollback_to_timestamp(timestamp); } } @@ -86,7 +82,6 @@ impl StorageOracle { paid_changes: Default::default(), initial_values: Default::default(), returned_refunds: Default::default(), - read_keys: Default::default(), } } @@ -97,7 +92,6 @@ impl StorageOracle { self.paid_changes.delete_history(); self.initial_values.delete_history(); self.returned_refunds.delete_history(); - self.read_keys.delete_history(); } fn is_storage_key_free(&self, key: &StorageKey) -> bool { @@ -108,9 +102,6 @@ impl StorageOracle { pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); - if !self.read_keys.inner().contains_key(&key) { - self.read_keys.insert(key, (), query.timestamp); - } let current_value = self.storage.read_from_storage(&key); query.read_value = current_value; diff --git a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs index c8c97ace66e..94e87a01d0d 100644 --- a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs @@ -52,8 +52,6 @@ pub struct StorageOracle { // While formally it does not have to be capable of rolling back, we still do it to avoid memory bloat // for unused slots. pub(crate) initial_values: HistoryRecorder, H>, - // Keeps track of storage keys that were ever read. - pub(crate) read_keys: HistoryRecorder, HistoryEnabled>, } impl OracleWithHistory for StorageOracle { @@ -61,7 +59,6 @@ impl OracleWithHistory for StorageOracle { self.frames_stack.rollback_to_timestamp(timestamp); self.storage.rollback_to_timestamp(timestamp); self.paid_changes.rollback_to_timestamp(timestamp); - self.read_keys.rollback_to_timestamp(timestamp); self.initial_values.rollback_to_timestamp(timestamp); } } @@ -72,7 +69,6 @@ impl StorageOracle { storage: HistoryRecorder::from_inner(StorageWrapper::new(storage)), frames_stack: Default::default(), paid_changes: Default::default(), - read_keys: Default::default(), initial_values: Default::default(), } } @@ -81,7 +77,6 @@ impl StorageOracle { self.frames_stack.delete_history(); self.storage.delete_history(); self.paid_changes.delete_history(); - self.read_keys.delete_history(); self.initial_values.delete_history(); } @@ -99,9 +94,6 @@ impl StorageOracle { pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); - if !self.read_keys.inner().contains_key(&key) { - self.read_keys.insert(key, (), query.timestamp); - } let current_value = self.storage.read_from_storage(&key); query.read_value = current_value; diff --git a/core/lib/state/src/lib.rs b/core/lib/state/src/lib.rs index f76f3884656..b0aa3fa3863 100644 --- a/core/lib/state/src/lib.rs +++ b/core/lib/state/src/lib.rs @@ -64,6 +64,9 @@ pub trait ReadStorage: fmt::Debug { /// /// So far, this trait is implemented only for [`StorageView`]. pub trait WriteStorage: ReadStorage { + /// Returns the map with the key–value pairs read by this batch. + fn read_storage_keys(&self) -> &HashMap; + /// Sets the new value under a given key and returns the previous value. fn set_value(&mut self, key: StorageKey, value: StorageValue) -> StorageValue; diff --git a/core/lib/state/src/storage_view.rs b/core/lib/state/src/storage_view.rs index ffc9019bac2..73dd25ad196 100644 --- a/core/lib/state/src/storage_view.rs +++ b/core/lib/state/src/storage_view.rs @@ -180,6 +180,9 @@ impl ReadStorage for StorageView { } impl WriteStorage for StorageView { + fn read_storage_keys(&self) -> &HashMap { + &self.read_storage_keys + } fn set_value(&mut self, key: StorageKey, value: StorageValue) -> StorageValue { let started_at = Instant::now(); self.metrics.set_value_storage_invocations += 1; From ec4c40e319d0b13f37427c7672662196f423b1bb Mon Sep 17 00:00:00 2001 From: Jrigada Date: Tue, 19 Mar 2024 10:21:35 -0300 Subject: [PATCH 22/26] remove initial_values --- .../versions/vm_virtual_blocks/old_vm/oracles/storage.rs | 8 -------- core/lib/state/src/storage_view.rs | 1 + 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs index 94e87a01d0d..4addb177506 100644 --- a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs @@ -85,12 +85,6 @@ impl StorageOracle { || *key == storage_key_for_eth_balance(&BOOTLOADER_ADDRESS) } - fn set_initial_value(&mut self, storage_key: &StorageKey, value: U256, timestamp: Timestamp) { - if !self.initial_values.inner().contains_key(storage_key) { - self.initial_values.insert(*storage_key, value, timestamp); - } - } - pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); @@ -98,8 +92,6 @@ impl StorageOracle { query.read_value = current_value; - self.set_initial_value(&key, current_value, query.timestamp); - self.frames_stack.push_forward( Box::new(StorageLogQuery { log_query: query.glue_into(), diff --git a/core/lib/state/src/storage_view.rs b/core/lib/state/src/storage_view.rs index 73dd25ad196..2db96cb73fc 100644 --- a/core/lib/state/src/storage_view.rs +++ b/core/lib/state/src/storage_view.rs @@ -183,6 +183,7 @@ impl WriteStorage for StorageView { fn read_storage_keys(&self) -> &HashMap { &self.read_storage_keys } + fn set_value(&mut self, key: StorageKey, value: StorageValue) -> StorageValue { let started_at = Instant::now(); self.metrics.set_value_storage_invocations += 1; From 0b3033c7231b5261b0ed2ef57d5412cc71e9a9e5 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Tue, 19 Mar 2024 10:23:36 -0300 Subject: [PATCH 23/26] remove initial_values --- .../versions/vm_virtual_blocks/old_vm/oracles/storage.rs | 7 ------- 1 file changed, 7 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs index 4addb177506..e901b756903 100644 --- a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs @@ -48,10 +48,6 @@ pub struct StorageOracle { // to cover this slot. // `paid_changes` history is necessary pub(crate) paid_changes: HistoryRecorder, HistoryEnabled>, - // The map that contains all the first values read from storage for each slot. - // While formally it does not have to be capable of rolling back, we still do it to avoid memory bloat - // for unused slots. - pub(crate) initial_values: HistoryRecorder, H>, } impl OracleWithHistory for StorageOracle { @@ -59,7 +55,6 @@ impl OracleWithHistory for StorageOracle { self.frames_stack.rollback_to_timestamp(timestamp); self.storage.rollback_to_timestamp(timestamp); self.paid_changes.rollback_to_timestamp(timestamp); - self.initial_values.rollback_to_timestamp(timestamp); } } @@ -69,7 +64,6 @@ impl StorageOracle { storage: HistoryRecorder::from_inner(StorageWrapper::new(storage)), frames_stack: Default::default(), paid_changes: Default::default(), - initial_values: Default::default(), } } @@ -77,7 +71,6 @@ impl StorageOracle { self.frames_stack.delete_history(); self.storage.delete_history(); self.paid_changes.delete_history(); - self.initial_values.delete_history(); } fn is_storage_key_free(&self, key: &StorageKey) -> bool { From f5ce49b48ed2ee60d7bd70c306adc350c626b225 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Tue, 19 Mar 2024 10:26:34 -0300 Subject: [PATCH 24/26] remove initial_values --- .../versions/vm_refunds_enhancement/old_vm/oracles/storage.rs | 1 - .../src/versions/vm_refunds_enhancement/oracles/storage.rs | 1 - .../src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs | 1 - 3 files changed, 3 deletions(-) diff --git a/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs b/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs index 86fa391d8c6..bf1871c9b68 100644 --- a/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_refunds_enhancement/old_vm/oracles/storage.rs @@ -46,7 +46,6 @@ pub struct StorageOracle { // to cover this slot. // `paid_changes` history is necessary pub(crate) paid_changes: HistoryRecorder, HistoryEnabled>, - pub(crate) read_keys: HistoryRecorder, HistoryEnabled>, } impl OracleWithHistory for StorageOracle { diff --git a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs index 9fbd0933e62..59ed4f9450e 100644 --- a/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_refunds_enhancement/oracles/storage.rs @@ -101,7 +101,6 @@ impl StorageOracle { pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); - let current_value = self.storage.read_from_storage(&key); query.read_value = current_value; diff --git a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs index e901b756903..423abfd1c4a 100644 --- a/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs +++ b/core/lib/multivm/src/versions/vm_virtual_blocks/old_vm/oracles/storage.rs @@ -80,7 +80,6 @@ impl StorageOracle { pub fn read_value(&mut self, mut query: LogQuery) -> LogQuery { let key = triplet_to_storage_key(query.shard_id, query.address, query.key); - let current_value = self.storage.read_from_storage(&key); query.read_value = current_value; From ce9eb7568ace43a7411df8042b41f1483d8a9884 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Tue, 19 Mar 2024 16:32:55 -0300 Subject: [PATCH 25/26] remove dead code annotation and collect vec --- core/lib/multivm/src/tracers/prestate_tracer/mod.rs | 1 - .../lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs | 6 +----- .../multivm/src/tracers/prestate_tracer/vm_latest/mod.rs | 6 +----- .../tracers/prestate_tracer/vm_refunds_enhancement/mod.rs | 6 +----- .../src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs | 6 +----- 5 files changed, 4 insertions(+), 21 deletions(-) diff --git a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs index 6a4dbaa0de7..32af69789e2 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs @@ -55,7 +55,6 @@ pub struct PrestateTracer { } impl PrestateTracer { - #[allow(dead_code)] pub fn new(diff_mode: bool, result: Arc>) -> Self { Self { pre: Default::default(), diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs index 3da5f77674d..2558e24275d 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs @@ -36,12 +36,8 @@ impl VmTracer for PrestateTracer { let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); if self.config.diff_mode { self.post = modified_storage_keys - .clone() - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); } else { let read_keys = &state.storage.read_keys; diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs index a7633059b5b..a1517b0bf44 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs @@ -37,12 +37,8 @@ impl VmTracer for PrestateTracer { let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); if self.config.diff_mode { self.post = modified_storage_keys - .clone() - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); } else { let read_keys = &state.storage.read_keys; diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs index 16c948444d0..16bb0cd97ed 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs @@ -39,12 +39,8 @@ impl VmTracer for PrestateTracer { let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); if self.config.diff_mode { self.post = modified_storage_keys - .clone() - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); } else { let read_keys: &HashMap = &state diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs index fb950d30c3b..d59f8b2f70c 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs @@ -44,12 +44,8 @@ impl ExecutionProcessing for PrestateTrac let modified_storage_keys = state.storage.storage.inner().get_modified_storage_keys(); if self.config.diff_mode { self.post = modified_storage_keys - .clone() - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); } else { let read_keys: &HashMap = &state From 7d8792a93ea897b9a81a35a5d82bf61b0e6ec611 Mon Sep 17 00:00:00 2001 From: Jrigada Date: Tue, 19 Mar 2024 16:40:01 -0300 Subject: [PATCH 26/26] remove collect vec --- .../multivm/src/tracers/prestate_tracer/mod.rs | 16 +++++++--------- .../src/tracers/prestate_tracer/vm_1_4_1/mod.rs | 5 +---- .../src/tracers/prestate_tracer/vm_latest/mod.rs | 5 +---- .../vm_refunds_enhancement/mod.rs | 5 +---- .../prestate_tracer/vm_virtual_blocks/mod.rs | 5 +---- 5 files changed, 11 insertions(+), 25 deletions(-) diff --git a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs index 32af69789e2..9bc7bd021ce 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/mod.rs @@ -82,26 +82,24 @@ where initial_storage_ref .modified_storage_keys() - .keys() - .cloned() - .collect::>() + .clone() .iter() - .filter(|k| !prestate.contains_key(k.account().address())) + .filter(|k| !prestate.contains_key(k.0.account().address())) .map(|k| { ( - *(k.account().address()), + *(k.0.account().address()), Account { balance: Some(h256_to_u256( - initial_storage_ref.read_value(&get_balance_key(k.account())), + initial_storage_ref.read_value(&get_balance_key(k.0.account())), )), code: Some(h256_to_u256( - initial_storage_ref.read_value(&get_code_key(k.account().address())), + initial_storage_ref.read_value(&get_code_key(k.0.account().address())), )), nonce: Some(h256_to_u256( - initial_storage_ref.read_value(&get_nonce_key(k.account().address())), + initial_storage_ref.read_value(&get_nonce_key(k.0.account().address())), )), storage: Some(get_storage_if_present( - k.account(), + k.0.account(), initial_storage_ref.modified_storage_keys(), )), }, diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs index 2558e24275d..f2080b2740f 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_1_4_1/mod.rs @@ -43,11 +43,8 @@ impl VmTracer for PrestateTracer { let read_keys = &state.storage.read_keys; let map = read_keys.inner().clone(); let res = map - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); self.post = res; } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs index a1517b0bf44..ceb11005456 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_latest/mod.rs @@ -44,11 +44,8 @@ impl VmTracer for PrestateTracer { let read_keys = &state.storage.read_keys; let map = read_keys.inner().clone(); let res = map - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); self.post = res; } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs index 16bb0cd97ed..970b0a8387b 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_refunds_enhancement/mod.rs @@ -54,11 +54,8 @@ impl VmTracer for PrestateTracer { .map(|(k, v)| (*k, *v)) .collect(); let res = read_keys - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); self.post = res; } diff --git a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs index d59f8b2f70c..34c60a6bc07 100644 --- a/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs +++ b/core/lib/multivm/src/tracers/prestate_tracer/vm_virtual_blocks/mod.rs @@ -60,11 +60,8 @@ impl ExecutionProcessing for PrestateTrac .collect(); let res = read_keys - .keys() - .copied() - .collect::>() .iter() - .map(|k| get_account_data(k, state, &modified_storage_keys)) + .map(|k| get_account_data(k.0, state, &modified_storage_keys)) .collect::(); self.post = res; }