Add OP Holocene fork

src/Nethermind/Chains/base-sepolia.json

@@ -10,6 +10,7 @@
         "ecotoneTimestamp": "0x65d62c10",
         "fjordTimestamp": "0x66575100",
         "graniteTimestamp": "0x66ba3180",
+        "holoceneTimestamp": "0x6745e270",
         "l1FeeRecipient": "0x420000000000000000000000000000000000001A",
         "l1BlockAddress": "0x4200000000000000000000000000000000000015",
         "canyonBaseFeeChangeDenominator": "250",
@@ -64,9 +65,10 @@
     "eip4844TransitionTimestamp": "0x65D62C10",
     "eip5656TransitionTimestamp": "0x65D62C10",
     "eip6780TransitionTimestamp": "0x65D62C10",
-    
+
     "rip7212TransitionTimestamp": "0x66575100",
     "opGraniteTransitionTimestamp": "0x66ba3180",
+    "opHoloceneTransitionTimestamp": "0x6745e270",
 
     "terminalTotalDifficulty": "0"
   },

src/Nethermind/Chains/op-sepolia.json

@@ -10,6 +10,7 @@
         "ecotoneTimestamp": "0x65D62C10",
         "fjordTimestamp": "0x66575100",
         "graniteTimestamp": "0x66ba3180",
+        "holoceneTimestamp": "0x6745e270",
         "l1FeeRecipient": "0x420000000000000000000000000000000000001A",
         "l1BlockAddress": "0x4200000000000000000000000000000000000015",
         "canyonBaseFeeChangeDenominator": "250",
@@ -64,6 +65,7 @@
     "eip6780TransitionTimestamp": "0x65D62C10",
     "rip7212TransitionTimestamp": "0x66575100",
     "opGraniteTransitionTimestamp": "0x66ba3180",
