Allow creating separate execution-only and storage proofs

crates/chain-state/src/in_memory.rs

@@ -318,7 +318,7 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
         {
             if self.inner.in_memory_state.blocks.read().get(&persisted_num_hash.hash).is_none() {
                 // do nothing
-                return
+                return;
             }
         }
 
@@ -542,7 +542,7 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
             if let Some(tx) =
                 block_state.block_ref().recovered_block().body().transaction_by_hash(&hash)
             {
-                return Some(tx.clone())
+                return Some(tx.clone());
             }
         }
         None
@@ -869,6 +869,7 @@ mod tests {
     use rand::Rng;
     use reth_errors::ProviderResult;
     use reth_ethereum_primitives::{EthPrimitives, Receipt};
+    use reth_execution_types::{FlatPreState, FlatWitnessRecord};
     use reth_primitives_traits::{Account, Bytecode};
     use reth_storage_api::{
         AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider,
@@ -1031,6 +1032,10 @@ mod tests {
         ) -> ProviderResult<Vec<Bytes>> {
             Ok(Vec::default())
         }
+
+        fn flat_witness(&self, _record: FlatWitnessRecord) -> ProviderResult<FlatPreState> {
+            Ok(FlatPreState::default())
+        }
     }
 
     #[test]

crates/chain-state/src/memory_overlay.rs

@@ -2,6 +2,7 @@ use super::ExecutedBlock;
 use alloy_consensus::BlockHeader;
 use alloy_primitives::{keccak256, Address, BlockNumber, Bytes, StorageKey, StorageValue, B256};
 use reth_errors::ProviderResult;
+use reth_execution_types::{FlatPreState, FlatWitnessRecord};
 use reth_primitives_traits::{Account, Bytecode, NodePrimitives};
 use reth_storage_api::{
     AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider, StateProofProvider,
@@ -203,6 +204,10 @@ impl<N: NodePrimitives> StateProofProvider for MemoryOverlayStateProviderRef<'_,
         input.prepend_self(self.trie_input().clone());
         self.historical.witness(input, target)
     }
+
+    fn flat_witness(&self, record: FlatWitnessRecord) -> ProviderResult<FlatPreState> {
+        self.historical.flat_witness(record)
+    }
 }
 
 impl<N: NodePrimitives> HashedPostStateProvider for MemoryOverlayStateProviderRef<'_, N> {

crates/engine/tree/src/tree/cached_state.rs

