[WIP]Make chainspec extendable by plugins

src/Nethermind/Nethermind.AuRa.Test/AuRaPluginTests.cs

@@ -9,6 +9,7 @@
 using Nethermind.Logging;
 using Nethermind.Serialization.Json;
 using Nethermind.Specs.ChainSpecStyle;
+using Nethermind.Specs.Test.ChainSpecStyle;
 using NUnit.Framework;
 
 namespace Nethermind.AuRa.Test
@@ -19,7 +20,9 @@ public class AuRaPluginTests
         public void Init_when_not_AuRa_doesnt_trow()
         {
             AuRaPlugin auRaPlugin = new();
-            Action init = () => auRaPlugin.Init(new AuRaNethermindApi(new ConfigProvider(), new EthereumJsonSerializer(), new TestLogManager(), new ChainSpec()));
+            ChainSpec chainSpec = new();
+            chainSpec.EngineChainSpecParametersProvider = new TestChainSpecParametersProvider(new AuthorityRoundChainSpecEngineParameters());
+            Action init = () => auRaPlugin.Init(new AuRaNethermindApi(new ConfigProvider(), new EthereumJsonSerializer(), new TestLogManager(), chainSpec));
             init.Should().NotThrow();
         }
 

src/Nethermind/Nethermind.AuRa.Test/AuRaSealValidatorTests.cs

