feat: implement bal specific rpc methods

crates/ethereum/node/Cargo.toml

@@ -65,6 +65,7 @@ reth-stages-types.workspace = true
 tempfile.workspace = true
 jsonrpsee-core.workspace = true
 
+alloy-eip7928.workspace = true
 alloy-primitives.workspace = true
 alloy-provider.workspace = true
 alloy-genesis.workspace = true

crates/rpc/rpc-api/Cargo.toml

@@ -20,7 +20,6 @@ reth-trie-common.workspace = true
 reth-chain-state.workspace = true
 
 # ethereum
-alloy-eip7928 = { workspace = true, features = ["serde"] }
 alloy-eips.workspace = true
 alloy-json-rpc.workspace = true
 alloy-primitives.workspace = true

crates/rpc/rpc-api/src/debug.rs

@@ -1,4 +1,3 @@
-use alloy_eip7928::BlockAccessList;
 use alloy_eips::{BlockId, BlockNumberOrTag};
 use alloy_genesis::ChainConfig;
 use alloy_json_rpc::RpcObject;
@@ -157,9 +156,10 @@ pub trait DebugApi<TxReq: RpcObject> {
         hash: B256,
     ) -> RpcResult<ExecutionWitness>;
 
-    /// Re-executes a block and returns the Block Access List (BAL) as defined in EIP-7928.
+    /// Re-executes a block and returns the RLP-encoded Block Access List (BAL) as defined in
+    /// EIP-7928.
     #[method(name = "getBlockAccessList")]
-    async fn debug_get_block_access_list(&self, block_id: BlockId) -> RpcResult<BlockAccessList>;
+    async fn debug_get_block_access_list(&self, block_id: BlockId) -> RpcResult<Bytes>;
 
     /// Sets the logging backtrace location. When a backtrace location is set and a log message is
     /// emitted at that location, the stack of the goroutine executing the log statement will

crates/rpc/rpc-eth-api/Cargo.toml

@@ -58,6 +58,7 @@ tokio.workspace = true
 auto_impl.workspace = true
 dyn-clone.workspace = true
 tracing.workspace = true
+serde_json.workspace = true
 
 [features]
 js-tracer = ["revm-inspectors/js-tracer", "reth-rpc-eth-types/js-tracer"]

crates/rpc/rpc-eth-api/src/core.rs

@@ -18,8 +18,10 @@ use alloy_serde::JsonStorageKey;
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use reth_primitives_traits::TxTy;
 use reth_rpc_convert::RpcTxReq;
-use reth_rpc_eth_types::FillTransaction;
+use reth_rpc_eth_types::{error::FromEthApiError, EthApiError, FillTransaction};
 use reth_rpc_server_types::{result::internal_rpc_err, ToRpcResult};
+use reth_storage_api::BlockIdReader;
+use serde_json::Value;
 use std::collections::HashMap;
 use tracing::trace;
 
@@ -406,14 +408,14 @@ pub trait EthApi<
 
     /// Returns the EIP-7928 block access list for a block by hash.
     #[method(name = "getBlockAccessListByBlockHash")]
-    async fn block_access_list_by_block_hash(&self, hash: B256) -> RpcResult<Option<Bytes>>;
+    async fn block_access_list_by_block_hash(&self, hash: B256) -> RpcResult<Option<Value>>;
 
     /// Returns the EIP-7928 block access list for a block by number.
     #[method(name = "getBlockAccessListByBlockNumber")]
     async fn block_access_list_by_block_number(
         &self,
         number: BlockNumberOrTag,
-    ) -> RpcResult<Option<Bytes>>;
+    ) -> RpcResult<Option<Value>>;
 }
 
 #[async_trait::async_trait]
@@ -913,17 +915,32 @@ where
     }
 
     /// Handler for: `eth_getBlockAccessListByBlockHash`
