Bal devnet 1

Cargo.toml

@@ -39,15 +39,18 @@ alloy-evm = { version = "0.25.2", path = "crates/evm", default-features = false
 alloy-op-evm = { version = "0.25.2", path = "crates/op-evm", default-features = false }
 
 # alloy
+
+alloy-eip7928 = { version = "0.2.0", default-features = false, git = "https://github.com/rakita/alloy-eips.git", rev = "734beaf" }
+
 alloy-eip2124 = { version = "0.2", default-features = false }
 alloy-chains = { version = "0.2.0", default-features = false }
-alloy-eips = { version = "1.0.34", default-features = false }
-alloy-consensus = { version = "1.0.27", default-features = false }
-alloy-primitives = { version = "1.0.0", default-features = false }
-alloy-sol-types = { version = "1.0.0", default-features = false }
-alloy-hardforks = { version = "0.4.2" }
-alloy-rpc-types-eth = { version = "1.0.27", default-features = false }
-alloy-rpc-types-engine = { version = "1.0.27", default-features = false }
+alloy-eips = { version = "1.1.3", default-features = false }
+alloy-consensus = { version = "1.1.3", default-features = false }
+alloy-primitives = { version = "1.4.1", default-features = false }
+alloy-sol-types = { version = "1.4.1", default-features = false }
+alloy-rpc-types-eth = { version = "1.1.3", default-features = false }
+alloy-rpc-types-engine = { version = "1.1.3", default-features = false }
+alloy-hardforks = { version = "0.4.3" }
 
 # op-alloy
 alloy-op-hardforks = { version = "0.4.2" }
@@ -56,20 +59,22 @@ op-alloy = { version = "0.23", default-features = false, features = [
 ] }
 
 # revm
-revm = { version = "33.0.0", default-features = false }
-op-revm = { version = "14.0.0", default-features = false }
+revm = { version = "33.1.0", default-features = false }
+op-revm = { version = "14.1.0", default-features = false }
 
 # misc
 auto_impl = "1"
 derive_more = { version = "2", default-features = false, features = ["full"] }
 serde = { version = "1", default-features = false, features = ["derive"] }
 thiserror = { version = "2.0.0", default-features = false }
 serde_json = "1"
+tracing = { version = "0.1.41", default-features = false }
 test-case = "3"
 
 [patch.crates-io]
-# revm = { git = "https://github.com/bluealloy/revm", rev = "11b16259" }
-# op-revm = { git = "https://github.com/bluealloy/revm", rev = "11b16259" }
-
-#alloy-hardforks = { git = "https://github.com/alloy-rs/hardforks", rev = "0fd230f5aa24c4f6a8c593918b7449df0c20f60a" }
-#alloy-op-hardforks = { git = "https://github.com/alloy-rs/hardforks", rev = "0fd230f5aa24c4f6a8c593918b7449df0c20f60a" }
+revm = { git = "https://github.com/bluealloy/revm.git", branch = "rakita/bal" }
+op-revm = { git = "https://github.com/bluealloy/revm.git", branch = "rakita/bal" }
+alloy-eips = { git = "https://github.com/Soubhik-10/alloy", branch = "bal-devnet-1" }
+alloy-consensus = { git = "https://github.com/Soubhik-10/alloy", branch = "bal-devnet-1" }
+alloy-rpc-types-eth = { git = "https://github.com/Soubhik-10/alloy", branch = "bal-devnet-1" }
+alloy-rpc-types-engine = { git = "https://github.com/Soubhik-10/alloy", branch = "bal-devnet-1" }

crates/evm/Cargo.toml

@@ -23,6 +23,9 @@ alloy-op-hardforks = { workspace = true, optional = true }
 alloy-rpc-types-eth = { workspace = true, optional = true }
 alloy-rpc-types-engine = { workspace = true, optional = true }
 
+tracing.workspace = true
+# alloy-eip7928.workspace = true
+
 revm.workspace = true
 op-revm = { workspace = true, optional = true }
 op-alloy = { workspace = true, optional = true }
@@ -38,22 +41,20 @@ test-case.workspace = true
 
 [features]
 default = ["std"]
-secp256k1 = [
-    "std",
-    "alloy-consensus/secp256k1",
-]
+secp256k1 = ["std", "alloy-consensus/secp256k1"]
 std = [
-	"alloy-primitives/std",
-	"revm/std",
-	"alloy-consensus/std",
-	"alloy-eips/std",
-	"alloy-sol-types/std",
-	"derive_more/std",
-	"op-revm?/std",
-	"thiserror/std",
-	"op-alloy?/std",
-	"alloy-rpc-types-eth?/std",
-	"alloy-rpc-types-engine?/std"
+    "alloy-primitives/std",
+    "revm/std",
+    "alloy-consensus/std",
+    "alloy-eips/std",
+    "alloy-sol-types/std",
+    "derive_more/std",
+    "op-revm?/std",
+    "thiserror/std",
+    "op-alloy?/std",
+    "alloy-rpc-types-eth?/std",
+    "alloy-rpc-types-engine?/std",
+    "tracing/std",
 ]
 op = ["op-revm", "op-alloy", "alloy-op-hardforks"]
 overrides = ["dep:alloy-rpc-types-eth"]

crates/evm/src/block/mod.rs

@@ -2,12 +2,11 @@
 
 use crate::{Database, Evm, EvmFactory, FromRecoveredTx, FromTxWithEncoded, RecoveredTx, ToTxEnv};
 use alloc::{boxed::Box, vec::Vec};
-use alloy_eips::eip7685::Requests;
+use alloy_eips::{eip7685::Requests, eip7928::BlockAccessList};
 use revm::{
     context::result::{ExecutionResult, ResultAndState},
-    database::State,
     inspector::NoOpInspector,
-    Inspector,
+    DatabaseCommit, Inspector,
 };
 
 mod error;
@@ -37,6 +36,8 @@ pub struct BlockExecutionResult<T> {
     pub gas_used: u64,
     /// Blob gas used by the block.
     pub blob_gas_used: u64,
+    /// Block Access List of the block
+    pub block_access_list: Option<BlockAccessList>,
 }
 
 /// Helper trait to encapsulate requirements for a type to be used as input for [`BlockExecutor`].
@@ -328,22 +329,22 @@ pub trait BlockExecutor {
 pub trait BlockExecutorFor<'a, F: BlockExecutorFactory + ?Sized, DB, I = NoOpInspector>
 where
     Self: BlockExecutor<
-        Evm = <F::EvmFactory as EvmFactory>::Evm<&'a mut State<DB>, I>,
+        Evm = <F::EvmFactory as EvmFactory>::Evm<DB, I>,
         Transaction = F::Transaction,
         Receipt = F::Receipt,
     >,
-    DB: Database + 'a,
-    I: Inspector<<F::EvmFactory as EvmFactory>::Context<&'a mut State<DB>>> + 'a,
+    DB: StateDB + Database + 'a,
+    I: Inspector<<F::EvmFactory as EvmFactory>::Context<DB>> + 'a,
 {
 }
 
 impl<'a, F, DB, I, T> BlockExecutorFor<'a, F, DB, I> for T
 where
     F: BlockExecutorFactory,
-    DB: Database + 'a,
-    I: Inspector<<F::EvmFactory as EvmFactory>::Context<&'a mut State<DB>>> + 'a,
+    DB: StateDB + Database + 'a,
+    I: Inspector<<F::EvmFactory as EvmFactory>::Context<DB>> + 'a,
     T: BlockExecutor<
-        Evm = <F::EvmFactory as EvmFactory>::Evm<&'a mut State<DB>, I>,
+        Evm = <F::EvmFactory as EvmFactory>::Evm<DB, I>,
         Transaction = F::Transaction,
         Receipt = F::Receipt,
     >,
@@ -467,10 +468,10 @@ pub trait BlockExecutorFactory: 'static {
     /// ```
     fn create_executor<'a, DB, I>(
         &'a self,
-        evm: <Self::EvmFactory as EvmFactory>::Evm<&'a mut State<DB>, I>,
+        evm: <Self::EvmFactory as EvmFactory>::Evm<DB, I>,
         ctx: Self::ExecutionCtx<'a>,
     ) -> impl BlockExecutorFor<'a, Self, DB, I>
     where
-        DB: Database + 'a,
-        I: Inspector<<Self::EvmFactory as EvmFactory>::Context<&'a mut State<DB>>> + 'a;
+        DB: StateDB + DatabaseCommit + Database + 'a,
+        I: Inspector<<Self::EvmFactory as EvmFactory>::Context<DB>> + 'a;
 }

