Zk server compatibility

src/op_handlers/far_call.rs

@@ -15,11 +15,13 @@ use crate::{
     rollbacks::Rollbackable,
     state::VMState,
     statistics::{VmStatistics, STORAGE_READ_STORAGE_APPLICATION_CYCLES},
-    store::{StorageError, StorageKey},
+    store::{Storage, StorageError, StorageKey},
     utils::{address_into_u256, is_kernel},
     value::{FatPointer, TaggedValue},
     Opcode,
 };
+
+use super::ret::panic_from_far_call;
 #[allow(dead_code)]
 struct FarCallParams {
     forward_memory: FatPointer,
@@ -134,14 +136,15 @@ fn decommit_code_hash(
     default_aa_code_hash: [u8; 32],
     evm_interpreter_code_hash: [u8; 32],
     is_constructor_call: bool,
+    storage: &mut dyn Storage,
 ) -> Result<(U256, bool, u32), EraVmError> {
     let mut is_evm = false;
     let deployer_system_contract_address =
         Address::from_low_u64_be(DEPLOYER_SYSTEM_CONTRACT_ADDRESS_LOW as u64);
     let storage_key = StorageKey::new(deployer_system_contract_address, address_into_u256(address));
 
     // reading when decommiting doesn't refund
-    let code_info = state.storage_read_with_no_refund(storage_key);
+    let code_info = state.storage_read_with_no_refund(storage_key, storage);
     let mut code_info_bytes = [0; 32];
     code_info.to_big_endian(&mut code_info_bytes);
 
@@ -216,6 +219,7 @@ pub fn far_call(
     far_call: &FarCallOpcode,
     state: &mut VMState,
     statistics: &mut VmStatistics,
+    storage: &mut dyn Storage,
 ) -> Result<(), EraVmError> {
     let (src0, src1) = address_operands_read(vm, opcode)?;
     let contract_address = address_from_u256(&src1.value);
@@ -227,45 +231,57 @@ pub fn far_call(
     abi.is_constructor_call = abi.is_constructor_call && vm.current_context()?.is_kernel();
     abi.is_system_call = abi.is_system_call && is_kernel(&contract_address);
 
+    let FarCallParams {
+        ergs_passed,
+        forward_memory,
+        ..
+    } = far_call_params_from_register(src0, vm)?;
+
+    let mut mandated_gas = if abi.is_system_call && src1.value == ADDRESS_MSG_VALUE.into() {
+        MSG_VALUE_SIMULATOR_ADDITIVE_COST
+    } else {
+        0
+    };
+
     let (code_key, is_evm, decommit_cost) = decommit_code_hash(
         state,
         contract_address,
         vm.default_aa_code_hash,
         vm.evm_interpreter_code_hash,
         abi.is_constructor_call,
+        storage,
     )?;
 
-    // Unlike all other gas costs, this one is not paid if low on gas.
-    if decommit_cost <= vm.gas_left()? {
-        vm.decrease_gas(decommit_cost)?;
+    if vm.decrease_gas(mandated_gas).is_err() {
+        vm.set_gas_left(0)?;
+        mandated_gas = 0;
+        panic_from_far_call(vm, opcode)?;
     } else {
-        return Err(EraVmError::DecommitFailed);
+        // Pay for decommit
+        // Unlike all other gas costs, this one is not paid if low on gas.
+        if decommit_cost <= vm.gas_left()? {
+            vm.decrease_gas(decommit_cost)?;
+        } else {
+            return Err(EraVmError::DecommitFailed);
+        }
     }
 
-    let FarCallParams {
-        ergs_passed,
-        forward_memory,
-        ..
-    } = far_call_params_from_register(src0, vm)?;
-
-    let mandated_gas = if abi.is_system_call && src1.value == ADDRESS_MSG_VALUE.into() {
-        MSG_VALUE_SIMULATOR_ADDITIVE_COST
-    } else {
-        0
-    };
+    let gas_left = vm.gas_left()?;
+    let maximum_gas =
+        gas_left / FAR_CALL_GAS_SCALAR_MODIFIER_DIVISOR * FAR_CALL_GAS_SCALAR_MODIFIER_DIVIDEND;
+    let ergs_passed = ergs_passed.min(maximum_gas);
+    vm.decrease_gas(ergs_passed)?;
 
     // mandated gas can surprass the 63/64 limit
     let ergs_passed = ergs_passed + mandated_gas;
 
-    vm.decrease_gas(ergs_passed)?;
-
     let stipend = if is_evm { EVM_SIMULATOR_STIPEND } else { 0 };
 
     let ergs_passed = (ergs_passed)
         .checked_add(stipend)
         .expect("stipend must not cause overflow");
 
-    let (program_code, was_decommited) = state.decommit(code_key);
+    let (program_code, was_decommited) = state.decommit(code_key, storage);
 
     let program_code = program_code.ok_or(StorageError::KeyNotPresent)?;
     if !was_decommited {

src/op_handlers/log.rs

@@ -6,7 +6,7 @@ use crate::{
         VmStatistics, STORAGE_READ_STORAGE_APPLICATION_CYCLES,
         STORAGE_WRITE_STORAGE_APPLICATION_CYCLES,
     },
-    store::StorageKey,
+    store::{Storage, StorageKey},
     value::TaggedValue,
     Opcode,
 };
@@ -16,6 +16,7 @@ pub fn storage_write(
     opcode: &Opcode,
     state: &mut VMState,
     statistics: &mut VmStatistics,
+    storage: &mut dyn Storage,
 ) -> Result<(), EraVmError> {
     let key_for_contract_storage = vm.get_register(opcode.src0_index).value;
     let address = vm.current_context()?.contract_address;
@@ -24,7 +25,7 @@ pub fn storage_write(
         statistics.storage_application_cycles += STORAGE_WRITE_STORAGE_APPLICATION_CYCLES;
     }
     let value = vm.get_register(opcode.src1_index).value;
-    let refund = state.storage_write(key, value);
+    let refund = state.storage_write(key, value, storage);
     vm.increase_gas(refund)?;
     Ok(())
 }
@@ -34,6 +35,7 @@ pub fn storage_read(
     opcode: &Opcode,
     state: &mut VMState,
     statistics: &mut VmStatistics,
+    storage: &mut dyn Storage,
 ) -> Result<(), EraVmError> {
     let key_for_contract_storage = vm.get_register(opcode.src0_index).value;
     let address = vm.current_context()?.contract_address;
@@ -43,7 +45,7 @@ pub fn storage_read(
     if !state.read_storage_slots().contains(&key) && !state.written_storage_slots().contains(&key) {
         statistics.storage_application_cycles += STORAGE_READ_STORAGE_APPLICATION_CYCLES;
     }
-    let (value, refund) = state.storage_read(key);
+    let (value, refund) = state.storage_read(key, storage);
     vm.increase_gas(refund)?;
     vm.set_register(opcode.dst0_index, TaggedValue::new_raw_integer(value));
     Ok(())
@@ -82,6 +84,10 @@ pub fn add_l2_to_l1_message(
 ) -> Result<(), EraVmError> {
     let key = vm_state.get_register(opcode.src0_index).value;
     let value = vm_state.get_register(opcode.src1_index).value;
+    println!(
+        "L1 TO L2 regusters indexes {} {}",
+        opcode.src0_index, opcode.src1_index
+    );
     let is_service = opcode.imm0 == 1;
     state.record_l2_to_l1_log(L2ToL1Log {
         key,

src/op_handlers/opcode_decommit.rs

@@ -6,6 +6,7 @@ use crate::{
     execution::Execution,
     state::VMState,
     statistics::{VmStatistics, STORAGE_READ_STORAGE_APPLICATION_CYCLES},
+    store::Storage,
     value::{FatPointer, TaggedValue},
     Opcode,
 };
@@ -15,6 +16,7 @@ pub fn opcode_decommit(
     opcode: &Opcode,
     state: &mut VMState,
     statistics: &mut VmStatistics,
+    storage: &mut dyn Storage,
 ) -> Result<(), EraVmError> {
     let (src0, src1) = address_operands_read(vm, opcode)?;
 
@@ -34,7 +36,7 @@ pub fn opcode_decommit(
         return Ok(());
     }
 
-    let (code, was_decommited) = state.decommit(code_hash);
+    let (code, was_decommited) = state.decommit(code_hash, storage);
     if was_decommited {
         // refund it
         vm.increase_gas(extra_cost)?;

src/state.rs

@@ -5,11 +5,7 @@ use crate::{
     },
     store::{Storage, StorageKey},
 };
-use std::{
-    cell::RefCell,
-    collections::{HashMap, HashSet},
-    rc::Rc,
-};
+use std::collections::{HashMap, HashSet};
 use u256::{H160, U256};
 use zkevm_opcode_defs::system_params::{
     STORAGE_ACCESS_COLD_READ_COST, STORAGE_ACCESS_COLD_WRITE_COST, STORAGE_ACCESS_WARM_READ_COST,
@@ -41,7 +37,6 @@ pub struct Event {
 
 #[derive(Debug, Clone)]
 pub struct VMState {
-    pub storage: Rc<RefCell<dyn Storage>>,
     storage_changes: RollbackableHashMap<StorageKey, U256>,
     transient_storage: RollbackableHashMap<StorageKey, U256>,
     l2_to_l1_logs: RollbackableVec<L2ToL1Log>,
@@ -59,10 +54,15 @@ pub struct VMState {
     decommitted_hashes: RollbackableHashSet<U256>,
 }
 
+impl Default for VMState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl VMState {
-    pub fn new(storage: Rc<RefCell<dyn Storage>>) -> Self {
+    pub fn new() -> Self {
         Self {
-            storage,
             storage_changes: RollbackableHashMap::<StorageKey, U256>::default(),
             transient_storage: RollbackableHashMap::<StorageKey, U256>::default(),
             l2_to_l1_logs: RollbackableVec::<L2ToL1Log>::default(),
@@ -78,7 +78,7 @@ impl VMState {
     }
 
     pub fn reset(&mut self) {
-        *self = Self::new(self.storage.clone());
+        *self = Self::new();
     }
 
     pub fn storage_changes(&self) -> &HashMap<StorageKey, U256> {
@@ -137,13 +137,11 @@ impl VMState {
 
     // reads shouldn't be mutable, we should consider change it to a non-mutable reference
     // though that would require a refactor in the integration with the operator
-    pub fn storage_read(&mut self, key: StorageKey) -> (U256, u32) {
+    pub fn storage_read(&mut self, key: StorageKey, storage: &mut dyn Storage) -> (U256, u32) {
         let value = self
-            .storage_read_inner(&key)
+            .storage_read_inner(&key, storage)
             .map_or_else(U256::zero, |val| val);
 
-        let storage = self.storage.borrow();
-
         let refund =
             if storage.is_free_storage_slot(&key) || self.read_storage_slots.map.contains(&key) {
                 WARM_READ_REFUND
@@ -158,11 +156,14 @@ impl VMState {
         (value, refund)
     }
 
-    pub fn storage_read_with_no_refund(&mut self, key: StorageKey) -> U256 {
+    pub fn storage_read_with_no_refund(
+        &mut self,
+        key: StorageKey,
+        storage: &mut dyn Storage,
+    ) -> U256 {
         let value = self
-            .storage_read_inner(&key)
+            .storage_read_inner(&key, storage)
             .map_or_else(U256::zero, |val| val);
-        let storage = self.storage.borrow();
 
         if !storage.is_free_storage_slot(&key) && !self.read_storage_slots.map.contains(&key) {
             self.read_storage_slots.map.insert(key);
@@ -173,18 +174,21 @@ impl VMState {
         value
     }
 
-    fn storage_read_inner(&self, key: &StorageKey) -> Option<U256> {
+    fn storage_read_inner(&self, key: &StorageKey, storage: &mut dyn Storage) -> Option<U256> {
         match self.storage_changes.map.get(key) {
-            None => self.storage.borrow_mut().storage_read(key),
+            None => storage.storage_read(key),
             value => value.copied(),
         }
     }
 
-    pub fn storage_write(&mut self, key: StorageKey, value: U256) -> u32 {
+    pub fn storage_write(
+        &mut self,
+        key: StorageKey,
+        value: U256,
+        storage: &mut dyn Storage,
+    ) -> u32 {
         self.storage_changes.map.insert(key, value);
 
-        let mut storage = self.storage.borrow_mut();
-
         if storage.is_free_storage_slot(&key) {
             self.written_storage_slots.map.insert(key);
             let refund = WARM_WRITE_REFUND;
@@ -257,9 +261,9 @@ impl VMState {
     /// A tuple containing:
     /// - `Option<Vec<U256>>`: the contract bytecode
     /// - `bool`: A boolean flag indicating whether the hash was decommitted (`true` if it was newly decommitted, `false` if it had already been decommitted).
-    pub fn decommit(&mut self, hash: U256) -> (Option<Vec<U256>>, bool) {
+    pub fn decommit(&mut self, hash: U256, storage: &mut dyn Storage) -> (Option<Vec<U256>>, bool) {
         let was_decommitted = !self.decommitted_hashes.map.insert(hash);
-        (self.storage.borrow_mut().decommit(hash), was_decommitted)
+        (storage.decommit(hash), was_decommitted)
     }
 
     pub fn decommitted_hashes(&self) -> &HashSet<U256> {
@@ -274,12 +278,15 @@ impl VMState {
     /// - `StorageKey`: The key for the storage value.
     /// - `Option<U256>`: The initial value from the storage.
     /// - `U256`: The current value after the change.
-    pub fn get_storage_changes(&mut self) -> Vec<(StorageKey, Option<U256>, U256)> {
+    pub fn get_storage_changes(
+        &mut self,
+        storage: &mut dyn Storage,
+    ) -> Vec<(StorageKey, Option<U256>, U256)> {
         self.storage_changes
             .map
             .iter()
             .filter_map(|(key, value)| {
-                let initial_value = self.storage.borrow_mut().storage_read(key);
+                let initial_value = storage.storage_read(key);
                 if initial_value.unwrap_or_default() == *value {
                     None
                 } else {
@@ -302,12 +309,13 @@ impl VMState {
     pub fn get_storage_changes_from_snapshot(
         &self,
         snapshot: <RollbackableHashMap<StorageKey, U256> as Rollbackable>::Snapshot,
+        storage: &mut dyn Storage,
     ) -> Vec<(StorageKey, Option<U256>, U256, bool)> {
         self.storage_changes
             .get_logs_after_snapshot(snapshot)
             .iter()
             .map(|(key, (before, after))| {
-                let initial = self.storage.borrow_mut().storage_read(key);
+                let initial = storage.storage_read(key);
                 (*key, before.or(initial), *after, initial.is_none())
             })
             .collect()