-    async fn block_access_list_by_block_hash(&self, hash: B256) -> RpcResult<Option<Bytes>> {
-        trace!(target: "rpc::eth", ?hash, "Serving eth_getBlockAccessListByBlockHash");
-        Err(internal_rpc_err("unimplemented"))
+    async fn block_access_list_by_block_hash(&self, block_hash: B256) -> RpcResult<Option<Value>> {
+        trace!(target: "rpc::eth", ?block_hash, "Serving eth_getBlockAccessListByBlockHash");
+
+        let bal = self.get_block_access_list(block_hash).await?;
+        let json = serde_json::to_value(&bal)
+            .map_err(|e| EthApiError::Internal(reth_errors::RethError::msg(e.to_string())))?;
+
+        Ok(Some(json))
     }
 
     /// Handler for: `eth_getBlockAccessListByBlockNumber`
     async fn block_access_list_by_block_number(
         &self,
         number: BlockNumberOrTag,
-    ) -> RpcResult<Option<Bytes>> {
+    ) -> RpcResult<Option<Value>> {
         trace!(target: "rpc::eth", ?number, "Serving eth_getBlockAccessListByBlockNumber");
-        Err(internal_rpc_err("unimplemented"))
+        let block_hash = self
+            .provider()
+            .block_hash_for_id(number.into())
+            .map_err(T::Error::from_eth_err)?
+            .ok_or(EthApiError::HeaderNotFound(number.into()))?;
+
+        let bal = self.get_block_access_list(block_hash).await?;
+        let json = serde_json::to_value(&bal)
+            .map_err(|e| EthApiError::Internal(reth_errors::RethError::msg(e.to_string())))?;
+
+        Ok(Some(json))
     }
 }

crates/rpc/rpc-eth-api/src/helpers/block_access_list.rs

@@ -0,0 +1,65 @@
+//! Helpers for `eth_blockAccessList` RPC method.
+use alloy_consensus::BlockHeader;
+use alloy_eips::eip7928::BlockAccessList;
+use alloy_primitives::B256;
+use reth_errors::RethError;
+use reth_evm::{block::BlockExecutor, ConfigureEvm};
+use reth_revm::{database::StateProviderDatabase, State};
+use reth_rpc_eth_types::{
+    cache::db::StateProviderTraitObjWrapper, error::FromEthApiError, EthApiError,
+};
+use reth_storage_api::StateProviderFactory;
+
+use crate::{
+    helpers::{Call, LoadBlock, Trace},
+    RpcNodeCore,
+};
+
+/// Helper trait for `eth_blockAccessList` RPC method.
+pub trait GetBlockAccessList: Trace + Call + LoadBlock {
+    /// Retrieves the block access list for a block identified by its hash.
+    fn get_block_access_list(
+        &self,
+        block_hash: B256,
+    ) -> impl Future<Output = Result<Option<BlockAccessList>, Self::Error>> + Send {
+        async move {
+            let block = self
+                .recovered_block(block_hash.into())
+                .await?
+                .ok_or_else(|| EthApiError::HeaderNotFound(block_hash.into()))?;
+
+            self.spawn_blocking_io(move |eth_api| {
+                let state = eth_api
+                    .provider()
+                    .state_by_block_id(block.parent_hash().into())
+                    .map_err(Self::Error::from_eth_err)?;
+
+                let mut db = State::builder()
+                    .with_database(StateProviderDatabase::new(StateProviderTraitObjWrapper(state)))
+                    .with_bal_builder()
+                    .build();
+
+                let block_txs = block.transactions_recovered();
+                let mut executor = RpcNodeCore::evm_config(&eth_api)
+                    .executor_for_block(&mut db, block.sealed_block())
+                    .map_err(RethError::other)
+                    .map_err(Self::Error::from_eth_err)?;
+
+                executor.apply_pre_execution_changes().map_err(Self::Error::from_eth_err)?;
+
+                // replay all transactions prior to the targeted transaction
+                for block_tx in block_txs {
+                    executor.execute_transaction(block_tx).map_err(Self::Error::from_eth_err)?;
+                }
+                let _ = executor.apply_post_execution_changes();
+
+                let bal = db.take_built_alloy_bal().ok_or_else(|| {
+                    EthApiError::Internal(reth_errors::RethError::msg("BAL not built"))
+                })?;
+
+                Ok(Some(bal))
+            })
+            .await
+        }
+    }
+}

crates/rpc/rpc-eth-api/src/helpers/mod.rs

@@ -15,6 +15,7 @@
 //! all the `Eth` traits, e.g. `reth_rpc::EthApi`.
 
 pub mod block;
+pub mod block_access_list;
 pub mod blocking_task;
 pub mod call;
 pub mod config;
