Merge remote-tracking branch 'origin/master' into evm-stream

# Conflicts:
#	src/Nethermind/Nethermind.Evm/EvmPooledMemory.cs

Author: svlachakis

src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs

@@ -78,6 +78,25 @@ public void CalculateMemoryCost_LengthExceedsULong_ShouldReturnOutOfGas()
         Assert.That(result, Is.EqualTo(0L));
     }
 
+    [TestCase(70 * 1024)]
+    [TestCase(2 * 1024 * 1024)]
+    public void Large_pooled_buffer_is_zeroed_on_reuse(int size)
+    {
+        EvmPooledMemory dirty = new();
+        UInt256 zero = UInt256.Zero;
+        Span<byte> pattern = new byte[size];
+        pattern.Fill(0xff);
+        Assert.That(dirty.TrySave(in zero, pattern), Is.True);
+        dirty.Dispose();
+
+        EvmPooledMemory clean = new();
+        UInt256 length = (UInt256)size;
+        Assert.That(clean.TryLoadSpan(in zero, in length, out Span<byte> data), Is.True);
+        Assert.That(data.Length, Is.EqualTo(size));
+        Assert.That(data.IndexOfAnyExcept((byte)0), Is.EqualTo(-1), "pooled buffer leaked stale data");
+        clean.Dispose();
+    }
+
     [Test]
     public void CalculateMemoryCost_LengthExceedsLongMax_ShouldReturnOutOfGas()
     {

src/Nethermind/Nethermind.Evm/EvmPooledMemory.cs

@@ -445,13 +445,7 @@ private static byte[] RentClean(int minLength)
 
         if (minLength > MaxCachedArrayLength)
         {
-            // Large buffers (Multicall memory, big returndata) would otherwise be fresh LOH allocations
-            // discarded every frame. Pool them through the runtime's per-core, low-contention shared pool
-            // rather than a hand-rolled cache: no per-thread large-array retention, no second pool to
-            // replicate. It may hand back a buffer dirtied by an earlier user, and RentSlow marks the whole
-            // array as zeroed, so clear the full length first. Buffers above the shared pool's 1 MB ceiling
-            // fall through to a plain allocation.
-            byte[] pooled = SafeArrayPool<byte>.Shared.Rent(minLength);
+            byte[] pooled = RentLarge(minLength);
             Array.Clear(pooled);
             return pooled;
         }
@@ -463,9 +457,7 @@ private static void ReturnClean(byte[] array, int dirtyLength)
     {
         if (array.Length > MaxCachedArrayLength)
         {
-            // Large buffers only ever come from the shared pool above, so return them there for reuse
-            // instead of dropping them to GC. Cleared on rent rather than here to avoid double-zeroing.
-            SafeArrayPool<byte>.Shared.Return(array);
+            ReturnLarge(array);
             return;
         }
 
@@ -477,6 +469,31 @@ private static void ReturnClean(byte[] array, int dirtyLength)
         }
     }
 
+#if ZK_EVM
+    private static byte[] RentLarge(int minLength) => SafeArrayPool<byte>.Shared.Rent(minLength);
+
+    private static void ReturnLarge(byte[] array) => SafeArrayPool<byte>.Shared.Return(array);
+#else
+    private const int MaxSharedArrayLength = 1 << 20;
+    // Above this, buffers fall back to plain allocation (not pooled), as before this change.
+    private const int MaxLargePooledArrayLength = 1 << 22;
+    private static readonly System.Buffers.ArrayPool<byte> _largeArrayPool =
+        System.Buffers.ArrayPool<byte>.Create(maxArrayLength: MaxLargePooledArrayLength, maxArraysPerBucket: 16);
+
+    private static byte[] RentLarge(int minLength)
+        => minLength > MaxSharedArrayLength
+            ? _largeArrayPool.Rent(minLength)
+            : SafeArrayPool<byte>.Shared.Rent(minLength);
+
+    private static void ReturnLarge(byte[] array)
+    {
+        if (array.Length > MaxSharedArrayLength)
+            _largeArrayPool.Return(array);
+        else
+            SafeArrayPool<byte>.Shared.Return(array);
+    }
+#endif
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     private void RentSlow()
     {