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);
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 DebugModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
IJsonRpcConfig jsonRpcConfig,
IBlockValidator blockValidator,
IBlockPreprocessorStep recoveryStep,
IRewardCalculatorSource rewardCalculator,
IReceiptStorage receiptStorage,
IReceiptsMigration receiptsMigration,
IReadOnlyTrieStore trieStore,
IConfigProvider configProvider,
ISpecProvider specProvider,
ILogManager logManager)
{
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_jsonRpcConfig = jsonRpcConfig ?? throw new ArgumentNullException(nameof(jsonRpcConfig));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource = rewardCalculator ?? throw new ArgumentNullException(nameof(rewardCalculator));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_receiptsMigration = receiptsMigration ?? throw new ArgumentNullException(nameof(receiptsMigration));
_trieStore = (trieStore ?? throw new ArgumentNullException(nameof(trieStore)));
_configProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_logger = logManager.GetClassLogger();
}
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 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 BeamBlockchainProcessor(
IReadOnlyDbProvider readOnlyDbProvider,
IBlockTree blockTree,
ISpecProvider specProvider,
ILogManager logManager,
IBlockValidator blockValidator,
IBlockPreprocessorStep recoveryStep,
IRewardCalculatorSource rewardCalculatorSource,
IBlockProcessingQueue processingQueue,
ISyncModeSelector syncModeSelector)
{
_readOnlyDbProvider = readOnlyDbProvider ?? throw new ArgumentNullException(nameof(readOnlyDbProvider));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource = rewardCalculatorSource ?? throw new ArgumentNullException(nameof(rewardCalculatorSource));
_standardProcessorQueue = processingQueue ?? throw new ArgumentNullException(nameof(processingQueue));
_syncModeSelector = syncModeSelector ?? throw new ArgumentNullException(nameof(syncModeSelector));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_readOnlyBlockTree = new ReadOnlyBlockTree(blockTree);
blockTree.NewBestSuggestedBlock += OnNewBlock;
_logger = logManager.GetClassLogger();
_blockAction = BeamProcess;
_syncModeSelector.Preparing += SyncModeSelectorOnPreparing;
_syncModeSelector.Changing += SyncModeSelectorOnChanging;
_syncModeSelector.Changed += SyncModeSelectorOnChanged;
}
public IBlockchainBridge CreateBlockchainBridge()
{
ReadOnlyBlockTree readOnlyTree = BlockTree.AsReadOnly();
LazyInitializer.EnsureInitialized(ref _readOnlyDbProvider, () => new ReadOnlyDbProvider(DbProvider, false));
// TODO: reuse the same trie cache here
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new(
_readOnlyDbProvider,
ReadOnlyTrieStore,
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,
_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 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 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 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 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 ReadOnlyTxProcessingEnv(IReadOnlyDbProvider readOnlyDbProvider, ReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, ILogManager logManager)
{
ISnapshotableDb stateDb = readOnlyDbProvider.StateDb;
IDb codeDb = readOnlyDbProvider.CodeDb;
StateReader = new StateReader(stateDb, codeDb, logManager);
StateProvider = new StateProvider(stateDb, codeDb, logManager);
StorageProvider = new StorageProvider(stateDb, StateProvider, logManager);
BlockTree = readOnlyBlockTree;
BlockhashProvider = new BlockhashProvider(BlockTree, logManager);
VirtualMachine = new VirtualMachine(StateProvider, StorageProvider, BlockhashProvider, specProvider, logManager);
TransactionProcessor = new TransactionProcessor(specProvider, StateProvider, StorageProvider, VirtualMachine, logManager);
}
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
});
}
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 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));
}
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,
ITrieStore 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.AsReadOnly();
}
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();
}
}
public EthModuleFactory(
ITxPool txPool,
ITxSender txSender,
IWallet wallet,
IBlockTree blockTree,
IJsonRpcConfig config,
ILogManager logManager,
IStateReader stateReader,
IBlockchainBridgeFactory blockchainBridgeFactory)
{
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
_txSender = txSender ?? throw new ArgumentNullException(nameof(txSender));
_wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
_rpcConfig = config ?? throw new ArgumentNullException(nameof(config));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_stateReader = stateReader ?? throw new ArgumentNullException(nameof(stateReader));
_blockchainBridgeFactory = blockchainBridgeFactory ?? throw new ArgumentNullException(nameof(blockchainBridgeFactory));
_blockTree = blockTree.AsReadOnly();
}
public ReadOnlyTxProcessingEnv(
IReadOnlyDbProvider readOnlyDbProvider,
ReadOnlyTrieStore readOnlyTrieStore,
ReadOnlyBlockTree readOnlyBlockTree,
ISpecProvider specProvider,
ILogManager logManager)
{
DbProvider = readOnlyDbProvider;
_codeDb = readOnlyDbProvider.CodeDb.AsReadOnly(true);
StateReader = new StateReader(readOnlyTrieStore, _codeDb, logManager);
StateProvider = new StateProvider(readOnlyTrieStore, _codeDb, logManager);
StorageProvider = new StorageProvider(readOnlyTrieStore, StateProvider, logManager);
BlockTree = readOnlyBlockTree;
BlockhashProvider = new BlockhashProvider(BlockTree, logManager);
Machine = new VirtualMachine(StateProvider, StorageProvider, BlockhashProvider, specProvider, logManager);
TransactionProcessor = new TransactionProcessor(specProvider, StateProvider, StorageProvider, Machine, logManager);
}
// 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 AlternativeChain(
IBlockTree blockTree,
IBlockValidator blockValidator,
IRewardCalculator rewardCalculator,
ISpecProvider specProvider,
IReadOnlyDbProvider dbProvider,
IBlockDataRecoveryStep recoveryStep,
ILogManager logManager,
ITransactionPool customTransactionPool,
IReceiptStorage receiptStorage)
{
StateProvider = new StateProvider(new StateTree(dbProvider.StateDb), dbProvider.CodeDb, logManager);
StorageProvider storageProvider = new StorageProvider(dbProvider.StateDb, StateProvider, logManager);
IBlockTree readOnlyTree = new ReadOnlyBlockTree(blockTree);
BlockhashProvider blockhashProvider = new BlockhashProvider(readOnlyTree);
VirtualMachine virtualMachine = new VirtualMachine(StateProvider, storageProvider, blockhashProvider, logManager);
ITransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, StateProvider, storageProvider, virtualMachine, logManager);
ITransactionPool transactionPool = customTransactionPool;
IBlockProcessor blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, transactionProcessor, dbProvider.StateDb, dbProvider.CodeDb, dbProvider.TraceDb, StateProvider, storageProvider, transactionPool, receiptStorage, logManager);
Processor = new BlockchainProcessor(readOnlyTree, blockProcessor, recoveryStep, logManager, false, false);
}
public ReadOnlyChain(
ReadOnlyBlockTree readOnlyTree,
IBlockValidator blockValidator,
IRewardCalculator rewardCalculator,
ISpecProvider specProvider,
IReadOnlyDbProvider dbProvider,
IBlockDataRecoveryStep recoveryStep,
ILogManager logManager,
ITxPool customTxPool,
IReceiptStorage receiptStorage)
{
ReadOnlyStateProvider = new StateProvider(dbProvider.StateDb, dbProvider.CodeDb, logManager);
StorageProvider storageProvider = new StorageProvider(dbProvider.StateDb, ReadOnlyStateProvider, logManager);
BlockhashProvider blockhashProvider = new BlockhashProvider(readOnlyTree, logManager);
VirtualMachine virtualMachine = new VirtualMachine(ReadOnlyStateProvider, storageProvider, blockhashProvider, specProvider, logManager);
ITransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, ReadOnlyStateProvider, storageProvider, virtualMachine, logManager);
ITxPool txPool = customTxPool;
IBlockProcessor blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, transactionProcessor, dbProvider.StateDb, dbProvider.CodeDb, dbProvider.TraceDb, ReadOnlyStateProvider, storageProvider, txPool, receiptStorage, logManager);
Processor = new OneTimeChainProcessor(dbProvider, new BlockchainProcessor(readOnlyTree, blockProcessor, recoveryStep, logManager, false, false));
}
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());
}
public BeamBlockchainProcessor(
IReadOnlyDbProvider readOnlyDbProvider,
IBlockTree blockTree,
ISpecProvider specProvider,
ILogManager logManager,
IBlockValidator blockValidator,
IBlockDataRecoveryStep recoveryStep,
IRewardCalculatorSource rewardCalculatorSource,
IBlockProcessingQueue blockchainProcessor)
{
_readOnlyDbProvider = readOnlyDbProvider ?? throw new ArgumentNullException(nameof(readOnlyDbProvider));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource = rewardCalculatorSource ?? throw new ArgumentNullException(nameof(rewardCalculatorSource));
_blockchainProcessor = blockchainProcessor ?? throw new ArgumentNullException(nameof(blockchainProcessor));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_readOnlyBlockTree = new ReadOnlyBlockTree(_blockTree);
_logger = logManager.GetClassLogger();
_blockTree.NewBestSuggestedBlock += OnNewBlock;
_blockTree.NewHeadBlock += BlockTreeOnNewHeadBlock;
}
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();
}