crates/evm/src/block/state.rs

@@ -1,7 +1,10 @@
 //! State database abstraction.
 
-use alloy_primitives::Address;
-use revm::database::State;
+use alloy_eips::eip7928::BlockAccessList;
+use revm::{
+    database::{states::bundle_state::BundleRetention, BundleState, State},
+    state::bal::Bal,
+};
 
 /// A type which has the state of the blockchain.
 ///
@@ -10,18 +13,30 @@ pub trait StateDB: revm::Database {
     /// State clear EIP-161 is enabled in Spurious Dragon hardfork.
     fn set_state_clear_flag(&mut self, has_state_clear: bool);
 
-    /// Iterates over received balances and increment all account balances.
-    ///
-    /// **Note**: If account is not found inside cache state it will be loaded from database.
-    ///
-    /// Update will create transitions for all accounts that are updated.
-    ///
-    /// If using this to implement withdrawals, zero balances must be filtered out before calling
-    /// this function.
-    fn increment_balances(
-        &mut self,
-        balances: impl IntoIterator<Item = (Address, u128)>,
-    ) -> Result<(), Self::Error>;
+    /// Gets a reference to the internal [`BundleState`]
+    fn bundle_state(&self) -> &BundleState;
+
+    /// Gets a mutable reference to the internal [`BundleState`]
+    fn bundle_state_mut(&mut self) -> &mut BundleState;
+
+    /// If the `State` has been built with the
+    /// [`revm::database::StateBuilder::with_bundle_prestate`] option, the pre-state will be
+    /// taken along with any changes made by [`StateDB::merge_transitions`].
+    fn take_bundle(&mut self) -> BundleState {
+        core::mem::take(self.bundle_state_mut())
+    }
+
+    /// Take all transitions and merge them inside [`BundleState`].
+    /// This action will create final post state and all reverts so that
+    /// we at any time revert state of bundle to the state before transition
+    /// is applied.
+    fn merge_transitions(&mut self, retention: BundleRetention);
+
+    /// Increments the internal BAL index used for tracking BAL transfers.
+    fn bump_bal_index(&mut self);
+
+    /// Takes the built Alloy BAL access list, if any.
+    fn take_built_alloy_bal(&mut self) -> Option<BlockAccessList>;
 }
 
 /// auto_impl unable to reconcile return associated type from supertrait
