From fea753beb27fefe55c6b897518777fdd31347591 Mon Sep 17 00:00:00 2001
From: Matthias Seitz <matthias.seitz@outlook.de>
Date: Thu, 24 Aug 2023 17:31:39 +0200
Subject: [PATCH] fix: compare prev value against new value (#4347)

---
 .../revm/revm-inspectors/src/tracing/types.rs | 46 +++++++++++++------
 1 file changed, 33 insertions(+), 13 deletions(-)

diff --git a/crates/revm/revm-inspectors/src/tracing/types.rs b/crates/revm/revm-inspectors/src/tracing/types.rs
index 6c87783054..6a64738854 100644
--- a/crates/revm/revm-inspectors/src/tracing/types.rs
+++ b/crates/revm/revm-inspectors/src/tracing/types.rs
@@ -310,31 +310,51 @@ impl CallTraceNode {
         // iterate over all storage diffs
         for change in self.trace.steps.iter().filter_map(|s| s.storage_change) {
             let StorageChange { key, value, had_value } = change;
-            let value = H256::from(value);
+            let h256_value = H256::from(value);
             match acc.storage.entry(key.into()) {
                 Entry::Vacant(entry) => {
                     if let Some(had_value) = had_value {
-                        entry.insert(Delta::Changed(ChangedType {
-                            from: had_value.into(),
-                            to: value,
-                        }));
+                        if value != had_value {
+                            entry.insert(Delta::Changed(ChangedType {
+                                from: had_value.into(),
+                                to: h256_value,
+                            }));
+                        }
                     } else {
-                        entry.insert(Delta::Added(value));
+                        entry.insert(Delta::Added(h256_value));
                     }
                 }
                 Entry::Occupied(mut entry) => {
                     let value = match entry.get() {
-                        Delta::Unchanged => Delta::Added(value),
-                        Delta::Added(added) => {
-                            if added == &value {
-                                Delta::Added(*added)
+                        Delta::Unchanged => {
+                            if let Some(had_value) = had_value {
+                                if value != had_value {
+                                    Delta::Changed(ChangedType {
+                                        from: had_value.into(),
+                                        to: h256_value,
+                                    })
+                                } else {
+                                    Delta::Unchanged
+                                }
                             } else {
-                                Delta::Changed(ChangedType { from: *added, to: value })
+                                Delta::Added(h256_value)
                             }
                         }
-                        Delta::Removed(_) => Delta::Added(value),
+                        Delta::Added(added) => {
+                            if added == &h256_value {
+                                Delta::Added(*added)
+                            } else {
+                                Delta::Changed(ChangedType { from: *added, to: h256_value })
+                            }
+                        }
+                        Delta::Removed(_) => Delta::Added(h256_value),
                         Delta::Changed(c) => {
-                            Delta::Changed(ChangedType { from: c.from, to: value })
+                            if c.from == h256_value {
+                                // remains unchanged if the value is the same
+                                Delta::Unchanged
+                            } else {
+                                Delta::Changed(ChangedType { from: c.from, to: h256_value })
+                            }
                         }
                     };
                     entry.insert(value);