@@ -24,7 +24,7 @@ namespace Nethermind.AuRa.Test
     public class AuRaSealValidatorTests
     {
         private AuRaSealValidator _sealValidator;
-        private AuRaParameters _auRaParameters;
+        private AuthorityRoundChainSpecEngineParameters _auRaParameters;
         private IAuRaStepCalculator _auRaStepCalculator;
         private ILogManager _logManager;
         private IWallet _wallet;
@@ -38,7 +38,7 @@ public class AuRaSealValidatorTests
         [SetUp]
         public void SetUp()
         {
-            _auRaParameters = new AuRaParameters();
+            _auRaParameters = new AuthorityRoundChainSpecEngineParameters();
             _auRaStepCalculator = Substitute.For<IAuRaStepCalculator>();
             _logManager = LimboLogs.Instance;
             _wallet = new DevWallet(new WalletConfig(), _logManager);
@@ -89,7 +89,7 @@ BlockHeaderBuilder GetParentBlock() => Build.A.BlockHeader
                 TestCaseData GetTestCaseData(
                     BlockHeaderBuilder parent,
                     BlockHeaderBuilder block,
-                    Action<AuRaParameters> paramAction = null,
+                    Action<AuthorityRoundChainSpecEngineParameters> paramAction = null,
                     Repeat repeat = Repeat.No,
                     bool parentIsHead = true,
                     bool isValidSealer = true) =>
@@ -141,7 +141,7 @@ TestCaseData GetTestCaseData(
         }
 
         [TestCaseSource(nameof(ValidateParamsTests))]
-        public (bool, object) validate_params(BlockHeader parentBlock, BlockHeader block, Action<AuRaParameters> modifyParameters, Repeat repeat, bool parentIsHead, bool isValidSealer)
+        public (bool, object) validate_params(BlockHeader parentBlock, BlockHeader block, Action<AuthorityRoundChainSpecEngineParameters> modifyParameters, Repeat repeat, bool parentIsHead, bool isValidSealer)
         {
             _blockTree.Head.Returns(parentIsHead ? new Block(parentBlock) : new Block(Build.A.BlockHeader.WithNumber(parentBlock.Number - 1).TestObject));
             _validSealerStrategy.IsValidSealer(Arg.Any<IList<Address>>(), block.Beneficiary, block.AuRaStep.Value, out _).Returns(isValidSealer);

src/Nethermind/Nethermind.AuRa.Test/ChainSpecLoaderTest.cs

@@ -0,0 +1,94 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.IO;
+using FluentAssertions;
+using Nethermind.Core;
+using Nethermind.Core.Extensions;
+using Nethermind.Serialization.Json;
+using Nethermind.Specs;
+using Nethermind.Specs.ChainSpecStyle;
+using NUnit.Framework;
+
+namespace Nethermind.AuRa.Test;
+
+public class ChainSpecLoaderTest
+{
+    private static ChainSpec LoadChainSpec(string path)
+    {
+        ChainSpecLoader chainSpecLoader = new(new EthereumJsonSerializer());
+        ChainSpec chainSpec = chainSpecLoader.LoadFromFile(path);
+        return chainSpec;
+    }
+
+    [Test]
+    public void Can_load_gnosis()
+    {
+        string path = Path.Combine(TestContext.CurrentContext.WorkDirectory, "../../../../", "Chains/gnosis.json");
+        ChainSpec chainSpec = LoadChainSpec(path);
+
+        Assert.That(chainSpec.Parameters.Eip1559BaseFeeInitialValue, Is.EqualTo(1.GWei()), $"fork base fee");
+        Assert.That(chainSpec.NetworkId, Is.EqualTo(100), $"{nameof(chainSpec.NetworkId)}");
+        Assert.That(chainSpec.Name, Is.EqualTo("GnosisChain"), $"{nameof(chainSpec.Name)}");
+        Assert.That(chainSpec.SealEngineType, Is.EqualTo(SealEngineType.AuRa), "engine");
+
+        int berlinGnosisBlockNumber = 16101500;
+        chainSpec.Parameters.Eip2565Transition.Should().Be(berlinGnosisBlockNumber);
+        chainSpec.Parameters.Eip2929Transition.Should().Be(berlinGnosisBlockNumber);
+        chainSpec.Parameters.Eip2930Transition.Should().Be(berlinGnosisBlockNumber);
+
+        chainSpec.Parameters.TerminalTotalDifficulty.ToString()
+            .Should().Be("8626000000000000000000058750000000000000000000");
+
+        var auraParams = chainSpec.EngineChainSpecParametersProvider.GetChainSpecParameters<AuthorityRoundChainSpecEngineParameters>();
+
+        auraParams.WithdrawalContractAddress.ToString(true)
+            .Should().Be("0x0B98057eA310F4d31F2a452B414647007d1645d9");
+    }
+
+    [Test]
+    public void Can_load_chiado()
+    {
+        string path = Path.Combine(TestContext.CurrentContext.WorkDirectory, "../../../../", "Chains/chiado.json");
+        ChainSpec chainSpec = LoadChainSpec(path);
+
+        Assert.That(chainSpec.Parameters.Eip1559BaseFeeInitialValue, Is.EqualTo(1.GWei()), $"fork base fee");
+        Assert.That(chainSpec.NetworkId, Is.EqualTo(10200), $"{nameof(chainSpec.NetworkId)}");
+        Assert.That(chainSpec.Name, Is.EqualTo("chiado"), $"{nameof(chainSpec.Name)}");
+        Assert.That(chainSpec.SealEngineType, Is.EqualTo(SealEngineType.AuRa), "engine");
+
+        chainSpec.Parameters.TerminalTotalDifficulty.ToString()
+            .Should().Be("231707791542740786049188744689299064356246512");
+
+        var auraParams = chainSpec.EngineChainSpecParametersProvider.GetChainSpecParameters<AuthorityRoundChainSpecEngineParameters>();
+
+        auraParams.WithdrawalContractAddress.ToString(true)
+            .Should().Be("0xb97036A26259B7147018913bD58a774cf91acf25");
+
+        chainSpec.ShanghaiTimestamp.Should().Be(ChiadoSpecProvider.ShanghaiTimestamp);
+        chainSpec.ShanghaiTimestamp.Should().Be(ChiadoSpecProvider.Instance.TimestampFork);
+    }
+
+    [Test]
+    public void Can_load_posdao_with_rewriteBytecode()
+    {
+        // TODO: modexp 2565
+        string path = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Specs/posdao.json");
+        ChainSpec chainSpec = LoadChainSpec(path);
+        IDictionary<long, IDictionary<Address, byte[]>> expected = new Dictionary<long, IDictionary<Address, byte[]>>
+        {
+            {
+                21300000, new Dictionary<Address, byte[]>()
+                {
+                    {new Address("0x1234000000000000000000000000000000000001"), Bytes.FromHexString("0x111")},
+                    {new Address("0x1234000000000000000000000000000000000002"), Bytes.FromHexString("0x222")},
+                }
+            }
+        };
+
+        var auraParams = chainSpec.EngineChainSpecParametersProvider.GetChainSpecParameters<AuthorityRoundChainSpecEngineParameters>();
+
+        auraParams.RewriteBytecode.Should().BeEquivalentTo(expected);
+    }
+}

src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs

@@ -17,6 +17,7 @@
 using Nethermind.Consensus.Withdrawals;
 using Nethermind.Core;
 using Nethermind.Logging;
+using Nethermind.Specs.ChainSpecStyle;
 using NUnit.Framework;
 
 namespace Nethermind.AuRa.Test.Contract;
@@ -81,8 +82,11 @@ public class TestGasLimitContractBlockchain : TestContractBlockchain
 
         protected override BlockProcessor CreateBlockProcessor()
         {
-            KeyValuePair<long, Address> blockGasLimitContractTransition = ChainSpec.AuRa.BlockGasLimitContractTransitions.First();
-            BlockGasLimitContract gasLimitContract = new(AbiEncoder.Instance, blockGasLimitContractTransition.Value, blockGasLimitContractTransition.Key,
+            KeyValuePair<long, Address> blockGasLimitContractTransition = ChainSpec.EngineChainSpecParametersProvider
+                .GetChainSpecParameters<AuthorityRoundChainSpecEngineParameters>().BlockGasLimitContractTransitions
+                .First();
+            BlockGasLimitContract gasLimitContract = new(AbiEncoder.Instance, blockGasLimitContractTransition.Value,
+                blockGasLimitContractTransition.Key,
                 new ReadOnlyTxProcessingEnv(
                     WorldStateManager,
                     BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance));
@@ -114,8 +118,10 @@ public class TestGasLimitContractBlockchainLateBlockGasLimit : TestGasLimitContr
     {
         protected override BlockProcessor CreateBlockProcessor()
         {
-            KeyValuePair<long, Address> blockGasLimitContractTransition = ChainSpec.AuRa.BlockGasLimitContractTransitions.First();
-            ChainSpec.AuRa.BlockGasLimitContractTransitions = new Dictionary<long, Address>() { { 10, blockGasLimitContractTransition.Value } };
+            var parameters = ChainSpec.EngineChainSpecParametersProvider
+                .GetChainSpecParameters<AuthorityRoundChainSpecEngineParameters>();
+            KeyValuePair<long, Address> blockGasLimitContractTransition = parameters.BlockGasLimitContractTransitions.First();
+            parameters.BlockGasLimitContractTransitions = new Dictionary<long, Address>() { { 10, blockGasLimitContractTransition.Value } };
             return base.CreateBlockProcessor();
         }
     }

src/Nethermind/Nethermind.AuRa.Test/Reward/AuRaRewardCalculatorTests.cs

@@ -25,7 +25,7 @@ namespace Nethermind.AuRa.Test.Reward
 {
     public class AuRaRewardCalculatorTests
     {
-        private AuRaParameters _auraParameters;
+        private AuthorityRoundChainSpecEngineParameters _auraParameters;
         private IAbiEncoder _abiEncoder;
         private ITransactionProcessor _transactionProcessor;
         private Block _block;
@@ -40,11 +40,11 @@ public void SetUp()
             _address10 = TestItem.AddressA;
             _address50 = TestItem.AddressB;
             _address150 = TestItem.AddressC;
-            _auraParameters = new AuRaParameters
+            _auraParameters = new AuthorityRoundChainSpecEngineParameters()
             {
                 BlockRewardContractAddress = _address10,
                 BlockRewardContractTransition = 10,
-                BlockReward = new Dictionary<long, UInt256>() { { 0, 200 } },
+                BlockReward = new SortedDictionary<long, UInt256>() { { 0, 200 } },
             };
 
             _abiEncoder = Substitute.For<IAbiEncoder>();

src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs

@@ -13,6 +13,7 @@
 using Nethermind.Consensus.AuRa;
 using Nethermind.Consensus.AuRa.Contracts;
 using Nethermind.Consensus.AuRa.Transactions;
+using Nethermind.Consensus.AuRa.Validators;
 using Nethermind.Consensus.Processing;
 using Nethermind.Consensus.Rewards;
 using Nethermind.Consensus.Validators;
@@ -27,7 +28,6 @@
 using Nethermind.Int256;
 using Nethermind.Evm.TransactionProcessing;
 using Nethermind.Logging;
-using Nethermind.Specs.ChainSpecStyle;
 using Nethermind.Trie.Pruning;
 using Nethermind.TxPool;
 using NSubstitute;

src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs

@@ -29,6 +29,7 @@
 using Nethermind.Consensus.Rewards;
 using Nethermind.Core.Test.Blockchain;
 using Nethermind.Evm.TransactionProcessing;
+using Nethermind.Specs.Test.ChainSpecStyle;
 
 namespace Nethermind.Blockchain.Test;
 
@@ -115,7 +116,7 @@ public async Task Process_long_running_branch(int blocksAmount)
     {
         Address address = TestItem.Addresses[0];
         TestSingleReleaseSpecProvider spec = new TestSingleReleaseSpecProvider(ConstantinopleFix.Instance);
-        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev)
+        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(TestSealEngineType.NethDev)
             .Build(spec);
         testRpc.TestWallet.UnlockAccount(address, new SecureString());
         await testRpc.AddFunds(address, 1.Ether());

src/Nethermind/Nethermind.Blockchain.Test/Producers/BlockProducerBaseTests.BaseFee.cs

@@ -12,6 +12,7 @@
 using Nethermind.Int256;
 using Nethermind.JsonRpc.Test.Modules;
 using Nethermind.Specs;
+using Nethermind.Specs.Test.ChainSpecStyle;
 using Nethermind.TxPool;
 using NUnit.Framework;
 
@@ -58,7 +59,7 @@ private async Task<ScenarioBuilder> CreateTestBlockchainAsync(long gasLimit)
                         IsEip155Enabled = true
                     });
                 BlockBuilder blockBuilder = Build.A.Block.Genesis.WithGasLimit(gasLimit);
-                _testRpcBlockchain = await TestRpcBlockchain.ForTest(SealEngineType.NethDev)
+                _testRpcBlockchain = await TestRpcBlockchain.ForTest(TestSealEngineType.NethDev)
                     .WithGenesisBlockBuilder(blockBuilder)
                     .Build(spec);
                 _testRpcBlockchain.TestWallet.UnlockAccount(_address, new SecureString());

src/Nethermind/Nethermind.Blockchain.Test/Producers/BlockProducerBaseTests.IsProducingBlocks.cs

@@ -24,6 +24,7 @@
 using Nethermind.Logging;
 using Nethermind.Specs;
 using Nethermind.Specs.Forks;
+using Nethermind.Specs.Test.ChainSpecStyle;
 using Nethermind.State;
 using NSubstitute;
 using NUnit.Framework;
@@ -149,7 +150,7 @@ private async Task<TestRpcBlockchain> CreateTestRpc()
     {
         Address address = TestItem.Addresses[0];
         TestSingleReleaseSpecProvider spec = new(ConstantinopleFix.Instance);
-        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev)
+        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(TestSealEngineType.NethDev)
             .Build(spec);
         testRpc.TestWallet.UnlockAccount(address, new SecureString());
         await testRpc.AddFunds(address, 1.Ether());

src/Nethermind/Nethermind.Blockchain.Test/Services/HealthHintServiceTests.cs

@@ -5,6 +5,7 @@
 using Nethermind.Blockchain.Services;
 using Nethermind.Core;
 using Nethermind.Specs.ChainSpecStyle;
+using Nethermind.Specs.Test.ChainSpecStyle;
 using NUnit.Framework;
 
 namespace Nethermind.Blockchain.Test.Services;
@@ -39,7 +40,7 @@ public static IEnumerable<BlockProcessorIntervalHint> BlockProcessorIntervalHint
         {
             yield return new BlockProcessorIntervalHint
             {
-                ChainSpec = new ChainSpec { SealEngineType = SealEngineType.NethDev, }
+                ChainSpec = new ChainSpec { SealEngineType = TestSealEngineType.NethDev, }
             };
             yield return new BlockProcessorIntervalHint
             {

src/Nethermind/Nethermind.Blockchain.Test/Visitors/StartupTreeFixerTests.cs

@@ -12,6 +12,7 @@
 using Nethermind.Db;
 using Nethermind.Logging;
 using Nethermind.JsonRpc.Test.Modules;
+using Nethermind.Specs.Test.ChainSpecStyle;
 using Nethermind.State;
 using NSubstitute;
 using NUnit.Framework;
@@ -95,7 +96,7 @@ public async Task Deletes_everything_after_the_missing_level()
     [TestCase(65)]
     public async Task Suggesting_blocks_works_correctly_after_processor_restart(int suggestedBlocksAmount)
     {
-        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build();
+        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(TestSealEngineType.NethDev).Build();
         await testRpc.BlockchainProcessor.StopAsync();
         IBlockTree tree = testRpc.BlockTree;
         long startingBlockNumber = tree.Head!.Number;
@@ -130,7 +131,7 @@ public async Task Suggesting_blocks_works_correctly_after_processor_restart(int
     [TestCase(6)]
     public async Task Fixer_should_not_suggest_block_without_state(int suggestedBlocksAmount)
     {
-        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build();
+        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(TestSealEngineType.NethDev).Build();
         await testRpc.BlockchainProcessor.StopAsync();
         IBlockTree tree = testRpc.BlockTree;
 
@@ -152,7 +153,7 @@ public async Task Fixer_should_not_suggest_block_without_state(int suggestedBloc
     [Test, MaxTime(Timeout.MaxTestTime)]
     public async Task Fixer_should_not_suggest_block_with_null_block()
     {
-        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build();
+        TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(TestSealEngineType.NethDev).Build();
         await testRpc.BlockchainProcessor.StopAsync();
         IBlockTree tree = testRpc.BlockTree;
 

src/Nethermind/Nethermind.Clique.Test/CliqueHealthHintServiceTests.cs

@@ -4,8 +4,6 @@
 using System.Collections.Generic;
 using Nethermind.Blockchain.Services;
 using Nethermind.Consensus.Clique;
-using Nethermind.Core;
-using Nethermind.Specs.ChainSpecStyle;
 using NSubstitute;
 using NUnit.Framework;
 
@@ -29,7 +27,7 @@ public void GetBlockProcessorAndProducerIntervalHint_returns_expected_result(
 
         public class BlockProcessorIntervalHint
         {
-            public ChainSpec ChainSpec { get; set; }
+            public CliqueChainSpecEngineParameters ChainSpec { get; set; }
 
             public ulong ValidatorsCount { get; set; }
 
@@ -47,27 +45,27 @@ public static IEnumerable<BlockProcessorIntervalHint> BlockProcessorIntervalHint
             {
                 yield return new BlockProcessorIntervalHint()
                 {
-                    ChainSpec = new ChainSpec() { SealEngineType = SealEngineType.Clique, Clique = new CliqueParameters() { Period = 15 } },
+                    ChainSpec = new CliqueChainSpecEngineParameters { Period = 15 },
                     ExpectedProcessingHint = 60,
                     ExpectedProducingHint = 30
                 };
                 yield return new BlockProcessorIntervalHint()
                 {
-                    ChainSpec = new ChainSpec() { SealEngineType = SealEngineType.Clique, Clique = new CliqueParameters() { Period = 23 } },
+                    ChainSpec = new CliqueChainSpecEngineParameters { Period = 23 },
                     ExpectedProcessingHint = 92,
                     ExpectedProducingHint = 46
                 };
                 yield return new BlockProcessorIntervalHint()
                 {
                     ValidatorsCount = 10,
-                    ChainSpec = new ChainSpec() { SealEngineType = SealEngineType.Clique, Clique = new CliqueParameters() { Period = 23 } },
+                    ChainSpec = new CliqueChainSpecEngineParameters { Period = 23 },
                     ExpectedProcessingHint = 92,
                     ExpectedProducingHint = 460
                 };
                 yield return new BlockProcessorIntervalHint()
                 {
                     ValidatorsCount = 2,
-                    ChainSpec = new ChainSpec() { SealEngineType = SealEngineType.Clique, Clique = new CliqueParameters() { Period = 10 } },
+                    ChainSpec = new CliqueChainSpecEngineParameters { Period = 10 },
                     ExpectedProcessingHint = 40,
                     ExpectedProducingHint = 40
                 };