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

crates/cheatcodes/Cargo.toml

@@ -24,7 +24,7 @@ foundry-evm-traces.workspace = true
 foundry-wallets.workspace = true
 forge-script-sequence.workspace = true
 
-alloy-dyn-abi.workspace = true
+alloy-dyn-abi = { workspace = true, features = ["eip712"] }
 alloy-evm.workspace = true
 alloy-json-abi.workspace = true
 alloy-primitives.workspace = true

crates/cheatcodes/src/evm/mapping.rs

@@ -1,52 +1,12 @@
 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;

crates/cheatcodes/src/inspector.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/common/src/lib.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/mapping_slots.rs

@@ -0,0 +1,39 @@
+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.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,
+        }
+    }
+}