feat: BAL EIP-7928

Cargo.toml

@@ -60,6 +60,7 @@ ee-tests = { path = "crates/ee-tests", package = "revm-ee-tests", version = "0.1
 # alloy
 alloy-eip2930 = { version = "0.2.1", default-features = false }
 alloy-eip7702 = { version = "0.6.1", default-features = false }
+alloy-eip7928 = { version = "0.1.0", default-features = false, git = "https://github.com/alloy-rs/eips.git" }
 alloy-primitives = { version = "1.3.1", default-features = false }
 
 # alloy in examples, revme or feature flagged.

bins/revme/src/cmd/blockchaintest.rs

@@ -11,7 +11,7 @@ use revm::{
     handler::EvmTr,
     inspector::inspectors::TracerEip3155,
     primitives::{hardfork::SpecId, hex, Address, HashMap, U256},
-    state::AccountInfo,
+    state::{bal::Bal, AccountInfo},
     Context, Database, ExecuteCommitEvm, ExecuteEvm, InspectEvm, MainBuilder, MainContext,
 };
 use serde_json::json;
@@ -22,6 +22,7 @@ use std::{
     collections::BTreeMap,
     fs,
     path::{Path, PathBuf},
+    sync::Arc,
     time::Instant,
 };
 use thiserror::Error;
@@ -654,7 +655,7 @@ fn execute_blockchain_test(
     }
 
     // Create database with initial state
-    let mut state = State::builder().build();
+    let mut state = State::builder().with_bal_builder().build();
 
     // Capture pre-state for debug info
     let mut pre_state_debug = HashMap::default();
@@ -667,6 +668,7 @@ fn execute_blockchain_test(
             nonce: account.nonce,
             code_hash: revm::primitives::keccak256(&account.code),
             code: Some(Bytecode::new_raw(account.code.clone())),
+            storage_id: None,
         };
 
         // Store for debug info
@@ -723,6 +725,15 @@ fn execute_blockchain_test(
             this_excess_blob_gas = None;
         }
 
+        let bal_test = block
+            .block_access_list
+            .as_ref()
+            .and_then(|bal| Bal::try_from(bal.clone()).ok())
+            .map(Arc::new);
+
+        //state.set_bal(bal_test);
+        state.reset_bal_index();
+
         // Create EVM context for each transaction to ensure fresh state access
         let evm_context = Context::mainnet()
             .with_block(&block_env)
@@ -808,6 +819,9 @@ fn execute_blockchain_test(
                 }
             };
 
+            // bump bal index
+            evm.db_mut().bump_bal_index();
+
             // If JSON output requested, output transaction details
             let execution_result = if json_output {
                 evm.inspect_tx(tx_env.clone())
@@ -917,6 +931,9 @@ fn execute_blockchain_test(
             }
         }
 
+        // bump bal index
+        evm.db_mut().bump_bal_index();
+
         // uncle rewards are not implemented yet
         post_block::post_block_transition(
             &mut evm,
@@ -930,6 +947,19 @@ fn execute_blockchain_test(
             .block_hashes
             .insert(block_env.number.to::<u64>(), block_hash.unwrap_or_default());
 
+        if let Some(bal) = state.bal_state.bal_builder.take() {
+            if let Some(state_bal) = bal_test {
+                if &bal != state_bal.as_ref() {
+                    println!("Bal mismatch");
+                    println!("Test bal");
+                    state_bal.pretty_print();
+                    println!("Bal:");
+                    bal.pretty_print();
+                    return Err(TestExecutionError::BalMismatchError);
+                }
+            }
+        }
+
         parent_block_hash = block_hash;
         if let Some(excess_blob_gas) = this_excess_blob_gas {
             parent_excess_blob_gas = excess_blob_gas;
@@ -983,7 +1013,8 @@ fn fork_to_spec_id(fork: ForkSpec) -> SpecId {
         ForkSpec::Cancun | ForkSpec::ShanghaiToCancunAtTime15k => SpecId::CANCUN,
         ForkSpec::Prague | ForkSpec::CancunToPragueAtTime15k => SpecId::PRAGUE,
         ForkSpec::Osaka | ForkSpec::PragueToOsakaAtTime15k => SpecId::OSAKA,
-        _ => SpecId::OSAKA, // For any unknown forks, use latest available
+        ForkSpec::Amsterdam => SpecId::AMSTERDAM,
+        _ => SpecId::AMSTERDAM, // For any unknown forks, use latest available
     }
 }
 
@@ -1088,6 +1119,9 @@ pub enum TestExecutionError {
         gas_used: u64,
     },
 
+    #[error("BAL error")]
+    BalMismatchError,
+
     #[error(
         "Post-state validation failed for {address:?}.{field}: expected {expected}, got {actual}"
     )]

