revert changes made by exceeding blob size

Author: tomip01

crates/vm/backends/levm/l2_utils.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use ethrex_common::{
-    types::{Receipt, Transaction, TxKind, SAFE_BYTES_PER_BLOB},
+    types::{Log, Transaction, TxKind, SAFE_BYTES_PER_BLOB},
     H256,
 };
 use ethrex_levm::db::gen_db::GeneralizedDatabase;
@@ -79,14 +79,14 @@ pub fn has_nonce_changed(
 pub fn update_state_diff_size(
     acc_state_diff_size: &mut Option<usize>,
     tx: &Transaction,
-    receipt: &Receipt,
+    logs: &[Log],
     db: &GeneralizedDatabase,
 ) -> Result<(), EvmError> {
     if acc_state_diff_size.is_none() {
         return Ok(());
     }
     let mut actual_size = 0;
-    if is_withdrawal_l2(tx, receipt)? {
+    if is_withdrawal_l2(tx, logs)? {
         actual_size += L2_WITHDRAWAL_SIZE;
     }
     if is_deposit_l2(tx) {
@@ -107,14 +107,14 @@ pub fn update_state_diff_size(
     Ok(())
 }
 
-fn is_withdrawal_l2(tx: &Transaction, receipt: &Receipt) -> Result<bool, EvmError> {
+fn is_withdrawal_l2(tx: &Transaction, logs: &[Log]) -> Result<bool, EvmError> {
     // WithdrawalInitiated(address,address,uint256)
     let withdrawal_event_selector: H256 =
         H256::from_str("bb2689ff876f7ef453cf8865dde5ab10349d222e2e1383c5152fbdb083f02da2")
             .map_err(|e| EvmError::Custom(e.to_string()))?;
 
     let is_withdrawal = match tx.to() {
-        TxKind::Call(to) if to == *COMMON_BRIDGE_L2_ADDRESS => receipt.logs.iter().any(|log| {
+        TxKind::Call(to) if to == *COMMON_BRIDGE_L2_ADDRESS => logs.iter().any(|log| {
             log.topics
                 .iter()
                 .any(|topic| *topic == withdrawal_event_selector)

crates/vm/backends/levm/mod.rs

@@ -145,6 +145,83 @@ impl LEVM {
 
         vm.execute().map_err(VMError::into)
     }
+
+    pub fn execute_tx_l2(
+        // The transaction to execute.
+        tx: &Transaction,
+        // The transactions recovered address
+        tx_sender: Address,
+        // The block header for the current block.
+        block_header: &BlockHeader,
+        db: &mut GeneralizedDatabase,
+        acc_state_diff_size: &mut Option<usize>,
+    ) -> Result<ExecutionReport, EvmError> {
+        let chain_config = db.store.get_chain_config();
+        let gas_price: U256 = tx
+            .effective_gas_price(block_header.base_fee_per_gas)
+            .ok_or(VMError::TxValidation(
+                TxValidationError::InsufficientMaxFeePerGas,
+            ))?
+            .into();
+
+        let config = EVMConfig::new_from_chain_config(&chain_config, block_header);
+        let env = Environment {
+            origin: tx_sender,
+            refunded_gas: 0,
+            gas_limit: tx.gas_limit(),
+            config,
+            block_number: block_header.number.into(),
+            coinbase: block_header.coinbase,
+            timestamp: block_header.timestamp.into(),
+            prev_randao: Some(block_header.prev_randao),
+            chain_id: chain_config.chain_id.into(),
+            base_fee_per_gas: block_header.base_fee_per_gas.unwrap_or_default().into(),
+            gas_price,
+            block_excess_blob_gas: block_header.excess_blob_gas.map(U256::from),
+            block_blob_gas_used: block_header.blob_gas_used.map(U256::from),
+            tx_blob_hashes: tx.blob_versioned_hashes(),
+            tx_max_priority_fee_per_gas: tx.max_priority_fee().map(U256::from),
+            tx_max_fee_per_gas: tx.max_fee_per_gas().map(U256::from),
+            tx_max_fee_per_blob_gas: tx.max_fee_per_blob_gas().map(U256::from),
+            tx_nonce: tx.nonce(),
+            block_gas_limit: block_header.gas_limit,
+            transient_storage: HashMap::new(),
+            difficulty: block_header.difficulty,
+            is_privileged: matches!(tx, Transaction::PrivilegedL2Transaction(_)),
+        };
+
+        let mut vm = VM::new(env, db, tx)?;
+
+        let report = vm.execute().map_err(EvmError::from)?;
+
+        // Here we differ from the execute_tx function from the L1.
+        // We need to check if the transaction exceeded the blob size limit.
+        // If it did, we need to revert the state changes made by the transaction and return the error.
+        let call_frame_backup = vm
+            .call_frames
+            .pop()
+            .ok_or(VMError::OutOfBounds)?
+            .call_frame_backup;
+
+        if let Err(e) = update_state_diff_size(acc_state_diff_size, tx, &report.logs, db) {
+            for (address, account) in call_frame_backup.original_accounts_info {
+                if let Some(current_account) = db.cache.get_mut(&address) {
+                    current_account.info = account.info;
+                    current_account.code = account.code;
+                }
+            }
+            for (address, storage) in call_frame_backup.original_account_storage_slots {
+                let account = db.cache.get_mut(&address).ok_or(VMError::InvalidBytecode)?;
+                for (key, value) in storage {
+                    account.storage.insert(key, value);
+                }
+            }
+            return Err(e);
+        }
+
+        Ok(report)
+    }
+
     pub fn simulate_tx_from_generic(
         // The transaction to execute.
         tx: &GenericTransaction,

crates/vm/backends/mod.rs

@@ -15,7 +15,7 @@ use ethrex_levm::db::gen_db::GeneralizedDatabase;
 use ethrex_levm::db::CacheDB;
 use ethrex_storage::Store;
 use ethrex_storage::{error::StoreError, AccountUpdate};
-use levm::{update_state_diff_size, LEVM};
+use levm::LEVM;
 use revm::db::EvmState;
 use revm::REVM;
 use std::sync::Arc;
@@ -185,7 +185,8 @@ impl Evm {
                 Ok((receipt, execution_result.gas_used()))
             }
             Evm::LEVM { db } => {
-                let execution_report = LEVM::execute_tx(tx, sender, block_header, db)?;
+                let execution_report =
+                    LEVM::execute_tx_l2(tx, sender, block_header, db, acc_state_diff_size)?;
 
                 *remaining_gas = remaining_gas.saturating_sub(execution_report.gas_used);
 
@@ -196,8 +197,6 @@ impl Evm {
                     execution_report.logs.clone(),
                 );
 
-                update_state_diff_size(acc_state_diff_size, tx, &receipt, db)?;
-
                 Ok((receipt, execution_report.gas_used))
             }
         }

crates/vm/levm/src/vm.rs

@@ -389,6 +389,11 @@ impl<'a> VM<'a> {
             return Err(e);
         }
 
+        // Here we need to backup the callframe because in the L2 we want to revert a transaction if it exceeds blob size
+        // even if the transaction succeeds.
+        #[cfg(feature = "l2")]
+        let callframe_backup = self.current_call_frame()?.call_frame_backup.clone();
+
         // Here we clear the cache backup because if prepare_execution succeeded we don't want to
         // revert the changes it made.
         // Even if the transaction reverts we want to apply these kind of changes!
@@ -429,6 +434,21 @@ impl<'a> VM<'a> {
         let mut report = self.run_execution()?;
 
         self.finalize_execution(&mut report)?;
+
+        // We want to restore to the initial state, this includes reverting the changes made by the prepare execution
+        // and the changes made by the execution itself.
+        #[cfg(feature = "l2")]
+        {
+            let current_backup = &mut self.current_call_frame_mut()?.call_frame_backup;
+            for (addr, acc) in callframe_backup.original_accounts_info {
+                current_backup.original_accounts_info.insert(addr, acc);
+            }
+            for (addr, storage) in callframe_backup.original_account_storage_slots {
+                current_backup
+                    .original_account_storage_slots
+                    .insert(addr, storage);
+            }
+        }
         Ok(report)
     }