Use BlockProducerEnvFactory in AuRa

NethermindEth · Apr 9, 2022 · b892b69 · b892b69
1 parent 1e81ff3
commit b892b69
Show file tree

Hide file tree

Showing 2 changed files with 56 additions and 354 deletions.
diff --git a/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/AuRaBlockProducerEnvFactory.cs b/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/AuRaBlockProducerEnvFactory.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 using Nethermind.Abi;
 using Nethermind.Api;
 using Nethermind.Blockchain;
@@ -20,7 +19,6 @@
 using Nethermind.Db;
 using Nethermind.Evm.TransactionProcessing;
 using Nethermind.Init.Steps;
-using Nethermind.Logging;
 using Nethermind.Specs.ChainSpecStyle;
 using Nethermind.TxPool;
 
@@ -30,13 +28,17 @@ public class AuRaBlockProducerEnvFactory : IBlockProducerEnvFactory
     {
         private readonly AuRaNethermindApi _api;
         private IAuraConfig _auraConfig;
-        private IAuRaValidator _validator;
-        private TxPriorityContract? _txPriorityContract;
-        private TxPriorityContract.LocalDataSource? _localDataSource;
         private DictionaryContractDataStore<TxPriorityContract.Destination>? _minGasPricesContractDataStore;
 
-        public IBlockTransactionsExecutorFactory TransactionsExecutorFactory { get; set; }
+        private IAuRaValidator _validator;
 
+        public AuRaBlockProducerEnvFactory(AuRaNethermindApi api, IAuraConfig auraConfig)
+        {
+            _api = api ?? throw new ArgumentNullException(nameof(api));
+            _auraConfig = auraConfig ?? throw new ArgumentNullException(nameof(auraConfig));
+        }
+
+        public IBlockTransactionsExecutorFactory TransactionsExecutorFactory { get; set; }
 
         public virtual BlockProducerEnv Create(ITxSource? additionalTxSource = null)
         {
@@ -45,8 +47,10 @@ public virtual BlockProducerEnv Create(ITxSource? additionalTxSource = null)
 
             ReadOnlyTxProcessingEnv txProcessingEnv = CreateReadonlyTxProcessingEnv(dbProvider, readOnlyBlockTree);
             ReadOnlyTxProcessingEnv constantContractsProcessingEnv = CreateReadonlyTxProcessingEnv(dbProvider, readOnlyBlockTree);
-            BlockProcessor blockProcessor = CreateBlockProcessor(txProcessingEnv, constantContractsProcessingEnv);
 
+            IGasLimitCalculator gasLimitCalculator = CreateGasLimitCalculator(constantContractsProcessingEnv);
+
+            BlockProcessor blockProcessor = CreateBlockProcessor(txProcessingEnv, constantContractsProcessingEnv, gasLimitCalculator as AuRaContractGasLimitOverride);
             IBlockchainProcessor blockchainProcessor =
                 new BlockchainProcessor(
                     readOnlyBlockTree,
@@ -61,17 +65,18 @@ public virtual BlockProducerEnv Create(ITxSource? additionalTxSource = null)
 
             var txSource = CreateTxSourceForProducer(txProcessingEnv, constantContractsProcessingEnv, additionalTxSource);
 
-            return new BlockProducerEnv()
+            return new AuRaBlockProducerEnv()
             {
                 BlockTree = readOnlyBlockTree,
                 ChainProcessor = chainProcessor,
                 ReadOnlyStateProvider = txProcessingEnv.StateProvider,
                 TxSource = txSource,
-                ReadOnlyTxProcessingEnv = constantContractsProcessingEnv
+                ReadOnlyTxProcessingEnv = constantContractsProcessingEnv,
+                GasLimitCalculator = gasLimitCalculator,
             };
         }
 
-        private BlockProcessor CreateBlockProcessor(ReadOnlyTxProcessingEnv changeableTxProcessingEnv, ReadOnlyTxProcessingEnv constantContractTxProcessingEnv)
+        private BlockProcessor CreateBlockProcessor(ReadOnlyTxProcessingEnv changeableTxProcessingEnv, ReadOnlyTxProcessingEnv constantContractTxProcessingEnv, AuRaContractGasLimitOverride? gasLimitOverride)
         {
             if (_api.RewardCalculatorSource == null) throw new StepDependencyException(nameof(_api.RewardCalculatorSource));
             if (_api.ValidatorStore == null) throw new StepDependencyException(nameof(_api.ValidatorStore));
@@ -100,7 +105,7 @@ private BlockProcessor CreateBlockProcessor(ReadOnlyTxProcessingEnv changeableTx
                 _api.LogManager,
                 changeableTxProcessingEnv.BlockTree,
                 auRaTxFilter,
-                CreateGasLimitCalculator(constantContractTxProcessingEnv) as AuRaContractGasLimitOverride);
+                gasLimitOverride);
 
             _validator = new AuRaValidatorFactory(_api.AbiEncoder,
                     changeableTxProcessingEnv.StateProvider,
@@ -129,33 +134,6 @@ private BlockProcessor CreateBlockProcessor(ReadOnlyTxProcessingEnv changeableTx
             return processor;
         }
 
-        private IGasLimitCalculator CreateGasLimitCalculator(IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
-        {
-            if (_api.ChainSpec == null) throw new StepDependencyException(nameof(_api.ChainSpec));
-            var blockGasLimitContractTransitions = _api.ChainSpec.AuRa.BlockGasLimitContractTransitions;
-
-            IGasLimitCalculator gasLimitCalculator =
-                new TargetAdjustedGasLimitCalculator(_api.SpecProvider, _api.Config<IMiningConfig>());
-            if (blockGasLimitContractTransitions?.Any() == true)
-            {
-                AuRaContractGasLimitOverride auRaContractGasLimitOverride = new(
-                        blockGasLimitContractTransitions.Select(blockGasLimitContractTransition =>
-                                new BlockGasLimitContract(
-                                    _api.AbiEncoder,
-                                    blockGasLimitContractTransition.Value,
-                                    blockGasLimitContractTransition.Key,
-                                    readOnlyTxProcessorSource))
-                            .ToArray<IBlockGasLimitContract>(),
-                        _api.GasLimitCalculatorCache,
-                        _auraConfig?.Minimum2MlnGasPerBlockWhenUsingBlockGasLimitContract == true,
-                        gasLimitCalculator,
-                        _api.LogManager);
-
-                gasLimitCalculator = auRaContractGasLimitOverride;
-            }
-
-            return gasLimitCalculator;
-        }
 
         protected ReadOnlyTxProcessingEnv CreateReadonlyTxProcessingEnv(ReadOnlyDbProvider dbProvider, ReadOnlyBlockTree blockTree)
         {
@@ -250,7 +228,7 @@ private TxPoolTxSource CreateTxPoolTxSource(ReadOnlyTxProcessingEnv processingEn
             IReadOnlyTxProcessorSource readOnlyTxProcessorSourceForTxPriority =
                 new ReadOnlyTxProcessingEnv(_api.DbProvider, _api.ReadOnlyTrieStore, _api.BlockTree, _api.SpecProvider, _api.LogManager);
 
-            (_txPriorityContract, _localDataSource) = TxAuRaFilterBuilders.CreateTxPrioritySources(_auraConfig, _api, readOnlyTxProcessorSourceForTxPriority);
+            (TxPriorityContract _txPriorityContract,TxPriorityContract.LocalDataSource _localDataSource) = TxAuRaFilterBuilders.CreateTxPrioritySources(_auraConfig, _api, readOnlyTxProcessorSourceForTxPriority);
 
             if (_txPriorityContract != null || _localDataSource != null)
             {
@@ -304,7 +282,7 @@ private TxPoolTxSource CreateTxPoolTxSource(ReadOnlyTxProcessingEnv processingEn
 
         private TxPoolTxSource CreateStandardTxPoolTxSource(ReadOnlyTxProcessingEnv processingEnv, IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
         {
-            ITxFilter txSourceFilter = CreateAuraTxFilterForProducer(readOnlyTxProcessorSource,_api.SpecProvider);
+            ITxFilter txSourceFilter = CreateAuraTxFilterForProducer(readOnlyTxProcessorSource, _api.SpecProvider);
             ITxFilterPipeline txFilterPipeline = new TxFilterPipelineBuilder(_api.LogManager)
                 .WithCustomTxFilter(txSourceFilter)
                 .WithBaseFeeFilter(_api.SpecProvider)
@@ -320,5 +298,38 @@ private ITxFilter CreateAuraTxFilterForProducer(IReadOnlyTxProcessorSource readO
                 _minGasPricesContractDataStore,
                 specProvider);
 
+        private IGasLimitCalculator CreateGasLimitCalculator(IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
+        {
+            if (_api.ChainSpec == null) throw new StepDependencyException(nameof(_api.ChainSpec));
+            var blockGasLimitContractTransitions = _api.ChainSpec.AuRa.BlockGasLimitContractTransitions;
+
+            IGasLimitCalculator gasLimitCalculator =
+                new TargetAdjustedGasLimitCalculator(_api.SpecProvider, _api.Config<IMiningConfig>());
+            if (blockGasLimitContractTransitions?.Any() == true)
+            {
+                AuRaContractGasLimitOverride auRaContractGasLimitOverride = new(
+                        blockGasLimitContractTransitions.Select(blockGasLimitContractTransition =>
+                                new BlockGasLimitContract(
+                                    _api.AbiEncoder,
+                                    blockGasLimitContractTransition.Value,
+                                    blockGasLimitContractTransition.Key,
+                                    readOnlyTxProcessorSource))
+                            .ToArray<IBlockGasLimitContract>(),
+                        _api.GasLimitCalculatorCache,
+                        _auraConfig?.Minimum2MlnGasPerBlockWhenUsingBlockGasLimitContract == true,
+                        gasLimitCalculator,
+                        _api.LogManager);
+
+                gasLimitCalculator = auRaContractGasLimitOverride;
+            }
+
+            return gasLimitCalculator;
+        }
+
+    }
+
+    public class AuRaBlockProducerEnv : BlockProducerEnv
+    {
+        public IGasLimitCalculator GasLimitCalculator { get; set; }
     }
 }