Revert "Merge branch 'master' of https://github.com/NethermindEth/nethermind into perf/block-processing-pipeline-v1"

This reverts commit 1d7dede, reversing
changes made to 46ae4aa.

Author: kamilchodola

src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs

@@ -101,8 +101,7 @@ protected virtual TxReceipt[] ProcessBlock(
 
         StoreBeaconRoot(block, spec);
         blockHashStore.ApplyBlockhashStateChanges(header, spec);
-        // System call changes (beacon root, blockhash) accumulate in journal and are
-        // flushed together with transaction changes in the commit after ProcessTransactions.
+        _stateProvider.Commit(spec, commitRoots: false);
 
         TxReceipt[] receipts = blockTransactionsExecutor.ProcessTransactions(block, options, ReceiptsTracer, token);
 

src/Nethermind/Nethermind.Evm/TransactionProcessing/TransactionProcessor.cs

@@ -211,13 +211,7 @@ protected virtual TransactionResult Execute(Transaction tx, ITxTracer tracer, Ex
                 return result;
             }
 
-            // Commit pre-execution changes (nonce increment, gas reservation) when:
-            // - restore: CallAndRestore needs state in _blockChanges to survive Reset()
-            // - tracer.IsTracingState: tracers need to see nonce/gas changes separately
-            // In the normal block-processing path (commit && !restore && !IsTracingState), skip this commit —
-            // pre-execution changes stay in the journal and are flushed with execution changes, saving one Commit cycle.
-            if (commit && (restore || tracer.IsTracingState))
-                WorldState.Commit(spec, tracer.IsTracingState ? tracer : NullStateTracer.Instance, commitRoots: false);
+            if (commit) WorldState.Commit(spec, tracer.IsTracingState ? tracer : NullTxTracer.Instance, commitRoots: false);
 
             // substate.Logs contains a reference to accessTracker.Logs so we can't Dispose until end of the method
             using StackAccessTracker accessTracker = new();

src/Nethermind/Nethermind.State/PersistentStorageProvider.cs

@@ -43,10 +43,6 @@ internal sealed class PersistentStorageProvider : PartialStorageProviderBase
 
     private readonly HashSet<StorageCell> _committedThisRound = new();
 
-    // Read-only cache: storage values loaded from the tree but not modified in the current tx.
-    // Avoids creating JustCache journal entries for pure reads, reducing Commit iteration cost.
-    private readonly Dictionary<StorageCell, byte[]> _storageReadCache = new();
-
     /// <summary>
     /// Manages persistent storage allowing for snapshotting and restoring
     /// Persists data to ITrieStore
@@ -66,7 +62,6 @@ public override void Reset(bool resetBlockChanges = true)
         base.Reset();
         _originalValues.Clear();
         _committedThisRound.Clear();
-        _storageReadCache.Clear();
         if (resetBlockChanges)
         {
             _storages.ResetAndClear();
@@ -84,16 +79,8 @@ public void SetBackendScope(IWorldStateScopeProvider.IScope scope)
     /// </summary>
     /// <param name="storageCell">Storage location</param>
     /// <returns>Value at location</returns>
-    protected override ReadOnlySpan<byte> GetCurrentValue(in StorageCell storageCell)
-    {
-        if (TryGetCachedValue(storageCell, out byte[]? bytes))
-            return bytes!;
-
-        if (_storageReadCache.TryGetValue(storageCell, out byte[]? cached))
-            return cached;
-
-        return LoadFromTree(storageCell);
-    }
+    protected override ReadOnlySpan<byte> GetCurrentValue(in StorageCell storageCell) =>
+        TryGetCachedValue(storageCell, out byte[]? bytes) ? bytes! : LoadFromTree(storageCell);
 
     /// <summary>
     /// Return the original persistent storage value from the storage cell
@@ -135,26 +122,16 @@ public bool IsStorageEmpty(Address address) =>
     /// Used for persistent storage specific logic
     /// </summary>
     /// <param name="tracer">Storage tracer</param>
-    // Override Commit to also call CommitCore when storage read-cache has entries for tracing
-    public new void Commit(IStorageTracer tracer)
-    {
-        if (_changes.Count == 0 && (!tracer.IsTracingStorage || _storageReadCache.Count == 0))
-        {
-            if (_logger.IsTrace) _logger.Trace("No storage changes to commit");
-            _storageReadCache.Clear();
-        }
-        else
-        {
-            CommitCore(tracer);
-        }
-    }
-
     protected override void CommitCore(IStorageTracer tracer)
     {
         if (_logger.IsTrace) _logger.Trace("Committing storage changes");
 
         int currentPosition = _changes.Count - 1;
-        if (currentPosition >= 0 && _changes[currentPosition].IsNull)
+        if (currentPosition < 0)
+        {
+            return;
+        }
+        if (_changes[currentPosition].IsNull)
         {
             throw new InvalidOperationException($"Change at current position {currentPosition} was null when committing {nameof(PartialStorageProviderBase)}");
         }
@@ -247,26 +224,9 @@ protected override void CommitCore(IStorageTracer tracer)
         }
         toUpdateRoots.Clear();
 
-        // Report storage reads from read cache for tracing (read-cache entries bypass the journal)
-        if (isTracing)
-        {
-            foreach (KeyValuePair<StorageCell, byte[]> kvp in _storageReadCache)
-            {
-                if (!_committedThisRound.Contains(kvp.Key))
-                {
-                    tracer!.ReportStorageRead(kvp.Key);
-                }
-                else if (trace!.TryGetValue(kvp.Key, out StorageChangeTrace existingTrace))
-                {
-                    trace[kvp.Key] = new StorageChangeTrace(kvp.Value, existingTrace.After);
-                }
-            }
-        }
-
         base.CommitCore(tracer);
         _originalValues.Clear();
         _committedThisRound.Clear();
-        _storageReadCache.Clear();
 
         if (isTracing)
         {
@@ -422,19 +382,6 @@ public override void ClearStorage(Address address)
     {
         base.ClearStorage(address);
 
-        // Cells in _storageReadCache bypassed the journal, so base.ClearStorage (which
-        // iterates _intraBlockCache) didn't set them to zero. Write explicit Update entries
-        // for cells belonging to this address so CommitCore flushes zeros to BlockChange.
-        // ClearStorage is rare (selfdestruct only).
-        foreach (KeyValuePair<StorageCell, byte[]> kvp in _storageReadCache)
-        {
-            if (kvp.Key.Address == address)
-            {
-                Set(kvp.Key, StorageTree.ZeroBytes);
-            }
-        }
-        _storageReadCache.Clear();
-
         _toUpdateRoots.TryAdd(address, true);
 
         PerContractState state = GetOrCreateStorage(address);
@@ -607,13 +554,7 @@ public ReadOnlySpan<byte> LoadFromTree(in StorageCell storageCell)
                 Db.Metrics.IncrementStorageTreeCache();
             }
 
-            if (!storageCell.IsHash)
-            {
-                // Populate _originalValues for EIP-2200 net gas metering and _storageReadCache
-                // to avoid creating JustCache journal entries that add commit overhead.
-                _provider._originalValues[storageCell] = valueChange.After;
-                _provider._storageReadCache[storageCell] = valueChange.After;
-            }
+            if (!storageCell.IsHash) _provider.PushToRegistryOnly(storageCell, valueChange.After);
             return valueChange.After;
         }
 

src/Nethermind/Nethermind.State/StateProvider.cs

@@ -33,9 +33,6 @@ internal class StateProvider
         private readonly Dictionary<AddressAsKey, StackList<int>> _intraTxCache = new();
         private readonly HashSet<AddressAsKey> _committedThisRound = new();
         private readonly HashSet<AddressAsKey> _nullAccountReads = new();
-        // Read-only cache: accounts looked up from _blockChanges but not modified in the current tx.
-        // Avoids creating JustCache journal entries for pure reads, reducing Commit iteration cost.
-        private readonly Dictionary<AddressAsKey, Account?> _readCache = new();
         // Only guarding against hot duplicates so filter doesn't need to be too big
         // Note:
         // False negatives are fine as they will just result in a overwrite set
@@ -93,23 +90,10 @@ public bool IsContract(Address address)
             return account is not null && account.IsContract;
         }
 
-        public bool AccountExists(Address address)
-        {
-            if (_intraTxCache.TryGetValue(address, out StackList<int> value))
-            {
-                return _changes[value.Peek()]!.ChangeType != ChangeType.Delete;
-            }
-
-            AddressAsKey key = address;
-            if (_readCache.TryGetValue(key, out Account? cached))
-            {
-                return cached is not null;
-            }
-
-            Account? account = GetState(address);
-            _readCache[key] = account;
-            return account is not null;
-        }
+        public bool AccountExists(Address address) =>
+            _intraTxCache.TryGetValue(address, out StackList<int> value)
+                ? _changes[value.Peek()]!.ChangeType != ChangeType.Delete
+                : GetAndAddToCache(address) is not null;
 
         public Account GetAccount(Address address) => GetThroughCache(address) ?? Account.TotallyEmpty;
 
@@ -619,31 +603,12 @@ public void Commit(IReleaseSpec releaseSpec, IWorldStateTracer stateTracer, bool
                 }
             }
 