+    "opHoloceneTransitionTimestamp": "0x6745e270",
     "terminalTotalDifficulty": "0"
   },
   "genesis": {

src/Nethermind/Nethermind.Consensus/Validators/HeaderValidator.cs

@@ -20,7 +20,7 @@ public class HeaderValidator : IHeaderValidator
         private static readonly byte[] DaoExtraData = Bytes.FromHexString("0x64616f2d686172642d666f726b");
 
         private readonly ISealValidator _sealValidator;
-        private readonly ISpecProvider _specProvider;
+        protected readonly ISpecProvider _specProvider;
         private readonly long? _daoBlockNumber;
         protected readonly ILogger _logger;
         private readonly IBlockTree _blockTree;

src/Nethermind/Nethermind.Core.Test/BlockHeaderTests.cs

@@ -109,6 +109,7 @@ public void Eip_1559_CalculateBaseFee_should_returns_zero_when_eip1559_not_enabl
     public void Eip_1559_CalculateBaseFee(long gasTarget, long baseFee, long expectedBaseFee, long gasUsed, long? minimalBaseFee = null)
     {
         IReleaseSpec releaseSpec = Substitute.For<IReleaseSpec>();
+        releaseSpec.BaseFeeCalculator.Returns(new DefaultBaseFeeCalculator());
         releaseSpec.IsEip1559Enabled.Returns(true);
         releaseSpec.Eip1559BaseFeeMinValue.Returns((UInt256?)minimalBaseFee);
         releaseSpec.ForkBaseFee.Returns(Eip1559Constants.DefaultForkBaseFee);

src/Nethermind/Nethermind.Core/BaseFeeCalculator.cs

@@ -4,55 +4,67 @@
 using Nethermind.Core.Specs;
 using Nethermind.Int256;
 
-namespace Nethermind.Core
+namespace Nethermind.Core;
+
+public interface IBaseFeeCalculator
 {
-    /// <summary>Calculate BaseFee based on block parent and release spec.</summary>
-    public static class BaseFeeCalculator
+    UInt256 Calculate(BlockHeader parent, IEip1559Spec specFor1559);
+}
+
+/// <summary>
+/// Calculate <c>BaseFee</c> based on parent <see cref="BlockHeader"/> and <see cref="IEip1559Spec"/>.
+/// </summary>
+public sealed class DefaultBaseFeeCalculator : IBaseFeeCalculator
+{
+    public UInt256 Calculate(BlockHeader parent, IEip1559Spec specFor1559)
     {
-        public static UInt256 Calculate(BlockHeader parent, IEip1559Spec specFor1559)
+        UInt256 expectedBaseFee = parent.BaseFeePerGas;
+        if (specFor1559.IsEip1559Enabled)
         {
-            UInt256 expectedBaseFee = parent.BaseFeePerGas;
-            if (specFor1559.IsEip1559Enabled)
+            UInt256 parentBaseFee = parent.BaseFeePerGas;
+            long gasDelta;
+            UInt256 feeDelta;
+            bool isForkBlockNumber = specFor1559.Eip1559TransitionBlock == parent.Number + 1;
+            long parentGasTarget = parent.GasLimit / specFor1559.ElasticityMultiplier;
+            if (isForkBlockNumber)
+                parentGasTarget = parent.GasLimit;
+
+            if (parent.GasUsed == parentGasTarget)
+            {
+                expectedBaseFee = parent.BaseFeePerGas;
+            }
+            else if (parent.GasUsed > parentGasTarget)
+            {
+                gasDelta = parent.GasUsed - parentGasTarget;
+                feeDelta = UInt256.Max(
+                    parentBaseFee * (UInt256)gasDelta / (UInt256)parentGasTarget / specFor1559.BaseFeeMaxChangeDenominator,
+                    UInt256.One);
+                expectedBaseFee = parentBaseFee + feeDelta;
+            }
+            else
             {
-                UInt256 parentBaseFee = parent.BaseFeePerGas;
-                long gasDelta;
-                UInt256 feeDelta;
-                bool isForkBlockNumber = specFor1559.Eip1559TransitionBlock == parent.Number + 1;
-                long parentGasTarget = parent.GasLimit / specFor1559.ElasticityMultiplier;
-                if (isForkBlockNumber)
-                    parentGasTarget = parent.GasLimit;
-
-                if (parent.GasUsed == parentGasTarget)
-                {
-                    expectedBaseFee = parent.BaseFeePerGas;
-                }
-                else if (parent.GasUsed > parentGasTarget)
-                {
-                    gasDelta = parent.GasUsed - parentGasTarget;
-                    feeDelta = UInt256.Max(
-                        parentBaseFee * (UInt256)gasDelta / (UInt256)parentGasTarget / specFor1559.BaseFeeMaxChangeDenominator,
-                        UInt256.One);
-                    expectedBaseFee = parentBaseFee + feeDelta;
-                }
-                else
-                {
-                    gasDelta = parentGasTarget - parent.GasUsed;
-                    feeDelta = parentBaseFee * (UInt256)gasDelta / (UInt256)parentGasTarget / specFor1559.BaseFeeMaxChangeDenominator;
-                    expectedBaseFee = UInt256.Max(parentBaseFee - feeDelta, 0);
-                }
-
-                if (isForkBlockNumber)
-                {
-                    expectedBaseFee = specFor1559.ForkBaseFee;
-                }
-
-                if (specFor1559.Eip1559BaseFeeMinValue.HasValue)
-                {
-                    expectedBaseFee = UInt256.Max(expectedBaseFee, specFor1559.Eip1559BaseFeeMinValue.Value);
-                }
+                gasDelta = parentGasTarget - parent.GasUsed;
+                feeDelta = parentBaseFee * (UInt256)gasDelta / (UInt256)parentGasTarget / specFor1559.BaseFeeMaxChangeDenominator;
+                expectedBaseFee = UInt256.Max(parentBaseFee - feeDelta, 0);
             }
 
-            return expectedBaseFee;
+            if (isForkBlockNumber)
+            {
+                expectedBaseFee = specFor1559.ForkBaseFee;
+            }
+
+            if (specFor1559.Eip1559BaseFeeMinValue.HasValue)
+            {
+                expectedBaseFee = UInt256.Max(expectedBaseFee, specFor1559.Eip1559BaseFeeMinValue.Value);
+            }
         }
+
+        return expectedBaseFee;
     }
 }
+
+public static class BaseFeeCalculator
+{
+    public static UInt256 Calculate(BlockHeader parent, IEip1559Spec specFor1559) =>
+        specFor1559.BaseFeeCalculator.Calculate(parent, specFor1559);
+}

src/Nethermind/Nethermind.Core/Specs/IEip1559Spec.cs

@@ -21,5 +21,30 @@ public interface IEip1559Spec
         public UInt256 ForkBaseFee { get; }
         public UInt256 BaseFeeMaxChangeDenominator { get; }
         public long ElasticityMultiplier { get; }
+        public IBaseFeeCalculator BaseFeeCalculator { get; }
+    }
+
+    public sealed class OverridableEip1559Spec : IEip1559Spec
+    {
+        public bool IsEip1559Enabled { get; init; }
+        public long Eip1559TransitionBlock { get; init; }
+        public Address? FeeCollector { get; init; }
+        public UInt256? Eip1559BaseFeeMinValue { get; init; }
+        public UInt256 ForkBaseFee { get; init; }
+        public UInt256 BaseFeeMaxChangeDenominator { get; init; }
+        public long ElasticityMultiplier { get; init; }
+        public IBaseFeeCalculator BaseFeeCalculator { get; init; }
+
+        public OverridableEip1559Spec(IEip1559Spec spec)
+        {
+            IsEip1559Enabled = spec.IsEip1559Enabled;
+            Eip1559TransitionBlock = spec.Eip1559TransitionBlock;
+            FeeCollector = spec.FeeCollector;
+            Eip1559BaseFeeMinValue = spec.Eip1559BaseFeeMinValue;
+            ForkBaseFee = spec.ForkBaseFee;
+            BaseFeeMaxChangeDenominator = spec.BaseFeeMaxChangeDenominator;
+            ElasticityMultiplier = spec.ElasticityMultiplier;
+            BaseFeeCalculator = spec.BaseFeeCalculator;
+        }
     }
 }

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

