public override void Subscribe(ISubscriber <R>[] subscribers)
{
if (!this.Validate(subscribers))
{
return;
}
int n = subscribers.Length;
var parents = new ISubscriber <T> [n];
for (int i = 0; i < n; i++)
{
R accumulator;
try
{
accumulator = initialFactory();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
foreach (var s in subscribers)
{
EmptySubscription <R> .Error(s, ex);
}
return;
}
parents[i] = new PublisherReduceWith <T, R> .ReduceWithSubscriber(subscribers[i], accumulator, reducer);
}
source.Subscribe(parents);
}
public void Subscribe(ISubscriber <R> s)
{
var pp = new PublishProcessor <T>(prefetch);
IPublisher <R> o;
try
{
o = transformer(pp);
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <R> .Error(s, ex);
return;
}
if (s is IConditionalSubscriber <R> )
{
o.Subscribe(new PublishSelectorConditionalSubscriber(pp, (IConditionalSubscriber <R>)s));
}
else
{
o.Subscribe(new PublishSelectorSubscriber(pp, s));
}
source.Subscribe(pp);
}
public void Subscribe(ISubscriber <V> s)
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
s.OnSubscribe(this);
if (s is IConditionalSubscriber <V> )
{
Volatile.Write(ref conditional, (IConditionalSubscriber <V>)s);
if (Volatile.Read(ref cancelled) != 0)
{
conditional = null;
return;
}
}
else
{
Volatile.Write(ref regular, s);
if (Volatile.Read(ref cancelled) != 0)
{
regular = null;
return;
}
}
Drain();
}
else
{
EmptySubscription <V> .Error(s, new InvalidOperationException("The IGroupedFlux allows only a single ISubscriber!"));
}
}
/// <inheritDoc/>
public void Subscribe(ISubscriber <T> s)
{
PublishSubscription ps = new PublishSubscription(s, this);
s.OnSubscribe(ps);
if (subscribers.Add(ps))
{
if (ps.IsCancelled())
{
subscribers.Remove(ps);
}
else
{
Drain();
}
}
else
{
var ex = error;
if (ex != null)
{
EmptySubscription <T> .Error(s, ex);
}
else
{
EmptySubscription <T> .Complete(s);
}
}
}
public void Subscribe(ISubscriber <T> s)
{
S state;
try
{
state = stateFactory();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <T> .Error(s, ex);
return;
}
if (s is IConditionalSubscriber <T> )
{
s.OnSubscribe(new GenerateConditionalSubscriber((IConditionalSubscriber <T>)s, state, generator, stateDisposer));
}
else
{
s.OnSubscribe(new GenerateSubscriber(s, state, generator, stateDisposer));
}
}
public void Subscribe(ISubscriber <T> s)
{
IPublisher <T> p;
try
{
p = supplier();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <T> .Error(s, ex);
return;
}
if (p == null)
{
EmptySubscription <T> .Error(s, new NullReferenceException("The supplier returned a null IPublisher"));
return;
}
p.Subscribe(s);
}
public void Subscribe(ISubscriber <R> s)
{
IEnumerator <U> enumerator;
bool hasValue;
try
{
enumerator = other.GetEnumerator();
hasValue = enumerator.MoveNext();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <R> .Error(s, ex);
return;
}
if (!hasValue)
{
EmptySubscription <R> .Complete(s);
return;
}
var parent = new ZipEnumerableSubscriber(s, enumerator, zipper);
source.Subscribe(parent);
}
public void Subscribe(ISubscriber <T> s)
{
if (!whenRequested)
{
EmptySubscription <T> .Error(s, error);
}
else
{
s.OnSubscribe(new ErrorSubscription(s, error));
}
}
/// <summary>
/// Validate that the parallelism of the IParallelFlux equals to the number of elements in
/// the ISubscriber array. If not, each ISubscriber is notified with an ArgumentException.
/// </summary>
/// <typeparam name="T">The element type of the parallel flux</typeparam>
/// <typeparam name="U">The element type of the ISubscriber array (could be T or IOrderedItem{T})</typeparam>
/// <param name="pf">The parent IParallelFlux instance</param>
/// <param name="subscribers">The ISubscriber array</param>
/// <returns>True if the subscribers were valid</returns>
internal static bool Validate <T, U>(this IParallelFlux <T> pf, ISubscriber <U>[] subscribers)
{
if (pf.Parallelism != subscribers.Length)
{
Exception ex = new ArgumentException("Parallelism(" + pf.Parallelism + ") != Subscriber count (" + subscribers.Length + ")");
foreach (ISubscriber <U> s in subscribers)
{
EmptySubscription <U> .Error(s, ex);
}
return(false);
}
return(true);
}
public void Subscribe(ISubscriber <T> s)
{
try
{
action();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <T> .Error(s, ex);
return;
}
EmptySubscription <T> .Complete(s);
}
public void Subscribe(ISubscriber <R> s)
{
ISubscriber <T> sr;
try
{
sr = onLift(s);
}
catch (Exception ex)
{
EmptySubscription.Error(s, ex);
return;
}
source.Subscribe(sr);
}
public void Subscribe(ISubscriber <A> s)
{
A accumulator;
try
{
accumulator = initialSupplier();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <A> .Error(s, ex);
return;
}
source.Subscribe(new ScanWithSubscriber(s, accumulator, scanner));
}
public void Subscribe(ISubscriber <T> s)
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
s.OnSubscribe(this);
Volatile.Write(ref actual, s);
if (Volatile.Read(ref cancelled))
{
actual = null;
return;
}
Drain();
}
else
{
EmptySubscription <T> .Error(s, new InvalidOperationException("The group can be subscribed to at most once"));
}
}
public static bool ToArray <T, U>(T[] values, IEnumerable <T> valuesEnumerable, ISubscriber <U> s, out int n, out T[] array)
{
if (values != null)
{
array = values;
n = values.Length;
}
else
{
var i = 0;
var a = new T[8];
try
{
foreach (var e in valuesEnumerable)
{
if (i == a.Length)
{
var b = new T[i + (i >> 1)];
Array.Copy(a, 0, b, 0, i);
a = b;
}
a[i] = e;
i++;
}
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <U> .Error(s, ex);
array = null;
n = 0;
return(false);
}
array = a;
n = i;
}
return(true);
}
public void Subscribe(ISubscriber <T> s)
{
IEnumerator <IPublisher <T> > enumerator;
bool hasValue;
try
{
enumerator = sources.GetEnumerator();
hasValue = enumerator.MoveNext();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <T> .Error(s, ex);
return;
}
if (!hasValue)
{
EmptySubscription <T> .Complete(s);
return;
}
if (s is IConditionalSubscriber <T> )
{
ConcatConditionalSubscriber parent = new ConcatConditionalSubscriber((IConditionalSubscriber <T>)s, enumerator, delayError);
s.OnSubscribe(parent);
parent.Drain();
}
else
{
ConcatSubscriber parent = new ConcatSubscriber(s, enumerator, delayError);
s.OnSubscribe(parent);
parent.Drain();
}
}
public void Subscribe(ISubscriber <C> s)
{
C c;
try
{
c = collectionSupplier();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <C> .Error(s, ex);
return;
}
CollectSubscriber parent = new CollectSubscriber(s, c, collector);
source.Subscribe(parent);
}
public void Subscribe(ISubscriber <T> s)
{
int n;
IPublisher <T>[] a;
if (!MultiSourceHelper.ToArray(sources, sourcesEnumerable, s, out n, out a))
{
return;
}
if (n == 0)
{
EmptySubscription <T> .Complete(s);
return;
}
else
if (n == 1)
{
a[0].Subscribe(s);
return;
}
if (s is IConditionalSubscriber <T> )
{
AmbConditionalSubscription parent = new AmbConditionalSubscription((IConditionalSubscriber <T>)s, n);
s.OnSubscribe(parent);
parent.Subscribe(a, n);
}
else
{
AmbSubscription parent = new AmbSubscription(s, n);
s.OnSubscribe(parent);
parent.Subscribe(a, n);
}
}
public void Subscribe(ISubscriber <R> s)
{
int n;
IPublisher <T>[] a;
if (!MultiSourceHelper.ToArray(sources, sourcesEnumerable, s, out n, out a))
{
return;
}
if (n == 0)
{
EmptySubscription <R> .Complete(s);
return;
}
else
if (n == 1)
{
new PublisherMap <T, R>(a[0], v => combiner(new T[] { v })).Subscribe(s);
return;
}
if (s is IConditionalSubscriber <R> )
{
CombineLatestConditionalSubscription parent = new CombineLatestConditionalSubscription((IConditionalSubscriber <R>)s, prefetch, delayError, combiner, n);
s.OnSubscribe(parent);
parent.Subscribe(a, n);
}
else
{
CombineLatestSubscription parent = new CombineLatestSubscription(s, prefetch, delayError, combiner, n);
s.OnSubscribe(parent);
parent.Subscribe(a, n);
}
}
internal bool TryConnect(
IPublisher <T> source,
Action <IDisposable> action,
Func <IProcessor <T, T> > processorSupplier,
Func <IFlux <T>, IPublisher <U> > selector)
{
if (Volatile.Read(ref done) != 0)
{
return(false);
}
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
try
{
processor = processorSupplier();
result = selector(Flux.Wrap(processor));
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
Volatile.Write(ref done, 1);
foreach (var s in subscribers.Terminate())
{
EmptySubscription <U> .Error(s, ex);
}
return(false);
}
foreach (var s in subscribers.Terminate())
{
result.Subscribe(s);
}
action?.Invoke(this);
source.Subscribe(this);
}
return(true);
}
public void Subscribe(ISubscriber <T> s)
{
IEnumerator <T> enumerator;
bool hasValue;
try
{
enumerator = enumerable.GetEnumerator();
hasValue = enumerator.MoveNext();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <T> .Error(s, ex);
return;
}
if (!hasValue)
{
EmptySubscription <T> .Complete(s);
return;
}
if (s is IConditionalSubscriber <T> )
{
s.OnSubscribe(new EnumerableConditionalSubscription((IConditionalSubscriber <T>)s, enumerator));
}
else
{
s.OnSubscribe(new EnumerableSubscription(s, enumerator));
}
}
/// <inheritdoc/>
public void Subscribe(ISubscriber <T> s)
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
s.OnSubscribe(this);
if (s is IConditionalSubscriber <T> )
{
Volatile.Write(ref conditional, (IConditionalSubscriber <T>)s);
if (lvCancelled())
{
conditional = null;
}
else
{
Drain();
}
}
else
{
Volatile.Write(ref regular, s);
if (lvCancelled())
{
regular = null;
}
else
{
Drain();
}
}
}
else
{
EmptySubscription <T> .Error(s, new InvalidOperationException("Only a one ISubscriber allowed. Use Publish() or Replay() to share an UnicastProcessor."));
}
}
/// <summary>
/// Applies shortcuts if the source is the empty instance or an ICallable.
/// </summary>
/// <param name="source">The source IPublisher.</param>
/// <param name="s">The ISubscriber</param>
/// <param name="mapper">The function that takes a source value and maps it into an IPublisher.</param>
/// <returns>True if the optimizations were applied.</returns>
internal static bool CallableXMap(IPublisher <T> source, ISubscriber <R> s, Func <T, IPublisher <R> > mapper)
{
if (source == PublisherEmpty <T> .Instance)
{
EmptySubscription <R> .Complete(s);
return(true);
}
if (source is ICallable <T> )
{
T t;
try
{
t = (source as ICallable <T>).Value;
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <R> .Error(s, ex);
return(true);
}
IPublisher <R> p;
try
{
p = mapper(t);
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <R> .Error(s, ex);
return(true);
}
if (p == null)
{
EmptySubscription <R> .Error(s, new NullReferenceException("The mapper returned a null IPublisher"));
return(true);
}
if (p == PublisherEmpty <R> .Instance)
{
EmptySubscription <R> .Complete(s);
return(true);
}
if (p is ICallable <R> )
{
R r;
try
{
r = (p as ICallable <R>).Value;
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <R> .Error(s, ex);
return(true);
}
s.OnSubscribe(new ScalarSubscription <R>(s, r));
return(true);
}
p.Subscribe(s);
return(true);
}
return(false);
}
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();
}
public void Subscribe(ISubscriber <T> s)
{
S state;
try
{
state = stateFactory();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
EmptySubscription <T> .Error(s, ex);
return;
}
IPublisher <T> p;
try
{
p = sourceFactory(state);
if (p == null)
{
throw new NullReferenceException("The sourceFactory returned a null IPublisher");
}
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
if (eager)
{
try
{
stateDisposer(state);
}
catch (Exception exc)
{
ExceptionHelper.ThrowIfFatal(ex);
ex = new AggregateException(ex, exc);
}
}
EmptySubscription <T> .Error(s, ex);
if (!eager)
{
try
{
stateDisposer(state);
}
catch (Exception exc)
{
ExceptionHelper.ThrowOrDrop(exc);
}
}
return;
}
if (s is IConditionalSubscriber <T> )
{
p.Subscribe(new UsingConditionalSubscriber((IConditionalSubscriber <T>)s, state, stateDisposer, eager));
}
else
{
p.Subscribe(new UsingSubscriber(s, state, stateDisposer, eager));
}
}
public void Subscribe(ISubscriber <T> s)
{
EmptySubscription <T> .Complete(s);
}
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();
}
