private async Task InitializeNetwork(
IReceiptStorage receiptStorage,
IHeaderValidator headerValidator,
TransactionValidator txValidator)
{
if (!_initConfig.NetworkEnabled)
{
if (_logger.IsWarn) _logger.Warn($"Skipping network init due to ({nameof(IInitConfig.NetworkEnabled)} set to false)");
return;
}
_syncManager = new QueueBasedSyncManager(
_dbProvider.StateDb,
_blockTree,
_blockValidator,
headerValidator,
txValidator,
_logManager,
_configProvider.GetConfig<IBlockchainConfig>(),
_perfService,
receiptStorage);
InitDiscovery();
await InitPeer().ContinueWith(initPeerTask =>
{
if (initPeerTask.IsFaulted)
{
_logger.Error("Unable to init peer manager.", initPeerTask.Exception);
}
});;
await StartSync().ContinueWith(initNetTask =>
{
if (initNetTask.IsFaulted)
{
_logger.Error("Unable to start sync.", initNetTask.Exception);
}
});
await StartDiscovery().ContinueWith(initDiscoveryTask =>
{
if (initDiscoveryTask.IsFaulted)
{
_logger.Error("Unable to start discovery protocol.", initDiscoveryTask.Exception);
}
});
await StartPeer().ContinueWith(initPeerManagerTask =>
{
if (initPeerManagerTask.IsFaulted)
{
_logger.Error("Unable to start peer manager.", initPeerManagerTask.Exception);
}
});
if (_logger.IsInfo) _logger.Info($"Node is up and listening on {_enode.IpAddress}:{_enode.P2PPort}");
if (_logger.IsInfo) _logger.Info($"{ClientVersion.Description}");
if (_logger.IsInfo) _logger.Info(_enode.Info);
if (_logger.IsInfo) _logger.Info($"enode address for test purposes: {_enode.Address}");
}
public void When_gaslimit_is_on_london_fork(long parentGasLimit, long blockNumber, long gasLimit, bool expectedResult)
{
OverridableReleaseSpec spec = new(London.Instance)
{
Eip1559TransitionBlock = 5
};
TestSpecProvider specProvider = new(spec);
_validator = new HeaderValidator(_blockTree, _ethash, specProvider, new OneLoggerLogManager(_testLogger));
_parentBlock = Build.A.Block.WithDifficulty(1)
.WithGasLimit(parentGasLimit)
.WithNumber(blockNumber)
.TestObject;
_block = Build.A.Block.WithParent(_parentBlock)
.WithDifficulty(131072)
.WithMixHash(new Keccak("0xd7db5fdd332d3a65d6ac9c4c530929369905734d3ef7a91e373e81d0f010b8e8"))
.WithGasLimit(gasLimit)
.WithNumber(_parentBlock.Number + 1)
.WithBaseFeePerGas(BaseFeeCalculator.Calculate(_parentBlock.Header, specProvider.GetSpec(_parentBlock.Number + 1)))
.WithNonce(0).TestObject;
_block.Header.SealEngineType = SealEngineType.None;
_block.Header.Hash = _block.CalculateHash();
bool result = _validator.Validate(_block.Header, _parentBlock.Header);
Assert.AreEqual(expectedResult, result);
}
public SynchronizationManager(
IBlockTree blockTree,
IBlockValidator blockValidator,
IHeaderValidator headerValidator,
ITransactionStore transactionStore,
ITransactionValidator transactionValidator,
ILogManager logManager,
IBlockchainConfig blockchainConfig, IPerfService perfService)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_blockchainConfig = blockchainConfig ?? throw new ArgumentNullException(nameof(blockchainConfig));
_perfService = perfService;
_transactionStore = transactionStore ?? throw new ArgumentNullException(nameof(transactionStore));
_transactionValidator = transactionValidator ?? throw new ArgumentNullException(nameof(transactionValidator));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_headerValidator = headerValidator ?? throw new ArgumentNullException(nameof(headerValidator));
if (_logger.IsDebug)
{
_logger.Debug($"Initialized SynchronizationManager with head block {Head.ToString(BlockHeader.Format.Short)}");
}
_entireSyncStopWatch.Start();
}
public BlockValidator(ITxValidator txValidator, IHeaderValidator headerValidator, IOmmersValidator ommersValidator, ISpecProvider specProvider, ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_txValidator = txValidator ?? throw new ArgumentNullException(nameof(headerValidator));
_ommersValidator = ommersValidator ?? throw new ArgumentNullException(nameof(ommersValidator));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_headerValidator = headerValidator ?? throw new ArgumentNullException(nameof(headerValidator));
}
public BlockValidator(ITxValidator?txValidator, IHeaderValidator?headerValidator, IUnclesValidator?unclesValidator, ISpecProvider?specProvider, ILogManager?logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_txValidator = txValidator ?? throw new ArgumentNullException(nameof(headerValidator));
_unclesValidator = unclesValidator ?? throw new ArgumentNullException(nameof(unclesValidator));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_headerValidator = headerValidator ?? throw new ArgumentNullException(nameof(headerValidator));
}
public InvalidHeaderInterceptor(
IHeaderValidator headerValidator,
IInvalidChainTracker invalidChainTracker,
ILogManager logManager)
{
_baseValidator = headerValidator;
_invalidChainTracker = invalidChainTracker;
_logger = logManager.GetClassLogger(typeof(InvalidHeaderInterceptor));
}
public void Setup()
{
_baseValidator = Substitute.For <IHeaderValidator>();
_tracker = Substitute.For <IInvalidChainTracker>();
_invalidHeaderInterceptor = new(
_baseValidator,
_tracker,
NullLogManager.Instance);
}
public void Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
IHeaderValidator headerValidator = Build.A.HeaderValidator.ThatAlwaysReturnsTrue.TestObject;
IBlockValidator blockValidator = Build.A.BlockValidator.ThatAlwaysReturnsTrue.TestObject;
ITransactionValidator transactionValidator = Build.A.TransactionValidator.ThatAlwaysReturnsTrue.TestObject;
_manager = new SynchronizationManager(_blockTree, blockValidator, headerValidator, new TransactionStore(), transactionValidator, NullLogManager.Instance, new BlockchainConfig(), new PerfService(NullLogManager.Instance));
}
public TestChainedHeaderTree(
Network network,
ILoggerFactory loggerFactory,
IHeaderValidator headerValidator,
ICheckpoints checkpoints,
IChainState chainState,
IFinalizedBlockInfoRepository finalizedBlockInfo,
ConsensusSettings consensusSettings,
IInvalidBlockHashStore invalidHashesStore) : base(network, loggerFactory, headerValidator, checkpoints,
chainState, finalizedBlockInfo, consensusSettings, invalidHashesStore)
{
}
private void Validate(ExcelPackage excelPackage, DatasetUploadValidationModel validationModel,
IEnumerable <ProviderSummary> providerSummaries)
{
IList <FieldDefinition> fieldDefinitions =
validationModel.DatasetDefinition.TableDefinitions.First().FieldDefinitions;
IHeaderValidator headerValidator = GetHeaderValidator(fieldDefinitions);
IList <IFieldValidator> fieldValidators = GetFieldValidators(providerSummaries);
IBulkFieldValidator bulkFieldValidator = GetBulkFieldValidator();
IList <IExcelErrorFormatter> excelFormatters = GetAllExcelFormatters(excelPackage);
IList <HeaderValidationResult> headerValidationFailures = new List <HeaderValidationResult>();
List <RowLoadResult> allRows = validationModel.Data.TableLoadResult.Rows;
IList <Field> allFieldsToBeValidated = RetrieveAllFields(allRows, fieldDefinitions, validationModel.Data.RetrievedHeaderFields);
headerValidationFailures.AddRange(headerValidator.ValidateHeaders(validationModel.Data.RetrievedHeaderFields.Keys.ToList()));
ConcurrentBag <FieldValidationResult> fieldValidationFailures = new ConcurrentBag <FieldValidationResult>();
Parallel.ForEach(allFieldsToBeValidated, (Field field, ParallelLoopState state) =>
{
FieldValidationResult validationResult = ReturnFirstOnFailureOrDefault(fieldValidators, field);
if (validationResult != null)
{
fieldValidationFailures.Add(validationResult);
}
});
IList <FieldValidationResult> bulkFieldValidationResults =
bulkFieldValidator.ValidateAllFields(allFieldsToBeValidated);
foreach (FieldValidationResult validationResult in bulkFieldValidationResults)
{
fieldValidationFailures.Add(validationResult);
}
validationModel.ValidationResult = new DatasetUploadValidationResult
{
FieldValidationFailures = fieldValidationFailures,
HeaderValitionFailures = headerValidationFailures
};
_isValid = validationModel.ValidationResult.IsValid();
foreach (var excelErrorFormatter in excelFormatters)
{
excelErrorFormatter.FormatExcelSheetBasedOnErrors(validationModel.ValidationResult);
}
}
public MergeHeaderValidator(
IPoSSwitcher poSSwitcher,
IHeaderValidator preMergeHeaderValidator,
IBlockTree blockTree,
ISpecProvider specProvider,
ISealValidator sealValidator,
ILogManager logManager)
: base(blockTree, sealValidator, specProvider, logManager)
{
_poSSwitcher = poSSwitcher;
_preMergeHeaderValidator = preMergeHeaderValidator;
_blockTree = blockTree;
_specProvider = specProvider;
}
public ConsensusManager(
Network network,
ILoggerFactory loggerFactory,
IChainState chainState,
IHeaderValidator headerValidator,
IIntegrityValidator integrityValidator,
IPartialValidation partialValidation,
ICheckpoints checkpoints,
ConsensusSettings consensusSettings,
IConsensusRules consensusRules,
IFinalizedBlockHeight finalizedBlockHeight,
Signals.Signals signals,
IPeerBanning peerBanning,
NodeSettings nodeSettings,
IDateTimeProvider dateTimeProvider,
IInitialBlockDownloadState ibdState,
ConcurrentChain chain,
IBlockStore blockStore = null)
{
this.network = network;
this.chainState = chainState;
this.partialValidation = partialValidation;
this.consensusSettings = consensusSettings;
this.consensusRules = consensusRules;
this.signals = signals;
this.peerBanning = peerBanning;
this.blockStore = blockStore;
this.finalizedBlockHeight = finalizedBlockHeight;
this.chain = chain;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.chainedHeaderTree = new ChainedHeaderTree(network, loggerFactory, headerValidator, integrityValidator, checkpoints, chainState, finalizedBlockHeight, consensusSettings, signals);
this.peerLock = new object();
this.reorgLock = new AsyncLock();
this.blockRequestedLock = new object();
this.expectedBlockDataBytes = 0;
this.expectedBlockSizes = new Dictionary <uint256, long>();
this.callbacksByBlocksRequestedHash = new Dictionary <uint256, List <OnBlockDownloadedCallback> >();
this.peersByPeerId = new Dictionary <int, INetworkPeer>();
this.toDownloadQueue = new Queue <BlockDownloadRequest>();
this.ibdState = ibdState;
ProtocolVersion protocolVersion = nodeSettings.ProtocolVersion;
this.blockPuller = new BlockPuller(this.BlockDownloaded, this.chainState, protocolVersion, dateTimeProvider, loggerFactory);
}
public void Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
_stateDb = new MemDb();
_receiptsDb = new MemDb();
_receiptStorage = Substitute.For <IReceiptStorage>();
BlockchainConfig quickConfig = new BlockchainConfig();
quickConfig.SyncTimerInterval = 100;
IHeaderValidator headerValidator = Build.A.HeaderValidator.ThatAlwaysReturnsTrue.TestObject;
IBlockValidator blockValidator = Build.A.BlockValidator.ThatAlwaysReturnsTrue.TestObject;
ITransactionValidator transactionValidator = Build.A.TransactionValidator.ThatAlwaysReturnsTrue.TestObject;
_manager = new QueueBasedSyncManager(_stateDb, _blockTree, blockValidator, headerValidator, transactionValidator, NullLogManager.Instance, quickConfig, new PerfService(NullLogManager.Instance), _receiptStorage);
}
public void Setup()
{
_ethash = new EthashSealEngine(new Ethash(NullLogManager.Instance), NullLogManager.Instance);
_testLogger = new TestLogger();
BlockTree blockStore = new BlockTree(new MemDb(), new MemDb(), new MemDb(), FrontierSpecProvider.Instance, NullLogManager.Instance);
DifficultyCalculator calculator = new DifficultyCalculator(new SingleReleaseSpecProvider(Frontier.Instance, ChainId.MainNet));
_validator = new HeaderValidator(calculator, blockStore, _ethash, new SingleReleaseSpecProvider(Byzantium.Instance, 3), new OneLoggerLogManager(_testLogger));
_parentBlock = Build.A.Block.WithDifficulty(1).TestObject;
_block = Build.A.Block.WithParent(_parentBlock)
.WithDifficulty(131072)
.WithMixHash(new Keccak("0xd7db5fdd332d3a65d6ac9c4c530929369905734d3ef7a91e373e81d0f010b8e8"))
.WithNonce(0).TestObject;
blockStore.SuggestBlock(_parentBlock);
blockStore.SuggestBlock(_block);
}
public void Setup()
{
DifficultyCalculator calculator = new DifficultyCalculator(new SingleReleaseSpecProvider(Frontier.Instance, ChainId.MainNet));
_ethash = new EthashSealValidator(LimboLogs.Instance, calculator, new CryptoRandom(), new Ethash(LimboLogs.Instance));
_testLogger = new TestLogger();
var blockInfoDb = new MemDb();
BlockTree blockStore = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), FrontierSpecProvider.Instance, Substitute.For <ITxPool>(), Substitute.For <IBloomStorage>(), LimboLogs.Instance);
_validator = new HeaderValidator(blockStore, _ethash, new SingleReleaseSpecProvider(Byzantium.Instance, 3), new OneLoggerLogManager(_testLogger));
_parentBlock = Build.A.Block.WithDifficulty(1).TestObject;
_block = Build.A.Block.WithParent(_parentBlock)
.WithDifficulty(131072)
.WithMixHash(new Keccak("0xd7db5fdd332d3a65d6ac9c4c530929369905734d3ef7a91e373e81d0f010b8e8"))
.WithNonce(0).TestObject;
blockStore.SuggestBlock(_parentBlock);
blockStore.SuggestBlock(_block);
}
public void When_gas_limit_is_long_max_value()
{
_validator = new HeaderValidator(_blockTree, _ethash, _specProvider, new OneLoggerLogManager(_testLogger));
_parentBlock = Build.A.Block.WithDifficulty(1)
.WithGasLimit(long.MaxValue)
.WithNumber(5)
.TestObject;
_block = Build.A.Block.WithParent(_parentBlock)
.WithDifficulty(131072)
.WithMixHash(new Keccak("0xd7db5fdd332d3a65d6ac9c4c530929369905734d3ef7a91e373e81d0f010b8e8"))
.WithGasLimit(long.MaxValue)
.WithNumber(_parentBlock.Number + 1)
.WithNonce(0).TestObject;
_block.Header.SealEngineType = SealEngineType.None;
_block.Header.Hash = _block.CalculateHash();
bool result = _validator.Validate(_block.Header, _parentBlock.Header);
Assert.True(result);
}
public SynchronizationManager(
IBlockTree blockTree,
IBlockValidator blockValidator,
IHeaderValidator headerValidator,
ITransactionStore transactionStore,
ITransactionValidator transactionValidator,
ILogger logger, IBlockchainConfig blockchainConfig)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_blockchainConfig = blockchainConfig;
_transactionStore = transactionStore ?? throw new ArgumentNullException(nameof(transactionStore));
_transactionValidator = transactionValidator ?? throw new ArgumentNullException(nameof(transactionValidator));
BlockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_headerValidator = headerValidator ?? throw new ArgumentNullException(nameof(headerValidator));
BlockTree.NewHeadBlock += OnNewHeadBlock;
_transactionStore.NewPending += OnNewPendingTransaction;
_logger.Info($"Initialized {nameof(SynchronizationManager)} with head block {Head.ToString(BlockHeader.Format.Short)}");
}
public SynchronizationProcessor(ILogger <SynchronizationProcessor> logger,
IEventBus eventBus,
IDateTimeProvider dateTimeProvider,
IPeerBehaviorManager peerBehaviorManager,
IConsensusParameters consensusParameters,
IInitialBlockDownloadTracker ibdState,
IBlockHeaderHashCalculator blockHeaderHashCalculator,
ITransactionHashCalculator transactionHashCalculator,
IBlockFetcherManager blockFetcherManager,
ILocalServiceProvider localServiceProvider,
IChainState chainState,
IHeaderValidator headerValidator,
IBlockValidator blockValidator,
IPeriodicWork headerSyncLoop,
IOptions <BitcoinSettings> options)
: base(logger, eventBus, peerBehaviorManager, isHandshakeAware: true, receiveMessagesOnlyIfHandshaked: true)
{
_dateTimeProvider = dateTimeProvider;
_consensusParameters = consensusParameters;
_ibdState = ibdState;
_blockHeaderHashCalculator = blockHeaderHashCalculator;
_transactionHashCalculator = transactionHashCalculator;
_blockFetcherManager = blockFetcherManager;
_localServiceProvider = localServiceProvider;
_chainState = chainState;
_headerValidator = headerValidator;
_blockValidator = blockValidator;
_headerSyncLoop = headerSyncLoop;
_options = options.Value;
_minimumChainWork = _options.MinimumChainWork ?? _consensusParameters.MinimumChainWork;
if (_minimumChainWork < _consensusParameters.MinimumChainWork)
{
this.logger.LogWarning($"{nameof(_minimumChainWork)} set below default value of {_consensusParameters.MinimumChainWork}");
}
headerSyncLoop.Configure(stopOnException: false, this);
}
private async Task InitBlockchain()
{
_specProvider = new ChainSpecBasedSpecProvider(_chainSpec);
Account.AccountStartNonce = _chainSpec.Parameters.AccountStartNonce;
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_syncConfig = _configProvider.GetConfig <ISyncConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts || _syncConfig.DownloadReceiptsInFastSync);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTxStorage(_dbProvider.PendingTxsDb, _specProvider),
Timestamp.Default,
_ethereumEcdsa,
_specProvider,
_txPoolConfig, _logManager);
var _rc7FixDb = _initConfig.EnableRc7Fix ? _dbProvider.HeadersDb : NullDb.Instance;
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _rc7FixDb, _specProvider, _logManager);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig));
// _dbProvider = debugReader;
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_syncConfig,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
/* validation */
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_txPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
_transactionPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor,
_blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager);
break;
}
case SealEngineType.NethDev:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Dev block producer & sealer");
}
_blockProducer = new DevBlockProducer(_txPool, producerChain.Processor, _blockTree,
_timestamp, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
_blockchainProcessor.Start();
LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider);
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
LoadBlocksFromDb();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
if (HiveEnabled)
{
await InitHive();
}
if (HiveEnabled)
{
await InitHive();
}
var producers = new List <IProducer>();
if (_initConfig.PubSubEnabled)
{
var kafkaProducer = await PrepareKafkaProducer(_blockTree, _configProvider.GetConfig <IKafkaConfig>());
producers.Add(kafkaProducer);
}
var grpcClientConfig = _configProvider.GetConfig <IGrpcClientConfig>();
if (grpcClientConfig.Enabled)
{
var grpcProducer = new GrpcProducer(_grpcClient, _logManager);
producers.Add(grpcProducer);
}
ISubscription subscription;
if (producers.Any())
{
subscription = new Subscription(producers, _blockProcessor, _logManager);
}
else
{
subscription = new EmptySubscription();
}
_disposeStack.Push(subscription);
_dataBridge = new DataBridge(subscription, _receiptStorage, _blockTree, _logManager);
_dataBridge.Start();
await InitializeNetwork();
}
internal static bool Add(string key, IHeaderValidator validator)
{
return(Headers.TryAdd(key, validator));
}
private async Task InitBlockchain()
{
_specProvider = new ChainSpecBasedSpecProvider(_chainSpec);
Account.AccountStartNonce = _chainSpec.Parameters.AccountStartNonce;
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_syncConfig = _configProvider.GetConfig <ISyncConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts || _syncConfig.DownloadReceiptsInFastSync);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_initConfig.BaseDbPath, "debug"), dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.Localhost, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_initConfig.BaseDbPath, "debug"), dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts), false);
// _dbProvider = debugReader;
_stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTxStorage(_dbProvider.PendingTxsDb, _specProvider),
Timestamper.Default,
_ethereumEcdsa,
_specProvider,
_txPoolConfig, _stateProvider, _logManager);
var _rc7FixDb = _initConfig.EnableRc7Fix ? _dbProvider.HeadersDb : NullDb.Instance;
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _rc7FixDb, _specProvider, _logManager);
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_syncConfig,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
_snapshotManager = null;
_storageProvider = new StorageProvider(
_dbProvider.StateDb,
_stateProvider,
_logManager);
IList <IAdditionalBlockProcessor> blockPreProcessors = new List <IAdditionalBlockProcessor>();
// blockchain processing
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
_stateProvider,
_storageProvider,
blockhashProvider,
_specProvider,
_logManager);
_transactionProcessor = new TransactionProcessor(
_specProvider,
_stateProvider,
_storageProvider,
virtualMachine,
_logManager);
InitSealEngine(blockPreProcessors);
/* validation */
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
_txPoolInfoProvider = new TxPoolInfoProvider(_stateProvider, _txPool);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
_transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
_stateProvider,
_storageProvider,
_txPool,
_receiptStorage,
_logManager,
blockPreProcessors);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager);
InitBlockProducers();
_blockchainProcessor.Start();
LoadGenesisBlock(string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash));
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
RunBlockTreeInitTasks();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
if (HiveEnabled)
{
await InitHive();
}
var producers = new List <IProducer>();
var kafkaConfig = _configProvider.GetConfig <IKafkaConfig>();
if (kafkaConfig.Enabled)
{
var kafkaProducer = await PrepareKafkaProducer(_blockTree, _configProvider.GetConfig <IKafkaConfig>());
producers.Add(kafkaProducer);
}
var grpcConfig = _configProvider.GetConfig <IGrpcConfig>();
if (grpcConfig.Enabled && grpcConfig.ProducerEnabled)
{
var grpcProducer = new GrpcProducer(_grpcServer);
producers.Add(grpcProducer);
}
ISubscription subscription;
if (producers.Any())
{
subscription = new Subscription(producers, _blockProcessor, _logManager);
}
else
{
subscription = new EmptySubscription();
}
_disposeStack.Push(subscription);
await InitializeNetwork();
}
public void AddMandatoryHeader(string key, IHeaderValidator validator)
{
MandatoryHeadersHolder.Headers.TryAdd(key, validator);
}
private async Task InitBlockchain()
{
/* spec */
if (_chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
_specProvider = RopstenSpecProvider.Instance;
}
else if (_chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
_specProvider = MainNetSpecProvider.Instance;
}
else if (_chainSpec.ChainId == RinkebySpecProvider.Instance.ChainId)
{
_specProvider = RinkebySpecProvider.Instance;
}
else if (_chainSpec.ChainId == GoerliSpecProvider.Instance.ChainId)
{
_specProvider = GoerliSpecProvider.Instance;
}
else if (_chainSpec.ChainId == SturebySpecProvider.Instance.ChainId)
{
_specProvider = SturebySpecProvider.Instance;
}
else
{
_specProvider = new SingleReleaseSpecProvider(LatestRelease.Instance, _chainSpec.ChainId);
}
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval,
_initConfig.RemovePendingTransactionInterval), new Timestamp(),
_ethereumEcdsa, _specProvider, _logManager, _initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig));
// _dbProvider = debugReader;
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.CliquePeriod;
cliqueConfig.Epoch = _chainSpec.CliqueEpoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
/* validation */
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_transactionPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_configProvider.GetConfig <ISyncConfig>(),
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor,
_blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager);
break;
}
case SealEngineType.NethDev:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Dev block producer & sealer");
}
_blockProducer = new DevBlockProducer(_txPool, producerChain.Processor, _blockTree,
_timestamp, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
if (!HiveEnabled)
{
_blockchainProcessor.Start();
LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider);
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
LoadBlocksFromDb();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
}
await InitializeNetwork(
_receiptStorage,
_sealValidator,
txValidator);
}
public void Setup()
{
_headerValidator = Substitute.For <IHeaderValidator>();
_headerValidator.Validate(Arg.Any <BlockHeader>(), true).Returns(true);
}
new protected async Task StartRunners(IConfigProvider configProvider)
{
InitRlp();
_configProvider = configProvider;
_initConfig = _configProvider.GetConfig <IInitConfig>();
_logManager = new NLogManager(_initConfig.LogFileName, _initConfig.LogDirectory);
_logger = _logManager.GetClassLogger();
_networkHelper = new NetworkHelper(_logger);
SetupKeyStore();
LoadChainSpec();
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_dbProvider = new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
/* blockchain processing */
if (_chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
_specProvider = RopstenSpecProvider.Instance;
}
else if (_chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
_specProvider = MainNetSpecProvider.Instance;
}
else if (_chainSpec.ChainId == RinkebySpecProvider.Instance.ChainId)
{
_specProvider = RinkebySpecProvider.Instance;
}
else if (_chainSpec.ChainId == GoerliSpecProvider.Instance.ChainId)
{
_specProvider = GoerliSpecProvider.Instance;
}
else
{
_specProvider = new SingleReleaseSpecProvider(Latest.Release, _chainSpec.ChainId);
}
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval,
_initConfig.RemovePendingTransactionInterval), new Timestamp(),
_ethereumEcdsa, _specProvider, _logManager, _initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_configProvider.GetConfig <ISyncConfig>(),
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
string chainFile = Path.Join(Path.GetDirectoryName(_initConfig.ChainSpecPath), "chain.rlp");
if (!File.Exists(chainFile))
{
_logger.Info($"Chain file does not exist: {chainFile}, skipping");
return;
}
var chainFileContent = File.ReadAllBytes(chainFile);
var context = new Rlp.DecoderContext(chainFileContent);
var blocks = new List <Block>();
while (context.ReadNumberOfItemsRemaining() > 0)
{
context.PeekNextItem();
blocks.Add(Rlp.Decode <Block>(context));
}
for (int i = 0; i < blocks.Count; i++)
{
ProcessBlock(blocks[i]);
}
}
public OmmersValidator(IBlockTree blockTree, IHeaderValidator headerValidator, ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_headerValidator = headerValidator ?? throw new ArgumentNullException(nameof(headerValidator));
}