@@ -326,6 +326,9 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec
         /// OP Granite
         bool IsOpGraniteEnabled { get; }
 
+        /// OP Holocene
+        bool IsOpHoloceneEnabled { get; }
+
         /// Taiko Ontake
         bool IsOntakeEnabled { get; }
 

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

@@ -12,6 +12,7 @@ public class ReleaseSpecDecorator(IReleaseSpec spec) : IReleaseSpec
     public virtual UInt256 ForkBaseFee => spec.ForkBaseFee;
     public virtual UInt256 BaseFeeMaxChangeDenominator => spec.BaseFeeMaxChangeDenominator;
     public virtual long ElasticityMultiplier => spec.ElasticityMultiplier;
+    public virtual IBaseFeeCalculator BaseFeeCalculator => spec.BaseFeeCalculator;
     public virtual bool IsEip658Enabled => spec.IsEip658Enabled;
     public virtual string Name => spec.Name;
     public virtual long MaximumExtraDataSize => spec.MaximumExtraDataSize;
@@ -80,6 +81,7 @@ public class ReleaseSpecDecorator(IReleaseSpec spec) : IReleaseSpec
     public bool IsEip7702Enabled => spec.IsEip7702Enabled;
     public virtual bool IsRip7212Enabled => spec.IsRip7212Enabled;
     public virtual bool IsOpGraniteEnabled => spec.IsOpGraniteEnabled;
+    public virtual bool IsOpHoloceneEnabled => spec.IsOpHoloceneEnabled;
     public virtual bool IsOntakeEnabled => spec.IsOntakeEnabled;
     public virtual ulong WithdrawalTimestamp => spec.WithdrawalTimestamp;
     public virtual ulong Eip4844TransitionTimestamp => spec.Eip4844TransitionTimestamp;

src/Nethermind/Nethermind.JsonRpc.Test/Modules/FeeHistoryOracleTests.cs

@@ -443,10 +443,21 @@ private static FeeHistoryOracle GetSubstitutedFeeHistoryOracle(
             int? cacheSize = null,
             int? maxDistFromHead = null)
         {
+            ISpecProvider provider;
+            if (specProvider is not null)
+            {
+                provider = specProvider;
+            }
+            else
+            {
+                provider = Substitute.For<ISpecProvider>();
+                provider.GetSpec(Arg.Any<ForkActivation>()).BaseFeeCalculator.Returns(new DefaultBaseFeeCalculator());
+            }
+
             return new(
                 blockTree ?? Substitute.For<IBlockTree>(),
                 receiptStorage ?? Substitute.For<IReceiptStorage>(),
-                specProvider ?? Substitute.For<ISpecProvider>(),
+                provider,
                 maxDistFromHead);
         }
     }

src/Nethermind/Nethermind.Merge.Plugin/MergeHeaderValidator.cs

@@ -22,7 +22,6 @@ public class MergeHeaderValidator : HeaderValidator
         private readonly IPoSSwitcher _poSSwitcher;
         private readonly IHeaderValidator _preMergeHeaderValidator;
         private readonly IBlockTree _blockTree;
