Make chainspec extendable by plugins

src/Nethermind/Nethermind.Config/ConfigSourceHelper.cs

@@ -8,13 +8,21 @@
 using Nethermind.Int256;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
 
 namespace Nethermind.Config
 {
-    internal static class ConfigSourceHelper
+    public static class ConfigSourceHelper
     {
         public static object ParseValue(Type valueType, string valueString, string category, string name)
         {
+            if (Nullable.GetUnderlyingType(valueType) is { } nullableType)
+            {
+                return !string.IsNullOrEmpty(valueString) && !valueString.Equals("null", StringComparison.InvariantCultureIgnoreCase)
+                    ? ParseValue(nullableType, valueString, category, name)
+                    : null;
+            }
             try
             {
                 object value;
@@ -23,8 +31,17 @@ public static object ParseValue(Type valueType, string valueString, string categ
                     //supports Arrays, e.g int[] and generic IEnumerable<T>, IList<T>
                     var itemType = valueType.IsGenericType ? valueType.GetGenericArguments()[0] : valueType.GetElementType();
 
+                    if (itemType == typeof(byte) && !valueString.AsSpan().TrimStart().StartsWith("["))
+                    {
+                        // hex encoded byte array
+                        string hex = valueString.Trim().RemoveStart('0').RemoveStart('x').TrimEnd();
+                        value = Enumerable.Range(0, hex.Length)
+                            .Where(x => x % 2 == 0)
+                            .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
+                            .ToArray();
+                    }
                     //In case of collection of objects (more complex config models) we parse entire collection
-                    if (itemType.IsClass && typeof(IConfigModel).IsAssignableFrom(itemType))
+                    else if (itemType.IsClass && typeof(IConfigModel).IsAssignableFrom(itemType))
                     {
                         var objCollection = JsonSerializer.Deserialize(valueString, valueType);
                         value = objCollection;
@@ -86,13 +103,76 @@ public static object GetDefault(Type type)
             return type.IsValueType ? (false, Activator.CreateInstance(type)) : (false, null);
         }
 
+        public static bool TryFromHex(Type type, string itemValue, out object value)
+        {
+            if (!itemValue.StartsWith("0x"))
+            {
+                value = null;
+                return false;
+            }
+            switch (Type.GetTypeCode(type))
+            {
+                case TypeCode.Byte:
+                    value = Convert.ToByte(itemValue, 16);
+                    return true;
+                case TypeCode.SByte:
+                    value = Convert.ToSByte(itemValue, 16);
+                    return true;
+                case TypeCode.UInt16:
+                    value = Convert.ToUInt16(itemValue, 16);
+                    return true;
+                case TypeCode.UInt32:
+                    value = Convert.ToUInt32(itemValue, 16);
+                    return true;
+                case TypeCode.UInt64:
+                    value = Convert.ToUInt64(itemValue, 16);
+                    return true;
+                case TypeCode.Int16:
+                    value = Convert.ToInt16(itemValue, 16);
+                    return true;
+                case TypeCode.Int32:
+                    value = Convert.ToInt32(itemValue, 16);
+                    return true;
+                case TypeCode.Int64:
+                    value = Convert.ToInt64(itemValue, 16);
+                    return true;
+                default:
+                    value = null;
+                    return false;
+            }
+        }
+
         private static object GetValue(Type valueType, string itemValue)
         {
+            if (Nullable.GetUnderlyingType(valueType) is var nullableType && nullableType is not null)
+            {
+                if (string.IsNullOrEmpty(itemValue) || itemValue.Equals("null", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return null;
+                }
+
+                return GetValue(nullableType, itemValue);
+            }
+
             if (valueType == typeof(UInt256))
             {
                 return UInt256.Parse(itemValue);
             }
 
+            if (valueType == typeof(Address))
+            {
+                if (Address.TryParse(itemValue, out var address))
+                {
+                    return address;
+                }
+                throw new FormatException($"Could not parse {itemValue} to {typeof(Address)}");
+            }
+
+            if (valueType == typeof(Hash256))
+            {
+                return new Hash256(itemValue);
+            }
+
             if (valueType.IsEnum)
             {
                 if (Enum.TryParse(valueType, itemValue, true, out var enumValue))
@@ -103,13 +183,12 @@ private static object GetValue(Type valueType, string itemValue)
                 throw new FormatException($"Cannot parse enum value: {itemValue}, type: {valueType.Name}");
             }
 
-            var nullableType = Nullable.GetUnderlyingType(valueType);
+            if (TryFromHex(valueType, itemValue, out object value))
+            {
+                return value;
+            }
 
-            return nullableType is null
-                ? Convert.ChangeType(itemValue, valueType)
-                : !string.IsNullOrEmpty(itemValue) && !itemValue.Equals("null", StringComparison.InvariantCultureIgnoreCase)
-                    ? Convert.ChangeType(itemValue, nullableType)
-                    : null;
+            return Convert.ChangeType(itemValue, valueType);
         }
     }
 }

src/Nethermind/Nethermind.Optimism/IOptimismSpecHelper.cs

@@ -7,7 +7,7 @@ namespace Nethermind.Optimism;
 
 public interface IOptimismSpecHelper
 {
-    Address L1FeeReceiver { get; }
+    Address? L1FeeReceiver { get; }
 
     bool IsBedrock(BlockHeader header);
     bool IsRegolith(BlockHeader header);

src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs

@@ -22,10 +22,13 @@ public class InitializeBlockchainOptimism(OptimismNethermindApi api) : Initializ
 {
     private readonly IBlocksConfig _blocksConfig = api.Config<IBlocksConfig>();
 
+    private readonly OptimismChainSpecEngineParameters _chainSpecParameters = api.ChainSpec
+        .EngineChainSpecParametersProvider.GetChainSpecParameters<OptimismChainSpecEngineParameters>();
+
     protected override async Task InitBlockchain()
     {
-        api.SpecHelper = new(api.ChainSpec.Optimism);
-        api.L1CostHelper = new(api.SpecHelper, api.ChainSpec.Optimism.L1BlockAddress);
+        api.SpecHelper = new(_chainSpecParameters);
+        api.L1CostHelper = new(api.SpecHelper, _chainSpecParameters.L1BlockAddress!);
 
         await base.InitBlockchain();
     }

src/Nethermind/Nethermind.Optimism/OPConfigHelper.cs

@@ -6,16 +6,16 @@
 
 namespace Nethermind.Optimism;
 
-public class OptimismSpecHelper(OptimismParameters parameters) : IOptimismSpecHelper
+public class OptimismSpecHelper(OptimismChainSpecEngineParameters parameters) : IOptimismSpecHelper
 {
-    private readonly long _bedrockBlockNumber = parameters.BedrockBlockNumber;
-    private readonly ulong _regolithTimestamp = parameters.RegolithTimestamp;
+    private readonly long? _bedrockBlockNumber = parameters.BedrockBlockNumber;
+    private readonly ulong? _regolithTimestamp = parameters.RegolithTimestamp;
     private readonly ulong? _canyonTimestamp = parameters.CanyonTimestamp;
     private readonly ulong? _ecotoneTimestamp = parameters.EcotoneTimestamp;
     private readonly ulong? _fjordTimestamp = parameters.FjordTimestamp;
     private readonly ulong? _graniteTimestamp = parameters.GraniteTimestamp;
 
-    public Address L1FeeReceiver { get; init; } = parameters.L1FeeRecipient;
+    public Address? L1FeeReceiver { get; init; } = parameters.L1FeeRecipient;
 
     public bool IsRegolith(BlockHeader header)
     {

src/Nethermind/Nethermind.Optimism/OptimismChainSpecEngineParameters.cs

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Collections.Generic;
+using Nethermind.Core;
+using Nethermind.Int256;
+using Nethermind.Specs;
+using Nethermind.Specs.ChainSpecStyle;
+
+namespace Nethermind.Optimism;
+
+public class OptimismChainSpecEngineParameters : IChainSpecEngineParameters
+{
+    public string? SealEngineType => "Optimism";
+
+    public ulong? RegolithTimestamp { get; set; }
+
+    public long? BedrockBlockNumber { get; set; }
+
+    public ulong? CanyonTimestamp { get; set; }
+
+    public ulong? EcotoneTimestamp { get; set; }
+
+    public ulong? FjordTimestamp { get; set; }
+
+    public ulong? GraniteTimestamp { get; set; }
+
+    public Address? L1FeeRecipient { get; set; }
+
+    public Address? L1BlockAddress { get; set; }
+
+    public UInt256? CanyonBaseFeeChangeDenominator { get; set; }
+
+    public Address? Create2DeployerAddress { get; set; }
+
+    public byte[]? Create2DeployerCode { get; set; }
+
+    public void AddTransitions(SortedSet<long> blockNumbers, SortedSet<ulong> timestamps)
+    {
+        ArgumentNullException.ThrowIfNull(RegolithTimestamp);
+        ArgumentNullException.ThrowIfNull(BedrockBlockNumber);
+        ArgumentNullException.ThrowIfNull(CanyonTimestamp);
+        ArgumentNullException.ThrowIfNull(EcotoneTimestamp);
+        ArgumentNullException.ThrowIfNull(FjordTimestamp);
+        ArgumentNullException.ThrowIfNull(GraniteTimestamp);
+        ArgumentNullException.ThrowIfNull(L1FeeRecipient);
+        ArgumentNullException.ThrowIfNull(L1BlockAddress);
+        ArgumentNullException.ThrowIfNull(CanyonBaseFeeChangeDenominator);
+        ArgumentNullException.ThrowIfNull(Create2DeployerAddress);
+        ArgumentNullException.ThrowIfNull(Create2DeployerCode);
+    }
+
+    public void AdjustReleaseSpec(ReleaseSpec spec, long startBlock, ulong? startTimestamp)
+    {
+        if (CanyonTimestamp <= startTimestamp)
+        {
+            // TODO: check
+            spec.BaseFeeMaxChangeDenominator = CanyonBaseFeeChangeDenominator!.Value;
+        }
+    }
+}

src/Nethermind/Nethermind.Optimism/OptimismTransactionProcessor.cs

@@ -146,7 +146,7 @@ protected override void PayFees(Transaction tx, BlockHeader header, IReleaseSpec
             if (opSpecHelper.IsBedrock(header))
             {
                 UInt256 l1Cost = _currentTxL1Cost ??= l1CostHelper.ComputeL1Cost(tx, header, WorldState);
-                WorldState.AddToBalanceAndCreateIfNotExists(opSpecHelper.L1FeeReceiver, l1Cost, spec);
+                WorldState.AddToBalanceAndCreateIfNotExists(opSpecHelper.L1FeeReceiver!, l1Cost, spec);
             }
         }
     }

src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpec.cs

@@ -40,10 +40,10 @@ public class ChainSpec
 
         public EthashParameters Ethash { get; set; }
 
-        public OptimismParameters Optimism { get; set; }
-
         public ChainParameters Parameters { get; set; }
 
+        public IChainSpecParametersProvider EngineChainSpecParametersProvider { get; set; }
+
         public Dictionary<Address, ChainSpecAllocation> Allocations { get; set; }
 
         public long? FixedDifficulty { get; set; }

src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs

@@ -41,6 +41,11 @@ private void BuildTransitions()
                 }
             }
 
+            foreach (IChainSpecEngineParameters item in _chainSpec.EngineChainSpecParametersProvider.AllChainSpecParameters)
+            {
+                item.AddTransitions(transitionBlockNumbers, transitionTimestamps);
+            }
+
             AddTransitions(transitionBlockNumbers, _chainSpec, n => n.EndsWith("BlockNumber") && n != "TerminalPoWBlockNumber");
             AddTransitions(transitionBlockNumbers, _chainSpec.Parameters, n => n.EndsWith("Transition"));
             AddTransitions(transitionBlockNumbers, _chainSpec.Ethash, n => n.EndsWith("Transition"));
@@ -107,7 +112,7 @@ static void Add(SortedSet<T> transitions, T value, T? minValueExclusive)
             TerminalTotalDifficulty = _chainSpec.Parameters.TerminalTotalDifficulty;
         }
 
-        private static (ForkActivation, IReleaseSpec Spec)[] CreateTransitions(
+        private (ForkActivation, IReleaseSpec Spec)[] CreateTransitions(
             ChainSpec chainSpec,
             SortedSet<long> transitionBlockNumbers,
             SortedSet<ulong> transitionTimestamps)
@@ -153,7 +158,7 @@ private static ForkActivation[] CreateTransitionActivations(SortedSet<long> tran
             return transitionActivations;
         }
 
-        private static ReleaseSpec CreateReleaseSpec(ChainSpec chainSpec, long releaseStartBlock, ulong? releaseStartTimestamp = null)
+        private ReleaseSpec CreateReleaseSpec(ChainSpec chainSpec, long releaseStartBlock, ulong? releaseStartTimestamp = null)
         {
             ReleaseSpec releaseSpec = new();
             releaseSpec.MaximumUncleCount = (int)(releaseStartBlock >= (chainSpec.AuRa?.MaximumUncleCountTransition ?? long.MaxValue) ? chainSpec.AuRa?.MaximumUncleCount ?? 2 : 2);
@@ -213,10 +218,6 @@ private static ReleaseSpec CreateReleaseSpec(ChainSpec chainSpec, long releaseSt
             releaseSpec.ForkBaseFee = chainSpec.Parameters.Eip1559BaseFeeInitialValue ?? Eip1559Constants.DefaultForkBaseFee;
             releaseSpec.BaseFeeMaxChangeDenominator = chainSpec.Parameters.Eip1559BaseFeeMaxChangeDenominator ?? Eip1559Constants.DefaultBaseFeeMaxChangeDenominator;
 
-            if (chainSpec.Optimism?.CanyonTimestamp <= releaseStartTimestamp)
-            {
-                releaseSpec.BaseFeeMaxChangeDenominator = chainSpec.Optimism.CanyonBaseFeeChangeDenominator;
-            }
 
 
             if (chainSpec.Ethash is not null)
@@ -262,6 +263,11 @@ private static ReleaseSpec CreateReleaseSpec(ChainSpec chainSpec, long releaseSt
             releaseSpec.IsEip7002Enabled = (chainSpec.Parameters.Eip7002TransitionTimestamp ?? ulong.MaxValue) <= releaseStartTimestamp;
             releaseSpec.Eip7002ContractAddress = chainSpec.Parameters.Eip7002ContractAddress;
 
+            foreach (IChainSpecEngineParameters item in _chainSpec.EngineChainSpecParametersProvider.AllChainSpecParameters)
+            {
+                item.AdjustReleaseSpec(releaseSpec, releaseStartBlock, releaseStartTimestamp);
+            }
+
             return releaseSpec;
         }
 

src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecLoader.cs

@@ -336,25 +336,6 @@ static AuRaParameters.Validator LoadValidator(ChainSpecJson.AuRaValidatorJson va
                 }
             }
         }
-        else if (chainSpecJson.Engine?.Optimism is not null)
-        {
-            chainSpec.SealEngineType = SealEngineType.Optimism;
-            chainSpec.Optimism = new OptimismParameters
-            {
-                RegolithTimestamp = chainSpecJson.Engine.Optimism.RegolithTimestamp,
-                BedrockBlockNumber = chainSpecJson.Engine.Optimism.BedrockBlockNumber,
-                CanyonTimestamp = chainSpecJson.Engine.Optimism.CanyonTimestamp,
-                EcotoneTimestamp = chainSpecJson.Engine.Optimism.EcotoneTimestamp,
-                FjordTimestamp = chainSpecJson.Engine.Optimism.FjordTimestamp,
-                GraniteTimestamp = chainSpecJson.Engine.Optimism.GraniteTimestamp,
-
-                L1FeeRecipient = chainSpecJson.Engine.Optimism.L1FeeRecipient,
-                L1BlockAddress = chainSpecJson.Engine.Optimism.L1BlockAddress,
-                CanyonBaseFeeChangeDenominator = chainSpecJson.Engine.Optimism.CanyonBaseFeeChangeDenominator,
-                Create2DeployerAddress = chainSpecJson.Engine.Optimism.Create2DeployerAddress,
-                Create2DeployerCode = chainSpecJson.Engine.Optimism.Create2DeployerCode
-            };
-        }
         else if (chainSpecJson.Engine?.NethDev is not null)
         {
             chainSpec.SealEngineType = SealEngineType.NethDev;
@@ -367,6 +348,25 @@ static AuRaParameters.Validator LoadValidator(ChainSpecJson.AuRaValidatorJson va
             chainSpec.SealEngineType = customEngineType;
         }
 
+        Dictionary<string, JsonElement> engineParameters = new();
+        foreach (KeyValuePair<string, JsonElement> engine in chainSpecJson.Engine.CustomEngineData)
+        {
+            if (engine.Value.TryGetProperty("params", out JsonElement value))
+            {
+                engineParameters.Add(engine.Key, value);
+            }
+            else
+            {
+                engineParameters.Add(engine.Key, engine.Value);
+            }
+        }
+
+        chainSpec.EngineChainSpecParametersProvider = new ChainSpecParametersProvider(engineParameters);
+        if (string.IsNullOrEmpty(chainSpec.SealEngineType))
+        {
+            chainSpec.SealEngineType = chainSpec.EngineChainSpecParametersProvider.SealEngineType;
+        }
+
         if (string.IsNullOrEmpty(chainSpec.SealEngineType))
         {
             throw new NotSupportedException("unknown seal engine in chainspec");