Consider type boundaries (#10000)

Author: flcl42

src/Nethermind/Nethermind.Core/Extensions/ByteArrayExtensions.cs

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
@@ -45,6 +45,7 @@ public static byte[] Slice(this byte[] bytes, int startIndex, int length)
         public static byte[] SliceWithZeroPaddingEmptyOnError(this byte[] bytes, int startIndex, int length)
         {
             int copiedFragmentLength = Math.Min(bytes.Length - startIndex, length);
+
             if (copiedFragmentLength <= 0)
             {
                 return [];
@@ -59,21 +60,44 @@ public static byte[] SliceWithZeroPaddingEmptyOnError(this byte[] bytes, int sta
         public static ReadOnlySpan<byte> SliceWithZeroPaddingEmptyOnError(this ReadOnlySpan<byte> bytes, int startIndex, int length)
         {
             int copiedFragmentLength = Math.Min(bytes.Length - startIndex, length);
+
             if (copiedFragmentLength <= 0)
             {
                 return default;
             }
 
+            return SafeSliceWithZeroPadding(bytes, startIndex, length, copiedFragmentLength);
+        }
+
+        public static ReadOnlySpan<byte> SliceWithZeroPaddingEmptyOnError(this ReadOnlySpan<byte> bytes, uint startIndex, uint length)
+        {
+            if (bytes.Length < startIndex)
+            {
+                return default;
+            }
+
+            long copiedFragmentLength = Math.Min((uint)bytes.Length - startIndex, length);
+
+            if (bytes.Length < startIndex + copiedFragmentLength)
+            {
+                return default;
+            }
+
+            return SafeSliceWithZeroPadding(bytes, (int)startIndex, (int)length, (int)copiedFragmentLength);
+        }
+
+        private static ReadOnlySpan<byte> SafeSliceWithZeroPadding(ReadOnlySpan<byte> bytes, int startIndex, int length, int copiedFragmentLength)
+        {
             ReadOnlySpan<byte> sliced = bytes.Slice(startIndex, copiedFragmentLength);
+
             if (copiedFragmentLength < length)
             {
                 byte[] extended = new byte[length];
                 sliced.CopyTo(extended);
-                sliced = extended;
+                return extended;
             }
 
             return sliced;
         }
-
     }
 }

src/Nethermind/Nethermind.Evm.Precompiles/ModExpPrecompile.cs

@@ -93,8 +93,16 @@ private static long DataGasCostInternal(ReadOnlySpan<byte> inputData, IReleaseSp
         ulong complexity = MultComplexity(baseLength, modulusLength, releaseSpec.IsEip7883Enabled);
 
         uint expLengthUpTo32 = Math.Min(LengthSize, expLength);
-        uint startIndex = LengthsLengths + baseLength; //+ expLength - expLengthUpTo32; // Geth takes head here, why?
-        UInt256 exp = new(inputData.SliceWithZeroPaddingEmptyOnError((int)startIndex, (int)expLengthUpTo32), isBigEndian: true);
+
+        ReadOnlySpan<byte> data = [];
+
+        if (baseLength < uint.MaxValue - LengthsLengths)
+        {
+            uint startIndex = LengthsLengths + baseLength; //+ expLength - expLengthUpTo32; // Geth takes head here, why?
+            data = inputData.SliceWithZeroPaddingEmptyOnError(startIndex, expLengthUpTo32);
+        }
+
+        UInt256 exp = new(data, isBigEndian: true);
         UInt256 iterationCount = CalculateIterationCount(expLength, exp, releaseSpec.IsEip7883Enabled);
 
         bool overflow = UInt256.MultiplyOverflow(complexity, iterationCount, out UInt256 result);
@@ -113,7 +121,7 @@ private static bool ExceedsMaxInputSize(IReleaseSpec releaseSpec, uint baseLengt
     {
         return releaseSpec.IsEip7823Enabled
             ? (baseLength > ModExpMaxInputSizeEip7823 | expLength > ModExpMaxInputSizeEip7823 | modulusLength > ModExpMaxInputSizeEip7823)
-            : (baseLength | modulusLength) > int.MaxValue;
+            : (baseLength | modulusLength) >= uint.MaxValue;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]