protected override BlockProcessor CreateBlockProcessor()
        {
            if (_api.SpecProvider == null) throw new StepDependencyException(nameof(_api.SpecProvider));
            if (_api.ChainHeadStateProvider == null) throw new StepDependencyException(nameof(_api.ChainHeadStateProvider));
            if (_api.BlockValidator == null) throw new StepDependencyException(nameof(_api.BlockValidator));
            if (_api.RewardCalculatorSource == null) throw new StepDependencyException(nameof(_api.RewardCalculatorSource));
            if (_api.TransactionProcessor == null) throw new StepDependencyException(nameof(_api.TransactionProcessor));
            if (_api.DbProvider == null) throw new StepDependencyException(nameof(_api.DbProvider));
            if (_api.StateProvider == null) throw new StepDependencyException(nameof(_api.StateProvider));
            if (_api.StorageProvider == null) throw new StepDependencyException(nameof(_api.StorageProvider));
            if (_api.TxPool == null) throw new StepDependencyException(nameof(_api.TxPool));
            if (_api.ReceiptStorage == null) throw new StepDependencyException(nameof(_api.ReceiptStorage));
       
            var processingReadOnlyTransactionProcessorSource = CreateReadOnlyTransactionProcessorSource();
            var txPermissionFilterOnlyTxProcessorSource = CreateReadOnlyTransactionProcessorSource();
            ITxFilter? txPermissionFilter = TxFilterBuilders.CreateTxPermissionFilter(_api, txPermissionFilterOnlyTxProcessorSource);
            
            var processor = new AuRaBlockProcessor(
                _api.SpecProvider,
                _api.BlockValidator,
                _api.RewardCalculatorSource.Get(_api.TransactionProcessor),
                _api.TransactionProcessor,
                _api.StateProvider,
                _api.StorageProvider,
                _api.TxPool,
                _api.ReceiptStorage,
                _api.LogManager,
                _api.BlockTree,
                txPermissionFilter,
                GetGasLimitCalculator());
            
            var auRaValidator = CreateAuRaValidator(processor, processingReadOnlyTransactionProcessorSource);
            processor.AuRaValidator = auRaValidator;
            var reportingValidator = auRaValidator.GetReportingValidator();
            _api.ReportingValidator = reportingValidator;
            if (_sealValidator != null)
            {
                _sealValidator.ReportingValidator = reportingValidator;
            }

            return processor;
        }
Ejemplo n.º 2
0
        protected override BlockProcessor CreateBlockProcessor(
            ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv,
            IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
            IReadOnlyDbProvider readOnlyDbProvider)
        {
            if (_api.RewardCalculatorSource == null)
            {
                throw new StepDependencyException(nameof(_api.RewardCalculatorSource));
            }
            if (_api.ValidatorStore == null)
            {
                throw new StepDependencyException(nameof(_api.ValidatorStore));
            }
            if (_api.ChainSpec == null)
            {
                throw new StepDependencyException(nameof(_api.ChainSpec));
            }
            if (_api.BlockTree == null)
            {
                throw new StepDependencyException(nameof(_api.BlockTree));
            }
            if (_api.EngineSigner == null)
            {
                throw new StepDependencyException(nameof(_api.EngineSigner));
            }

            var chainSpecAuRa = _api.ChainSpec.AuRa;

            _txPermissionFilter = TxFilterBuilders.CreateTxPermissionFilter(_api, readOnlyTxProcessorSource);

            _validator = new AuRaValidatorFactory(
                readOnlyTxProcessingEnv.StateProvider,
                _api.AbiEncoder,
                readOnlyTxProcessingEnv.TransactionProcessor,
                readOnlyTxProcessorSource,
                readOnlyTxProcessingEnv.BlockTree,
                _api.ReceiptStorage,
                _api.ValidatorStore,
                _api.FinalizationManager,
                NullTxSender.Instance,
                NullTxPool.Instance,
                NethermindApi.Config <IMiningConfig>(),
                _api.LogManager,
                _api.EngineSigner,
                _api.ReportingContractValidatorCache,
                chainSpecAuRa.PosdaoTransition,
                true)
                         .CreateValidatorProcessor(chainSpecAuRa.Validators, _api.BlockTree.Head?.Header);

            if (_validator is IDisposable disposableValidator)
            {
                _api.DisposeStack.Push(disposableValidator);
            }

            return(new AuRaBlockProcessor(
                       _api.SpecProvider,
                       _api.BlockValidator,
                       _api.RewardCalculatorSource.Get(readOnlyTxProcessingEnv.TransactionProcessor),
                       readOnlyTxProcessingEnv.TransactionProcessor,
                       readOnlyTxProcessingEnv.StateProvider,
                       readOnlyTxProcessingEnv.StorageProvider,
                       NullTxPool.Instance,
                       _api.ReceiptStorage,
                       _api.LogManager,
                       readOnlyTxProcessingEnv.BlockTree,
                       _txPermissionFilter,
                       CreateGasLimitCalculator(readOnlyTxProcessorSource) as AuRaContractGasLimitOverride)
            {
                AuRaValidator = _validator
            });
        }