eip-7883 implementation

src/Nethermind/Chains/chiado.json

@@ -94,6 +94,7 @@
     "depositContractAddress": "0xb97036A26259B7147018913bD58a774cf91acf25",
     "blobSchedule": [
       {
+        "name": "cancun",
         "timestamp": "0x65ba8e4c",
         "target": 1,
         "max": 2,

src/Nethermind/Chains/gnosis.json

@@ -101,6 +101,7 @@
     "depositContractAddress": "0x0B98057eA310F4d31F2a452B414647007d1645d9",
     "blobSchedule": [
       {
+        "name": "cancun",
         "timestamp": "0x65ef4dbc",
         "target": 1,
         "max": 2,

src/Nethermind/Chains/holesky.json

@@ -63,6 +63,7 @@
     "MergeForkIdTransition": "0x0",
     "blobSchedule": [
       {
+        "name": "prague",
         "timestamp": "0x67BCEAC0",
         "target": 6,
         "max": 9,

src/Nethermind/Chains/hoodi.json

@@ -56,6 +56,7 @@
     "eip6780TransitionTimestamp": "0x0",
     "blobSchedule": [
       {
+        "name": "prague",
         "timestamp": "0x67e41118",
         "target": 6,
         "max": 9,

src/Nethermind/Chains/sepolia.json

@@ -77,6 +77,7 @@
     "depositContractAddress": "0x7f02c3e3c98b133055b8b348b2ac625669ed295d",
     "blobSchedule": [
       {
+        "name": "prague",
         "timestamp": "0x67C7FD60",
         "target": 6,
         "max": 9,

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/OsakaBlockChainTests.cs

@@ -10,6 +10,7 @@
 namespace Ethereum.Blockchain.Pyspec.Test;
 
 [TestFixture]
+[Ignore("EOF")]
 [Parallelizable(ParallelScope.All)]
 public class OsakaBlockChainTests : BlockchainTestBase
 {

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/OsakaEofTests.cs

@@ -9,6 +9,7 @@
 namespace Ethereum.Blockchain.Pyspec.Test;
 
 [TestFixture]
+[Ignore("EOF")]
 [Parallelizable(ParallelScope.All)]
 public class OsakaEofTests : EofTestBase
 {

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/OsakaStateTests.cs

@@ -10,6 +10,7 @@
 namespace Ethereum.Blockchain.Pyspec.Test;
 
 [TestFixture]
+[Ignore("EOF")]
 [Parallelizable(ParallelScope.All)]
 public class OsakaStateTests : GeneralStateTestBase
 {

src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs

@@ -353,6 +353,11 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec
         /// </summary>
         bool IsEip7825Enabled { get; }
 
+        /// <summary>
+        ///  Increase ModExp Gas Cost
+        /// </summary>
+        bool IsEip7883Enabled { get; }
+
         /// <summary>
         /// Should transactions be validated against chainId.
         /// </summary>

src/Nethermind/Nethermind.Core/Specs/ReleaseSpecDecorator.cs

@@ -90,6 +90,7 @@ public class ReleaseSpecDecorator(IReleaseSpec spec) : IReleaseSpec
     public virtual bool IsOpIsthmusEnabled => spec.IsOpIsthmusEnabled;
     public virtual bool IsEip7623Enabled => spec.IsEip7623Enabled;
     public virtual bool IsEip7825Enabled => spec.IsEip7825Enabled;
+    public bool IsEip7883Enabled => spec.IsEip7883Enabled;
     public virtual ulong WithdrawalTimestamp => spec.WithdrawalTimestamp;
     public virtual ulong Eip4844TransitionTimestamp => spec.Eip4844TransitionTimestamp;
     public virtual bool IsEofEnabled => spec.IsEofEnabled;

src/Nethermind/Nethermind.Evm.Test/Eip7883Tests.cs

@@ -0,0 +1,96 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Collections.Generic;
+using FluentAssertions;
+using Nethermind.Core.Specs;
+using Nethermind.Evm.Precompiles;
+using Nethermind.Int256;
+using Nethermind.Specs;
+using NUnit.Framework;
+
+namespace Nethermind.Evm.Test;
+
+public class Eip7883Tests
+{
+    [Test]
+    public void DataGasCost([ValueSource(nameof(Eip7883TestCases))] Eip7883TestCase test)
+    {
+        var inputData = PrepareInput(test.BaseLength, test.ExpLength, test.ModulusLength);
+
+        long gas = ModExpPrecompile.Instance.DataGasCost(inputData, test.Spec);
+        gas.Should().Be(test.Result);
+    }
+
+    public class Eip7883TestCase
+    {
+        public IReleaseSpec Spec { get; set; }
+        public UInt256 BaseLength { get; set; }
+        public UInt256 ExpLength { get; set; }
+        public UInt256 ModulusLength { get; set; }
+        public long Result { get; set; }
+    }
+
+    private static readonly IReleaseSpec SpecEipEnabled = new ReleaseSpec
+    {
+        IsEip7883Enabled = true,
+        IsEip2565Enabled = true,
+    };
+
+    private static readonly IReleaseSpec SpecEipDisabled = new ReleaseSpec
+    {
+        IsEip7883Enabled = false,
+        IsEip2565Enabled = true,
+    };
+
+    private static IEnumerable<Eip7883TestCase> Eip7883TestCases()
+    {
+        // eip enabled test cases
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 32, ExpLength = 32, ModulusLength = 32, Result = 500L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 32, ExpLength = 32, ModulusLength = 10000, Result = 1041666L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 32, ExpLength = 10000, ModulusLength = 32, Result = 850602L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 10000, ExpLength = 32, ModulusLength = 32, Result = 1041666L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 32, ExpLength = 10000, ModulusLength = 10000, Result = 166133333333L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 10000, ExpLength = 10000, ModulusLength = 32, Result = 166133333333L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 10000, ExpLength = 32, ModulusLength = 10000, Result = 1041666L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipEnabled, BaseLength = 10000, ExpLength = 10000, ModulusLength = 10000, Result = 166133333333L };
+
+        // eip disabled test cases
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 32, ExpLength = 32, ModulusLength = 32, Result = 200L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 32, ExpLength = 32, ModulusLength = 10000, Result = 520833L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 32, ExpLength = 10000, ModulusLength = 32, Result = 425301L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 10000, ExpLength = 32, ModulusLength = 32, Result = 520833L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 32, ExpLength = 10000, ModulusLength = 10000, Result = 41533333333L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 10000, ExpLength = 10000, ModulusLength = 32, Result = 41533333333L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 10000, ExpLength = 32, ModulusLength = 10000, Result = 520833L };
+        yield return new Eip7883TestCase
+        { Spec = SpecEipDisabled, BaseLength = 10000, ExpLength = 10000, ModulusLength = 10000, Result = 41533333333L };
+    }
+
+    private static ReadOnlyMemory<byte> PrepareInput(UInt256 baseLength, UInt256 expLength, UInt256 modulusLength)
+    {
+        var inputBytes = new byte[96];
+
+        Array.Copy(baseLength.ToBigEndian(), 0, inputBytes, 0, 32);
+        Array.Copy(expLength.ToBigEndian(), 0, inputBytes, 32, 32);
+        Array.Copy(modulusLength.ToBigEndian(), 0, inputBytes, 64, 32);
+
+        return new ReadOnlyMemory<byte>(inputBytes);
+    }
+}

src/Nethermind/Nethermind.Evm/GasCostOf.cs

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
 namespace Nethermind.Evm
@@ -71,6 +71,9 @@ public static class GasCostOf
         public const long TxDataNonZeroMultiplier = TxDataNonZero / TxDataZero;
         public const long TxDataNonZeroMultiplierEip2028 = TxDataNonZeroEip2028 / TxDataZero;
 
+        public const long MinModExpEip2565 = 200; // eip-2565
+        public const long MinModExpEip7883 = 500; // eip-7883
+
         // Eof Execution EIP-7692
         public const long DataLoad = 4;
         public const long DataLoadN = 3;

src/Nethermind/Nethermind.Evm/Precompiles/ModExpPrecompile.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;
@@ -70,15 +70,20 @@ public long DataGasCost(ReadOnlyMemory<byte> inputData, IReleaseSpec releaseSpec
                     return long.MaxValue;
                 }
 
-                UInt256 complexity = MultComplexity(baseLength, modulusLength);
+                if (ExceedsMaxInputSize(releaseSpec, baseLength, expLength, modulusLength))
+                {
+                    return long.MaxValue;
+                }
+
+                UInt256 complexity = MultComplexity(baseLength, modulusLength, releaseSpec.IsEip7883Enabled);
 
                 UInt256 expLengthUpTo32 = UInt256.Min(32, expLength);
                 UInt256 startIndex = 96 + baseLength; //+ expLength - expLengthUpTo32; // Geth takes head here, why?
                 UInt256 exp = new(inputData.Span.SliceWithZeroPaddingEmptyOnError((int)startIndex, (int)expLengthUpTo32), true);
-                UInt256 iterationCount = CalculateIterationCount(expLength, exp);
+                UInt256 iterationCount = CalculateIterationCount(expLength, exp, releaseSpec.IsEip7883Enabled);
                 bool overflow = UInt256.MultiplyOverflow(complexity, iterationCount, out UInt256 result);
                 result /= 3;
-                return result > long.MaxValue || overflow ? long.MaxValue : Math.Max(200L, (long)result);
+                return result > long.MaxValue || overflow ? long.MaxValue : Math.Max(releaseSpec.IsEip7883Enabled ? GasCostOf.MinModExpEip7883 : GasCostOf.MinModExpEip2565, (long)result);
             }
             catch (OverflowException)
             {
@@ -192,14 +197,18 @@ public static (byte[], bool) OldRun(byte[] inputData)
         /// return words**2
         /// </summary>
         /// <returns></returns>
-        private static UInt256 MultComplexity(in UInt256 baseLength, in UInt256 modulusLength)
+        private static UInt256 MultComplexity(in UInt256 baseLength, in UInt256 modulusLength, bool isEip7883Enabled)
         {
             UInt256 maxLength = UInt256.Max(baseLength, modulusLength);
             UInt256.Mod(maxLength, 8, out UInt256 mod8);
             UInt256 words = (maxLength / 8) + ((mod8.IsZero) ? UInt256.Zero : UInt256.One);
-            return words * words;
+            return maxLength > 32 && isEip7883Enabled ? 2 * words * words : words * words;
         }
 
+        static readonly UInt256 IterationCountMultiplierEip2565 = 8;
+
+        static readonly UInt256 IterationCountMultiplierEip7883 = 16;
+
         /// <summary>
         /// def calculate_iteration_count(exponent_length, exponent):
         /// iteration_count = 0
@@ -210,8 +219,9 @@ private static UInt256 MultComplexity(in UInt256 baseLength, in UInt256 modulusL
         /// </summary>
         /// <param name="exponentLength"></param>
         /// <param name="exponent"></param>
+        /// <param name="isEip7883Enabled"></param>
         /// <returns></returns>
-        private static UInt256 CalculateIterationCount(UInt256 exponentLength, UInt256 exponent)
+        private static UInt256 CalculateIterationCount(UInt256 exponentLength, UInt256 exponent, bool isEip7883Enabled)
         {
             try
             {
@@ -228,7 +238,9 @@ private static UInt256 CalculateIterationCount(UInt256 exponentLength, UInt256 e
                         bitLength--;
                     }
 
-                    bool overflow = UInt256.MultiplyOverflow((exponentLength - 32), 8, out UInt256 multiplicationResult);
+                    bool overflow = UInt256.MultiplyOverflow(exponentLength - 32,
+                        isEip7883Enabled ? IterationCountMultiplierEip7883 : IterationCountMultiplierEip2565,
+                        out UInt256 multiplicationResult);
                     overflow |= UInt256.AddOverflow(multiplicationResult, (UInt256)bitLength, out iterationCount);
                     if (overflow)
                     {

src/Nethermind/Nethermind.Specs.Test/ChainParametersTests.cs

@@ -1,11 +1,13 @@
 // SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
-using System.Collections.Generic;
-using System.Linq;
+using Nethermind.Core.Specs;
 using Nethermind.Specs.ChainSpecStyle;
 using Nethermind.Specs.ChainSpecStyle.Json;
 using NUnit.Framework;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 
 namespace Nethermind.Specs.Test;
 
@@ -29,4 +31,42 @@ public void ChainParameters_should_have_same_properties_as_chainSpecParamsJson()
 
         Assert.That(chainParametersProperties, Is.EquivalentTo(chainSpecParamsJsonProperties));
     }
+
+    [Test]
+    public void ChainParameters_should_be_loaded_from_chainSpecParamsJson()
+    {
+        // eips with additional dependencies or non standard names
+        string[] exceptions = [
+            "MaxCodeSizeTransitionTimestamp",
+            "Eip4844FeeCollectorTransitionTimestamp",
+            "Eip6110TransitionTimestamp",
+            "Eip7692TransitionTimestamp"
+        ];
+
+        const ulong testValue = 1ul;
+
+        foreach (PropertyInfo jsonParamsProp in typeof(ChainSpecParamsJson).GetProperties().Where(x => x.Name.EndsWith("TransitionTimestamp") && !exceptions.Contains(x.Name)))
+        {
+            ChainSpecJson test = new() { Params = new ChainSpecParamsJson() };
+            jsonParamsProp.SetValue(test.Params, testValue);
+            (ChainSpecBasedSpecProvider? prov, ChainSpec? spec) = TestSpecHelper.LoadChainSpec(test);
+
+            PropertyInfo? paramsProp = typeof(ChainParameters).GetProperty(jsonParamsProp.Name);
+
+            Assert.That(paramsProp, Is.Not.Null, $"Property {jsonParamsProp.Name} not found in ChainParameters.");
+            object? paramsValue = paramsProp.GetValue(spec.Parameters);
+            Assert.That(paramsValue, Is.EqualTo(testValue), $"Property {jsonParamsProp.Name} in ChainParameters does not match the value set in ChainSpecParamsJson, got {paramsValue} expected {testValue}.");
+
+
+            IReleaseSpec preSpec = prov.GetSpec(ForkActivation.TimestampOnly(0));
+            string specPropName = $"Is{jsonParamsProp.Name.Replace("TransitionTimestamp", "")}Enabled";
+            PropertyInfo? specProp = preSpec.GetType().GetProperty(specPropName);
+            Assert.That(specProp, Is.Not.Null, $"Property {specPropName} not found in {preSpec.GetType().Name}.");
+
+            Assert.That(specProp.GetValue(preSpec), Is.False, $"Property {specPropName} is activated, which was not expected.");
+
+            IReleaseSpec postSpec = prov.GetSpec(ForkActivation.TimestampOnly(1));
+            Assert.That(specProp.GetValue(postSpec), Is.True, $"Property {specPropName} is not activated.");
+        }
+    }
 }

src/Nethermind/Nethermind.Specs.Test/ChainSpecStyle/ChainSpecBasedSpecProviderTests.cs

@@ -829,15 +829,14 @@ public void Test_BlobSchedule_IsApplied_AlongWithForkSchedule(
         BlobScheduleSettings[] blobScheduleSettings,
         ulong[] expectedActivationSettings)
     {
-        ChainSpecBasedSpecProvider provider = new(new ChainSpec
+        (ChainSpecBasedSpecProvider provider, _) = TestSpecHelper.LoadChainSpec(new ChainSpecJson
         {
-            Parameters = new ChainParameters
+            Params = new ChainSpecParamsJson
             {
                 Eip4844TransitionTimestamp = eip4844Timestamp,
                 Eip7002TransitionTimestamp = eip7002Timestamp,
                 BlobSchedule = [.. blobScheduleSettings]
             },
-            EngineChainSpecParametersProvider = Substitute.For<IChainSpecParametersProvider>()
         });
 
         IReleaseSpec spec = provider.GenesisSpec;
@@ -863,7 +862,7 @@ static TestCaseData MakeTestCase(string testName, int eip4844Timestamp, int eip7
                 => new([
                     (ulong)eip4844Timestamp,
                     (ulong)eip7002Timestamp,
-                    settings.Select(s => new BlobScheduleSettings { Timestamp = (ulong)s.timestamp, Max = (ulong)s.max, Target = (ulong)s.max, BaseFeeUpdateFraction = (ulong)s.max }).ToArray(),
+                    settings.Select(s => new BlobScheduleSettings { Timestamp = (ulong)s.timestamp, Max = (ulong)s.max }).ToArray(),
                     expectedActivationSettings])
                 { TestName = $"BlobScheduleActivations: {testName}" };
 
@@ -893,6 +892,10 @@ static TestCaseData MakeTestCase(string testName, int eip4844Timestamp, int eip7
             yield return MakeTestCase("BPOs match named forks", 1, 2, [(1, 10), (2, 3)], [NoneAllowed, 10, 3]);
 
             yield return MakeTestCase("BPO timestamp matches genesis, but not any other fork", 0, 2, [(0, 10), (1, 11)], [10, 11, 11]);
+
+            yield return MakeTestCase("Unordered", 0, 2, [(4, 10), (3, 11)], [Default, Default, 11, 10]);
+
+            yield return MakeTestCase("Unordered between named forks", 0, 2, [(4, 10), (1, 11)], [Default, 11, 11, 10]);
         }
     }
 

src/Nethermind/Nethermind.Specs.Test/MainnetSpecProviderTests.cs

@@ -77,7 +77,9 @@ public void Prague_eips(long blockNumber, ulong timestamp, bool isEnabled)
         [TestCase(MainnetSpecProvider.ParisBlockNumber, MainnetSpecProvider.OsakaBlockTimestamp, true)]
         public void Osaka_eips(long blockNumber, ulong timestamp, bool isEnabled)
         {
-            _specProvider.GetSpec(new ForkActivation(blockNumber, timestamp)).IsEofEnabled.Should().Be(isEnabled);
+            _specProvider.GetSpec(new ForkActivation(blockNumber, timestamp)).IsEip7594Enabled.Should().Be(isEnabled);
+            _specProvider.GetSpec(new ForkActivation(blockNumber, timestamp)).IsEip7823Enabled.Should().Be(isEnabled);
+            _specProvider.GetSpec(new ForkActivation(blockNumber, timestamp)).IsEip7883Enabled.Should().Be(isEnabled);
         }
 
         [Test]

src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs

@@ -126,6 +126,8 @@ public UInt256 BlockReward
 
         public bool IsEip7623Enabled => _spec.IsEip7623Enabled;
 
+        public bool IsEip7883Enabled => _spec.IsEip7883Enabled;
+
         public bool IsEip3607Enabled { get; set; }
 
         public bool IsEip158IgnoredAccount(Address address) => _spec.IsEip158IgnoredAccount(address);