public override IEthModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
TimeSpan cancellationTokenTimeout = TimeSpan.FromMilliseconds(_jsonRpcConfig.TracerTimeout);
CancellationToken cancellationToken = new CancellationTokenSource(cancellationTokenTimeout).Token;
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv.StateReader,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
readOnlyTxProcessingEnv.BlockTree,
_txPool,
_receiptFinder,
_filterStore,
_filterManager,
_wallet,
readOnlyTxProcessingEnv.TransactionProcessor,
_ethereumEcdsa,
_bloomStorage,
Timestamper.Default,
_logManager,
_isMining,
_rpcConfig.FindLogBlockDepthLimit,
cancellationToken);
TxPoolBridge txPoolBridge = new TxPoolBridge(_txPool, new WalletTxSigner(_wallet, _specProvider.ChainId), Timestamper.Default);
return(new EthModule(_rpcConfig, blockchainBridge, txPoolBridge, _logManager));
}
public override IEthModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv,
_txPool,
_receiptFinder,
_filterStore,
_filterManager,
_ethereumEcdsa,
_bloomStorage,
Timestamper.Default,
_logManager,
_isMining,
_rpcConfig.FindLogBlockDepthLimit
);
return(new EthModule(
_rpcConfig,
blockchainBridge,
readOnlyTxProcessingEnv.BlockTree,
readOnlyTxProcessingEnv.StateReader,
_txPool,
_txSender,
_wallet,
_logManager));
}
public Task InitBlockProducer()
{
if (_nethermindApi !.SealEngineType != SealEngineType.NethDev)
{
return(Task.CompletedTask);
}
var(getFromApi, setInApi) = _nethermindApi !.ForProducer;
ITxFilter txFilter = new NullTxFilter();
ITxSource txSource = new TxPoolTxSource(
getFromApi.TxPool, getFromApi.StateReader, getFromApi.LogManager, txFilter);
ILogger logger = getFromApi.LogManager.GetClassLogger();
if (logger.IsWarn)
{
logger.Warn("Starting Neth Dev block producer & sealer");
}
ReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(getFromApi.DbProvider, false);
ReadOnlyBlockTree readOnlyBlockTree = new ReadOnlyBlockTree(getFromApi.BlockTree);
ReadOnlyTxProcessingEnv producerEnv = new ReadOnlyTxProcessingEnv(
readOnlyDbProvider,
readOnlyBlockTree,
getFromApi.SpecProvider,
getFromApi.LogManager);
BlockProcessor producerProcessor = new BlockProcessor(
getFromApi !.SpecProvider,
getFromApi !.BlockValidator,
NoBlockRewards.Instance,
producerEnv.TransactionProcessor,
producerEnv.DbProvider.StateDb,
producerEnv.DbProvider.CodeDb,
producerEnv.StateProvider,
producerEnv.StorageProvider,
NullTxPool.Instance,
NullReceiptStorage.Instance,
getFromApi.LogManager);
IBlockchainProcessor producerChainProcessor = new BlockchainProcessor(
readOnlyBlockTree,
producerProcessor,
getFromApi.BlockPreprocessor,
getFromApi.LogManager,
BlockchainProcessor.Options.NoReceipts);
setInApi.BlockProducer = new DevBlockProducer(
txSource,
producerChainProcessor,
producerEnv.StateProvider,
getFromApi.BlockTree,
getFromApi.BlockProcessingQueue,
getFromApi.TxPool,
getFromApi.Timestamper,
getFromApi.LogManager);
return(Task.CompletedTask);
}
public IBlockchainBridge CreateBlockchainBridge()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(BlockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(DbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(
readOnlyDbProvider,
readOnlyTree,
SpecProvider,
LogManager);
IMiningConfig miningConfig = ConfigProvider.GetConfig <IMiningConfig>();
ISyncConfig syncConfig = ConfigProvider.GetConfig <ISyncConfig>();
return(new BlockchainBridge(
readOnlyTxProcessingEnv,
TxPool,
ReceiptFinder,
FilterStore,
FilterManager,
EthereumEcdsa,
Timestamper,
LogFinder,
miningConfig.Enabled,
syncConfig.BeamSync && syncConfig.FastSync
));
}
public override IEthModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv.StateReader,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
readOnlyTxProcessingEnv.BlockTree,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_wallet,
readOnlyTxProcessingEnv.TransactionProcessor,
_ethereumEcdsa,
_bloomStorage,
new ReceiptsRecovery(),
_logManager,
_rpcConfig.FindLogBlockDepthLimit);
return(new EthModule(_rpcConfig, _logManager, blockchainBridge));
}
public override ITraceModule Create()
{
var readOnlyTree = new ReadOnlyBlockTree(_blockTree);
var readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(readOnlyTxProcessingEnv, AlwaysValidBlockValidator.Instance, _recoveryStep, _rewardCalculatorSource.Get(readOnlyTxProcessingEnv.TransactionProcessor), _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
Tracer tracer = new Tracer(readOnlyChainProcessingEnv.StateProvider, readOnlyChainProcessingEnv.ChainProcessor);
return(new TraceModule(_receiptStorage, tracer, readOnlyTree));
}
public MulticallModuleFactory(IDbProvider dbProvider, IBlockTree blockTree, IJsonRpcConfig jsonRpcConfig, IReadOnlyTrieStore trieNodeResolver, IBlockPreprocessorStep recoveryStep, IRewardCalculatorSource rewardCalculatorSource, IReceiptStorage receiptFinder, ISpecProvider specProvider, ILogManager logManager)
{
this.dbProvider = dbProvider.AsReadOnly(false);
this.blockTree = blockTree.AsReadOnly();
this.jsonRpcConfig = jsonRpcConfig;
this.trieNodeResolver = trieNodeResolver;
this.recoveryStep = recoveryStep;
this.rewardCalculatorSource = rewardCalculatorSource;
this.receiptFinder = receiptFinder;
this.specProvider = specProvider;
this.logManager = logManager;
}
public override IDebugModule Create()
{
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
ReadOnlyTxProcessingEnv txEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
ReadOnlyChainProcessingEnv readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(txEnv, _blockValidator, _recoveryStep, _rewardCalculator, _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
ITracer tracer = new Tracer(readOnlyChainProcessingEnv.Processor, _receiptStorage, new ReadOnlyBlockTree(_blockTree), _dbProvider.TraceDb);
DebugBridge debugBridge = new DebugBridge(_configProvider, readOnlyDbProvider, tracer, readOnlyChainProcessingEnv.Processor, readOnlyTree);
return(new DebugModule(_logManager, debugBridge));
}
public override IProofModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
ReadOnlyChainProcessingEnv readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(readOnlyTxProcessingEnv, Always.Valid, _recoveryStep, NoBlockRewards.Instance, new InMemoryReceiptStorage(), readOnlyDbProvider, _specProvider, _logManager);
Tracer tracer = new Tracer(
readOnlyTxProcessingEnv.StateProvider,
readOnlyChainProcessingEnv.ChainProcessor);
return(new ProofModule(tracer, _blockTree, _receiptFinder, _specProvider, _logManager));
}
public override ITraceModule Create()
{
var readOnlyTree = new ReadOnlyBlockTree(_blockTree);
var readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(readOnlyTxProcessingEnv, Always.Valid, _recoveryStep, _rewardCalculatorSource.Get(readOnlyTxProcessingEnv.TransactionProcessor), _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
Tracer tracer = new Tracer(readOnlyChainProcessingEnv.StateProvider, readOnlyChainProcessingEnv.ChainProcessor);
TimeSpan cancellationTokenTimeout = TimeSpan.FromMilliseconds(_jsonRpcConfig.TracerTimeout);
CancellationToken cancellationToken = new CancellationTokenSource(cancellationTokenTimeout).Token;
return(new TraceModule(_receiptStorage, tracer, readOnlyTree, cancellationToken));
}
public async Task ProviderInitTests_ReadonlyDbProvider()
{
var dbProvider = new DbProvider(DbModeHint.Persisted);
var rocksDbFactory = new RocksDbFactory(new DbConfig(), LimboLogs.Instance, Path.Combine(_folderWithDbs, "readonly"));
var readonlyDbProvider = new ReadOnlyDbProvider(dbProvider, true);
var initializer = new BaselineDbInitializer(readonlyDbProvider, new BaselineConfig(), rocksDbFactory, new MemDbFactory());
await initializer.Init();
Assert.NotNull(readonlyDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTree));
Assert.NotNull(readonlyDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTreeMetadata));
Assert.AreEqual(2, readonlyDbProvider.RegisteredDbs.Count());
Assert.IsTrue(readonlyDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTree) is ReadOnlyDb);
Assert.IsTrue(readonlyDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTreeMetadata) is ReadOnlyDb);
}
protected BlockProducerContext GetProducerChain(IBlockTree blockTree,
IDbProvider dbProvider,
IReadOnlyTrieStore readOnlyTrieStore,
IBlockPreprocessorStep blockPreprocessor,
ITxPool txPool,
IBlockValidator blockValidator,
IRewardCalculatorSource rewardCalculatorSource,
IReceiptStorage receiptStorage,
ISpecProvider specProvider,
IMiningConfig miningConfig,
ILogManager logManager)
{
ReadOnlyDbProvider readOnlyDbProvider = dbProvider.AsReadOnly(false);
ReadOnlyBlockTree readOnlyBlockTree = blockTree.AsReadOnly();
ReadOnlyTxProcessingEnv txProcessingEnv =
new(readOnlyDbProvider, readOnlyTrieStore, readOnlyBlockTree, specProvider, logManager);
ITransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, blockTree);
BlockProcessor blockProcessor =
CreateBlockProcessor(txProcessingEnv,
specProvider,
blockValidator,
rewardCalculatorSource,
txPool,
receiptStorage,
logManager);
IBlockchainProcessor blockchainProcessor =
new BlockchainProcessor(
readOnlyBlockTree,
blockProcessor,
blockPreprocessor,
logManager,
BlockchainProcessor.Options.NoReceipts);
OneTimeChainProcessor chainProcessor = new(
readOnlyDbProvider,
blockchainProcessor);
return(new BlockProducerContext
{
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = txProcessingEnv.StateProvider,
TxSource = CreateTxSourceForProducer(txProcessingEnv, txPool, specProvider, logManager, miningConfig, transactionComparerProvider),
ReadOnlyTxProcessingEnv = txProcessingEnv
});
}
public async Task ProviderInitTests_ReadonlyDbProvider()
{
var dbProvider = new DbProvider(DbModeHint.Persisted);
var rocksDbFactory = new RocksDbFactory(new DbConfig(), LimboLogs.Instance, Path.Combine(_folderWithDbs, "readonly"));
var readonlyDbProvider = new ReadOnlyDbProvider(dbProvider, true);
var initializer = new ConsumerNdmDbInitializer(readonlyDbProvider, new NdmConfig(), rocksDbFactory, new MemDbFactory());
initializer.Reset();
await initializer.InitAsync();
Assert.AreEqual(4, readonlyDbProvider.RegisteredDbs.Count());
Assert.IsTrue(readonlyDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerDepositApprovals) is ReadOnlyDb);
Assert.IsTrue(readonlyDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerReceipts) is ReadOnlyDb);
Assert.IsTrue(readonlyDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerSessions) is ReadOnlyDb);
Assert.IsTrue(readonlyDbProvider.GetDb <IDb>(ConsumerNdmDbNames.Deposits) is ReadOnlyDb);
}
public async Task InitializerTests_ReadonlyDbProvider(bool useReceipts)
{
using (IDbProvider dbProvider = new DbProvider(DbModeHint.Persisted))
{
var rocksDbFactory = new RocksDbFactory(new DbConfig(), LimboLogs.Instance, Path.Combine(_folderWithDbs, $"readonly_{useReceipts}"));
var initializer = new StandardDbInitializer(dbProvider, rocksDbFactory, new MemDbFactory());
await initializer.InitStandardDbsAsync(useReceipts);
using (var readonlyDbProvider = new ReadOnlyDbProvider(dbProvider, true))
{
var receiptsType = useReceipts ? typeof(SimpleColumnRocksDb <ReceiptsColumns>) : typeof(ReadOnlyColumnsDb <ReceiptsColumns>);
AssertStandardDbs(dbProvider, typeof(SimpleRocksDb), typeof(StateDb), receiptsType);
AssertStandardDbs(readonlyDbProvider, typeof(ReadOnlyDb), typeof(StateDb), typeof(ReadOnlyColumnsDb <ReceiptsColumns>));
}
}
}
public override IDebugModule Create()
{
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
ReadOnlyTxProcessingEnv txEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
ReadOnlyChainProcessingEnv readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(txEnv, _blockValidator, _recoveryStep, _rewardCalculatorSource.Get(txEnv.TransactionProcessor), _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
TimeSpan cancellationTokenTimeout = TimeSpan.FromMilliseconds(_jsonRpcConfig.TracerTimeout);
CancellationToken cancellationToken = new CancellationTokenSource(cancellationTokenTimeout).Token;
IGethStyleTracer tracer = new GethStyleTracer(readOnlyChainProcessingEnv.ChainProcessor, _receiptStorage, new ReadOnlyBlockTree(_blockTree), cancellationToken);
DebugBridge debugBridge = new DebugBridge(_configProvider, readOnlyDbProvider, tracer, readOnlyChainProcessingEnv.BlockProcessingQueue, readOnlyTree);
return(new DebugModule(_logManager, debugBridge));
}
protected BlockProducerContext GetProducerChain()
{
ReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_context.DbProvider, false);
ReadOnlyBlockTree readOnlyBlockTree = new ReadOnlyBlockTree(_context.BlockTree);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyBlockTree, _context.SpecProvider, _context.LogManager);
BlockProcessor blockProcessor = CreateBlockProcessor(readOnlyTxProcessingEnv, readOnlyDbProvider);
OneTimeChainProcessor chainProcessor = new OneTimeChainProcessor(readOnlyDbProvider, new BlockchainProcessor(readOnlyBlockTree, blockProcessor, _context.RecoveryStep, _context.LogManager, false));
PendingTxSelector pendingTxSelector = new PendingTxSelector(_context.TxPool, readOnlyTxProcessingEnv.StateProvider, _context.LogManager);
return(new BlockProducerContext
{
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = readOnlyTxProcessingEnv.StateProvider,
PendingTxSelector = pendingTxSelector
});
}
public INdmServices Init(NdmRequiredServices services)
{
AddDecoders();
var config = services.NdmConfig;
var providerAddress = string.IsNullOrWhiteSpace(config.ProviderAddress)
? Address.Zero
: new Address(config.ProviderAddress);
var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
? Address.Zero
: new Address(config.ConsumerAddress);
var contractAddress = string.IsNullOrWhiteSpace(config.ContractAddress)
? Address.Zero
: new Address(config.ContractAddress);
UnlockHardcodedAccounts(providerAddress, consumerAddress, services.Wallet);
var logManager = services.LogManager;
var readOnlyTree = new ReadOnlyBlockTree(services.BlockTree);
var readOnlyDbProvider = new ReadOnlyDbProvider(services.RocksProvider, false);
var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree,
services.SpecProvider, logManager);
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv.StateReader,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
readOnlyTxProcessingEnv.BlockTree,
services.TransactionPool,
services.ReceiptStorage,
services.FilterStore,
services.FilterManager,
services.Wallet,
readOnlyTxProcessingEnv.TransactionProcessor,
services.Ecdsa);
var dataAssetRlpDecoder = new DataAssetDecoder();
var encoder = new AbiEncoder();
var depositService = new DepositService(blockchainBridge, services.TransactionPool, encoder,
services.Wallet, contractAddress, logManager);
var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
var ndmDataPublisher = services.NdmDataPublisher;
var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel();
// ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);
return(new Services(services, new NdmCreatedServices(consumerAddress, encoder, dataAssetRlpDecoder,
depositService, ndmDataPublisher, jsonRpcNdmConsumerChannel, ndmConsumerChannelManager,
blockchainBridge)));
}
public ProofModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
IReadOnlyTrieStore trieStore,
IBlockPreprocessorStep recoveryStep,
IReceiptFinder receiptFinder,
ISpecProvider specProvider,
ILogManager logManager)
{
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_receiptFinder = receiptFinder ?? throw new ArgumentNullException(nameof(receiptFinder));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_trieStore = trieStore;
}
public TracerFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
IReadOnlyTrieStore trieStore,
IBlockPreprocessorStep recoveryStep,
ISpecProvider specProvider,
ILogManager logManager,
ProcessingOptions processingOptions = ProcessingOptions.Trace)
{
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_processingOptions = processingOptions;
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_trieStore = trieStore;
}
public static IServices Init(RequiredServices services)
{
AddDecoders();
var config = services.NdmConfig;
var providerAddress = string.IsNullOrWhiteSpace(config.ProviderAddress)
? Address.Zero
: new Address(config.ProviderAddress);
var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
? Address.Zero
: new Address(config.ConsumerAddress);
UnlockHardcodedAccounts(providerAddress, consumerAddress, services.Wallet);
var readOnlyDbProvider = new ReadOnlyDbProvider(services.RocksProvider, false);
var filterStore = new FilterStore();
var filterManager = new FilterManager(filterStore, services.BlockProcessor, services.TransactionPool,
services.LogManager);
var state = new RpcState(services.BlockTree, services.SpecProvider, readOnlyDbProvider,
services.LogManager);
var blockchainBridge = new BlockchainBridge(
state.StateReader,
state.StateProvider,
state.StorageProvider,
state.BlockTree,
services.TransactionPool,
services.TransactionPoolInfoProvider,
services.ReceiptStorage,
filterStore,
filterManager,
services.Wallet,
state.TransactionProcessor,
services.Ecdsa);
var dataHeaderRlpDecoder = new DataHeaderDecoder();
var encoder = new AbiEncoder();
var depositService = new DepositService(blockchainBridge, encoder, services.Wallet, config,
LimboLogs.Instance);
var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
var ndmDataPublisher = services.NdmDataPublisher;
var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel();
// ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);
return(new Services(services, new CreatedServices(consumerAddress, encoder, dataHeaderRlpDecoder,
depositService, ndmDataPublisher, jsonRpcNdmConsumerChannel, ndmConsumerChannelManager,
blockchainBridge)));
}
private void InitBlockProducers()
{
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyBlockTree readOnlyBlockTree = new ReadOnlyBlockTree(_blockTree);
ReadOnlyChain producerChain = new ReadOnlyChain(readOnlyBlockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
CliqueConfig cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor,
_blockTree, _timestamper, _cryptoRandom, producerChain.ReadOnlyStateProvider, _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,
_timestamper, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
}
// TODO: Use BlockProducerEnvFactory
private BlockProducerEnv GetProducerChain(ITxSource?additionalTxSource)
{
ReadOnlyTxProcessingEnv CreateReadonlyTxProcessingEnv(ReadOnlyDbProvider dbProvider, ReadOnlyBlockTree blockTree)
{
return(new(dbProvider, _api.ReadOnlyTrieStore, blockTree, _api.SpecProvider, _api.LogManager));
}
BlockProducerEnv Create()
{
ReadOnlyDbProvider dbProvider = _api.DbProvider.AsReadOnly(false);
ReadOnlyBlockTree readOnlyBlockTree = _api.BlockTree.AsReadOnly();
ReadOnlyTxProcessingEnv txProcessingEnv = CreateReadonlyTxProcessingEnv(dbProvider, readOnlyBlockTree);
ReadOnlyTxProcessingEnv constantContractsProcessingEnv = CreateReadonlyTxProcessingEnv(dbProvider, readOnlyBlockTree);
BlockProcessor blockProcessor = CreateBlockProcessor(txProcessingEnv, constantContractsProcessingEnv);
IBlockchainProcessor blockchainProcessor =
new BlockchainProcessor(
readOnlyBlockTree,
blockProcessor,
_api.BlockPreprocessor,
txProcessingEnv.StateReader,
_api.LogManager,
BlockchainProcessor.Options.NoReceipts);
OneTimeChainProcessor chainProcessor = new(
dbProvider,
blockchainProcessor);
return(new BlockProducerEnv()
{
BlockTree = readOnlyBlockTree,
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = txProcessingEnv.StateProvider,
TxSource = CreateTxSourceForProducer(txProcessingEnv, constantContractsProcessingEnv, additionalTxSource),
ReadOnlyTxProcessingEnv = constantContractsProcessingEnv
});
}
return(_blockProducerContext ??= Create());
}
public override IDebugModule Create()
{
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
ReadOnlyTxProcessingEnv txEnv =
new ReadOnlyTxProcessingEnv(
readOnlyDbProvider,
readOnlyTree,
_specProvider,
_logManager);
ReadOnlyChainProcessingEnv readOnlyChainProcessingEnv =
new ReadOnlyChainProcessingEnv(
txEnv,
_blockValidator,
_recoveryStep,
_rewardCalculatorSource.Get(txEnv.TransactionProcessor),
_receiptStorage,
readOnlyDbProvider,
_specProvider,
_logManager);
IGethStyleTracer tracer =
new GethStyleTracer(
readOnlyChainProcessingEnv.ChainProcessor,
_receiptStorage,
new ReadOnlyBlockTree(_blockTree));
DebugBridge debugBridge =
new DebugBridge(
_configProvider,
readOnlyDbProvider,
tracer,
readOnlyTree,
_receiptStorage,
_receiptsMigration,
_specProvider);
return(new DebugModule(_logManager, debugBridge, _jsonRpcConfig));
}
public virtual BlockProducerEnv Create(ITxSource?additionalTxSource = null)
{
ReadOnlyDbProvider readOnlyDbProvider = _dbProvider.AsReadOnly(false);
ReadOnlyBlockTree readOnlyBlockTree = _blockTree.AsReadOnly();
ReadOnlyTxProcessingEnv txProcessingEnv =
CreateReadonlyTxProcessingEnv(readOnlyDbProvider, readOnlyBlockTree);
BlockProcessor blockProcessor =
CreateBlockProcessor(txProcessingEnv,
_specProvider,
_blockValidator,
_rewardCalculatorSource,
_receiptStorage,
_logManager,
_miningConfig);
IBlockchainProcessor blockchainProcessor =
new BlockchainProcessor(
readOnlyBlockTree,
blockProcessor,
_blockPreprocessorStep,
txProcessingEnv.StateReader,
_logManager,
BlockchainProcessor.Options.NoReceipts);
OneTimeChainProcessor chainProcessor = new(
readOnlyDbProvider,
blockchainProcessor);
return(new BlockProducerEnv
{
BlockTree = readOnlyBlockTree,
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = txProcessingEnv.StateProvider,
TxSource = CreateTxSourceForProducer(additionalTxSource, txProcessingEnv, _txPool, _miningConfig, _transactionComparerProvider, _logManager),
ReadOnlyTxProcessingEnv = txProcessingEnv
});
}
protected BlockProducerContext GetProducerChain()
{
BlockProducerContext Create()
{
ReadOnlyDbProvider dbProvider = new ReadOnlyDbProvider(_api.DbProvider, false);
ReadOnlyBlockTree blockTree = new ReadOnlyBlockTree(_api.BlockTree);
ReadOnlyTxProcessingEnv txProcessingEnv =
new ReadOnlyTxProcessingEnv(dbProvider, blockTree, _api.SpecProvider, _api.LogManager);
ReadOnlyTxProcessorSource txProcessorSource =
new ReadOnlyTxProcessorSource(txProcessingEnv);
BlockProcessor blockProcessor =
CreateBlockProcessor(txProcessingEnv, txProcessorSource, dbProvider);
IBlockchainProcessor blockchainProcessor =
new BlockchainProcessor(
blockTree,
blockProcessor,
_api.RecoveryStep,
_api.LogManager,
BlockchainProcessor.Options.NoReceipts);
OneTimeChainProcessor chainProcessor = new OneTimeChainProcessor(
dbProvider,
blockchainProcessor);
return(new BlockProducerContext
{
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = txProcessingEnv.StateProvider,
TxSource = CreateTxSourceForProducer(txProcessingEnv, txProcessorSource),
ReadOnlyTxProcessingEnv = txProcessingEnv,
ReadOnlyTxProcessorSource = txProcessorSource
});
}
return(_blockProducerContext ??= Create());
}
protected BlockProducerContext GetProducerChain()
{
BlockProducerContext Create()
{
ReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_context.DbProvider, false);
ReadOnlyBlockTree readOnlyBlockTree = new ReadOnlyBlockTree(_context.BlockTree);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyBlockTree, _context.SpecProvider, _context.LogManager);
var readOnlyTransactionProcessorSource = new ReadOnlyTransactionProcessorSource(readOnlyTxProcessingEnv);
BlockProcessor blockProcessor = CreateBlockProcessor(readOnlyTxProcessingEnv, readOnlyTransactionProcessorSource, readOnlyDbProvider);
OneTimeChainProcessor chainProcessor = new OneTimeChainProcessor(readOnlyDbProvider, new BlockchainProcessor(readOnlyBlockTree, blockProcessor, _context.RecoveryStep, _context.LogManager, BlockchainProcessor.Options.NoReceipts));
return(new BlockProducerContext
{
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = readOnlyTxProcessingEnv.StateProvider,
TxSource = CreateTxSourceForProducer(readOnlyTxProcessingEnv, readOnlyTransactionProcessorSource),
ReadOnlyTxProcessingEnv = readOnlyTxProcessingEnv,
ReadOnlyTransactionProcessorSource = readOnlyTransactionProcessorSource
});
}
return(_blockProducerContext ??= Create());
}
public TraceModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
IReadOnlyTrieStore trieNodeResolver,
IJsonRpcConfig jsonRpcConfig,
IBlockPreprocessorStep recoveryStep,
IRewardCalculatorSource rewardCalculatorSource,
IReceiptStorage receiptFinder,
ISpecProvider specProvider,
ILogManager logManager)
{
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_trieNodeResolver = trieNodeResolver;
_jsonRpcConfig = jsonRpcConfig ?? throw new ArgumentNullException(nameof(jsonRpcConfig));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource =
rewardCalculatorSource ?? throw new ArgumentNullException(nameof(rewardCalculatorSource));
_receiptStorage = receiptFinder ?? throw new ArgumentNullException(nameof(receiptFinder));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_logger = logManager.GetClassLogger();
}
private BlockProducerContext GetProducerChain()
{
BlockProducerContext Create()
{
ReadOnlyDbProvider dbProvider = _api.DbProvider.AsReadOnly(false);
ReadOnlyBlockTree blockTree = _api.BlockTree.AsReadOnly();
ReadOnlyTxProcessingEnv txProcessingEnv =
new ReadOnlyTxProcessingEnv(dbProvider, _api.ReadOnlyTrieStore, blockTree, _api.SpecProvider, _api.LogManager);
BlockProcessor blockProcessor =
CreateBlockProcessor(txProcessingEnv, txProcessingEnv, dbProvider);
IBlockchainProcessor blockchainProcessor =
new BlockchainProcessor(
blockTree,
blockProcessor,
_api.BlockPreprocessor,
_api.LogManager,
BlockchainProcessor.Options.NoReceipts);
OneTimeChainProcessor chainProcessor = new OneTimeChainProcessor(
dbProvider,
blockchainProcessor);
return(new BlockProducerContext
{
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = txProcessingEnv.StateProvider,
TxSource = CreateTxSourceForProducer(txProcessingEnv, txProcessingEnv),
ReadOnlyTxProcessingEnv = txProcessingEnv
});
}
return(_blockProducerContext ??= Create());
}
public override ITraceModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv txEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var blockchainBridge = new BlockchainBridge(
txEnv.StateReader,
txEnv.StateProvider,
txEnv.StorageProvider,
txEnv.BlockTree,
_txPool,
_receiptStorage,
NullFilterStore.Instance,
NullFilterManager.Instance,
NullWallet.Instance,
txEnv.TransactionProcessor,
_ethereumEcdsa);
ReadOnlyChainProcessingEnv chainEnv = new ReadOnlyChainProcessingEnv(txEnv, _blockValidator, _recoveryStep, _rewardCalculator, _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
ITracer tracer = new Tracer(chainEnv.Processor, _receiptStorage, new ReadOnlyBlockTree(_blockTree), _dbProvider.TraceDb);
return(new TraceModule(blockchainBridge, _logManager, tracer));
}
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);
_transactionPool = new TransactionPool(
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.BlockInfosDb,
_specProvider,
_transactionPool,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _transactionPool);
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 */
var headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
headerValidator,
_logManager);
var txValidator = new TransactionValidator(
new SignatureValidator(_specProvider.ChainId));
_blockValidator = new BlockValidator(
txValidator,
headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateTree = new StateTree(_dbProvider.StateDb);
var stateProvider = new StateProvider(
stateTree,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_transactionPoolInfoProvider = new TransactionPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree);
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,
_transactionPool,
_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, !statsConfig.CaptureNodeStatsEventHistory);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _transactionPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
// TODO: need to introduce snapshot provider for clique and pass it here instead of CliqueSealEngine
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_transactionPool, 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(_transactionPool, 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 processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
}
await InitializeNetwork(
_receiptStorage,
_sealValidator,
txValidator);
}
