perf(zkevm): install the hash seed from the payload root

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/ZkEvmFixtures/ZkEvmBlockchainTests.cs

@@ -38,6 +38,9 @@ protected ZkEvmBlockchainTestFixture() : base(parallel: false, batchRead: false)
     [TestCaseSource(nameof(LoadWitnessTests))]
     public async Task WitnessMatchesFixture(BlockchainTest test) => Assert.That((await RunTest(test)).Pass, Is.True);
 
+    // Decoding installs the process-wide hash seed; this fixture is ParallelScope.All, so the
+    // reseed would otherwise land while a WitnessMatchesFixture case is hashing.
+    [NonParallelizable]
     [TestCaseSource(nameof(LoadStatelessTests))]
     public void StatelessExecutorOutputMatchesFixture(string inputBytes, string expectedOutputBytes)
     {

src/Nethermind/Nethermind.Benchmark/Core/FastHashBenchmarks.cs

@@ -5,11 +5,53 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
+#if !ZK_EVM
+using System.IO.Hashing;
+#endif
 using BenchmarkDotNet.Attributes;
+using Nethermind.Core.Crypto;
 using Nethermind.Core.Extensions;
+using Nethermind.Trie;
+using Nethermind.Trie.Pruning;
 
 namespace Nethermind.Benchmarks.Core;
 
+[ShortRunJob]
+[MemoryDiagnoser]
+public class TinyTreePathHashBenchmarks
+{
+    private const int OperationsPerInvoke = 1024;
+    private readonly HashAndTinyPath[] _keys = new HashAndTinyPath[OperationsPerInvoke];
+
+    [Params(false, true)]
+    public bool WithAddress;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+#if ZK_EVM
+        SpanExtensions.SeedHashes(new Int256.UInt256(0x243F6A8885A308D3UL, 0x13198A2E03707344UL, 0xA4093822299F31D0UL, 0x082EFA98EC4E6C89UL));
+#endif
+        Random random = new(42);
+        for (int i = 0; i < _keys.Length; i++)
+        {
+            byte[] bytes = new byte[Hash256.Size];
+            random.NextBytes(bytes);
+            TinyTreePath path = new(new TreePath(new ValueHash256(bytes), i % (TinyTreePath.MaxNibbleLength + 1)));
+            random.NextBytes(bytes);
+            _keys[i] = new HashAndTinyPath(WithAddress ? new Hash256(bytes) : null, path);
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
+    public int HashAndTinyPath()
+    {
+        int hash = 0;
+        for (int i = 0; i < _keys.Length; i++) hash = unchecked(hash + _keys[i].GetHashCode());
+        return hash;
+    }
+}
+
 [ShortRunJob]
 [DisassemblyDiagnoser]
 [MemoryDiagnoser]
@@ -21,14 +63,17 @@ public class FastHashBenchmarks
 #endif
     private byte[] _data = null!;
 
-    [Params(16, 20, 32, 64, 128, 256, 512, 1024)]
+    [Params(8, 16, 20, 32, 64, 128, 256, 512, 1024)]
     public int Size;
 
     [GlobalSetup]
     public void Setup()
     {
         _data = new byte[Size * OperationsPerInvoke];
         Random.Shared.NextBytes(_data);
+#if ZK_EVM
+        SpanExtensions.SeedHashes(new Int256.UInt256(0x243F6A8885A308D3UL, 0x13198A2E03707344UL, 0xA4093822299F31D0UL, 0x082EFA98EC4E6C89UL));
+#endif
     }
 
     [Benchmark(Baseline = true, OperationsPerInvoke = OperationsPerInvoke)]
@@ -58,21 +103,19 @@ public int FastHashAes()
         return hash;
     }
 
-#if ZK_EVM
     [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
-    public int FastHashCrc()
+    public int FastHashScalar()
     {
         int hash = 0;
         ref byte data = ref MemoryMarshal.GetArrayDataReference(_data);
-        uint seed = SpanExtensions.ComputeSeed(Size);
         for (int i = 0; i < OperationsPerInvoke; i++)
         {
             ref byte start = ref Unsafe.Add(ref data, i * Size);
-            hash = unchecked(hash + SpanExtensions.FastHashCrc(ref start, Size, seed));
+            hash = unchecked(hash + SpanExtensions.FastHashFallback(MemoryMarshal.CreateReadOnlySpan(ref start, Size)));
         }
         return hash;
     }
-#else
+#if !ZK_EVM
     [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
     public int FastHashXxHash3()
     {
@@ -81,7 +124,8 @@ public int FastHashXxHash3()
         for (int i = 0; i < OperationsPerInvoke; i++)
         {
             ReadOnlySpan<byte> input = MemoryMarshal.CreateReadOnlySpan(ref Unsafe.Add(ref data, i * Size), Size);
-            hash = unchecked(hash + SpanExtensions.FastHashXxHash3(input, XxHashSeed));
+            ulong next = XxHash3.HashToUInt64(input, XxHashSeed);
+            hash = unchecked(hash + (int)(next ^ (next >> 32)));
         }
         return hash;
     }
@@ -107,6 +151,9 @@ public void Setup()
     {
         _data = new byte[Size * OperationsPerInvoke];
         Random.Shared.NextBytes(_data);
+#if ZK_EVM
+        SpanExtensions.SeedHashes(new Int256.UInt256(0x243F6A8885A308D3UL, 0x13198A2E03707344UL, 0xA4093822299F31D0UL, 0x082EFA98EC4E6C89UL));
+#endif
     }
 
     [Benchmark(Baseline = true, OperationsPerInvoke = OperationsPerInvoke)]
@@ -125,24 +172,22 @@ public long FastHash64()
         return hash;
     }
 
-#if ZK_EVM
     [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
-    public long FastHash64Crc()
+    public long FastHash64Scalar()
     {
         long hash = 0;
         ref byte data = ref MemoryMarshal.GetArrayDataReference(_data);
-        uint seed = SpanExtensions.ComputeSeed(Size);
         for (int i = 0; i < OperationsPerInvoke; i++)
         {
             ref byte start = ref Unsafe.Add(ref data, i * Size);
             long next = Size == 20
-                ? SpanExtensions.FastHash64For20BytesCrc(ref start, seed)
-                : SpanExtensions.FastHash64For32BytesCrc(ref start, seed);
+                ? SpanExtensions.FastHash64For20BytesFallback(ref start)
+                : SpanExtensions.FastHash64For32BytesFallback(ref start);
             hash = unchecked(hash + next);
         }
         return hash;
     }
-#else
+#if !ZK_EVM
     [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
     public long FastHash64XxHash3()
     {
@@ -151,7 +196,7 @@ public long FastHash64XxHash3()
         for (int i = 0; i < OperationsPerInvoke; i++)
         {
             ref byte start = ref Unsafe.Add(ref data, i * Size);
-            hash = unchecked(hash + SpanExtensions.FastHash64XxHash3(ref start, Size, XxHashSeed));
+            hash = unchecked(hash + (long)XxHash3.HashToUInt64(MemoryMarshal.CreateReadOnlySpan(ref start, Size), XxHashSeed));
         }
         return hash;
     }

src/Nethermind/Nethermind.Benchmark/Nethermind.Benchmark.csproj

@@ -6,6 +6,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" />
+    <PackageReference Include="System.IO.Hashing" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Nethermind.Consensus.Ethash\Nethermind.Consensus.Ethash.csproj" />

src/Nethermind/Nethermind.Consensus.Test/Stateless/HashKeyedNodeStorageTests.cs

@@ -2,9 +2,13 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using Nethermind.Consensus.Stateless;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Core.Extensions;
 using Nethermind.Db;
 using Nethermind.Trie;
 using NUnit.Framework;
@@ -98,19 +102,16 @@ public void Keeps_the_seeded_empty_root_whatever_is_written_to_it([Values] bool
     }
 
     [Test]
-    public void Separates_keys_that_share_their_leading_bytes()
+    public void Separates_keys_that_share_a_hash_code()
     {
-        // The hash code is the keccak's leading four bytes, so equality is what has to tell these apart.
-        byte[] first = new byte[32];
-        byte[] second = new byte[32];
-        second[31] = 1;
+        (ValueHash256 first, ValueHash256 second) = FindHashCodeCollision();
 
         HashKeyedNodeStorage storage = Storage();
-        storage.Set(null, TreePath.Empty, new ValueHash256(first), [0x01]);
-        storage.Set(null, TreePath.Empty, new ValueHash256(second), [0x02]);
+        storage.Set(null, TreePath.Empty, first, [0x01]);
+        storage.Set(null, TreePath.Empty, second, [0x02]);
 
-        Assert.That(storage.Get(null, TreePath.Empty, new ValueHash256(first)), Is.EqualTo(new byte[] { 0x01 }));
-        Assert.That(storage.Get(null, TreePath.Empty, new ValueHash256(second)), Is.EqualTo(new byte[] { 0x02 }));
+        Assert.That(storage.Get(null, TreePath.Empty, first), Is.EqualTo(new byte[] { 0x01 }));
+        Assert.That(storage.Get(null, TreePath.Empty, second), Is.EqualTo(new byte[] { 0x02 }));
     }
 
     [Test]
@@ -165,4 +166,37 @@ private static void Write(HashKeyedNodeStorage storage, bool throughBatch, in Va
             storage.Set(null, TreePath.Empty, hash, data);
         }
     }
+
+    /// <summary>Finds two distinct keys the store buckets together, so equality is what tells them apart.</summary>
+    /// <remarks>
+    /// Searched rather than hard-coded: the hash code is seeded, so no fixed pair collides across runs.
+    /// A 32-bit birthday collision is overwhelmingly likely well inside <c>Attempts</c>.
+    /// </remarks>
+    private static (ValueHash256, ValueHash256) FindHashCodeCollision()
+    {
+        const int Attempts = 1 << 19;
+        Dictionary<int, ValueHash256> seen = new(Attempts);
+
+        for (int i = 0; i < Attempts; i++)
+        {
+            ValueHash256 candidate = ValueKeccak.Compute(MemoryMarshal.AsBytes(new ReadOnlySpan<int>(in i)));
+            int hashCode = NodeKeyHashCode(in candidate);
+
+            if (seen.TryGetValue(hashCode, out ValueHash256 previous))
+            {
+                if (previous != candidate) return (previous, candidate);
+            }
+            else
+            {
+                seen[hashCode] = candidate;
+            }
+        }
+
+        Assert.Fail($"No hash-code collision within {Attempts} keys.");
+        return default;
+    }
+
+    /// <summary>Mirrors the store's private key hash so the search targets the same buckets.</summary>
+    private static int NodeKeyHashCode(in ValueHash256 hash) =>
+        (int)SpanExtensions.FastHash64For32Bytes(ref Unsafe.As<ValueHash256, byte>(ref Unsafe.AsRef(in hash)));
 }

src/Nethermind/Nethermind.Consensus/Stateless/HashKeyedNodeStorage.cs

@@ -111,9 +111,11 @@ public void Compact() { }
     /// Equality is spelled out word-wise rather than deferred to
     /// <see cref="ValueHash256.Equals(ValueHash256)"/>, which compares
     /// <see cref="System.Runtime.Intrinsics.Vector256{T}"/>s and so expands to a byte-at-a-time loop on
-    /// the guest's target. The hash code is the keccak's own leading bytes: they are already uniformly
-    /// distributed, so <see cref="ValueHash256.GetHashCode"/>'s re-mix of all 32 buys nothing. Reading
-    /// the leading word and truncating it instead measured 0.15% worse.
+    /// the guest's target. The hash code goes through the run-seeded mixer rather than the keccak's own
+    /// leading bytes: those are uniformly distributed, which answers accidental collisions but not a
+    /// chosen witness. Unseeded, one offline grind yields node hashes sharing a bucket for every block
+    /// and payload, and nothing here rejects unreachable witness nodes. See
+    /// <see cref="SpanExtensions.SeedHashes"/>.
     /// </remarks>
     private readonly struct NodeKey(in ValueHash256 hash) : IEquatable<NodeKey>
     {
@@ -132,6 +134,7 @@ public bool Equals(NodeKey other)
 
         public override bool Equals(object? obj) => obj is NodeKey other && Equals(other);
 
-        public override int GetHashCode() => Unsafe.As<ValueHash256, int>(ref Unsafe.AsRef(in _hash));
+        public override int GetHashCode() =>
+            (int)SpanExtensions.FastHash64For32Bytes(ref Unsafe.As<ValueHash256, byte>(ref Unsafe.AsRef(in _hash)));
     }
 }

src/Nethermind/Nethermind.Core.Test/AccountTests.cs

@@ -8,6 +8,29 @@ namespace Nethermind.Core.Test;
 
 public class AccountTests
 {
+    [TestCase(0)]
+    [TestCase(1)]
+    [TestCase(2)]
+    [TestCase(3)]
+    public void Hashing_includes_each_account_field(int field)
+    {
+        Account original = new(1UL, 2, TestItem.KeccakA, TestItem.KeccakB);
+        Account changed = field switch
+        {
+            0 => original.WithChangedNonce(0x100000000UL),
+            1 => original.WithChangedBalance(3),
+            2 => original.WithChangedStorageRoot(TestItem.KeccakC),
+            _ => original.WithChangedCodeHash(TestItem.KeccakC)
+        };
+        Account equal = new(1UL, 2, TestItem.KeccakA, TestItem.KeccakB);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(equal.GetHashCode(), Is.EqualTo(original.GetHashCode()));
+            Assert.That(changed.GetHashCode(), Is.Not.EqualTo(original.GetHashCode()));
+        }
+    }
+
     [Test]
     public void Test_totally_empty()
     {