public async Task InitNetworkProtocol()
{
if (_ndmInitializer == null)
{
throw new InvalidOperationException(
$"Cannot {nameof(InitNetworkProtocol)} in NDM before preparing an NDM initializer.");
}
ILogger logger = _ndmApi.LogManager.GetClassLogger();
if (logger.IsInfo)
{
logger.Info("Initializing NDM network protocol...");
}
_ndmApi.HttpClient = new DefaultHttpClient(new HttpClient(), _ndmApi.EthereumJsonSerializer, _ndmApi.LogManager);
INdmConfig ndmConfig = _ndmApi.Config <INdmConfig>();
if (ndmConfig.ProxyEnabled)
{
_ndmApi.JsonRpcClientProxy = new JsonRpcClientProxy(
_ndmApi.HttpClient,
ndmConfig.JsonRpcUrlProxies,
_ndmApi.LogManager);
_ndmApi.EthJsonRpcClientProxy = new EthJsonRpcClientProxy(_ndmApi.JsonRpcClientProxy);
}
INdmCapabilityConnector capabilityConnector = await _ndmInitializer.InitAsync(_ndmApi);
capabilityConnector.Init();
if (logger.IsInfo)
{
logger.Info("NDM network protocol initialized.");
}
}
protected async Task Prepare()
{
_wallet = new DevWallet(new WalletConfig(), _logManager);
_feeAccount = _wallet.GetAccounts()[0];
_consumerAccount = _wallet.GetAccounts()[1];
_providerAccount = _wallet.GetAccounts()[2];
_ndmConfig = new NdmConfig();
IReleaseSpec spec = _releaseSpec;
ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99);
StateDb stateDb = new StateDb();
_state = new StateProvider(stateDb, new StateDb(), _logManager);
StorageProvider storageProvider = new StorageProvider(stateDb, _state, _logManager);
_state.CreateAccount(_consumerAccount, 1000.Ether());
_state.CreateAccount(_providerAccount, 1.Ether());
_state.Commit(spec);
_state.CommitTree();
VirtualMachine machine = new VirtualMachine(_state, storageProvider, Substitute.For <IBlockhashProvider>(),
specProvider, _logManager);
TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager);
_bridge = new BlockchainBridge(processor);
TxReceipt receipt = await DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount)));
((NdmConfig)_ndmConfig).ContractAddress = receipt.ContractAddress.ToString();
_contractAddress = receipt.ContractAddress;
_txPool = new TxPool.TxPool(new InMemoryTxStorage(), Timestamper.Default,
new EthereumEcdsa(specProvider.ChainId, _logManager), specProvider, new TxPoolConfig(), _state, _logManager);
_ndmBridge = new NdmBlockchainBridge(_bridge, _bridge, _bridge, _bridge);
}
public void Ndm_disabled_by_default(string configFile)
{
ConfigProvider configProvider = GetConfigProviderFromFile(configFile);
INdmConfig config = configProvider.GetConfig <INdmConfig>();
Assert.AreEqual(config.Enabled, false);
}
public void Setup()
{
_configProvider = Substitute.For <IConfigProvider>();
_configManager = Substitute.For <IConfigManager>();
_ndmConfig = new NdmConfig();
_baseDbPath = "db";
_rocksProvider = Substitute.For <IDbProvider>();
_mongoProvider = Substitute.For <IMongoProvider>();
_logManager = Substitute.For <ILogManager>();
_blockTree = Substitute.For <IBlockTree>();
_specProvider = Substitute.For <ISpecProvider>();
_transactionPool = Substitute.For <ITxPool>();
_receiptStorage = Substitute.For <IReceiptStorage>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_wallet = Substitute.For <IWallet>();
_timestamper = Substitute.For <ITimestamper>();
_ecdsa = Substitute.For <IEthereumEcdsa>();
_keyStore = Substitute.For <IKeyStore>();
_rpcModuleProvider = Substitute.For <IRpcModuleProvider>();
_jsonSerializer = Substitute.For <IJsonSerializer>();
_cryptoRandom = Substitute.For <ICryptoRandom>();
_enode = Substitute.For <IEnode>();
_ndmConsumerChannelManager = Substitute.For <INdmConsumerChannelManager>();
_ndmDataPublisher = Substitute.For <INdmDataPublisher>();
_grpcServer = Substitute.For <IGrpcServer>();
_ethRequestService = Substitute.For <IEthRequestService>();
_notifier = Substitute.For <INdmNotifier>();
_enableUnsecuredDevWallet = false;
_blockProcessor = Substitute.For <IBlockProcessor>();
_ndmModule = new NdmModule();
}
protected void Prepare()
{
_wallet = new DevWallet(new WalletConfig(), _logManager);
_feeAccount = _wallet.GetAccounts()[0];
_consumerAccount = _wallet.GetAccounts()[1];
_providerAccount = _wallet.GetAccounts()[2];
_ndmConfig = new NdmConfig();
IReleaseSpec spec = _releaseSpec;
ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99);
StateDb stateDb = new StateDb();
_state = new StateProvider(stateDb, new StateDb(), _logManager);
StorageProvider storageProvider = new StorageProvider(stateDb, _state, _logManager);
_state.CreateAccount(_consumerAccount, 1000.Ether());
_state.CreateAccount(_providerAccount, 1.Ether());
_state.Commit(spec);
_state.CommitTree();
VirtualMachine machine = new VirtualMachine(_state, storageProvider, Substitute.For <IBlockhashProvider>(), _logManager);
TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager);
_bridge = new BlockchainBridge(processor, _releaseSpec);
TxReceipt receipt = DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount)));
_ndmConfig.ContractAddress = receipt.ContractAddress.ToString();
}
public RefundService(IBlockchainBridge blockchainBridge, IAbiEncoder abiEncoder, IWallet wallet, INdmConfig ndmConfig, ILogManager logManager)
{
_blockchainBridge = blockchainBridge ?? throw new ArgumentNullException(nameof(blockchainBridge));
_abiEncoder = abiEncoder ?? throw new ArgumentNullException(nameof(abiEncoder));
_wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
_ndmConfig = ndmConfig ?? throw new ArgumentNullException(nameof(ndmConfig));
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
}
public ConsumerNdmDbInitializer(
IDbProvider dbProvider,
INdmConfig ndmConfig,
IRocksDbFactory rocksDbFactory,
IMemDbFactory memDbFactory)
: base(dbProvider, rocksDbFactory, memDbFactory)
{
_ndmConfig = ndmConfig ?? throw new ArgumentNullException(nameof(NdmConfig));
}
public Task Init(INethermindApi api)
{
_ndmApi = new NdmApi(api);
// TODO: load messages nicely?
api.MessageSerializationService.Register(Assembly.GetAssembly(typeof(HiMessageSerializer)));
ILogger logger = api.LogManager.GetClassLogger();
INdmConfig ndmConfig = api.ConfigProvider.GetConfig <INdmConfig>();
bool ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
_ndmApi.NdmDataPublisher = new NdmDataPublisher();
_ndmApi.NdmConsumerChannelManager = new NdmConsumerChannelManager();
string initializerName = ndmConfig.InitializerName;
if (logger.IsInfo)
{
logger.Info($"NDM initializer: {initializerName}");
}
Type?ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
if (ndmInitializerType == null)
{
if (logger.IsError)
{
logger.Error(
$"NDM enabled but the initializer {initializerName} has not been found. Ensure that a plugin exists with the properly set {nameof(NdmInitializerAttribute)}");
}
}
NdmModule ndmModule = new(_ndmApi);
NdmConsumersModule ndmConsumersModule = new(_ndmApi);
_ndmInitializer =
new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule, api.LogManager)
.CreateOrFail();
if (api.GrpcServer != null)
{
var grpcChannel = new GrpcNdmConsumerChannel(api.GrpcServer);
_ndmApi.NdmConsumerChannelManager.Add(grpcChannel);
}
NdmWebSocketsModule ndmWebSocketsModule =
new(
_ndmApi.NdmConsumerChannelManager,
_ndmApi.NdmDataPublisher,
api.EthereumJsonSerializer);
api.WebSocketsManager.AddModule(ndmWebSocketsModule);
}
return(Task.CompletedTask);
}
public override async Task <INdmCapabilityConnector> InitAsync(INdmApi ndmApi)
{
INdmConfig ndmConfig = ndmApi.ConfigProvider.GetConfig <INdmConfig>();
await PreInitAsync(ndmApi);
if (!ndmConfig.Enabled)
{
return(NullNdmCapabilityConnector.Instance);
}
providersModule = new NdmProvidersModule(ndmApi);
await _consumerModule.Init();
await providersModule.InitAsync();
IProviderService providerService = providersModule.GetProviderService();
var subprotocolFactory = new NdmProviderSubprotocolFactory(ndmApi.MessageSerializationService, ndmApi.NodeStatsManager,
ndmApi.LogManager, ndmApi.AccountService, ndmApi.ConsumerService, providerService, ndmApi.NdmConsumerChannelManager, ndmApi.EthereumEcdsa,
ndmApi.Wallet, ndmApi.NdmFaucet, ndmApi.Enode.PublicKey, ndmApi.ProviderAddress, ndmApi.ConsumerAddress, ndmConfig.VerifyP2PSignature);
var protocolHandlerFactory = new ProtocolHandlerFactory(subprotocolFactory, ndmApi.ProtocolValidator,
ndmApi.EthRequestService, ndmApi.LogManager);
var capabilityConnector = new NdmCapabilityConnector(ndmApi.ProtocolsManager, protocolHandlerFactory,
ndmApi.AccountService, ndmApi.LogManager, ndmApi.ProviderAddress);
providerService.AddressChanged += (_, e) =>
{
if (!(e.OldAddress is null) && e.OldAddress != Address.Zero)
{
return;
}
capabilityConnector.AddCapability();
};
var pluginBuilder = new YamlNdmPluginBuilder();
var pluginLoader = new YamlNdmPluginLoader("ndm-plugins", pluginBuilder, ndmApi.LogManager);
var plugins = pluginLoader.Load();
foreach (var plugin in plugins)
{
await providerService.InitPluginAsync(plugin);
}
ndmApi.MonitoringService?.RegisterMetrics(typeof(Metrics));
return(capabilityConnector);
}
protected async Task Prepare()
{
_wallet = new DevWallet(new WalletConfig(), _logManager);
_feeAccount = _wallet.GetAccounts()[0];
_consumerAccount = _wallet.GetAccounts()[1];
_providerAccount = _wallet.GetAccounts()[2];
_ndmConfig = new NdmConfig();
IReleaseSpec spec = _releaseSpec;
ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99);
MemDb stateDb = new MemDb();
TrieStore trieStore = new TrieStore(stateDb, _logManager);
_state = new StateProvider(trieStore, new MemDb(), _logManager);
StorageProvider storageProvider = new StorageProvider(trieStore, _state, _logManager);
_state.CreateAccount(_consumerAccount, 1000.Ether());
_state.CreateAccount(_providerAccount, 1.Ether());
_state.Commit(spec);
_state.CommitTree(0);
VirtualMachine machine =
new VirtualMachine(Substitute.For <IBlockhashProvider>(), specProvider, _logManager);
TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager);
_bridge = new BlockchainBridge(processor);
TxReceipt receipt = await DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount)));
((NdmConfig)_ndmConfig).ContractAddress = receipt.ContractAddress.ToString();
_contractAddress = receipt.ContractAddress;
IBlockTree blockTree = Substitute.For <IBlockTree>();
Block block = Build.A.Block.WithNumber(0).TestObject;
blockTree.Head.Returns(block);
TransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, blockTree);
_txPool = new TxPool.TxPool(
new EthereumEcdsa(specProvider.ChainId, _logManager),
new ChainHeadInfoProvider(specProvider, blockTree, _state),
new TxPoolConfig(),
new TxValidator(specProvider.ChainId),
_logManager,
transactionComparerProvider.GetDefaultComparer());
_ndmBridge = new NdmBlockchainBridge(_bridge, _bridge, _bridge, _bridge);
}
public NdmRequiredServices(IConfigProvider configProvider, IConfigManager configManager, INdmConfig ndmConfig,
string baseDbPath, IDbProvider rocksProvider, IMongoProvider mongoProvider, ILogManager logManager,
IBlockTree blockTree, ITxPool transactionPool, ISpecProvider specProvider, IReceiptStorage receiptStorage,
IFilterStore filterStore, IFilterManager filterManager, IWallet wallet, ITimestamper timestamper,
IEthereumEcdsa ecdsa, IKeyStore keyStore, IRpcModuleProvider rpcModuleProvider,
IJsonSerializer jsonSerializer, ICryptoRandom cryptoRandom, IEnode enode,
INdmConsumerChannelManager ndmConsumerChannelManager, INdmDataPublisher ndmDataPublisher,
IGrpcServer grpcServer, IEthRequestService ethRequestService, INdmNotifier notifier,
bool enableUnsecuredDevWallet, IBlockProcessor blockProcessor, IJsonRpcClientProxy jsonRpcClientProxy,
IEthJsonRpcClientProxy ethJsonRpcClientProxy, IHttpClient httpClient, IMonitoringService monitoringService)
{
ConfigProvider = configProvider;
ConfigManager = configManager;
NdmConfig = ndmConfig;
BaseDbPath = baseDbPath;
RocksProvider = rocksProvider;
MongoProvider = mongoProvider;
LogManager = logManager;
BlockTree = blockTree;
TransactionPool = transactionPool;
SpecProvider = specProvider;
ReceiptStorage = receiptStorage;
FilterStore = filterStore;
FilterManager = filterManager;
Wallet = wallet;
Timestamper = timestamper;
Ecdsa = ecdsa;
KeyStore = keyStore;
RpcModuleProvider = rpcModuleProvider;
JsonSerializer = jsonSerializer;
CryptoRandom = cryptoRandom;
Enode = enode;
NdmConsumerChannelManager = ndmConsumerChannelManager;
NdmDataPublisher = ndmDataPublisher;
GrpcServer = grpcServer;
EthRequestService = ethRequestService;
Notifier = notifier;
EnableUnsecuredDevWallet = enableUnsecuredDevWallet;
BlockProcessor = blockProcessor;
JsonRpcClientProxy = jsonRpcClientProxy;
EthJsonRpcClientProxy = ethJsonRpcClientProxy;
HttpClient = httpClient;
MonitoringService = monitoringService;
}
public virtual async Task <INdmCapabilityConnector> InitAsync(INdmApi api)
{
_logger = api.LogManager.GetClassLogger() ?? throw new ArgumentNullException(nameof(api.LogManager));
INdmConfig ndmConfig = api.Config <INdmConfig>();
if (!ndmConfig.Enabled)
{
// can we not even call it here? // can be step and use the subsystems
return(NullNdmCapabilityConnector.Instance);
}
await PreInitAsync(api);
NdmSubprotocolFactory subprotocolFactory = new NdmSubprotocolFactory(
api.MessageSerializationService,
api.NodeStatsManager,
api.LogManager,
api.AccountService,
api.ConsumerService,
api.NdmConsumerChannelManager,
api.EthereumEcdsa,
api.Wallet,
api.NdmFaucet,
api.Enode.PublicKey,
api.ProviderAddress,
api.ConsumerAddress,
api.Config <INdmConfig>().VerifyP2PSignature);
ProtocolHandlerFactory protocolHandlerFactory = new(
subprotocolFactory,
api.ProtocolValidator,
api.EthRequestService,
api.LogManager);
NdmCapabilityConnector capabilityConnector = new(
api.ProtocolsManager,
protocolHandlerFactory,
api.AccountService,
api.LogManager,
ndmConfig.ProviderAddress == null ? Address.Zero : new Address(ndmConfig.ProviderAddress));
return(capabilityConnector);
}
public DepositService(IBlockchainBridge blockchainBridge, IAbiEncoder abiEncoder, IWallet wallet,
INdmConfig ndmConfig, ILogManager logManager)
{
_blockchainBridge = blockchainBridge ?? throw new ArgumentNullException(nameof(blockchainBridge));
_abiEncoder = abiEncoder ?? throw new ArgumentNullException(nameof(abiEncoder));
_wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
if (ndmConfig is null)
{
throw new ArgumentNullException(nameof(ndmConfig));
}
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_consumerAddress = string.IsNullOrWhiteSpace(ndmConfig.ConsumerAddress)
? Address.Zero
: new Address(ndmConfig.ConsumerAddress);
_contractAddress = string.IsNullOrWhiteSpace(ndmConfig.ContractAddress)
? Address.Zero
: new Address(ndmConfig.ContractAddress);
}
public RequiredServices(IConfigProvider configProvider, IConfigManager configManager, INdmConfig ndmConfig,
string baseDbPath, IDbProvider rocksProvider, IMongoProvider mongoProvider, ILogManager logManager,
IBlockProcessor blockProcessor, IBlockTree blockTree, ITxPool transactionPool,
ITxPoolInfoProvider transactionPoolInfoProvider, ISpecProvider specProvider,
IReceiptStorage receiptStorage, IWallet wallet, ITimestamp timestamp, IEthereumEcdsa ecdsa,
IKeyStore keyStore, IRpcModuleProvider rpcModuleProvider, IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom, IEnode enode, INdmConsumerChannelManager ndmConsumerChannelManager,
INdmDataPublisher ndmDataPublisher, IGrpcService grpcService, EthRequestService ethRequestService,
bool enableUnsecuredDevWallet)
{
ConfigProvider = configProvider;
ConfigManager = configManager;
NdmConfig = ndmConfig;
BaseDbPath = baseDbPath;
RocksProvider = rocksProvider;
MongoProvider = mongoProvider;
LogManager = logManager;
BlockProcessor = blockProcessor;
BlockTree = blockTree;
TransactionPool = transactionPool;
TransactionPoolInfoProvider = transactionPoolInfoProvider;
SpecProvider = specProvider;
ReceiptStorage = receiptStorage;
Wallet = wallet;
Timestamp = timestamp;
Ecdsa = ecdsa;
KeyStore = keyStore;
RpcModuleProvider = rpcModuleProvider;
JsonSerializer = jsonSerializer;
CryptoRandom = cryptoRandom;
Enode = enode;
NdmConsumerChannelManager = ndmConsumerChannelManager;
NdmDataPublisher = ndmDataPublisher;
GrpcService = grpcService;
EthRequestService = ethRequestService;
EnableUnsecuredDevWallet = enableUnsecuredDevWallet;
}
public virtual Task Execute()
{
if (_context.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_context.RpcModuleProvider));
}
ILogger logger = _context.LogManager.GetClassLogger();
IJsonRpcConfig jsonRpcConfig = _context.Config <IJsonRpcConfig>();
if (!jsonRpcConfig.Enabled)
{
return(Task.CompletedTask);
}
// the following line needs to be called in order to make sure that the CLI library is referenced from runner and built alongside
if (logger.IsDebug)
{
logger.Debug($"Resolving CLI ({nameof(CliModuleLoader)})");
}
IInitConfig initConfig = _context.Config <IInitConfig>();
INdmConfig ndmConfig = _context.Config <INdmConfig>();
IJsonRpcConfig rpcConfig = _context.Config <IJsonRpcConfig>();
if (ndmConfig.Enabled && !(_context.NdmInitializer is null) && ndmConfig.ProxyEnabled)
{
EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_context.EthJsonRpcClientProxy, _context.Wallet);
_context.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true));
if (logger.IsInfo)
{
logger.Info("Enabled JSON RPC Proxy for NDM.");
}
}
else
{
EthModuleFactory ethModuleFactory = new EthModuleFactory(_context.DbProvider, _context.TxPool, _context.Wallet, _context.BlockTree,
_context.EthereumEcdsa, _context.MainBlockProcessor, _context.ReceiptStorage, _context.SpecProvider, rpcConfig, _context.BloomStorage, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_context.DbProvider, _context.BlockTree, _context.RecoveryStep, _context.ReceiptStorage, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(_context.DbProvider, _context.BlockTree, _context.BlockValidator, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.ConfigProvider, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_context.DbProvider, _context.BlockTree, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory));
if (initConfig.EnableUnsecuredDevWallet)
{
PersonalBridge personalBridge = new PersonalBridge(_context.EthereumEcdsa, _context.Wallet);
PersonalModule personalModule = new PersonalModule(personalBridge, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
}
AdminModule adminModule = new AdminModule(_context.PeerManager, _context.StaticNodesManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
TxPoolModule txPoolModule = new TxPoolModule(_context.LogManager, _context.TxPoolInfoProvider);
_context.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
NetModule netModule = new NetModule(_context.LogManager, new NetBridge(_context.Enode, _context.SyncServer, _context.PeerManager));
_context.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(_context.EthereumEcdsa, _context.TxPool, _context.BlockTree, _context.ReceiptStorage, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
SubsystemStateChanged?.Invoke(this, new SubsystemStateEventArgs(EthereumSubsystemState.Running));
return(Task.CompletedTask);
}
protected async Task StartRunners(IConfigProvider configProvider)
{
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
IMetricsConfig metricsConfig = configProvider.GetConfig <IMetricsConfig>();
NLogManager logManager = new NLogManager(initConfig.LogFileName, initConfig.LogDirectory);
IRpcModuleProvider rpcModuleProvider = jsonRpcConfig.Enabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>(), logManager)
: (IRpcModuleProvider)NullModuleProvider.Instance;
EthereumJsonSerializer jsonSerializer = new EthereumJsonSerializer();
WebSocketsManager webSocketsManager = new WebSocketsManager();
if (!string.IsNullOrEmpty(metricsConfig.NodeName))
{
logManager.SetGlobalVariable("nodeName", metricsConfig.NodeName);
}
if (metricsConfig.Enabled)
{
Metrics.Version = VersionToMetrics.ConvertToNumber(ClientVersion.Version);
MetricsUpdater metricsUpdater = new MetricsUpdater(metricsConfig);
_monitoringService = new MonitoringService(metricsUpdater, metricsConfig, logManager);
_monitoringService.RegisterMetrics(typeof(Nethermind.Blockchain.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Db.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Evm.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.JsonRpc.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Trie.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Network.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Synchronization.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.TxPool.Metrics));
_monitoringService.RegisterMetrics(typeof(Metrics));
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during starting a monitoring.", x.Exception);
}
});
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Grafana / Prometheus metrics are disabled in configuration");
}
}
IGrpcConfig grpcConfig = configProvider.GetConfig <IGrpcConfig>();
GrpcServer? grpcServer = null;
if (grpcConfig.Enabled)
{
grpcServer = new GrpcServer(jsonSerializer, logManager);
_grpcRunner = new GrpcRunner(grpcServer, grpcConfig, logManager);
await _grpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during GRPC runner start", x.Exception);
}
});
}
INdmDataPublisher? ndmDataPublisher = null;
INdmConsumerChannelManager?ndmConsumerChannelManager = null;
INdmInitializer? ndmInitializer = null;
INdmConfig ndmConfig = configProvider.GetConfig <INdmConfig>();
bool ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
ndmDataPublisher = new NdmDataPublisher();
ndmConsumerChannelManager = new NdmConsumerChannelManager();
string initializerName = ndmConfig.InitializerName;
if (_logger?.IsInfo ?? false)
{
_logger !.Info($"NDM initializer: {initializerName}");
}
Type ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
NdmModule ndmModule = new NdmModule();
NdmConsumersModule ndmConsumersModule = new NdmConsumersModule();
ndmInitializer = new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule, logManager).CreateOrFail();
if (grpcServer != null)
{
ndmConsumerChannelManager.Add(new GrpcNdmConsumerChannel(grpcServer));
}
webSocketsManager.AddModule(new NdmWebSocketsModule(ndmConsumerChannelManager, ndmDataPublisher, jsonSerializer));
}
_ethereumRunner = new EthereumRunner(
rpcModuleProvider,
configProvider,
logManager,
grpcServer,
ndmConsumerChannelManager,
ndmDataPublisher,
ndmInitializer,
webSocketsManager,
jsonSerializer,
_monitoringService);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during ethereum runner start", x.Exception);
}
});
if (jsonRpcConfig.Enabled)
{
rpcModuleProvider.Register(new SingletonModulePool <IWeb3Module>(new Web3Module(logManager), true));
JsonRpcService jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
JsonRpcProcessor jsonRpcProcessor = new JsonRpcProcessor(jsonRpcService, jsonSerializer, jsonRpcConfig, new FileSystem(), logManager);
if (initConfig.WebSocketsEnabled)
{
webSocketsManager.AddModule(new JsonRpcWebSocketsModule(jsonRpcProcessor, jsonSerializer), true);
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = jsonSerializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager, jsonRpcProcessor, webSocketsManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Json RPC is disabled");
}
}
}
public virtual Task Execute(CancellationToken cancellationToken)
{
if (_context.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_context.RpcModuleProvider));
}
if (_context.TxPool == null)
{
throw new StepDependencyException(nameof(_context.TxPool));
}
if (_context.BlockTree == null)
{
throw new StepDependencyException(nameof(_context.BlockTree));
}
if (_context.Wallet == null)
{
throw new StepDependencyException(nameof(_context.Wallet));
}
if (_context.SpecProvider == null)
{
throw new StepDependencyException(nameof(_context.SpecProvider));
}
ILogger logger = _context.LogManager.GetClassLogger();
IJsonRpcConfig jsonRpcConfig = _context.Config <IJsonRpcConfig>();
if (!jsonRpcConfig.Enabled)
{
return(Task.CompletedTask);
}
// the following line needs to be called in order to make sure that the CLI library is referenced from runner and built alongside
if (logger.IsDebug)
{
logger.Debug($"Resolving CLI ({nameof(CliModuleLoader)})");
}
IInitConfig initConfig = _context.Config <IInitConfig>();
INdmConfig ndmConfig = _context.Config <INdmConfig>();
IJsonRpcConfig rpcConfig = _context.Config <IJsonRpcConfig>();
IBaselineConfig baselineConfig = _context.Config <IBaselineConfig>();
INetworkConfig networkConfig = _context.Config <INetworkConfig>();
if (ndmConfig.Enabled && !(_context.NdmInitializer is null) && ndmConfig.ProxyEnabled)
{
EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_context.EthJsonRpcClientProxy, _context.Wallet);
_context.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true));
if (logger.IsInfo)
{
logger.Info("Enabled JSON RPC Proxy for NDM.");
}
}
else
{
EthModuleFactory ethModuleFactory = new EthModuleFactory(_context.DbProvider, _context.TxPool, _context.Wallet, rpcConfig, _context.BlockTree,
_context.EthereumEcdsa, _context.MainBlockProcessor, _context.ReceiptFinder, _context.SpecProvider, rpcConfig, _context.BloomStorage, _context.LogManager, initConfig.IsMining);
_context.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_context.DbProvider, _context.BlockTree, _context.RecoveryStep, _context.ReceiptFinder, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(_context.DbProvider, _context.BlockTree, rpcConfig, _context.BlockValidator, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.ConfigProvider, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_context.DbProvider, _context.BlockTree, rpcConfig, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory));
PersonalBridge personalBridge = new PersonalBridge(_context.EthereumEcdsa, _context.Wallet);
PersonalModule personalModule = new PersonalModule(personalBridge, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
AdminModule adminModule = new AdminModule(_context.BlockTree, networkConfig, _context.PeerManager, _context.StaticNodesManager, _context.Enode, initConfig.BaseDbPath);
_context.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
LogFinder logFinder = new LogFinder(
_context.BlockTree,
_context.ReceiptFinder,
_context.BloomStorage,
_context.LogManager,
new ReceiptsRecovery(), 1024);
if (baselineConfig.Enabled)
{
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_context.TxPool,
logFinder,
_context.BlockTree,
_context.AbiEncoder,
_context.Wallet,
_context.SpecProvider,
_context.FileSystem,
_context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IBaselineModule>(baselineModuleFactory, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Baseline RPC Module has been enabled");
}
}
// commented out because of temporary strange build issues on the build server
// IDepositConfig depositConfig = _context.Config<IDepositConfig>();
// if (depositConfig.DepositContractAddress != null)
// {
// TxPoolBridge txPoolBridge = new TxPoolBridge(
// _context.TxPool, new WalletTxSigner(_context.Wallet, _context.SpecProvider.ChainId), _context.Timestamper);
// DepositModule depositModule = new DepositModule(txPoolBridge, logFinder, depositConfig, _context.LogManager);
// _context.RpcModuleProvider.Register(new SingletonModulePool<IDepositModule>(depositModule, true));
// }
TxPoolModule txPoolModule = new TxPoolModule(_context.BlockTree, _context.TxPoolInfoProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
NetModule netModule = new NetModule(_context.LogManager, new NetBridge(_context.Enode, _context.SyncServer));
_context.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(
_context.EthereumEcdsa,
_context.TxPool,
_context.BlockTree,
_context.ReceiptFinder,
_context.Enode,
_context.Signer,
_context.KeyStore,
_context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
return(Task.CompletedTask);
}
public virtual Task Execute(CancellationToken cancellationToken)
{
if (_api.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_api.RpcModuleProvider));
}
if (_api.TxPool == null)
{
throw new StepDependencyException(nameof(_api.TxPool));
}
if (_api.BlockTree == null)
{
throw new StepDependencyException(nameof(_api.BlockTree));
}
if (_api.Wallet == null)
{
throw new StepDependencyException(nameof(_api.Wallet));
}
if (_api.SpecProvider == null)
{
throw new StepDependencyException(nameof(_api.SpecProvider));
}
if (_api.TxSender == null)
{
throw new StepDependencyException(nameof(_api.TxSender));
}
ILogger logger = _api.LogManager.GetClassLogger();
IJsonRpcConfig jsonRpcConfig = _api.Config <IJsonRpcConfig>();
if (!jsonRpcConfig.Enabled)
{
return(Task.CompletedTask);
}
// the following line needs to be called in order to make sure that the CLI library is referenced from runner and built alongside
if (logger.IsDebug)
{
logger.Debug($"Resolving CLI ({nameof(CliModuleLoader)})");
}
IInitConfig initConfig = _api.Config <IInitConfig>();
INdmConfig ndmConfig = _api.Config <INdmConfig>();
IJsonRpcConfig rpcConfig = _api.Config <IJsonRpcConfig>();
IBaselineConfig baselineConfig = _api.Config <IBaselineConfig>();
IVaultConfig vaultConfig = _api.Config <IVaultConfig>();
INetworkConfig networkConfig = _api.Config <INetworkConfig>();
if (ndmConfig.Enabled && !(_api.NdmInitializer is null) && ndmConfig.ProxyEnabled)
{
EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_api.EthJsonRpcClientProxy, _api.Wallet);
_api.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true));
if (logger.IsInfo)
{
logger.Info("Enabled JSON RPC Proxy for NDM.");
}
}
else
{
EthModuleFactory ethModuleFactory = new EthModuleFactory(
_api.DbProvider,
_api.TxPool,
_api.TxSender,
_api.Wallet,
_api.BlockTree,
_api.EthereumEcdsa,
_api.MainBlockProcessor,
_api.ReceiptFinder,
_api.SpecProvider,
rpcConfig,
_api.BloomStorage,
_api.LogManager,
initConfig.IsMining);
_api.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_api.DbProvider, _api.BlockTree, _api.RecoveryStep, _api.ReceiptFinder, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(
_api.DbProvider,
_api.BlockTree,
rpcConfig,
_api.BlockValidator,
_api.RecoveryStep,
_api.RewardCalculatorSource,
_api.ReceiptStorage,
new ReceiptMigration(_api),
_api.ConfigProvider,
_api.SpecProvider,
_api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_api.DbProvider, _api.BlockTree, rpcConfig, _api.RecoveryStep, _api.RewardCalculatorSource, _api.ReceiptStorage, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory));
PersonalModule personalModule = new PersonalModule(
_api.EthereumEcdsa,
_api.Wallet,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
AdminModule adminModule = new AdminModule(_api.BlockTree, networkConfig, _api.PeerManager, _api.StaticNodesManager, _api.Enode, initConfig.BaseDbPath);
_api.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
LogFinder logFinder = new LogFinder(
_api.BlockTree,
_api.ReceiptFinder,
_api.BloomStorage,
_api.LogManager,
new ReceiptsRecovery(), 1024);
if (baselineConfig.Enabled)
{
IDbProvider dbProvider = _api.DbProvider !;
IStateReader stateReader = new StateReader(dbProvider.StateDb, dbProvider.CodeDb, _api.LogManager);
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_api.TxSender,
stateReader,
logFinder,
_api.BlockTree,
_api.AbiEncoder,
_api.FileSystem,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IBaselineModule>(baselineModuleFactory, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Baseline RPC Module has been enabled");
}
}
TxPoolModule txPoolModule = new TxPoolModule(_api.BlockTree, _api.TxPoolInfoProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
if (vaultConfig.Enabled)
{
VaultService vaultService = new VaultService(vaultConfig, _api.LogManager);
VaultModule vaultModule = new VaultModule(vaultService, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IVaultModule>(vaultModule, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Vault RPC Module has been enabled");
}
}
NetModule netModule = new NetModule(_api.LogManager, new NetBridge(_api.Enode, _api.SyncServer));
_api.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(
_api.EthereumEcdsa,
_api.TxPool,
_api.BlockTree,
_api.ReceiptFinder,
_api.Enode,
_api.EngineSignerStore,
_api.KeyStore,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
return(Task.CompletedTask);
}
public NdmRequiredServices(
IConfigProvider configProvider,
IConfigManager configManager,
INdmConfig ndmConfig,
string baseDbPath,
IDbProvider rocksProvider,
IMongoProvider mongoProvider,
ILogManager logManager,
IBlockTree blockTree,
ITxPool transactionPool,
ISpecProvider specProvider,
IReceiptStorage receiptStorage,
IFilterStore filterStore,
IFilterManager filterManager,
IWallet wallet,
ITimestamper timestamper,
IEthereumEcdsa ecdsa,
IKeyStore keyStore,
IRpcModuleProvider rpcModuleProvider,
IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom,
IEnode enode,
INdmConsumerChannelManager ndmConsumerChannelManager,
INdmDataPublisher ndmDataPublisher,
IGrpcServer grpcServer,
IEthRequestService ethRequestService,
INdmNotifier notifier,
bool enableUnsecuredDevWallet,
IBlockProcessor blockProcessor,
IJsonRpcClientProxy?jsonRpcClientProxy,
IEthJsonRpcClientProxy?ethJsonRpcClientProxy,
IHttpClient httpClient,
IMonitoringService monitoringService,
IBloomStorage bloomStorage)
{
ConfigProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
ConfigManager = configManager ?? throw new ArgumentNullException(nameof(configManager));
NdmConfig = ndmConfig ?? throw new ArgumentNullException(nameof(ndmConfig));
BaseDbPath = baseDbPath ?? throw new ArgumentNullException(nameof(baseDbPath));
RocksProvider = rocksProvider ?? throw new ArgumentNullException(nameof(rocksProvider));
MongoProvider = mongoProvider ?? throw new ArgumentNullException(nameof(mongoProvider));
LogManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
BlockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
TransactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
SpecProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
ReceiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
FilterStore = filterStore ?? throw new ArgumentNullException(nameof(filterStore));
FilterManager = filterManager ?? throw new ArgumentNullException(nameof(filterManager));
Wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
Timestamper = timestamper ?? throw new ArgumentNullException(nameof(timestamper));
Ecdsa = ecdsa ?? throw new ArgumentNullException(nameof(ecdsa));
KeyStore = keyStore ?? throw new ArgumentNullException(nameof(keyStore));
RpcModuleProvider = rpcModuleProvider ?? throw new ArgumentNullException(nameof(rpcModuleProvider));
JsonSerializer = jsonSerializer ?? throw new ArgumentNullException(nameof(jsonSerializer));
CryptoRandom = cryptoRandom ?? throw new ArgumentNullException(nameof(cryptoRandom));
Enode = enode ?? throw new ArgumentNullException(nameof(enode));
NdmConsumerChannelManager = ndmConsumerChannelManager ?? throw new ArgumentNullException(nameof(ndmConsumerChannelManager));
NdmDataPublisher = ndmDataPublisher ?? throw new ArgumentNullException(nameof(ndmDataPublisher));
GrpcServer = grpcServer ?? throw new ArgumentNullException(nameof(grpcServer));
EthRequestService = ethRequestService ?? throw new ArgumentNullException(nameof(ethRequestService));
Notifier = notifier ?? throw new ArgumentNullException(nameof(notifier));
EnableUnsecuredDevWallet = enableUnsecuredDevWallet;
BlockProcessor = blockProcessor ?? throw new ArgumentNullException(nameof(blockProcessor));
HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
MonitoringService = monitoringService ?? throw new ArgumentNullException(nameof(monitoringService));
JsonRpcClientProxy = jsonRpcClientProxy;
EthJsonRpcClientProxy = ethJsonRpcClientProxy;
BloomStorage = bloomStorage;
}
public virtual async Task <INdmCapabilityConnector> InitAsync(
IConfigProvider configProvider,
IDbProvider dbProvider,
string baseDbPath,
IBlockTree blockTree,
ITxPool txPool,
ITxSender txSender,
ISpecProvider specProvider,
IReceiptFinder receiptFinder,
IWallet wallet,
IFilterStore filterStore,
IFilterManager filterManager,
ITimestamper timestamper,
IEthereumEcdsa ecdsa,
IRpcModuleProvider rpcModuleProvider,
IKeyStore keyStore,
IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom,
IEnode enode,
INdmConsumerChannelManager consumerChannelManager,
INdmDataPublisher dataPublisher,
IGrpcServer grpcServer,
INodeStatsManager nodeStatsManager,
IProtocolsManager protocolsManager,
IProtocolValidator protocolValidator,
IMessageSerializationService messageSerializationService,
bool enableUnsecuredDevWallet,
IWebSocketsManager webSocketsManager,
ILogManager logManager,
IBlockProcessor blockProcessor,
IJsonRpcClientProxy?jsonRpcClientProxy,
IEthJsonRpcClientProxy?ethJsonRpcClientProxy,
IHttpClient httpClient,
IMonitoringService monitoringService,
IBloomStorage bloomStorage)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
INdmConfig ndmConfig = configProvider.GetConfig <INdmConfig>();
if (!ndmConfig.Enabled)
{
// can we not even call it here? // can be step and use the subsystems
return(NullNdmCapabilityConnector.Instance);
}
(NdmConfig config, INdmServices services, INdmFaucet faucet, IEthRequestService ethRequestService, IAccountService accountService, IConsumerService consumerService, Address consumerAddress, Address providerAddress) = await PreInitAsync(
configProvider,
dbProvider,
baseDbPath,
blockTree,
txPool,
txSender,
specProvider,
receiptFinder,
wallet,
filterStore,
filterManager,
timestamper,
ecdsa,
rpcModuleProvider,
keyStore,
jsonSerializer,
cryptoRandom,
enode,
consumerChannelManager,
dataPublisher,
grpcServer,
enableUnsecuredDevWallet,
webSocketsManager,
logManager,
blockProcessor,
jsonRpcClientProxy,
ethJsonRpcClientProxy,
httpClient,
monitoringService,
bloomStorage);
NdmSubprotocolFactory subprotocolFactory = new NdmSubprotocolFactory(messageSerializationService, nodeStatsManager,
logManager, accountService, consumerService, consumerChannelManager, ecdsa, wallet, faucet,
enode.PublicKey, providerAddress, consumerAddress, config.VerifyP2PSignature);
ProtocolHandlerFactory protocolHandlerFactory = new ProtocolHandlerFactory(subprotocolFactory, protocolValidator,
ethRequestService, logManager);
NdmCapabilityConnector capabilityConnector = new NdmCapabilityConnector(
protocolsManager,
protocolHandlerFactory,
accountService,
logManager,
ndmConfig.ProviderAddress == null ? Address.Zero : new Address(ndmConfig.ProviderAddress));
return(capabilityConnector);
}
private async Task InitPeer()
{
if (_ctx.DbProvider == null)
{
throw new StepDependencyException(nameof(_ctx.DbProvider));
}
if (_ctx.BlockTree == null)
{
throw new StepDependencyException(nameof(_ctx.BlockTree));
}
if (_ctx.ReceiptStorage == null)
{
throw new StepDependencyException(nameof(_ctx.ReceiptStorage));
}
if (_ctx.BlockValidator == null)
{
throw new StepDependencyException(nameof(_ctx.BlockValidator));
}
if (_ctx.SyncPeerPool == null)
{
throw new StepDependencyException(nameof(_ctx.SyncPeerPool));
}
if (_ctx.Synchronizer == null)
{
throw new StepDependencyException(nameof(_ctx.Synchronizer));
}
if (_ctx.Enode == null)
{
throw new StepDependencyException(nameof(_ctx.Enode));
}
if (_ctx.NodeKey == null)
{
throw new StepDependencyException(nameof(_ctx.NodeKey));
}
if (_ctx.MainBlockProcessor == null)
{
throw new StepDependencyException(nameof(_ctx.MainBlockProcessor));
}
if (_ctx.NodeStatsManager == null)
{
throw new StepDependencyException(nameof(_ctx.NodeStatsManager));
}
if (_ctx.KeyStore == null)
{
throw new StepDependencyException(nameof(_ctx.KeyStore));
}
if (_ctx.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_ctx.RpcModuleProvider));
}
if (_ctx.Wallet == null)
{
throw new StepDependencyException(nameof(_ctx.Wallet));
}
if (_ctx.EthereumEcdsa == null)
{
throw new StepDependencyException(nameof(_ctx.EthereumEcdsa));
}
if (_ctx.SpecProvider == null)
{
throw new StepDependencyException(nameof(_ctx.SpecProvider));
}
if (_ctx.TxPool == null)
{
throw new StepDependencyException(nameof(_ctx.TxPool));
}
if (_ctx.EthereumJsonSerializer == null)
{
throw new StepDependencyException(nameof(_ctx.EthereumJsonSerializer));
}
/* rlpx */
EciesCipher eciesCipher = new EciesCipher(_ctx.CryptoRandom);
Eip8MessagePad eip8Pad = new Eip8MessagePad(_ctx.CryptoRandom);
_ctx._messageSerializationService.Register(new AuthEip8MessageSerializer(eip8Pad));
_ctx._messageSerializationService.Register(new AckEip8MessageSerializer(eip8Pad));
_ctx._messageSerializationService.Register(Assembly.GetAssembly(typeof(HelloMessageSerializer)));
_ctx._messageSerializationService.Register(new ReceiptsMessageSerializer(_ctx.SpecProvider));
HandshakeService encryptionHandshakeServiceA = new HandshakeService(_ctx._messageSerializationService, eciesCipher,
_ctx.CryptoRandom, new Ecdsa(), _ctx.NodeKey.Unprotect(), _ctx.LogManager);
_ctx._messageSerializationService.Register(Assembly.GetAssembly(typeof(HiMessageSerializer)));
IDiscoveryConfig discoveryConfig = _ctx.Config <IDiscoveryConfig>();
IInitConfig initConfig = _ctx.Config <IInitConfig>();
_ctx.SessionMonitor = new SessionMonitor(_networkConfig, _ctx.LogManager);
_ctx.RlpxPeer = new RlpxPeer(
_ctx._messageSerializationService,
_ctx.NodeKey.PublicKey,
_networkConfig.P2PPort,
encryptionHandshakeServiceA,
_ctx.LogManager,
_ctx.SessionMonitor);
await _ctx.RlpxPeer.Init();
_ctx.StaticNodesManager = new StaticNodesManager(initConfig.StaticNodesPath, _ctx.LogManager);
await _ctx.StaticNodesManager.InitAsync();
var dbName = "PeersDB";
IFullDb peersDb = initConfig.DiagnosticMode == DiagnosticMode.MemDb
? (IFullDb) new MemDb(dbName)
: new SimpleFilePublicKeyDb(dbName, PeersDbPath.GetApplicationResourcePath(initConfig.BaseDbPath), _ctx.LogManager);
NetworkStorage peerStorage = new NetworkStorage(peersDb, _ctx.LogManager);
ProtocolValidator protocolValidator = new ProtocolValidator(_ctx.NodeStatsManager, _ctx.BlockTree, _ctx.LogManager);
_ctx.ProtocolsManager = new ProtocolsManager(_ctx.SyncPeerPool, _ctx.SyncServer, _ctx.TxPool, _ctx.DiscoveryApp, _ctx._messageSerializationService, _ctx.RlpxPeer, _ctx.NodeStatsManager, protocolValidator, peerStorage, _ctx.SpecProvider, _ctx.LogManager);
if (!(_ctx.NdmInitializer is null))
{
if (_ctx.WebSocketsManager == null)
{
throw new StepDependencyException(nameof(_ctx.WebSocketsManager));
}
if (_ctx.GrpcServer == null)
{
throw new StepDependencyException(nameof(_ctx.GrpcServer));
}
if (_ctx.NdmDataPublisher == null)
{
throw new StepDependencyException(nameof(_ctx.NdmDataPublisher));
}
if (_ctx.NdmConsumerChannelManager == null)
{
throw new StepDependencyException(nameof(_ctx.NdmConsumerChannelManager));
}
if (_ctx.BloomStorage == null)
{
throw new StepDependencyException(nameof(_ctx.BloomStorage));
}
if (_ctx.ReceiptFinder == null)
{
throw new StepDependencyException(nameof(_ctx.ReceiptFinder));
}
if (_logger.IsInfo)
{
_logger.Info($"Initializing NDM...");
}
_ctx.HttpClient = new DefaultHttpClient(new HttpClient(), _ctx.EthereumJsonSerializer, _ctx.LogManager);
INdmConfig ndmConfig = _ctx.Config <INdmConfig>();
if (ndmConfig.ProxyEnabled)
{
_ctx.JsonRpcClientProxy = new JsonRpcClientProxy(_ctx.HttpClient, ndmConfig.JsonRpcUrlProxies,
_ctx.LogManager);
_ctx.EthJsonRpcClientProxy = new EthJsonRpcClientProxy(_ctx.JsonRpcClientProxy);
}
FilterStore filterStore = new FilterStore();
FilterManager filterManager = new FilterManager(filterStore, _ctx.MainBlockProcessor, _ctx.TxPool, _ctx.LogManager);
INdmCapabilityConnector capabilityConnector = await _ctx.NdmInitializer.InitAsync(
_ctx.ConfigProvider,
_ctx.DbProvider,
initConfig.BaseDbPath,
_ctx.BlockTree,
_ctx.TxPool,
_ctx.SpecProvider,
_ctx.ReceiptFinder,
_ctx.Wallet,
filterStore,
filterManager,
_ctx.Timestamper,
_ctx.EthereumEcdsa,
_ctx.RpcModuleProvider,
_ctx.KeyStore,
_ctx.EthereumJsonSerializer,
_ctx.CryptoRandom,
_ctx.Enode,
_ctx.NdmConsumerChannelManager,
_ctx.NdmDataPublisher,
_ctx.GrpcServer,
_ctx.NodeStatsManager,
_ctx.ProtocolsManager,
protocolValidator,
_ctx._messageSerializationService,
initConfig.EnableUnsecuredDevWallet,
_ctx.WebSocketsManager,
_ctx.LogManager,
_ctx.MainBlockProcessor,
_ctx.JsonRpcClientProxy,
_ctx.EthJsonRpcClientProxy,
_ctx.HttpClient,
_ctx.MonitoringService,
_ctx.BloomStorage);
capabilityConnector.Init();
if (_logger.IsInfo)
{
_logger.Info($"NDM initialized.");
}
}
PeerLoader peerLoader = new PeerLoader(_networkConfig, discoveryConfig, _ctx.NodeStatsManager, peerStorage, _ctx.LogManager);
_ctx.PeerManager = new PeerManager(_ctx.RlpxPeer, _ctx.DiscoveryApp, _ctx.NodeStatsManager, peerStorage, peerLoader, _networkConfig, _ctx.LogManager, _ctx.StaticNodesManager);
_ctx.PeerManager.Init();
}
public async Task Init()
{
AddDecoders();
ILogManager logManager = _api.LogManager;
ILogger logger = logManager.GetClassLogger();
bool disableSendingDepositTransaction = HasEnabledVariable("SENDING_DEPOSIT_TRANSACTION_DISABLED");
bool instantDepositVerificationEnabled = HasEnabledVariable("INSTANT_DEPOSIT_VERIFICATION_ENABLED");
bool backgroundServicesDisabled = HasEnabledVariable("BACKGROUND_SERVICES_DISABLED");
if (disableSendingDepositTransaction)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM sending deposit transaction is disabled ***");
}
}
if (instantDepositVerificationEnabled)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM instant deposit verification is enabled ***");
}
}
if (backgroundServicesDisabled)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM background services are disabled ***");
}
}
INdmConfig ndmConfig = _api.NdmConfig;
string configId = ndmConfig.Id;
IDbConfig dbConfig = _api.ConfigProvider.GetConfig <IDbConfig>();
Address contractAddress = string.IsNullOrWhiteSpace(ndmConfig.ContractAddress)
? Address.Zero
: new Address(ndmConfig.ContractAddress);
DepositDetailsDecoder depositDetailsRlpDecoder = new DepositDetailsDecoder();
DepositApprovalDecoder depositApprovalRlpDecoder = new DepositApprovalDecoder();
DataDeliveryReceiptDetailsDecoder receiptRlpDecoder = new DataDeliveryReceiptDetailsDecoder();
ConsumerSessionDecoder sessionRlpDecoder = new ConsumerSessionDecoder();
ReceiptRequestValidator receiptRequestValidator = new ReceiptRequestValidator(logManager);
IDepositDetailsRepository depositRepository;
IConsumerDepositApprovalRepository depositApprovalRepository;
IProviderRepository providerRepository;
IReceiptRepository receiptRepository;
IConsumerSessionRepository sessionRepository;
IDepositUnitsCalculator depositUnitsCalculator;
switch (ndmConfig.Persistence?.ToLowerInvariant())
{
case "mongo":
IMongoDatabase?database = _api.MongoProvider.GetDatabase();
if (database == null)
{
throw new ApplicationException("Failed to initialize Mongo DB.");
}
sessionRepository = new ConsumerSessionMongoRepository(database);
depositUnitsCalculator = new DepositUnitsCalculator(sessionRepository, _api.Timestamper);
depositRepository = new DepositDetailsMongoRepository(database, depositUnitsCalculator);
depositApprovalRepository = new ConsumerDepositApprovalMongoRepository(database);
providerRepository = new ProviderMongoRepository(database);
receiptRepository = new ReceiptMongoRepository(database, "consumerReceipts");
break;
case "memory":
if (logger.IsWarn)
{
logger.Warn("*** NDM is using in memory database ***");
}
DepositsInMemoryDb depositsDatabase = new DepositsInMemoryDb();
sessionRepository = new ConsumerSessionInMemoryRepository();
depositUnitsCalculator = new DepositUnitsCalculator(sessionRepository, _api.Timestamper);
depositRepository = new DepositDetailsInMemoryRepository(depositsDatabase, depositUnitsCalculator);
depositApprovalRepository = new ConsumerDepositApprovalInMemoryRepository();
providerRepository = new ProviderInMemoryRepository(depositsDatabase);
receiptRepository = new ReceiptInMemoryRepository();
break;
default:
var dbInitializer = new ConsumerNdmDbInitializer(_api.DbProvider, ndmConfig, _api.RocksDbFactory, _api.MemDbFactory);
await dbInitializer.InitAsync();
sessionRepository = new ConsumerSessionRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.ConsumerSessions),
sessionRlpDecoder);
depositUnitsCalculator = new DepositUnitsCalculator(sessionRepository, _api.Timestamper);
depositRepository = new DepositDetailsRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.Deposits),
depositDetailsRlpDecoder, depositUnitsCalculator);
depositApprovalRepository = new ConsumerDepositApprovalRocksRepository(
_api.Db <IDb>(ConsumerNdmDbNames.ConsumerDepositApprovals), depositApprovalRlpDecoder);
providerRepository = new ProviderRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.Deposits),
depositDetailsRlpDecoder);
receiptRepository = new ReceiptRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.ConsumerReceipts),
receiptRlpDecoder);
break;
}
uint requiredBlockConfirmations = ndmConfig.BlockConfirmations;
IAbiEncoder abiEncoder = _api.AbiEncoder;
INdmBlockchainBridge blockchainBridge = _api.BlockchainBridge;
IBlockProcessor blockProcessor = _api.MainBlockProcessor;
IConfigManager configManager = _api.ConfigManager;
Address consumerAddress = _api.ConsumerAddress;
ICryptoRandom cryptoRandom = _api.CryptoRandom;
IDepositService depositService = _api.DepositService;
gasPriceService = _api.GasPriceService;
IEthereumEcdsa ecdsa = _api.EthereumEcdsa;
ethRequestService = _api.EthRequestService;
jsonRpcNdmConsumerChannel = _api.JsonRpcNdmConsumerChannel;
INdmNotifier ndmNotifier = _api.NdmNotifier;
PublicKey nodePublicKey = _api.Enode.PublicKey;
timestamper = _api.Timestamper;
IWallet wallet = _api.Wallet;
IHttpClient httpClient = _api.HttpClient;
IJsonRpcClientProxy? jsonRpcClientProxy = _api.JsonRpcClientProxy;
IEthJsonRpcClientProxy?ethJsonRpcClientProxy = _api.EthJsonRpcClientProxy;
TransactionService transactionService = _api.TransactionService;
IMonitoringService monitoringService = _api.MonitoringService;
IWebSocketsModule ndmWebSocketsModule = _api.WebSocketsManager.GetModule("ndm");
monitoringService?.RegisterMetrics(typeof(Metrics));
DataRequestFactory dataRequestFactory = new DataRequestFactory(wallet, nodePublicKey);
TransactionVerifier transactionVerifier = new TransactionVerifier(blockchainBridge, requiredBlockConfirmations);
DepositProvider depositProvider = new DepositProvider(depositRepository, depositUnitsCalculator, logManager);
KycVerifier kycVerifier = new KycVerifier(depositApprovalRepository, logManager);
ConsumerNotifier consumerNotifier = new ConsumerNotifier(ndmNotifier);
DataAssetService dataAssetService = new DataAssetService(providerRepository, consumerNotifier, logManager);
ProviderService providerService = new ProviderService(providerRepository, consumerNotifier, logManager);
DataRequestService dataRequestService = new DataRequestService(dataRequestFactory, depositProvider, kycVerifier, wallet,
providerService, timestamper, sessionRepository, consumerNotifier, logManager);
SessionService sessionService = new SessionService(providerService, depositProvider, dataAssetService,
sessionRepository, timestamper, consumerNotifier, logManager);
DataConsumerService dataConsumerService = new DataConsumerService(depositProvider, sessionService,
consumerNotifier, timestamper, sessionRepository, logManager);
DataStreamService dataStreamService = new DataStreamService(dataAssetService, depositProvider,
providerService, sessionService, wallet, consumerNotifier, sessionRepository, logManager);
DepositApprovalService depositApprovalService = new DepositApprovalService(dataAssetService, providerService,
depositApprovalRepository, timestamper, consumerNotifier, logManager);
DepositConfirmationService depositConfirmationService = new DepositConfirmationService(blockchainBridge, consumerNotifier,
depositRepository, depositService, logManager, requiredBlockConfirmations);
IDepositManager depositManager = new DepositManager(depositService, depositUnitsCalculator,
dataAssetService, kycVerifier, providerService, abiEncoder, cryptoRandom, wallet, gasPriceService,
depositRepository, timestamper, logManager, requiredBlockConfirmations,
disableSendingDepositTransaction);
if (instantDepositVerificationEnabled)
{
depositManager = new InstantDepositManager(depositManager, depositRepository, timestamper, logManager,
requiredBlockConfirmations);
}
depositReportService = new DepositReportService(depositRepository, depositUnitsCalculator, receiptRepository, sessionRepository,
timestamper);
ReceiptService receiptService = new ReceiptService(depositProvider, providerService, receiptRequestValidator,
sessionService, timestamper, receiptRepository, sessionRepository, abiEncoder, wallet, ecdsa,
nodePublicKey, logManager);
RefundService refundService = new RefundService(blockchainBridge, abiEncoder, depositRepository,
contractAddress, logManager, wallet);
RefundClaimant refundClaimant = new RefundClaimant(refundService, blockchainBridge, depositRepository,
transactionVerifier, gasPriceService, timestamper, logManager);
_api.AccountService = new AccountService(configManager, dataStreamService, providerService,
sessionService, consumerNotifier, wallet, configId, consumerAddress, logManager);
_api.NdmAccountUpdater = new NdmAccountUpdater(ndmWebSocketsModule, consumerAddress, _api.MainBlockProcessor, _api.ChainHeadStateProvider);
ProxyService proxyService = new ProxyService(jsonRpcClientProxy, configManager, configId, logManager);
_api.ConsumerService = new ConsumerService(_api.AccountService, dataAssetService, dataRequestService,
dataConsumerService, dataStreamService, depositManager, depositApprovalService, providerService,
receiptService, refundService, sessionService, proxyService);
ethPriceService = new EthPriceService(httpClient, timestamper, logManager);
daiPriceService = new DaiPriceService(httpClient, timestamper, logManager);
consumerTransactionsService = new ConsumerTransactionsService(transactionService, depositRepository,
timestamper, logManager);
gasLimitsService = new ConsumerGasLimitsService(depositService, refundService);
if (!backgroundServicesDisabled)
{
bool useDepositTimer = ndmConfig.ProxyEnabled;
ConsumerServicesBackgroundProcessor consumerServicesBackgroundProcessor =
new ConsumerServicesBackgroundProcessor(
_api.AccountService,
refundClaimant,
depositConfirmationService,
ethPriceService,
daiPriceService,
_api.GasPriceService,
_api.MainBlockProcessor,
depositRepository,
consumerNotifier,
logManager,
useDepositTimer,
ethJsonRpcClientProxy);
consumerServicesBackgroundProcessor.Init();
}
}