bins/revme/src/cmd/blockchaintest/post_block.rs

@@ -1,25 +1,24 @@
 use revm::{
-    context::{Block, ContextTr},
-    database::{DatabaseCommitExt as _, State},
+    context::{Block, ContextTr, JournalTr},
     handler::EvmTr,
-    primitives::{hardfork::SpecId, ONE_ETHER, ONE_GWEI},
-    Database, SystemCallCommitEvm,
+    primitives::{address, hardfork::SpecId, Address, Bytes, ONE_ETHER, ONE_GWEI, U256},
+    Database, DatabaseCommit, SystemCallCommitEvm,
 };
 use statetest_types::blockchain::Withdrawal;
 
 /// Post block transition that includes:
 ///   * Block and uncle rewards before the Merge/Paris hardfork.
-///   * system calls
+///   * Withdrawals (EIP-4895)
+///   * Post-block system calls: EIP-7002 (withdrawal requests) and EIP-7251 (consolidation requests)
 ///
 /// # Note
 ///
 /// Uncle rewards are not implemented yet.
 #[inline]
 pub fn post_block_transition<
     'a,
-    DB: Database + 'a,
-    EVM: SystemCallCommitEvm<Error: core::fmt::Debug>
-        + EvmTr<Context: ContextTr<Db = &'a mut State<DB>>>,
+    DB: Database + DatabaseCommit + 'a,
+    EVM: SystemCallCommitEvm<Error: core::fmt::Debug> + EvmTr<Context: ContextTr<Db = DB>>,
 >(
     evm: &mut EVM,
     block: impl Block,
@@ -29,24 +28,36 @@ pub fn post_block_transition<
     // block reward
     let block_reward = block_reward(spec, 0);
     if block_reward != 0 {
-        let _ = evm
-            .ctx_mut()
-            .db_mut()
-            .increment_balances(vec![(block.beneficiary(), block_reward)]);
+        evm.ctx_mut()
+            .journal_mut()
+            .balance_incr(block.beneficiary(), U256::from(block_reward))
+            .expect("Db actions to pass");
     }
 
     // withdrawals
     if spec.is_enabled_in(SpecId::SHANGHAI) {
         for withdrawal in withdrawals {
             evm.ctx_mut()
-                .db_mut()
-                .increment_balances(vec![(
+                .journal_mut()
+                .balance_incr(
                     withdrawal.address,
-                    withdrawal.amount.to::<u128>().saturating_mul(ONE_GWEI),
-                )])
+                    withdrawal.amount.saturating_mul(U256::from(ONE_GWEI)),
+                )
                 .expect("Db actions to pass");
         }
     }
+
+    evm.commit_inner();
+
+    // EIP-7002: Withdrawal requests system call
+    if spec.is_enabled_in(SpecId::PRAGUE) {
+        system_call_eip7002_withdrawal_request(evm);
+    }
+
+    // EIP-7251: Consolidation requests system call
+    if spec.is_enabled_in(SpecId::PRAGUE) {
+        system_call_eip7251_consolidation_request(evm);
+    }
 }
 
 /// Block reward for a block.
@@ -66,3 +77,34 @@ pub const fn block_reward(spec: SpecId, ommers: usize) -> u128 {
 
     reward + (reward >> 5) * ommers as u128
 }
+
+pub const WITHDRAWAL_REQUEST_ADDRESS: Address =
+    address!("0x00000961Ef480Eb55e80D19ad83579A64c007002");
+
+/// EIP-7002: Withdrawal requests system call
+pub(crate) fn system_call_eip7002_withdrawal_request(
+    evm: &mut impl SystemCallCommitEvm<Error: core::fmt::Debug>,
+) {
+    // empty data is valid for EIP-7002
+    let _ = match evm.system_call_commit(WITHDRAWAL_REQUEST_ADDRESS, Bytes::new()) {
+        Ok(res) => res,
+        Err(e) => {
+            panic!("System call failed: {e:?}");
+        }
+    };
+}
+
+pub const CONSOLIDATION_REQUEST_ADDRESS: Address =
+    address!("0x0000BBdDc7CE488642fb579F8B00f3a590007251");
+
+/// EIP-7251: Consolidation requests system call
+pub(crate) fn system_call_eip7251_consolidation_request(
+    evm: &mut impl SystemCallCommitEvm<Error: core::fmt::Debug>,
+) {
+    let _ = match evm.system_call_commit(CONSOLIDATION_REQUEST_ADDRESS, Bytes::new()) {
+        Ok(res) => res,
+        Err(e) => {
+            panic!("System call failed: {e:?}");
+        }
+    };
+}

