feat(cheatcodes): decode and show mismatched params on expectEmit (foundry-rs#11098)

* feat(`cheatcodes`): show mismatched params in events

* more param related failure tests

* fmt

* clippy

* feat: decode events using SignaturesIdentifier

* correctly identify indexed params

* don't  decode anon events

* fix

* clippy

* fix test

* fix test: build to cache selectors

* name mismatched logs

* nits

* check has_indexed_info

* addr checksum

* reinstate early data check

* fix

* nit

Author: yash-atreya

crates/cheatcodes/src/inspector.rs

@@ -41,7 +41,9 @@ use foundry_evm_core::{
     constants::{CHEATCODE_ADDRESS, HARDHAT_CONSOLE_ADDRESS, MAGIC_ASSUME},
     evm::{FoundryEvm, new_evm_with_existing_context},
 };
-use foundry_evm_traces::{TracingInspector, TracingInspectorConfig};
+use foundry_evm_traces::{
+    TracingInspector, TracingInspectorConfig, identifier::SignaturesIdentifier,
+};
 use foundry_wallets::multi_wallet::MultiWallet;
 use itertools::Itertools;
 use proptest::test_runner::{RngAlgorithm, TestRng, TestRunner};
@@ -493,6 +495,8 @@ pub struct Cheatcodes {
     pub deprecated: HashMap<&'static str, Option<&'static str>>,
     /// Unlocked wallets used in scripts and testing of scripts.
     pub wallets: Option<Wallets>,
+    /// Signatures identifier for decoding events and functions
+    pub signatures_identifier: Option<SignaturesIdentifier>,
 }
 
 // This is not derived because calling this in `fn new` with `..Default::default()` creates a second
@@ -547,6 +551,7 @@ impl Cheatcodes {
             arbitrary_storage: Default::default(),
             deprecated: Default::default(),
             wallets: Default::default(),
+            signatures_identifier: SignaturesIdentifier::new(true).ok(),
         }
     }
 