@@ -9,8 +9,9 @@ use reth_errors::ProviderResult;
 use reth_metrics::Metrics;
 use reth_primitives_traits::{Account, Bytecode};
 use reth_provider::{
-    AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider, StateProofProvider,
-    StateProvider, StateRootProvider, StorageRootProvider,
+    AccountReader, BlockHashReader, BytecodeReader, FlatPreState, FlatWitnessRecord,
+    HashedPostStateProvider, StateProofProvider, StateProvider, StateRootProvider,
+    StorageRootProvider,
 };
 use reth_revm::db::BundleState;
 use reth_trie::{
@@ -119,7 +120,7 @@ impl<S: AccountReader> AccountReader for CachedStateProvider<S> {
     fn basic_account(&self, address: &Address) -> ProviderResult<Option<Account>> {
         if let Some(res) = self.caches.account_cache.get(address) {
             self.metrics.account_cache_hits.increment(1);
-            return Ok(res)
+            return Ok(res);
         }
 
         self.metrics.account_cache_misses.increment(1);
@@ -170,7 +171,7 @@ impl<S: BytecodeReader> BytecodeReader for CachedStateProvider<S> {
     fn bytecode_by_hash(&self, code_hash: &B256) -> ProviderResult<Option<Bytecode>> {
         if let Some(res) = self.caches.code_cache.get(code_hash) {
             self.metrics.code_cache_hits.increment(1);
-            return Ok(res)
+            return Ok(res);
         }
 
         self.metrics.code_cache_misses.increment(1);
@@ -230,6 +231,10 @@ impl<S: StateProofProvider> StateProofProvider for CachedStateProvider<S> {
     ) -> ProviderResult<Vec<alloy_primitives::Bytes>> {
         self.state_provider.witness(input, target)
     }
+
+    fn flat_witness(&self, record: FlatWitnessRecord) -> ProviderResult<FlatPreState> {
+        self.state_provider.flat_witness(record)
+    }
 }
 
 impl<S: StorageRootProvider> StorageRootProvider for CachedStateProvider<S> {
@@ -410,7 +415,7 @@ impl ExecutionCache {
             // If the account was not modified, as in not changed and not destroyed, then we have
             // nothing to do w.r.t. this particular account and can move on
             if account.status.is_not_modified() {
-                continue
+                continue;
             }
 
             // If the account was destroyed, invalidate from the account / storage caches
@@ -419,15 +424,15 @@ impl ExecutionCache {
                 self.account_cache.invalidate(addr);
 
                 invalidated_accounts.insert(addr);
-                continue
+                continue;
             }
 
             // If we have an account that was modified, but it has a `None` account info, some wild
             // error has occurred because this state should be unrepresentable. An account with
             // `None` current info, should be destroyed.
             let Some(ref account_info) = account.info else {
                 trace!(target: "engine::caching", ?account, "Account with None account info found in state updates");
-                return Err(())
+                return Err(());
             };
 
             // Now we iterate over all storage and make updates to the cached storage values

crates/engine/tree/src/tree/instrumented_state.rs

@@ -5,8 +5,9 @@ use reth_errors::ProviderResult;
 use reth_metrics::Metrics;
 use reth_primitives_traits::{Account, Bytecode};
 use reth_provider::{
-    AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider, StateProofProvider,
-    StateProvider, StateRootProvider, StorageRootProvider,
+    AccountReader, BlockHashReader, BytecodeReader, FlatPreState, FlatWitnessRecord,
+    HashedPostStateProvider, StateProofProvider, StateProvider, StateRootProvider,
+    StorageRootProvider,
 };
 use reth_trie::{
     updates::TrieUpdates, AccountProof, HashedPostState, HashedStorage, MultiProof,
@@ -251,6 +252,10 @@ impl<S: StateProofProvider> StateProofProvider for InstrumentedStateProvider<S>
     ) -> ProviderResult<Vec<alloy_primitives::Bytes>> {
         self.state_provider.witness(input, target)
     }
+
+    fn flat_witness(&self, record: FlatWitnessRecord) -> ProviderResult<FlatPreState> {
+        self.state_provider.flat_witness(record)
+    }
 }
 
 impl<S: StorageRootProvider> StorageRootProvider for InstrumentedStateProvider<S> {

crates/evm/execution-types/src/lib.rs

@@ -20,6 +20,9 @@ pub use execute::*;
 mod execution_outcome;
 pub use execution_outcome::*;
 
+pub mod witness;
+pub use witness::*;
+
 /// Bincode-compatible serde implementations for commonly used types for (EVM) block execution.
 ///
 /// `bincode` crate doesn't work with optionally serializable serde fields, but some of the

crates/evm/execution-types/src/witness.rs

@@ -0,0 +1,63 @@
+//! Witness recording types for EVM execution.
+
+use alloy_primitives::{keccak256, Address, B256, U256};
+use revm::{
+    database::{AccountStatus, DbAccount, State},
+    primitives::{HashMap, HashSet},
+    state::Bytecode,
+};
+
+/// Records pre-state data for witness generation.
+#[derive(Debug, Clone, Default)]
+pub struct FlatPreState {
+    /// Accounts accessed during execution.
+    pub accounts: HashMap<Address, DbAccount>,
+    /// Bytecode accessed during execution.
+    pub contracts: HashMap<B256, Bytecode>,
+    /// The set of addresses that have been self-destructed in the execution.
+    pub destructed_addresses: HashSet<Address>,
+}
+
+/// Records pre-state accesses that occurred during execution.
+#[derive(Debug, Clone, Default)]
+pub struct FlatWitnessRecord {
+    /// Accounts accessed during execution.
+    pub accounts: HashMap<Address, AccessedAccount>,
+    /// Bytecode accessed during execution.
+    pub contracts: HashMap<B256, Option<Bytecode>>,
+}
+
+/// Represents an accessed account during execution.
+#[derive(Debug, Clone)]
+pub enum AccessedAccount {
+    /// Indicates if the account was destroyed during execution.
+    Destroyed,
+    /// Storage keys accessed during execution.
+    StorageKeys(HashSet<U256>),
+}
+
+impl FlatWitnessRecord {
+    /// Records the accessed state after execution.
+    pub fn record_executed_state<DB>(&mut self, statedb: &State<DB>) {
+        self.contracts = statedb
+            .cache
+            .contracts
+            .values()
+            .map(|code| (keccak256(code.original_bytes()), Some(code.clone())))
+            .collect();
+
+        for (address, account) in &statedb.cache.accounts {
+            let account = match account.status {
+                AccountStatus::Destroyed => AccessedAccount::Destroyed,
+                _ => {
+                    let storage_keys = account
+                        .account
+                        .as_ref()
+                        .map_or_else(HashSet::default, |a| a.storage.keys().copied().collect());
+                    AccessedAccount::StorageKeys(storage_keys)
+                }
+            };
+            self.accounts.insert(*address, account);
+        }
+    }
+}

crates/revm/Cargo.toml

@@ -17,6 +17,7 @@ reth-primitives-traits.workspace = true
 reth-storage-errors.workspace = true
 reth-storage-api.workspace = true
 reth-trie = { workspace = true, optional = true }
+reth-execution-types.workspace = true
 
 # alloy
 alloy-primitives.workspace = true

crates/revm/src/test_utils.rs

@@ -2,6 +2,7 @@ use alloc::vec::Vec;
 use alloy_primitives::{
     keccak256, map::HashMap, Address, BlockNumber, Bytes, StorageKey, B256, U256,
 };
+use reth_execution_types::{FlatPreState, FlatWitnessRecord};
 use reth_primitives_traits::{Account, Bytecode};
 use reth_storage_api::{
     AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider, StateProofProvider,
@@ -142,6 +143,10 @@ impl StateProofProvider for StateProviderTest {
     fn witness(&self, _input: TrieInput, _target: HashedPostState) -> ProviderResult<Vec<Bytes>> {
         unimplemented!("witness generation is not supported")
     }
+
+    fn flat_witness(&self, record: FlatWitnessRecord) -> ProviderResult<FlatPreState> {
+        unimplemented!("flat witness generation is not supported")
+    }
 }
 
 impl HashedPostStateProvider for StateProviderTest {

crates/rpc/rpc-api/Cargo.toml

@@ -18,6 +18,7 @@ reth-engine-primitives.workspace = true
 reth-network-peers.workspace = true
 reth-trie-common.workspace = true
 reth-chain-state.workspace = true
+reth-stateless.workspace = true
 
 # ethereum
 alloy-eips.workspace = true

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

@@ -8,6 +8,7 @@ use alloy_rpc_types_trace::geth::{
     BlockTraceResult, GethDebugTracingCallOptions, GethDebugTracingOptions, GethTrace, TraceResult,
 };
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use reth_stateless::flat_witness::FlatExecutionWitness;
 use reth_trie_common::{updates::TrieUpdates, HashedPostState};
 
 /// Debug rpc interface.
@@ -144,6 +145,16 @@ pub trait DebugApi<TxReq: RpcObject> {
     async fn debug_execution_witness(&self, block: BlockNumberOrTag)
         -> RpcResult<ExecutionWitness>;
 
+    /// The `debug_flatExecutionWitness` method allows for re-execution of a block with the purpose of
+    /// generating an execution-only witness.
+    ///
+    /// The first argument is the block number or tag.
+    #[method(name = "flatExecutionWitness")]
+    async fn debug_flat_execution_witness(
+        &self,
+        block: BlockNumberOrTag,
+    ) -> RpcResult<FlatExecutionWitness>;
+
     /// The `debug_executionWitnessByBlockHash` method allows for re-execution of a block with the
     /// purpose of generating an execution witness. The witness comprises of a map of all hashed
     /// trie nodes to their preimages that were required during the execution of the block,
@@ -156,6 +167,16 @@ pub trait DebugApi<TxReq: RpcObject> {
         hash: B256,
     ) -> RpcResult<ExecutionWitness>;
 
+    /// The `debug_executionWitnessByBlockHash` method allows for re-execution of a block with the
+    /// purpose of generating an execution-only witness.
+    ///
+    /// The first argument is the block hash.
+    #[method(name = "flatExecutionWitnessByBlockHash")]
+    async fn debug_flat_execution_witness_by_block_hash(
+        &self,
+        hash: B256,
+    ) -> RpcResult<FlatExecutionWitness>;
+
     /// 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
     /// be printed to stderr.

crates/rpc/rpc-eth-types/src/cache/db.rs

@@ -4,6 +4,7 @@
 
 use alloy_primitives::{Address, B256, U256};
 use reth_errors::ProviderResult;
+use reth_execution_types::{FlatPreState, FlatWitnessRecord};
 use reth_revm::{database::StateProviderDatabase, DatabaseRef};
 use reth_storage_api::{BytecodeReader, HashedPostStateProvider, StateProvider};
 use reth_trie::{HashedStorage, MultiProofTargets};
@@ -105,6 +106,10 @@ impl reth_storage_api::StateProofProvider for StateProviderTraitObjWrapper<'_> {
     ) -> reth_errors::ProviderResult<Vec<alloy_primitives::Bytes>> {
         self.0.witness(input, target)
     }
+
+    fn flat_witness(&self, record: FlatWitnessRecord) -> ProviderResult<FlatPreState> {
+        self.0.flat_witness(record)
+    }
 }
 
 impl reth_storage_api::AccountReader for StateProviderTraitObjWrapper<'_> {

crates/rpc/rpc/Cargo.toml

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