[WIP]Make chainspec extendable by plugins

src/Nethermind/Nethermind.AuRa.Test/AuRaAdditionalBlockProcessorFactoryTests.cs

@@ -26,11 +26,11 @@ namespace Nethermind.AuRa.Test
 {
     public class AuRaAdditionalBlockProcessorFactoryTests
     {
-        [TestCase(AuRaParameters.ValidatorType.List, typeof(ListBasedValidator))]
-        [TestCase(AuRaParameters.ValidatorType.Contract, typeof(ContractBasedValidator))]
-        [TestCase(AuRaParameters.ValidatorType.ReportingContract, typeof(ReportingContractBasedValidator))]
-        [TestCase(AuRaParameters.ValidatorType.Multi, typeof(MultiValidator))]
-        public void returns_correct_validator_type(AuRaParameters.ValidatorType validatorType, Type expectedType)
+        [TestCase(ValidatorType.List, typeof(ListBasedValidator))]
+        [TestCase(ValidatorType.Contract, typeof(ContractBasedValidator))]
+        [TestCase(ValidatorType.ReportingContract, typeof(ReportingContractBasedValidator))]
+        [TestCase(ValidatorType.Multi, typeof(MultiValidator))]
+        public void returns_correct_validator_type(ValidatorType validatorType, Type expectedType)
         {
             AuRaValidatorFactory factory = new(Substitute.For<IAbiEncoder>(),
                 Substitute.For<IWorldState>(),
@@ -50,16 +50,16 @@ public void returns_correct_validator_type(AuRaParameters.ValidatorType validato
                 Substitute.For<IGasPriceOracle>(),
                 new ReportingContractBasedValidator.Cache(), long.MaxValue);
 
-            AuRaParameters.Validator validator = new()
+            Validator validator = new()
             {
                 ValidatorType = validatorType,
                 Addresses = new[] { Address.Zero },
-                Validators = new Dictionary<long, AuRaParameters.Validator>()
+                Validators = new Dictionary<long, Validator>()
                 {
                     {
-                        0, new AuRaParameters.Validator()
+                        0, new Validator()
                         {
-                            ValidatorType = AuRaParameters.ValidatorType.List, Addresses = new[] {Address.SystemUser}
+                            ValidatorType = ValidatorType.List, Addresses = new[] {Address.SystemUser}
                         }
                     }
                 }

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/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

@@ -267,10 +267,10 @@ public class TestTxPermissionsBlockchain : TestContractBlockchain
 
         protected override BlockProcessor CreateBlockProcessor()
         {
-            AuRaParameters.Validator validator = new()
+            Validator validator = new()
             {
                 Addresses = TestItem.Addresses,
-                ValidatorType = AuRaParameters.ValidatorType.List
+                ValidatorType = ValidatorType.List
             };
 
             TransactionPermissionContractVersions =

src/Nethermind/Nethermind.AuRa.Test/Validators/ContractBasedValidatorTests.cs

@@ -41,7 +41,7 @@ public class ContractBasedValidatorTests
     private IWorldState _stateProvider;
     private IAbiEncoder _abiEncoder;
     private ILogManager _logManager;
-    private AuRaParameters.Validator _validator;
+    private Validator _validator;
     private Block _block;
     private BlockHeader _parentHeader;
     private ITransactionProcessor _transactionProcessor;
@@ -68,10 +68,10 @@ public void SetUp()
         _blockTree = Substitute.For<IBlockTree>();
         _blockFinalizationManager = Substitute.For<IAuRaBlockFinalizationManager>();
         _receiptsStorage = Substitute.For<IReceiptStorage>();
-        _validator = new AuRaParameters.Validator()
+        _validator = new Validator()
         {
             Addresses = new[] { _contractAddress },
-            ValidatorType = AuRaParameters.ValidatorType.Contract
+            ValidatorType = ValidatorType.Contract
         };
         _block = new Block(Build.A.BlockHeader.WithNumber(1).WithAura(1, Array.Empty<byte>()).TestObject, new BlockBody());
 

src/Nethermind/Nethermind.AuRa.Test/Validators/ListValidatorTests.cs

@@ -24,9 +24,9 @@ private ListBasedValidator GetListValidator(params Address[] address)
             LimboLogs logManager = LimboLogs.Instance;
             _validSealerStrategy = new ValidSealerStrategy();
             ListBasedValidator validator = new(
-                new AuRaParameters.Validator()
+                new Validator()
                 {
-                    ValidatorType = AuRaParameters.ValidatorType.List,
+                    ValidatorType = ValidatorType.List,
                     Addresses = address
                 }, _validSealerStrategy, Substitute.For<IValidatorStore>(), logManager, 1);
 

src/Nethermind/Nethermind.AuRa.Test/Validators/MultiValidatorTests.cs

@@ -21,7 +21,7 @@ namespace Nethermind.AuRa.Test.Validators
 {
     public class MultiValidatorTests
     {
-        private AuRaParameters.Validator _validator;
+        private Validator _validator;
         private IAuRaValidatorFactory _factory;
         private ILogManager _logManager;
         private IDictionary<long, IAuRaValidator> _innerValidators;
@@ -33,7 +33,7 @@ public class MultiValidatorTests
         [SetUp]
         public void SetUp()
         {
-            _validator = GetValidator(AuRaParameters.ValidatorType.List);
+            _validator = GetValidator(ValidatorType.List);
             _innerValidators = new SortedList<long, IAuRaValidator>();
             _factory = Substitute.For<IAuRaValidatorFactory>();
             _logManager = LimboLogs.Instance;
@@ -80,7 +80,7 @@ public void throws_ArgumentNullException_on_empty_logManager()
         [Test]
         public void throws_ArgumentException_on_wrong_validator_type()
         {
-            _validator.ValidatorType = AuRaParameters.ValidatorType.Contract;
+            _validator.ValidatorType = ValidatorType.Contract;
             Action act = () => new MultiValidator(_validator, _factory, _blockTree, _validatorStore, _finalizationManager, default, _logManager);
             act.Should().Throw<ArgumentException>();
         }
@@ -96,7 +96,7 @@ public void throws_ArgumentException_on_empty_inner_validators()
         [Test]
         public void creates_inner_validators()
         {
-            _validator = GetValidator(AuRaParameters.ValidatorType.Contract);
+            _validator = GetValidator(ValidatorType.Contract);
             MultiValidator validator = new(_validator, _factory, _blockTree, _validatorStore, _finalizationManager, default, _logManager);
             validator.SetFinalizationManager(_finalizationManager, null);
 
@@ -109,15 +109,15 @@ public void creates_inner_validators()
             _innerValidators.Keys.Should().BeEquivalentTo(_validator.Validators.Keys.Select(x => x == 0 ? 1 : x + 2));
         }
 
-        [TestCase(AuRaParameters.ValidatorType.Contract, 1)]
-        [TestCase(AuRaParameters.ValidatorType.List, 0)]
-        [TestCase(AuRaParameters.ValidatorType.ReportingContract, 2)]
-        public void correctly_consecutively_calls_inner_validators(AuRaParameters.ValidatorType validatorType, int blocksToFinalization)
+        [TestCase(ValidatorType.Contract, 1)]
+        [TestCase(ValidatorType.List, 0)]
+        [TestCase(ValidatorType.ReportingContract, 2)]
+        public void correctly_consecutively_calls_inner_validators(ValidatorType validatorType, int blocksToFinalization)
         {
             // Arrange
             _validator = GetValidator(validatorType);
             IAuRaValidator validator = new MultiValidator(_validator, _factory, _blockTree, _validatorStore, _finalizationManager, default, _logManager);
-            Dictionary<AuRaParameters.Validator, long> innerValidatorsFirstBlockCalls = GetInnerValidatorsFirstBlockCalls(_validator);
+            Dictionary<Validator, long> innerValidatorsFirstBlockCalls = GetInnerValidatorsFirstBlockCalls(_validator);
             long maxCalls = innerValidatorsFirstBlockCalls.Values.Max() + 10;
 
             // Act
@@ -165,17 +165,17 @@ public long initializes_validator_when_producing_block(long blockNumber)
             return _innerValidators.Keys.Last();
         }
 
-        [TestCase(16L, AuRaParameters.ValidatorType.List, true, ExpectedResult = 11)]
-        [TestCase(21L, AuRaParameters.ValidatorType.List, false, ExpectedResult = 21)]
-        [TestCase(16L, AuRaParameters.ValidatorType.Contract, true, ExpectedResult = 15)]
-        [TestCase(23L, AuRaParameters.ValidatorType.Contract, true, ExpectedResult = 22)]
-        [TestCase(16L, AuRaParameters.ValidatorType.Contract, false, ExpectedResult = 1)]
-        [TestCase(21L, AuRaParameters.ValidatorType.Contract, false, ExpectedResult = 11)]
-        public long initializes_validator_when_on_nonconsecutive_block(long blockNumber, AuRaParameters.ValidatorType validatorType, bool finalizedLastValidatorBlockLevel)
+        [TestCase(16L, ValidatorType.List, true, ExpectedResult = 11)]
+        [TestCase(21L, ValidatorType.List, false, ExpectedResult = 21)]
+        [TestCase(16L, ValidatorType.Contract, true, ExpectedResult = 15)]
+        [TestCase(23L, ValidatorType.Contract, true, ExpectedResult = 22)]
+        [TestCase(16L, ValidatorType.Contract, false, ExpectedResult = 1)]
+        [TestCase(21L, ValidatorType.Contract, false, ExpectedResult = 11)]
+        public long initializes_validator_when_on_nonconsecutive_block(long blockNumber, ValidatorType validatorType, bool finalizedLastValidatorBlockLevel)
         {
             _validator = GetValidator(validatorType);
             IAuRaValidator validator = new MultiValidator(_validator, _factory, _blockTree, _validatorStore, _finalizationManager, default, _logManager);
-            _validator.Validators.ToList().TryGetSearchedItem(in blockNumber, (l, pair) => l.CompareTo(pair.Key), out KeyValuePair<long, AuRaParameters.Validator> validatorInfo);
+            _validator.Validators.ToList().TryGetSearchedItem(in blockNumber, (l, pair) => l.CompareTo(pair.Key), out KeyValuePair<long, Validator> validatorInfo);
             _finalizationManager.GetFinalizationLevel(validatorInfo.Key).Returns(finalizedLastValidatorBlockLevel ? blockNumber - 2 : (long?)null);
             _block.Header.Number = blockNumber;
             validator.OnBlockProcessingStart(_block);
@@ -212,37 +212,37 @@ private void EnsureInnerValidatorsCalled(Func<int, (IAuRaValidator Validator, in
             }
         }
 
-        private Dictionary<AuRaParameters.Validator, long> GetInnerValidatorsFirstBlockCalls(AuRaParameters.Validator validator)
+        private Dictionary<Validator, long> GetInnerValidatorsFirstBlockCalls(Validator validator)
         {
             return validator.Validators.ToDictionary(x => x.Value, x => Math.Max(x.Key + 1, 1));
         }
 
-        private static AuRaParameters.Validator GetValidator(AuRaParameters.ValidatorType validatorType)
+        private static Validator GetValidator(ValidatorType validatorType)
         {
             return new()
             {
-                ValidatorType = AuRaParameters.ValidatorType.Multi,
-                Validators = new SortedList<long, AuRaParameters.Validator>()
+                ValidatorType = ValidatorType.Multi,
+                Validators = new SortedList<long, Validator>()
                 {
                     {
                         0,
-                        new AuRaParameters.Validator()
+                        new Validator()
                         {
                             ValidatorType = validatorType,
                             Addresses = new[] {Address.FromNumber(0)}
                         }
                     },
                     {
                         10,
-                        new AuRaParameters.Validator()
+                        new Validator()
                         {
                             ValidatorType = validatorType,
                             Addresses = new[] {Address.FromNumber(10)}
                         }
                     },
                     {
                         20,
-                        new AuRaParameters.Validator()
+                        new Validator()
                         {
                             ValidatorType = validatorType,
                             Addresses = new[] {Address.FromNumber(20)}

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());