impl create_access_list in Evm

Author: eshaan7

common/src/types.rs

@@ -1,21 +1,37 @@
-use std::collections::HashMap;
 use std::fmt::Display;
 
 use alloy::{
+    consensus::Account as TrieAccount,
     eips::{BlockId, BlockNumberOrTag},
     primitives::{Bytes, B256, U256},
+    rpc::types::EIP1186StorageProof,
 };
 use eyre::{eyre, Report, Result};
 use serde::{de::Error, Deserialize, Serialize};
 
 #[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
 pub struct Account {
-    pub balance: U256,
-    pub nonce: u64,
-    pub code_hash: B256,
+    pub account: TrieAccount,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub code: Option<Bytes>,
-    pub storage_hash: B256,
-    pub slots: HashMap<B256, U256>,
+    pub account_proof: Vec<Bytes>,
+    pub storage_proof: Vec<EIP1186StorageProof>,
+}
+
+impl Account {
+    /// Retrieve the value at the given storage slot.
+    pub fn get_storage_value(&self, slot: B256) -> Option<U256> {
+        self.storage_proof
+            .iter()
+            .find_map(|EIP1186StorageProof { key, value, .. }| {
+                if key.as_b256() == slot {
+                    Some(*value)
+                } else {
+                    None
+                }
+            })
+    }
 }
 
 #[derive(Debug, Clone, Copy)]

core/src/client/node.rs

@@ -95,7 +95,7 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>> Node<N, C> {
             .execution
             .get_account(address, None, tag, false)
             .await?;
-        Ok(account.balance)
+        Ok(account.account.balance)
     }
 
     pub async fn get_nonce(&self, address: Address, tag: BlockTag) -> Result<u64> {
@@ -105,7 +105,7 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>> Node<N, C> {
             .execution
             .get_account(address, None, tag, false)
             .await?;
-        Ok(account.nonce)
+        Ok(account.account.nonce)
     }
 
     pub async fn get_block_transaction_count_by_hash(&self, hash: B256) -> Result<Option<u64>> {

core/src/execution/client/rpc.rs

@@ -1,6 +1,6 @@
 use std::collections::{HashMap, HashSet};
 
-use alloy::consensus::BlockHeader;
+use alloy::consensus::{Account as TrieAccount, BlockHeader};
 use alloy::eips::BlockId;
 use alloy::network::{BlockResponse, ReceiptResponse, TransactionBuilder};
 use alloy::primitives::{Address, B256, U256};
@@ -66,7 +66,7 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionSpec<N> for ExecutionInnerRpcC
             .get_proof(address, slots, block.header().number().into())
             .await?;
 
-        self.verify_proof_to_account(&proof, &block, include_code)
+        self.verify_proof_to_account(proof, &block, include_code)
             .await
     }
 
@@ -243,34 +243,37 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionSpec<N> for ExecutionInnerRpcC
 impl<N: NetworkSpec, R: ExecutionRpc<N>> ExecutionInnerRpcClient<N, R> {
     async fn verify_proof_to_account(
         &self,
-        proof: &EIP1186AccountProofResponse,
+        proof: EIP1186AccountProofResponse,
         block: &N::BlockResponse,
         verify_code: bool,
     ) -> Result<Account> {
         // Verify the account proof
-        verify_account_proof(proof, block.header().state_root())?;
-        // Verify the storage proofs, collecting the slot values
-        let slot_map = verify_storage_proof(proof)?;
+        verify_account_proof(&proof, block.header().state_root())?;
+        // Verify the storage proofs
+        verify_storage_proof(&proof)?;
         // Verify the code hash
         let code = if verify_code {
             let code = self
                 .rpc
                 .get_code(proof.address, block.header().number().into())
                 .await?
                 .into();
-            verify_code_hash_proof(proof, &code)?;
+            verify_code_hash_proof(&proof, &code)?;
             Some(code)
         } else {
             None
         };
 
         Ok(Account {
-            balance: proof.balance,
-            nonce: proof.nonce,
-            code_hash: proof.code_hash,
+            account: TrieAccount {
+                nonce: proof.nonce,
+                balance: proof.balance,
+                storage_root: proof.storage_hash,
+                code_hash: proof.code_hash,
+            },
             code,
-            storage_hash: proof.storage_hash,
-            slots: slot_map,
+            account_proof: proof.account_proof,
+            storage_proof: proof.storage_proof,
         })
     }
 

core/src/execution/client/verifiable_api.rs

@@ -64,12 +64,14 @@ impl<N: NetworkSpec, A: VerifiableApi<N>> ExecutionSpec<N>
             .map(|s| (*s).into())
             .collect::<Vec<_>>();
 
-        let account_response = self
+        let account = self
             .api
             .get_account(address, &slots, Some(block_id), include_code)
             .await?;
 
-        self.verify_account_response(address, account_response, &block)
+        self.verify_account(address, &account, &block)?;
+
+        Ok(account)
     }
 
     async fn get_transaction_receipt(&self, tx_hash: B256) -> Result<Option<N::ReceiptResponse>> {
@@ -138,15 +140,11 @@ impl<N: NetworkSpec, A: VerifiableApi<N>> ExecutionSpec<N>
             .create_access_list(tx.clone(), Some(block_id))
             .await?;
 
-        let account_map = accounts
-            .into_iter()
-            .map(|(address, account_response)| {
-                self.verify_account_response(address, account_response, &block)
-                    .map(|account| (address, account))
-            })
-            .collect::<Result<HashMap<_, _>>>()?;
+        for (address, account) in &accounts {
+            self.verify_account(*address, account, &block)?;
+        }
 
-        Ok(account_map)
+        Ok(accounts)
     }
 
     async fn chain_id(&self) -> Result<u64> {
@@ -196,42 +194,31 @@ impl<N: NetworkSpec, A: VerifiableApi<N>> ExecutionSpec<N>
 }
 
 impl<N: NetworkSpec, A: VerifiableApi<N>> ExecutionInnerVerifiableApiClient<N, A> {
-    fn verify_account_response(
+    fn verify_account(
         &self,
         address: Address,
-        account: AccountResponse,
+        account: &AccountResponse,
         block: &N::BlockResponse,
-    ) -> Result<Account> {
+    ) -> Result<()> {
         let proof = EIP1186AccountProofResponse {
             address,
             balance: account.account.balance,
             code_hash: account.account.code_hash,
             nonce: account.account.nonce,
             storage_hash: account.account.storage_root,
-            account_proof: account.account_proof,
-            storage_proof: account.storage_proof,
+            account_proof: account.account_proof.clone(),
+            storage_proof: account.storage_proof.clone(),
         };
         // Verify the account proof
         verify_account_proof(&proof, block.header().state_root())?;
-        // Verify the storage proofs, collecting the slot values
-        let slot_map = verify_storage_proof(&proof)?;
+        // Verify the storage proofs
+        verify_storage_proof(&proof)?;
         // Verify the code hash (if code is included in the response)
-        let code = match account.code {
-            Some(code) => {
-                verify_code_hash_proof(&proof, &code)?;
-                Some(code)
-            }
-            None => None,
-        };
+        if let Some(code) = &account.code {
+            verify_code_hash_proof(&proof, code)?;
+        }
 
-        Ok(Account {
-            balance: proof.balance,
-            nonce: proof.nonce,
-            code_hash: proof.code_hash,
-            code,
-            storage_hash: proof.storage_hash,
-            slots: slot_map,
-        })
+        Ok(())
     }
 
     async fn verify_logs_and_receipts(