-            // When tracing, reconcile _readCache entries with the trace:
-            // - Accounts both read-cached and modified: set the Before value from read cache
-            // - Accounts only read-cached: report as read-only via _nullAccountReads
-            if (trace is not null)
-            {
-                foreach (KeyValuePair<AddressAsKey, Account?> kvp in _readCache)
-                {
-                    if (trace.TryGetValue(kvp.Key, out ChangeTrace existingTrace))
-                    {
-                        trace[kvp.Key] = new ChangeTrace(kvp.Value, existingTrace.After);
-                    }
-                    else
-                    {
-                        _nullAccountReads.Add(kvp.Key);
-                    }
-                }
-            }
-
             trace?.ReportStateTrace(stateTracer, _nullAccountReads, this);
 
             _changes.Clear();
             _committedThisRound.Clear();
             _nullAccountReads.Clear();
             _intraTxCache.ResetAndClear();
-            _readCache.Clear();
 
             codeFlushTask.GetAwaiter().GetResult();
 
@@ -791,15 +756,7 @@ internal void SetState(Address address, Account? account)
                 return _changes[value.Peek()].Account;
             }
 
-            // Check read-only cache before falling through to journal
-            AddressAsKey key = address;
-            if (_readCache.TryGetValue(key, out Account? cached))
-            {
-                return cached;
-            }
-
-            Account? account = GetState(address);
-            _readCache[key] = account;
+            Account account = GetAndAddToCache(address);
             return account;
         }
 
@@ -822,7 +779,6 @@ private void Push(Address address, Account? touchedAccount, ChangeType changeTyp
         {
             StackList<int> stack = SetupCache(address);
             if (changeType == ChangeType.Touch
-                && stack.Count > 0
                 && _changes[stack.Peek()]!.ChangeType == ChangeType.Touch)
             {
                 return;
@@ -886,7 +842,6 @@ public void Reset(bool resetBlockChanges = true)
             _intraTxCache.ResetAndClear();
             _committedThisRound.Clear();
             _nullAccountReads.Clear();
-            _readCache.Clear();
             _changes.Clear();
             _needsStateRootUpdate = false;