@@ -40,12 +41,15 @@ pub use state::{EthState, LoadState};
 pub use trace::Trace;
 pub use transaction::{EthTransactions, LoadTransaction};
 
-use crate::FullEthApiTypes;
+use crate::{helpers::block_access_list::GetBlockAccessList, FullEthApiTypes};
 
 /// Extension trait that bundles traits needed for tracing transactions.
-pub trait TraceExt: LoadTransaction + LoadBlock + SpawnBlocking + Trace + Call {}
+pub trait TraceExt:
+    LoadTransaction + LoadBlock + SpawnBlocking + Trace + Call + GetBlockAccessList
+{
+}
 
-impl<T> TraceExt for T where T: LoadTransaction + LoadBlock + Trace + Call {}
+impl<T> TraceExt for T where T: LoadTransaction + LoadBlock + Trace + Call + GetBlockAccessList {}
 
 /// Helper trait to unify all `eth` rpc server building block traits, for simplicity.
 ///
@@ -60,6 +64,7 @@ pub trait FullEthApi:
     + EthFees
     + Trace
     + LoadReceipt
+    + GetBlockAccessList
 {
 }
 
@@ -73,5 +78,6 @@ impl<T> FullEthApi for T where
         + EthFees
         + Trace
         + LoadReceipt
+        + GetBlockAccessList
 {
 }

crates/rpc/rpc/Cargo.toml

@@ -44,7 +44,6 @@ reth-node-api.workspace = true
 reth-trie-common.workspace = true
 
 # ethereum
-alloy-eip7928.workspace = true
 alloy-evm = { workspace = true, features = ["overrides"] }
 alloy-consensus.workspace = true
 alloy-signer.workspace = true

crates/rpc/rpc/src/debug.rs

@@ -1,5 +1,4 @@
 use alloy_consensus::{transaction::TxHashRef, BlockHeader};
-use alloy_eip7928::BlockAccessList;
 use alloy_eips::{eip2718::Encodable2718, BlockId, BlockNumberOrTag};
 use alloy_evm::env::BlockEnvironment;
 use alloy_genesis::ChainConfig;
@@ -159,6 +158,19 @@ where
             .await
     }
 
+    /// Replays a block and generates the RLP-encoded Block Access List (EIP-7928).
+    pub async fn get_block_access_list(&self, block_id: BlockId) -> Result<Bytes, Eth::Error> {
+        let block_hash = self
+            .provider()
+            .block_hash_for_id(block_id)
+            .map_err(Eth::Error::from_eth_err)?
+            .ok_or(EthApiError::HeaderNotFound(block_id))?;
+
+        let bal = self.eth_api().get_block_access_list(block_hash).await?;
+
+        Ok(alloy_rlp::encode(bal.unwrap_or_default()).into())
+    }
+
     /// Replays the given block and returns the trace of each transaction.
     ///
     /// This expects a rlp encoded block
@@ -831,8 +843,9 @@ where
         Self::debug_execution_witness_by_block_hash(self, hash).await.map_err(Into::into)
     }
 
-    async fn debug_get_block_access_list(&self, _block_id: BlockId) -> RpcResult<BlockAccessList> {
-        Err(internal_rpc_err("unimplemented"))
+    async fn debug_get_block_access_list(&self, block_id: BlockId) -> RpcResult<Bytes> {
+        let _permit = self.acquire_trace_permit().await;
+        self.get_block_access_list(block_id).await.map_err(Into::into)
     }
 
     async fn debug_backtrace_at(&self, _location: &str) -> RpcResult<()> {

crates/rpc/rpc/src/eth/helpers/block_access_list.rs

@@ -0,0 +1,15 @@
+//! Contains RPC handler implementations specific to block access lists.
+
+use reth_rpc_convert::RpcConvert;
+use reth_rpc_eth_api::{helpers::block_access_list::GetBlockAccessList, FromEvmError, RpcNodeCore};
+use reth_rpc_eth_types::EthApiError;
+
+use crate::EthApi;
+
+impl<N, Rpc> GetBlockAccessList for EthApi<N, Rpc>
+where
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, Evm = N::Evm>,
+{
+}

crates/rpc/rpc/src/eth/helpers/mod.rs

@@ -16,3 +16,4 @@ mod trace;
 mod transaction;
 
 pub use sync_listener::SyncListener;
+pub mod block_access_list;