feat(forge): add accessList and cold/warm cheatcodes (#10112)

* feat(forge): add cold/warm cheatcodes

* Add accessList cheatcode

* Add comment, apply default acess list only if option is some

Author: grandizzy

crates/cheatcodes/assets/cheatcodes.json

@@ -90,6 +90,7 @@ impl Cheatcodes<'static> {
                 Vm::BroadcastTxSummary::STRUCT.clone(),
                 Vm::SignedDelegation::STRUCT.clone(),
                 Vm::PotentialRevert::STRUCT.clone(),
+                Vm::AccessListItem::STRUCT.clone(),
             ]),
             enums: Cow::Owned(vec![
                 Vm::CallerMode::ENUM.clone(),

crates/cheatcodes/spec/src/lib.rs

@@ -223,6 +223,14 @@ interface Vm {
         bool reverted;
     }
 
+    /// An EIP-2930 access list item.
+    struct AccessListItem {
+        /// The address to be added in access list.
+        address target;
+        /// The storage keys to be added in access list.
+        bytes32[] storageKeys;
+    }
+
     /// The result of a `stopAndReturnStateDiff` call.
     struct AccountAccess {
         /// The chain and fork the access occurred.
@@ -544,6 +552,22 @@ interface Vm {
     #[cheatcode(group = Evm, safety = Unsafe, status = Experimental)]
     function cool(address target) external;
 
+    /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.
+    #[cheatcode(group = Evm, safety = Unsafe, status = Experimental)]
+    function accessList(AccessListItem[] calldata accessList) external;
+
+    /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.
+    #[cheatcode(group = Evm, safety = Unsafe, status = Experimental)]
+    function noAccessList() external;
+
+    /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.
+    #[cheatcode(group = Evm, safety = Unsafe, status = Experimental)]
+    function warm(address target, bytes32 slot) external;
+
+    /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.
+    #[cheatcode(group = Evm, safety = Unsafe, status = Experimental)]
+    function cold(address target, bytes32 slot) external;
+
     // -------- Call Manipulation --------
     // --- Mocks ---
 

crates/cheatcodes/spec/src/vm.rs

@@ -16,6 +16,7 @@ use foundry_evm_core::{
     constants::{CALLER, CHEATCODE_ADDRESS, HARDHAT_CONSOLE_ADDRESS, TEST_CONTRACT_ADDRESS},
 };
 use foundry_evm_traces::StackSnapshotType;
+use itertools::Itertools;
 use rand::Rng;
 use revm::primitives::{Account, Bytecode, SpecId, KECCAK_EMPTY};
 use std::{
@@ -585,6 +586,48 @@ impl Cheatcode for coolCall {
     }
 }
 
+impl Cheatcode for accessListCall {
+    fn apply(&self, state: &mut Cheatcodes) -> Result {
+        let Self { accessList } = self;
+        let access_list = accessList
+            .iter()
+            .map(|item| {
+                let keys = item.storageKeys.iter().map(|key| B256::from(*key)).collect_vec();
+                alloy_rpc_types::AccessListItem { address: item.target, storage_keys: keys }
+            })
+            .collect_vec();
+        state.access_list = Some(alloy_rpc_types::AccessList::from(access_list));
+        Ok(Default::default())
+    }
+}
+
+impl Cheatcode for noAccessListCall {
+    fn apply(&self, state: &mut Cheatcodes) -> Result {
+        let Self {} = self;
+        // Set to empty option in order to override previous applied access list.
+        if state.access_list.is_some() {
+            state.access_list = Some(alloy_rpc_types::AccessList::default());
+        }
+        Ok(Default::default())
+    }
+}
+
+impl Cheatcode for warmCall {
+    fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
+        let Self { target, slot } = *self;
+        set_cold_slot(ccx, target, slot.into(), false);
+        Ok(Default::default())
+    }
+}
+
+impl Cheatcode for coldCall {
+    fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
+        let Self { target, slot } = *self;
+        set_cold_slot(ccx, target, slot.into(), true);
+        Ok(Default::default())
+    }
+}
+
 impl Cheatcode for readCallersCall {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self {} = self;
@@ -1195,3 +1238,12 @@ fn get_recorded_state_diffs(state: &mut Cheatcodes) -> BTreeMap<Address, Account
     }
     state_diffs
 }
+
+/// Helper function to set / unset cold storage slot of the target address.
+fn set_cold_slot(ccx: &mut CheatsCtxt, target: Address, slot: U256, cold: bool) {
+    if let Some(account) = ccx.ecx.journaled_state.state.get_mut(&target) {
+        if let Some(storage_slot) = account.storage.get_mut(&slot) {
+            storage_slot.is_cold = cold;
+        }
+    }
+}

crates/cheatcodes/src/evm.rs

@@ -26,7 +26,10 @@ use alloy_primitives::{
     map::{AddressHashMap, HashMap},
     Address, Bytes, Log, TxKind, B256, U256,
 };
-use alloy_rpc_types::request::{TransactionInput, TransactionRequest};
+use alloy_rpc_types::{
+    request::{TransactionInput, TransactionRequest},
+    AccessList,
+};
 use alloy_sol_types::{SolCall, SolInterface, SolValue};
 use foundry_common::{evm::Breakpoints, TransactionMaybeSigned, SELECTOR_LEN};
 use foundry_evm_core::{
@@ -443,6 +446,9 @@ pub struct Cheatcodes {
     /// Scripting based transactions
     pub broadcastable_transactions: BroadcastableTransactions,
 
+    /// Current EIP-2930 access lists.
+    pub access_list: Option<AccessList>,
+
     /// Additional, user configurable context this Inspector has access to when inspecting a call.
     pub config: Arc<CheatsConfig>,
 
@@ -527,6 +533,7 @@ impl Cheatcodes {
             allowed_mem_writes: Default::default(),
             broadcast: Default::default(),
             broadcastable_transactions: Default::default(),
+            access_list: Default::default(),
             context: Default::default(),
             serialized_jsons: Default::default(),
             eth_deals: Default::default(),
@@ -661,6 +668,11 @@ impl Cheatcodes {
             }
         }
 
+        // Apply EIP-2930 access lists.
+        if let Some(access_list) = &self.access_list {
+            ecx.env.tx.access_list = access_list.to_vec();
+        }
+
         // Apply our broadcast
         if let Some(broadcast) = &self.broadcast {
             if curr_depth >= broadcast.depth && input.caller() == broadcast.original_caller {
@@ -1037,6 +1049,11 @@ where {
             }
         }
 
+        // Apply EIP-2930 access lists.
+        if let Some(access_list) = &self.access_list {
+            ecx.env.tx.access_list = access_list.to_vec();
+        }
+
         // Apply our broadcast
         if let Some(broadcast) = &self.broadcast {
             // We only apply a broadcast *to a specific depth*.

crates/cheatcodes/src/inspector.rs

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.18;
+
+import "ds-test/test.sol";
+import "cheats/Vm.sol";
+
+contract AccessListIsolatedTest is DSTest {
+    Vm constant vm = Vm(HEVM_ADDRESS);
+
+    function test_access_list() public {
+        Write anotherWrite = new Write();
+        Write write = new Write();
+
+        uint256 initial = gasleft();
+        write.setNumber(1);
+        assertEq(initial - gasleft(), 26762);
+
+        // set access list to anotherWrite address, hence becoming more expensive
+        Vm.AccessListItem[] memory accessList = new Vm.AccessListItem[](1);
+        bytes32[] memory readKeys = new bytes32[](0);
+        accessList[0] = Vm.AccessListItem(address(anotherWrite), readKeys);
+        vm.accessList(accessList);
+
+        uint256 initial1 = gasleft();
+        write.setNumber(2);
+        assertEq(initial1 - gasleft(), 29162);
+
+        uint256 initial2 = gasleft();
+        write.setNumber(3);
+        assertEq(initial2 - gasleft(), 29162);
+
+        // reset access list, should take same gas as before setting
+        vm.noAccessList();
+        uint256 initial4 = gasleft();
+        write.setNumber(4);
+        assertEq(initial4 - gasleft(), 26762);
+
+        uint256 initial5 = gasleft();
+        write.setNumber(5);
+        assertEq(initial5 - gasleft(), 26762);
+
+        vm.accessList(accessList);
+        uint256 initial6 = gasleft();
+        write.setNumber(6);
+        assertEq(initial6 - gasleft(), 29162);
+    }
+}
+
+contract Write {
+    uint256 public number = 10;
+
+    function setNumber(uint256 _number) external {
+        number = _number;
+    }
+}