-        private readonly ISpecProvider _specProvider;
 
         public MergeHeaderValidator(
             IPoSSwitcher poSSwitcher,
@@ -36,7 +35,6 @@ public MergeHeaderValidator(
             _poSSwitcher = poSSwitcher;
             _preMergeHeaderValidator = preMergeHeaderValidator;
             _blockTree = blockTree;
-            _specProvider = specProvider;
         }
 
         public override bool Validate(BlockHeader header, BlockHeader? parent, bool isUncle = false)

src/Nethermind/Nethermind.Mining.Test/MinGasPriceTests.cs

@@ -52,6 +52,7 @@ public void Test1559(long minimum, long maxFeePerGas, long maxPriorityFeePerGas,
         {
             ISpecProvider specProvider = Substitute.For<ISpecProvider>();
             specProvider.GetSpec(Arg.Any<ForkActivation>()).IsEip1559Enabled.Returns(true);
+            specProvider.GetSpec(Arg.Any<ForkActivation>()).BaseFeeCalculator.Returns(new DefaultBaseFeeCalculator());
 
             specProvider.GetSpec(Arg.Any<ForkActivation>()).ForkBaseFee.Returns(Eip1559Constants.DefaultForkBaseFee);
             specProvider.GetSpec(Arg.Any<ForkActivation>()).BaseFeeMaxChangeDenominator.Returns(Eip1559Constants.DefaultBaseFeeMaxChangeDenominator);

src/Nethermind/Nethermind.Optimism.Test/EIP1559ParametersTests.cs

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using Nethermind.Core.Extensions;
+using Nethermind.Core.Test.Builders;
+using NUnit.Framework;
+using FluentAssertions;
+using System;
+
+namespace Nethermind.Optimism.Test;
+
+[Parallelizable(ParallelScope.All)]
+public class EIP1559ParametersTests
+{
+    private static IEnumerable<(string hexString, EIP1559Parameters expected)> DecodeBlockHeaderParametersCases()
+    {
+        yield return ("0x000000000000000000", new(0, 0, 0));
+        yield return ("0x000000000100000000", new(0, 1, 0));
+        yield return ("0x0000000001000001bc", new(0, 1, 444));
+        yield return ("0x0000000001ffffffff", new(0, 1, UInt32.MaxValue));
+        yield return ("0x00ffffffff00000000", new(0, UInt32.MaxValue, 0));
+        yield return ("0x00ffffffff000001bc", new(0, UInt32.MaxValue, 444));
+        yield return ("0x00ffffffffffffffff", new(0, UInt32.MaxValue, UInt32.MaxValue));
+    }
+    [TestCaseSource(nameof(DecodeBlockHeaderParametersCases))]
+    public void DecodeBlockHeaderParameters((string HexString, EIP1559Parameters Expected) testCase)
+    {
+        var bytes = Bytes.FromHexString(testCase.HexString);
+        var blockHeader = Build.A.BlockHeader.WithExtraData(bytes).TestObject;
+
+        blockHeader.TryDecodeEIP1559Parameters(out EIP1559Parameters decoded, out _);
+
+        decoded.Should().Be(testCase.Expected);
+    }
+}

src/Nethermind/Nethermind.Optimism.Test/OptimismBaseFeeCalculatorTests.cs

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using FluentAssertions;
+using Nethermind.Core;
+using Nethermind.Core.Specs;
+using Nethermind.Core.Test.Builders;
+using Nethermind.Int256;
+using Nethermind.Specs;
+using NUnit.Framework;
+
+namespace Nethermind.Optimism.Test;
+
+public class OptimismBaseFeeCalculatorTests
+{
+    /// <remarks>
+    /// Tests sourced from <see href="https://github.com/ethereum-optimism/op-geth/blob/1e60ba82d31bc17111481998100cd948ee06c0ab/consensus/misc/eip1559/eip1559_test.go#L191"/>
+    /// </remarks>
+    [TestCase(15_000_000, 10_000_000, 10u, 2u)] // Target
+    [TestCase(10_000_000, 9_666_667, 10u, 2u)] // Below
+    [TestCase(20_000_000, 10_333_333, 10u, 2u)] // Above
+    [TestCase(3_000_000, 10_000_000, 2u, 10u)] // Target
+    [TestCase(1_000_000, 6_666_667, 2u, 10u)] // Below
+    [TestCase(30_000_000, 55_000_000, 2u, 10u)] // Above
+    public void CalculatesBaseFee_AfterHolocene_UsingExtraDataParameters(long gasUsed, long expectedBaseFee, UInt32 denominator, UInt32 elasticity)
+    {
+        const ulong HoloceneTimestamp = 10_000_000;
+
+        IReleaseSpec releaseSpec = new ReleaseSpec
+        {
+            IsEip1559Enabled = true,
+            IsOpHoloceneEnabled = true,
+            BaseFeeCalculator = new OptimismBaseFeeCalculator(HoloceneTimestamp, new DefaultBaseFeeCalculator())
+        };
+
+        var extraData = new byte[EIP1559Parameters.ByteLength];
+        var parameters = new EIP1559Parameters(0, denominator, elasticity);
+        parameters.WriteTo(extraData);
+
+        BlockHeader blockHeader = Build.A.BlockHeader
+            .WithGasLimit(30_000_000)
+            .WithBaseFee(10_000_000)
+            .WithTimestamp(HoloceneTimestamp)
+            .WithGasUsed(gasUsed)
+            .WithExtraData(extraData)
+            .TestObject;
+
+        UInt256 actualBaseFee = BaseFeeCalculator.Calculate(blockHeader, releaseSpec);
+
+        actualBaseFee.Should().Be((UInt256)expectedBaseFee);
+    }
+}