Hacky verifytrie

Author: asdacap

src/Nethermind/Nethermind.Db/FlatDbConfig.cs

@@ -51,7 +51,7 @@ public class FlatDbConfig: IFlatDbConfig
     public int CompactInterval { get; set; } = 4;
     public int MaxInFlightCompactJob { get; set; } = 32;
     public bool ReadWithTrie { get; set; } = false;
-    public bool VerifyWithTrie { get; set; } = false;
+    public bool VerifyWithTrie { get; set; } = true;
     public bool InlineCompaction { get; set; } = false;
 
     // 1 GB is enough for 19% dirty load. Without it, then the diff layers on its own have around 35% dirty load.

src/Nethermind/Nethermind.State/Flat/FlatDiffRepository.cs

@@ -104,7 +104,7 @@ public FlatDiffRepository(
     private RefCountingPersistenceReader? _cachedReader = null;
     private readonly TrieNodeCache _trieNodeCache;
 
-    private RefCountingPersistenceReader LeaseReader()
+    public IPersistence.IPersistenceReader LeaseReader()
     {
         using var _ = _readerCacheLock.EnterScope();
         var cachedReader = _cachedReader;
@@ -798,4 +798,33 @@ public bool HasStateForBlock(StateId stateId)
         if (_currentPersistedState == stateId) return true;
         return false;
     }
+
+    public StateId? FindStateIdForStateRoot(Hash256 stateRoot)
+    {
+        using (EnterRepolockReadOnly())
+        {
+            foreach (var stateId in _inMemorySnapshotStore.GetKeysBetween(new StateId(0, Hash256.Zero), new StateId(long.MaxValue, Keccak.MaxValue)))
+            {
+                if (stateId.stateRoot == stateRoot) return stateId;
+            }
+
+            if (_currentPersistedState.stateRoot == stateRoot)
+            {
+                return _currentPersistedState;
+            }
+        }
+
+        return null;
+    }
+
+    public StateId? FindLatestAvailableState()
+    {
+        using (EnterRepolockReadOnly())
+        {
+            StateId? lastInMemory = _inMemorySnapshotStore.GetLast();
+            if (lastInMemory != null) return lastInMemory;
+
+            return _currentPersistedState;
+        }
+    }
 }

src/Nethermind/Nethermind.State/Flat/FlatStateReader.cs

@@ -8,14 +8,17 @@
 using Nethermind.Core.Utils;
 using Nethermind.Db;
 using Nethermind.Int256;
+using Nethermind.Logging;
+using Nethermind.State.Flat.ScopeProvider;
 using Nethermind.Trie;
 
 namespace Nethermind.State.Flat;
 
 public class FlatStateReader(
     [KeyFilter(DbNames.Code)] IDb codeDb,
     ReadonlyReaderRepository readonlyReaderRepositor,
-    IFlatDiffRepository flatDiffRepository
+    IFlatDiffRepository flatDiffRepository,
+    ILogManager  logManager
 ): IStateReader
 {
     public bool TryGetAccount(BlockHeader? baseBlock, Address address, out AccountStruct account)
@@ -62,7 +65,26 @@ public ReadOnlySpan<byte> GetStorage(BlockHeader? baseBlock, Address address, in
 
     public void RunTreeVisitor<TCtx>(ITreeVisitor<TCtx> treeVisitor, Hash256 stateRoot, VisitingOptions? visitingOptions = null) where TCtx : struct, INodeContext<TCtx>
     {
-        throw new NotImplementedException();
+        StateId? stateId = flatDiffRepository.FindStateIdForStateRoot(stateRoot);
+        if (stateId is null)
+        {
+            throw new InvalidOperationException($"State root {stateRoot} not found");
+        }
+
+        using RefCountingDisposableBox<SnapshotBundle> readerBox = readonlyReaderRepositor.GatherReadOnlyReaderAtBaseBlock(stateId.Value);
+        if (readerBox is null)
+        {
+            throw new InvalidOperationException($"State root {stateRoot} not found");
+        }
+
+        SnapshotBundle reader = readerBox.Item;
+        StateTrieStoreAdapter trieStoreAdapter = new StateTrieStoreAdapter(
+            reader,
+            new ConcurrencyQuota(),
+            false);
+
+        PatriciaTree patriciaTree = new PatriciaTree(trieStoreAdapter, logManager);
+        patriciaTree.Accept(treeVisitor, stateRoot, visitingOptions);
     }
 
     public bool HasStateForBlock(BlockHeader? baseBlock)