@@ -30,23 +45,50 @@ impl<T: StateDB> StateDB for &mut T {
         StateDB::set_state_clear_flag(*self, has_state_clear);
     }
 
-    fn increment_balances(
-        &mut self,
-        balances: impl IntoIterator<Item = (Address, u128)>,
-    ) -> Result<(), Self::Error> {
-        StateDB::increment_balances(*self, balances)
+    fn bundle_state(&self) -> &BundleState {
+        StateDB::bundle_state(*self)
+    }
+
+    fn bundle_state_mut(&mut self) -> &mut BundleState {
+        StateDB::bundle_state_mut(*self)
+    }
+
+    fn merge_transitions(&mut self, retention: BundleRetention) {
+        StateDB::merge_transitions(*self, retention);
+    }
+
+    fn bump_bal_index(&mut self) {
+        StateDB::bump_bal_index(*self);
+    }
+
+    fn take_built_alloy_bal(&mut self) -> Option<BlockAccessList> {
+        StateDB::take_built_alloy_bal(*self)
     }
 }
 
 impl<DB: revm::Database> StateDB for State<DB> {
     fn set_state_clear_flag(&mut self, has_state_clear: bool) {
-        self.cache.set_state_clear_flag(has_state_clear);
+        Self::set_state_clear_flag(self, has_state_clear);
     }
 
-    fn increment_balances(
-        &mut self,
-        balances: impl IntoIterator<Item = (Address, u128)>,
-    ) -> Result<(), Self::Error> {
-        Self::increment_balances(self, balances)
+    fn bundle_state(&self) -> &BundleState {
+        &self.bundle_state
+    }
+
+    fn bundle_state_mut(&mut self) -> &mut BundleState {
+        &mut self.bundle_state
+    }
+    fn merge_transitions(&mut self, retention: BundleRetention) {
+        Self::merge_transitions(self, retention);
+    }
+    fn bump_bal_index(&mut self) {
+        let bal_index = self.bal_state.bump_bal_index();
+        bal_index
+    }
+    fn take_built_alloy_bal(&mut self) -> Option<BlockAccessList> {
+        let bal = self.bal_state.take_built_alloy_bal();
+        tracing::debug!("bal : {:?}", bal);
+        self.bal_state.bal_builder = Some(Bal::new());
+        bal
     }
 }

crates/evm/src/block/state_changes.rs

@@ -1,6 +1,7 @@
 //! State changes that are not related to transactions.
 
 use super::{calc, BlockExecutionError};
+use alloc::boxed::Box;
 use alloy_consensus::BlockHeader;
 use alloy_eips::eip4895::{Withdrawal, Withdrawals};
 use alloy_hardforks::EthereumHardforks;
@@ -95,10 +96,8 @@ pub fn insert_post_block_withdrawals_balance_increments(
     if spec.is_shanghai_active_at_timestamp(block_timestamp) {
         if let Some(withdrawals) = withdrawals {
             for withdrawal in withdrawals {
-                if withdrawal.amount > 0 {
-                    *balance_increments.entry(withdrawal.address).or_default() +=
-                        withdrawal.amount_wei().to::<u128>();
-                }
+                *balance_increments.entry(withdrawal.address).or_default() +=
+                    withdrawal.amount_wei().to::<u128>();
             }
         }
     }
@@ -114,6 +113,7 @@ pub fn balance_increment_state<DB>(
 where
     DB: Database,
 {
+    tracing::debug!("Entered balance incr fn");
     let mut load_account = |address: &Address| -> Result<(Address, Account), BlockExecutionError> {
         let cache_account = state.basic(*address).map_err(|_| {
             BlockExecutionError::msg("could not load account for balance increment")
@@ -130,13 +130,16 @@ where
                 storage: Default::default(),
                 status: AccountStatus::Touched,
                 transaction_id: 0,
+                original_info: Box::new(account.clone()),
             },
         ))
     };
 
-    balance_increments
+    let evm_state = balance_increments
         .iter()
         .filter(|(_, &balance)| balance != 0)
         .map(|(addr, _)| load_account(addr))
-        .collect::<Result<EvmState, _>>()
+        .collect::<Result<EvmState, _>>();
+    tracing::debug!("Created balance increment state for {:?} accounts", evm_state);
+    evm_state
 }