@@ -1381,10 +1386,14 @@ impl Inspector<EthEvmContext<&mut dyn DatabaseExt>> for Cheatcodes {
                 .collect::<Vec<_>>();
 
             // Revert if not all emits expected were matched.
-            if self.expected_emits.iter().any(|(expected, _)| !expected.found && expected.count > 0)
+            if let Some((expected, _)) = self
+                .expected_emits
+                .iter()
+                .find(|(expected, _)| !expected.found && expected.count > 0)
             {
                 outcome.result.result = InstructionResult::Revert;
-                outcome.result.output = "log != expected log".abi_encode().into();
+                let error_msg = expected.mismatch_error.as_deref().unwrap_or("log != expected log");
+                outcome.result.output = error_msg.abi_encode().into();
                 return;
             }
 

crates/cheatcodes/src/test/expect.rs

@@ -4,10 +4,14 @@ use std::{
 };
 
 use crate::{Cheatcode, Cheatcodes, CheatsCtxt, Error, Result, Vm::*};
+use alloy_dyn_abi::{DynSolValue, EventExt};
+use alloy_json_abi::Event;
 use alloy_primitives::{
-    Address, Bytes, LogData as RawLog, U256,
+    Address, Bytes, LogData as RawLog, U256, hex,
     map::{AddressHashMap, HashMap, hash_map::Entry},
 };
+use foundry_common::{abi::get_indexed_event, fmt::format_token};
+use foundry_evm_traces::DecodedCallLog;
 use revm::{
     context::JournalTr,
     interpreter::{
@@ -110,6 +114,8 @@ pub struct ExpectedEmit {
     pub found: bool,
     /// Number of times the log is expected to be emitted
     pub count: u64,
+    /// Stores mismatch details if a log didn't match
+    pub mismatch_error: Option<String>,
 }
 
 #[derive(Clone, Debug)]
@@ -762,8 +768,16 @@ fn expect_emit(
     anonymous: bool,
     count: u64,
 ) -> Result {
-    let expected_emit =
-        ExpectedEmit { depth, checks, address, found: false, log: None, anonymous, count };
+    let expected_emit = ExpectedEmit {
+        depth,
+        checks,
+        address,
+        found: false,
+        log: None,
+        anonymous,
+        count,
+        mismatch_error: None,
+    };
     if let Some(found_emit_pos) = state.expected_emits.iter().position(|(emit, _)| emit.found) {
         // The order of emits already found (back of queue) should not be modified, hence push any
         // new emit before first found emit.
@@ -857,11 +871,41 @@ pub(crate) fn handle_expect_emit(
 
     event_to_fill_or_check.found = || -> bool {
         if !checks_topics_and_data(event_to_fill_or_check.checks, expected, log) {
+            // Store detailed mismatch information
+
+            // Try to decode the events if we have a signature identifier
+            let (expected_decoded, actual_decoded) = if let Some(signatures_identifier) =
+                &state.signatures_identifier
+                && !event_to_fill_or_check.anonymous
+            {
+                (
+                    decode_event(signatures_identifier, expected),
+                    decode_event(signatures_identifier, log),
+                )
+            } else {
+                (None, None)
+            };
+            event_to_fill_or_check.mismatch_error = Some(get_emit_mismatch_message(
+                event_to_fill_or_check.checks,
+                expected,
+                log,
+                event_to_fill_or_check.anonymous,
+                expected_decoded.as_ref(),
+                actual_decoded.as_ref(),
+            ));
             return false;
         }
 
         // Maybe match source address.
-        if event_to_fill_or_check.address.is_some_and(|addr| addr != log.address) {
+        if event_to_fill_or_check
+            .address
+            .is_some_and(|addr| addr.to_checksum(None) != log.address.to_checksum(None))
+        {
+            event_to_fill_or_check.mismatch_error = Some(format!(
+                "log emitter mismatch: expected={:#x}, got={:#x}",
+                event_to_fill_or_check.address.unwrap(),
+                log.address
+            ));
             return false;
         }
 
@@ -1019,6 +1063,214 @@ fn checks_topics_and_data(checks: [bool; 5], expected: &RawLog, log: &RawLog) ->
     true
 }
 
+fn decode_event(
+    identifier: &foundry_evm_traces::identifier::SignaturesIdentifier,
+    log: &RawLog,
+) -> Option<DecodedCallLog> {
+    let topics = log.topics();
+    if topics.is_empty() {
+        return None;
+    }
+    let t0 = topics[0]; // event sig
+    // Try to identify the event
+    let event = foundry_common::block_on(identifier.identify_event(t0))?;
+
+    // Check if event already has indexed information from signatures
+    let has_indexed_info = event.inputs.iter().any(|p| p.indexed);
+    // Only use get_indexed_event if the event doesn't have indexing info
+    let indexed_event = if has_indexed_info { event } else { get_indexed_event(event, log) };
+
+    // Try to decode the event
+    if let Ok(decoded) = indexed_event.decode_log(log) {
+        let params = reconstruct_params(&indexed_event, &decoded);
+
+        let decoded_params = params
+            .into_iter()
+            .zip(indexed_event.inputs.iter())
+            .map(|(param, input)| (input.name.clone(), format_token(&param)))
+            .collect();
+
+        return Some(DecodedCallLog {
+            name: Some(indexed_event.name),
+            params: Some(decoded_params),
+        });
+    }
+
+    None
+}
+
+/// Restore the order of the params of a decoded event
+fn reconstruct_params(event: &Event, decoded: &alloy_dyn_abi::DecodedEvent) -> Vec<DynSolValue> {
+    let mut indexed = 0;
+    let mut unindexed = 0;
+    let mut inputs = vec![];
+    for input in &event.inputs {
+        if input.indexed && indexed < decoded.indexed.len() {
+            inputs.push(decoded.indexed[indexed].clone());
+            indexed += 1;
+        } else if unindexed < decoded.body.len() {
+            inputs.push(decoded.body[unindexed].clone());
+            unindexed += 1;
+        }
+    }
+    inputs
+}
+
+/// Gets a detailed mismatch message for emit assertions
+pub(crate) fn get_emit_mismatch_message(
+    checks: [bool; 5],
+    expected: &RawLog,
+    actual: &RawLog,
+    is_anonymous: bool,
+    expected_decoded: Option<&DecodedCallLog>,
+    actual_decoded: Option<&DecodedCallLog>,
+) -> String {
+    // Early return for completely different events or incompatible structures
+
+    // 1. Different number of topics
+    if actual.topics().len() != expected.topics().len() {
+        return name_mismatched_logs(expected_decoded, actual_decoded);
+    }
+
+    // 2. Different event signatures (for non-anonymous events)
+    if !is_anonymous
+        && checks[0]
+        && (!expected.topics().is_empty() && !actual.topics().is_empty())
+        && expected.topics()[0] != actual.topics()[0]
+    {
+        return name_mismatched_logs(expected_decoded, actual_decoded);
+    }
+
+    let expected_data = expected.data.as_ref();
+    let actual_data = actual.data.as_ref();
+
+    // 3. Check data
+    if checks[4] && expected_data != actual_data {
+        // Different lengths or not ABI-encoded
+        if expected_data.len() != actual_data.len()
+            || !expected_data.len().is_multiple_of(32)
+            || expected_data.is_empty()
+        {
+            return name_mismatched_logs(expected_decoded, actual_decoded);
+        }
+    }
+
+    // expected and actual events are the same, so check individual parameters
+    let mut mismatches = Vec::new();
+
+    // Check topics (indexed parameters)
+    for (i, (expected_topic, actual_topic)) in
+        expected.topics().iter().zip(actual.topics().iter()).enumerate()
+    {
+        // Skip topic[0] for non-anonymous events (already checked above)
+        if i == 0 && !is_anonymous {
+            continue;
+        }
+
+        // Only check if the corresponding check flag is set
+        if i < checks.len() && checks[i] && expected_topic != actual_topic {
+            let param_idx = if is_anonymous {
+                i // For anonymous events, topic[0] is param 0
+            } else {
+                i - 1 // For regular events, topic[0] is event signature, so topic[1] is param 0
+            };
+            mismatches
+                .push(format!("param {param_idx}: expected={expected_topic}, got={actual_topic}"));
+        }
+    }
+
+    // Check data (non-indexed parameters)
+    if checks[4] && expected_data != actual_data {
+        let num_indexed_params = if is_anonymous {
+            expected.topics().len()
+        } else {
+            expected.topics().len().saturating_sub(1)
+        };
+
+        for (i, (expected_chunk, actual_chunk)) in
+            expected_data.chunks(32).zip(actual_data.chunks(32)).enumerate()
+        {
+            if expected_chunk != actual_chunk {
+                let param_idx = num_indexed_params + i;
+                mismatches.push(format!(
+                    "param {}: expected={}, got={}",
+                    param_idx,
+                    hex::encode_prefixed(expected_chunk),
+                    hex::encode_prefixed(actual_chunk)
+                ));
+            }
+        }
+    }
+
+    if mismatches.is_empty() {
+        name_mismatched_logs(expected_decoded, actual_decoded)
+    } else {
+        // Build the error message with event names if available
+        let event_prefix = match (expected_decoded, actual_decoded) {
+            (Some(expected_dec), Some(actual_dec)) if expected_dec.name == actual_dec.name => {
+                format!(
+                    "{} param mismatch",
+                    expected_dec.name.as_ref().unwrap_or(&"log".to_string())
+                )
+            }
+            _ => {
+                if is_anonymous {
+                    "anonymous log mismatch".to_string()
+                } else {
+                    "log mismatch".to_string()
+                }
+            }
+        };
+
+        // Add parameter details if available from decoded events
+        let detailed_mismatches = if let (Some(expected_dec), Some(actual_dec)) =
+            (expected_decoded, actual_decoded)
+            && let (Some(expected_params), Some(actual_params)) =
+                (&expected_dec.params, &actual_dec.params)
+        {
+            mismatches
+                .into_iter()
+                .map(|basic_mismatch| {
+                    // Try to find the parameter name and decoded value
+                    if let Some(param_idx) = basic_mismatch
+                        .split(' ')
+                        .nth(1)
+                        .and_then(|s| s.trim_end_matches(':').parse::<usize>().ok())
+                        && param_idx < expected_params.len()
+                        && param_idx < actual_params.len()
+                    {
+                        let (expected_name, expected_value) = &expected_params[param_idx];
+                        let (_actual_name, actual_value) = &actual_params[param_idx];
+                        let param_name = if !expected_name.is_empty() {
+                            expected_name
+                        } else {
+                            &format!("param{param_idx}")
+                        };
+                        return format!(
+                            "{param_name}: expected={expected_value}, got={actual_value}",
+                        );
+                    }
+                    basic_mismatch
+                })
+                .collect::<Vec<_>>()
+        } else {
+            mismatches
+        };
+
+        format!("{} at {}", event_prefix, detailed_mismatches.join(", "))
+    }
+}
+
+/// Formats the generic mismatch message: "log != expected log" to include event names if available
+fn name_mismatched_logs(
+    expected_decoded: Option<&DecodedCallLog>,
+    actual_decoded: Option<&DecodedCallLog>,
+) -> String {
+    let expected_name = expected_decoded.and_then(|d| d.name.as_deref()).unwrap_or("log");
+    let actual_name = actual_decoded.and_then(|d| d.name.as_deref()).unwrap_or("log");
+    format!("{actual_name} != expected {expected_name}")
+}
+
 fn expect_safe_memory(state: &mut Cheatcodes, start: u64, end: u64, depth: u64) -> Result {
     ensure!(start < end, "memory range start ({start}) is greater than end ({end})");
     #[expect(clippy::single_range_in_vec_init)] // Wanted behaviour