bins/revme/src/cmd/blockchaintest/pre_block.rs

@@ -2,22 +2,21 @@
 
 use revm::{
     context::{Block, ContextTr},
-    database::{Database, State},
+    database::Database,
     handler::EvmTr,
     primitives::{address, hardfork::SpecId, Address, B256},
-    SystemCallCommitEvm,
+    DatabaseCommit, SystemCallCommitEvm,
 };
 
 /// Pre block state transition
 ///
 /// # Note
 ///
-/// Contains only withdrawal processing. And it is missing block hash system call.
+/// Contains pre-block system calls: EIP-2935 (blockhash) and EIP-4788 (beacon root).
 pub fn pre_block_transition<
     'a,
-    DB: Database + 'a,
-    EVM: SystemCallCommitEvm<Error: core::fmt::Debug>
-        + EvmTr<Context: ContextTr<Db = &'a mut State<DB>>>,
+    DB: Database + DatabaseCommit + 'a,
+    EVM: SystemCallCommitEvm<Error: core::fmt::Debug> + EvmTr<Context: ContextTr<Db = DB>>,
 >(
     evm: &mut EVM,
     spec: SpecId,
@@ -31,11 +30,15 @@ pub fn pre_block_transition<
 
     // blockhash system call
     if let Some(parent_block_hash) = parent_block_hash {
-        system_call_eip2935_blockhash(spec, parent_block_hash, evm);
+        if spec.is_enabled_in(SpecId::PRAGUE) {
+            system_call_eip2935_blockhash(evm, parent_block_hash);
+        }
     }
 
     if let Some(parent_beacon_block_root) = parent_beacon_block_root {
-        system_call_eip4788_beacon_root(spec, parent_beacon_block_root, evm);
+        if spec.is_enabled_in(SpecId::CANCUN) {
+            system_call_eip4788_beacon_root(evm, parent_beacon_block_root);
+        }
     }
 }
 
@@ -44,42 +47,28 @@ pub const HISTORY_STORAGE_ADDRESS: Address = address!("0x0000F90827F1C53a10cb7A0
 /// Blockhash system callEIP-2935
 #[inline]
 pub(crate) fn system_call_eip2935_blockhash(
-    spec: SpecId,
-    parent_block_hash: B256,
     evm: &mut impl SystemCallCommitEvm<Error: core::fmt::Debug>,
-) -> bool {
-    if !spec.is_enabled_in(SpecId::PRAGUE) {
-        return true;
-    }
-
+    parent_block_hash: B256,
+) {
     let _ = match evm.system_call_commit(HISTORY_STORAGE_ADDRESS, parent_block_hash.0.into()) {
         Ok(res) => res,
         Err(e) => {
             panic!("System call failed: {e:?}");
         }
     };
-
-    true
 }
 
 pub const BEACON_ROOTS_ADDRESS: Address = address!("000F3df6D732807Ef1319fB7B8bB8522d0Beac02");
 
 /// Beacon root system call EIP-4788
 pub(crate) fn system_call_eip4788_beacon_root(
-    spec: SpecId,
-    parent_beacon_block_root: B256,
     evm: &mut impl SystemCallCommitEvm<Error: core::fmt::Debug>,
-) -> bool {
-    if !spec.is_enabled_in(SpecId::CANCUN) {
-        return true;
-    }
-
+    parent_beacon_block_root: B256,
+) {
     let _ = match evm.system_call_commit(BEACON_ROOTS_ADDRESS, parent_beacon_block_root.0.into()) {
         Ok(res) => res,
         Err(e) => {
             panic!("System call failed: {e:?}");
         }
     };
-
-    true
 }

bins/revme/src/cmd/statetest/runner.rs

@@ -437,6 +437,7 @@ fn execute_single_test(ctx: TestExecutionContext) -> Result<(), TestErrorKind> {
     };
     *ctx.elapsed.lock().unwrap() += timer.elapsed();
 
+    let exec_result = exec_result.map_err(|b| b.map_db_err(|db| db.into_db_error()));
     // Check results
     check_evm_execution(
         ctx.test,