feat(cheatcodes): decode structs and mappings in state diff output (#11331)

* feat(`forge`): sample typed storage values

* arc it

* nit

* clippy

* nit

* strip file prefixes

* fmt

* don't add adjacent values to sample

* feat(cheatcodes): add contract identifier to AccountStateDiffs

* forge fmt

* doc nits

* fix tests

* feat(`cheatcodes`): include `SlotInfo` in SlotStateDiff

* cleanup + identify slots of static arrays

* nits

* nit

* nits

* test + nits

* docs

* handle 2d arrays

* use DynSolType

* feat: decode storage values

* doc nit

* skip decoded serialization if none

* nit

* fmt

* fix

* fix

* fix

* feat(cheatcodes): decode structs in state diff output

* fix

* while decode

* fix: show only decoded in plaintext / display output + test

* feat: format slots to only significant bits in vm.getStateDiff output

* encode_prefixed

* nit

* chore: add @onbjerg to `CODEOWNERS` (#11343)

* add @onbjerg

* add @0xrusowsky

* resolve conflicts

* fix: disable tx gas limit cap (#11347)

* chore(deps): bump all dependencies (#11349)

* chore: use get_or_calculate_hash better (#11350)

* resolve more conflicts

* fix(lint): 'unwrapped-modifier-logic' incorrectly marked with `Severity::Gas` (#11358)

fix(lint): 'unwrapped-modifier-logic' incorrectly marked with Severity::Gas

* feat: identify and decode nested structs

* cleanup

* decode structs and members recursively

* cleanup

* doc fix

* feat(cheatcodes): decode mappings in state diffs (#11381)

* feat(cheatcodes): decode mappings in state diffs

* feat: decode nested mappings

* assert vm.getStateDiff output

* feat: add `keys` fields to `SlotInfo` in case of mappings

* remove wrapper

* refactor: moves state diff decoding to common (#11413)

* refactor: storage decoder

* cleanup

* dedup MappingSlots by moving it to common

* move decoding logic into SlotInfo

* rename to SlotIndentifier

* docs

* fix: delegate identification according to encoding types

* clippy + fmt

* docs fix

* fix

* merge match arms

* merge ifs

* recurse handle_struct

* dedup assertContains test util

* fix

* Update crates/common/src/slot_identifier.rs

Co-authored-by: zerosnacks <[email protected]>

* Review changes: simplify get or insert, use common fmt

* alloy-dyn-abi.workspace

* nits

---------

Co-authored-by: Yash Atreya <[email protected]>
Co-authored-by: zerosnacks <[email protected]>
Co-authored-by: Matthias Seitz <[email protected]>
Co-authored-by: DaniPopes <[email protected]>
Co-authored-by: srdtrk <[email protected]>
Co-authored-by: 0xrusowsky <[email protected]>
Co-authored-by: grandizzy <[email protected]>
Co-authored-by: grandizzy <[email protected]>

Author: 8 people

crates/cheatcodes/src/evm.rs

@@ -1,58 +1,16 @@
 use crate::{Cheatcode, Cheatcodes, Result, Vm::*};
-use alloy_primitives::{
-    Address, B256, U256, keccak256,
-    map::{AddressHashMap, B256HashMap},
-};
+use alloy_primitives::{Address, B256, U256, keccak256, map::AddressHashMap};
 use alloy_sol_types::SolValue;
+use foundry_common::mapping_slots::MappingSlots;
 use revm::{
     bytecode::opcode,
     interpreter::{Interpreter, interpreter_types::Jumps},
 };
 
-/// Recorded mapping slots.
-#[derive(Clone, Debug, Default)]
-pub struct MappingSlots {
-    /// Holds mapping parent (slots => slots)
-    pub parent_slots: B256HashMap<B256>,
-
-    /// Holds mapping key (slots => key)
-    pub keys: B256HashMap<B256>,
-
-    /// Holds mapping child (slots => slots[])
-    pub children: B256HashMap<Vec<B256>>,
-
-    /// Holds the last sha3 result `sha3_result => (data_low, data_high)`, this would only record
-    /// when sha3 is called with `size == 0x40`, and the lower 256 bits would be stored in
-    /// `data_low`, higher 256 bits in `data_high`.
-    /// This is needed for mapping_key detect if the slot is for some mapping and record that.
-    pub seen_sha3: B256HashMap<(B256, B256)>,
-}
-
-impl MappingSlots {
-    /// Tries to insert a mapping slot. Returns true if it was inserted.
-    pub fn insert(&mut self, slot: B256) -> bool {
-        match self.seen_sha3.get(&slot).copied() {
-            Some((key, parent)) => {
-                if self.keys.contains_key(&slot) {
-                    return false;
-                }
-                self.keys.insert(slot, key);
-                self.parent_slots.insert(slot, parent);
-                self.children.entry(parent).or_default().push(slot);
-                self.insert(parent);
-                true
-            }
-            None => false,
-        }
-    }
-}
-
 impl Cheatcode for startMappingRecordingCall {
     fn apply(&self, state: &mut Cheatcodes) -> Result {
         let Self {} = self;
-        if state.mapping_slots.is_none() {
-            state.mapping_slots = Some(Default::default());
-        }
+        state.mapping_slots.get_or_insert_default();
         Ok(Default::default())
     }
 }

crates/cheatcodes/src/evm/mapping.rs

@@ -4,8 +4,7 @@ use crate::{
     CheatsConfig, CheatsCtxt, DynCheatcode, Error, Result,
     Vm::{self, AccountAccess},
     evm::{
-        DealRecord, GasRecord, RecordAccess,
-        mapping::{self, MappingSlots},
+        DealRecord, GasRecord, RecordAccess, mapping,
         mock::{MockCallDataContext, MockCallReturnData},
         prank::Prank,
     },
@@ -33,7 +32,9 @@ use alloy_rpc_types::{
     request::{TransactionInput, TransactionRequest},
 };
 use alloy_sol_types::{SolCall, SolInterface, SolValue};
-use foundry_common::{SELECTOR_LEN, TransactionMaybeSigned, evm::Breakpoints};
+use foundry_common::{
+    SELECTOR_LEN, TransactionMaybeSigned, evm::Breakpoints, mapping_slots::MappingSlots,
+};
 use foundry_evm_core::{
     InspectorExt,
     abi::Vm::stopExpectSafeMemoryCall,

crates/cheatcodes/src/inspector.rs

@@ -26,12 +26,14 @@ pub mod contracts;
 pub mod errors;
 pub mod evm;
 pub mod fs;
+pub mod mapping_slots;
 mod preprocessor;
 pub mod provider;
 pub mod reports;
 pub mod retry;
 pub mod selectors;
 pub mod serde_helpers;
+pub mod slot_identifier;
 pub mod term;
 pub mod traits;
 pub mod transactions;

crates/common/src/lib.rs

@@ -0,0 +1,38 @@
+use alloy_primitives::{B256, map::B256HashMap};
+
+/// Recorded mapping slots.
+#[derive(Clone, Debug, Default)]
+pub struct MappingSlots {
+    /// Holds mapping parent (slots => slots)
+    pub parent_slots: B256HashMap<B256>,
+
+    /// Holds mapping key (slots => key)
+    pub keys: B256HashMap<B256>,
+
+    /// Holds mapping child (slots => slots[])
+    pub children: B256HashMap<Vec<B256>>,
+
+    /// Holds the last sha3 result `sha3_result => (data_low, data_high)`, this would only record
+    /// when sha3 is called with `size == 0x40`, and the lower 256 bits would be stored in
+    /// `data_low`, higher 256 bits in `data_high`.
+    /// This is needed for mapping_key detect if the slot is for some mapping and record that.
+    pub seen_sha3: B256HashMap<(B256, B256)>,
+}
+
+impl MappingSlots {
+    /// Tries to insert a mapping slot. Returns true if it was inserted.
+    pub fn insert(&mut self, slot: B256) -> bool {
+        match self.seen_sha3.get(&slot).copied() {
+            Some((key, parent)) => {
+                if self.keys.insert(slot, key).is_some() {
+                    return false;
+                }
+                self.parent_slots.insert(slot, parent);
+                self.children.entry(parent).or_default().push(slot);
+                self.insert(parent);
+                true
+            }
+            None => false,
+        }
+    }
+}