public void Initialize()
{
NetworkNodeDecoder.Init();
var privateKey = new PrivateKey(TestPrivateKeyHex);
_publicKey = privateKey.PublicKey;
var logManager = NullLogManager.Instance;
IDiscoveryConfig discoveryConfig = new DiscoveryConfig();
discoveryConfig.PongTimeout = 100;
IStatsConfig statsConfig = new StatsConfig();
_messageSender = Substitute.For <IMessageSender>();
var calculator = new NodeDistanceCalculator(discoveryConfig);
_nodeTable = new NodeTable(calculator, discoveryConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
_timestamp = new Timestamp();
var evictionManager = new EvictionManager(_nodeTable, logManager);
var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeTable, new DiscoveryMessageFactory(_timestamp), evictionManager, new NodeStatsManager(statsConfig, logManager), discoveryConfig, logManager);
_nodes = new[] { new Node("192.168.1.18", 1), new Node("192.168.1.19", 2) };
IFullDb nodeDb = new SimpleFilePublicKeyDb("test_db", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(nodeDb, logManager), discoveryConfig, logManager);
_discoveryManager.MessageSender = _messageSender;
}
public void Initialize()
{
NetworkNodeDecoder.Init();
var privateKey = new PrivateKey(TestPrivateKeyHex);
_publicKey = privateKey.PublicKey;
var logManager = LimboLogs.Instance;
IDiscoveryConfig discoveryConfig = new DiscoveryConfig();
discoveryConfig.PongTimeout = 100;
_messageSender = Substitute.For <IMessageSender>();
var calculator = new NodeDistanceCalculator(discoveryConfig);
_networkConfig.ExternalIp = "99.10.10.66";
_networkConfig.LocalIp = "10.0.0.5";
_nodeTable = new NodeTable(calculator, discoveryConfig, _networkConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
_timestamper = Timestamper.Default;
_ipResolver = new IPResolver(_networkConfig, logManager);
var evictionManager = new EvictionManager(_nodeTable, logManager);
var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeTable, new DiscoveryMessageFactory(_timestamper), evictionManager, new NodeStatsManager(logManager), discoveryConfig, logManager);
_nodes = new[] { new Node("192.168.1.18", 1), new Node("192.168.1.19", 2) };
IFullDb nodeDb = new SimpleFilePublicKeyDb("Test", "test_db", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(nodeDb, logManager), discoveryConfig, logManager, _ipResolver);
_discoveryManager.MessageSender = _messageSender;
}
public void Initialize()
{
NetworkNodeDecoder.Init();
PrivateKey privateKey = new(TestPrivateKeyHex);
_publicKey = privateKey.PublicKey;
LimboLogs?logManager = LimboLogs.Instance;
IDiscoveryConfig discoveryConfig = new DiscoveryConfig();
discoveryConfig.PongTimeout = 100;
_msgSender = Substitute.For <IMsgSender>();
NodeDistanceCalculator calculator = new(discoveryConfig);
_networkConfig.ExternalIp = "99.10.10.66";
_networkConfig.LocalIp = "10.0.0.5";
_nodeTable = new NodeTable(calculator, discoveryConfig, _networkConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
EvictionManager evictionManager = new(_nodeTable, logManager);
ITimerFactory timerFactory = Substitute.For <ITimerFactory>();
NodeLifecycleManagerFactory lifecycleFactory = new(_nodeTable, evictionManager,
new NodeStatsManager(timerFactory, logManager), new NodeRecord(), discoveryConfig, Timestamper.Default, logManager);
_nodes = new[] { new Node(TestItem.PublicKeyA, "192.168.1.18", 1), new Node(TestItem.PublicKeyB, "192.168.1.19", 2) };
IFullDb nodeDb = new SimpleFilePublicKeyDb("Test", "test_db", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(nodeDb, logManager), discoveryConfig, logManager);
_discoveryManager.MsgSender = _msgSender;
}
public void Initialize()
{
NetworkNodeDecoder.Init();
SetupNodeIds();
var logManager = NullLogManager.Instance;
//setting config to store 3 nodes in a bucket and for table to have one bucket//setting config to store 3 nodes in a bucket and for table to have one bucket
_configurationProvider = new ConfigProvider();
IDiscoveryConfig discoveryConfig = _configurationProvider.GetConfig <IDiscoveryConfig>();
discoveryConfig.PongTimeout = 50;
discoveryConfig.BucketSize = 3;
discoveryConfig.BucketsCount = 1;
IStatsConfig statsConfig = _configurationProvider.GetConfig <IStatsConfig>();
var calculator = new NodeDistanceCalculator(discoveryConfig);
_nodeTable = new NodeTable(calculator, discoveryConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
_timestamp = new Timestamp();
var evictionManager = new EvictionManager(_nodeTable, logManager);
var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeTable, new DiscoveryMessageFactory(_timestamp), evictionManager, new NodeStatsManager(statsConfig, logManager), discoveryConfig, logManager);
_udpClient = Substitute.For <IMessageSender>();
var discoveryDb = new SimpleFilePublicKeyDb("test", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(discoveryDb, logManager), discoveryConfig, logManager);
_discoveryManager.MessageSender = _udpClient;
}
public void SetUp()
{
NetworkNodeDecoder.Init();
ILogManager logManager = LimboLogs.Instance;
ConfigProvider configSource = new ConfigProvider();
_tempDir = TempPath.GetTempDirectory();
var db = new SimpleFilePublicKeyDb("Test", _tempDir.Path, logManager);
_storage = new NetworkStorage(db, logManager);
}
public void SetUp()
{
NetworkNodeDecoder.Init();
NullLogManager logManager = NullLogManager.Instance;
ConfigProvider configSource = new ConfigProvider();
_tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
_statsConfig = configSource.GetConfig <IStatsConfig>();
var db = new SimpleFilePublicKeyDb("Test", _tempDir, logManager);
_storage = new NetworkStorage(db, logManager);
}
public void Initialize()
{
_discoveryManagerMock = Substitute.For <IDiscoveryManager>();
_discoveryConfigMock = Substitute.For <IDiscoveryConfig>();
NetworkNodeDecoder.Init();
SetupNodeIds();
var logManager = LimboLogs.Instance;
_loggerMock = Substitute.For <ILogger>();
//setting config to store 3 nodes in a bucket and for table to have one bucket//setting config to store 3 nodes in a bucket and for table to have one bucket
_configurationProvider = new ConfigProvider();
_networkConfig.ExternalIp = "99.10.10.66";
_networkConfig.LocalIp = "10.0.0.5";
IDiscoveryConfig discoveryConfig = _configurationProvider.GetConfig <IDiscoveryConfig>();
discoveryConfig.PongTimeout = 50;
discoveryConfig.BucketSize = 3;
discoveryConfig.BucketsCount = 1;
_ipResolverMock = Substitute.For <IIPResolver>();
IStatsConfig statsConfig = _configurationProvider.GetConfig <IStatsConfig>();
var calculator = new NodeDistanceCalculator(discoveryConfig);
_nodeTable = new NodeTable(calculator, discoveryConfig, _networkConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
_nodeStatsMock = Substitute.For <INodeStats>();
_timestamper = Timestamper.Default;
var evictionManager = new EvictionManager(_nodeTable, logManager);
_evictionManagerMock = Substitute.For <IEvictionManager>();
var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeTable, new DiscoveryMessageFactory(_timestamper), evictionManager, new NodeStatsManager(statsConfig, logManager), discoveryConfig, logManager);
_udpClient = Substitute.For <IMessageSender>();
var discoveryDb = new SimpleFilePublicKeyDb("Test", "test", logManager);
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage(discoveryDb, logManager), discoveryConfig, logManager, _ipResolverMock);
_discoveryManager.MessageSender = _udpClient;
_discoveryManagerMock = Substitute.For <IDiscoveryManager>();
}
public void Save_and_load()
{
File.Delete(Path.Combine(Path.GetTempPath(), SimpleFilePublicKeyDb.DbFileName));
SimpleFilePublicKeyDb filePublicKeyDb = new SimpleFilePublicKeyDb("Test", Path.GetTempPath(), LimboLogs.Instance);
filePublicKeyDb[TestItem.PublicKeyA.Bytes] = new byte[] { 1, 2, 3 };
filePublicKeyDb[TestItem.PublicKeyB.Bytes] = new byte[] { 4, 5, 6 };
filePublicKeyDb[TestItem.PublicKeyC.Bytes] = new byte[] { 1, 2, 3 };
filePublicKeyDb.CommitBatch();
SimpleFilePublicKeyDb copy = new SimpleFilePublicKeyDb("Test", Path.GetTempPath(), LimboLogs.Instance);
Assert.AreEqual(3, copy.Keys.Count);
}
public void Save_and_load()
{
using TempPath tempPath = TempPath.GetTempFile(SimpleFilePublicKeyDb.DbFileName);
tempPath.Dispose();
SimpleFilePublicKeyDb filePublicKeyDb = new SimpleFilePublicKeyDb("Test", Path.GetTempPath(), LimboLogs.Instance);
using (filePublicKeyDb.StartBatch())
{
filePublicKeyDb[TestItem.PublicKeyA.Bytes] = new byte[] { 1, 2, 3 };
filePublicKeyDb[TestItem.PublicKeyB.Bytes] = new byte[] { 4, 5, 6 };
filePublicKeyDb[TestItem.PublicKeyC.Bytes] = new byte[] { 1, 2, 3 };
}
SimpleFilePublicKeyDb copy = new SimpleFilePublicKeyDb("Test", Path.GetTempPath(), LimboLogs.Instance);
Assert.AreEqual(3, copy.Keys.Count);
}
private async Task InitPeer()
{
/* rlpx */
var eciesCipher = new EciesCipher(_cryptoRandom);
var eip8Pad = new Eip8MessagePad(_cryptoRandom);
_messageSerializationService.Register(new AuthEip8MessageSerializer(eip8Pad));
_messageSerializationService.Register(new AckEip8MessageSerializer(eip8Pad));
_messageSerializationService.Register(Assembly.GetAssembly(typeof(HelloMessageSerializer)));
var encryptionHandshakeServiceA = new EncryptionHandshakeService(_messageSerializationService, eciesCipher,
_cryptoRandom, new Ecdsa(), _nodeKey, _logManager);
var networkConfig = _configProvider.GetConfig <INetworkConfig>();
var discoveryConfig = _configProvider.GetConfig <IDiscoveryConfig>();
_sessionMonitor = new SessionMonitor(networkConfig, _logManager);
_rlpxPeer = new RlpxPeer(
_nodeKey.PublicKey,
_initConfig.P2PPort,
encryptionHandshakeServiceA,
_logManager,
_sessionMonitor);
await _rlpxPeer.Init();
_staticNodesManager = new StaticNodesManager(_initConfig.StaticNodesPath, _logManager);
await _staticNodesManager.InitAsync();
var peersDb = new SimpleFilePublicKeyDb(PeersDbPath, _logManager);
var peerStorage = new NetworkStorage(peersDb, _logManager);
ProtocolValidator protocolValidator = new ProtocolValidator(_nodeStatsManager, _blockTree, _logManager);
_protocolsManager = new ProtocolsManager(_syncPeerPool, _syncServer, _txPool, _discoveryApp, _messageSerializationService, _rlpxPeer, _nodeStatsManager, protocolValidator, peerStorage, _perfService, _logManager);
PeerLoader peerLoader = new PeerLoader(networkConfig, discoveryConfig, _nodeStatsManager, peerStorage, _logManager);
_peerManager = new PeerManager(_rlpxPeer, _discoveryApp, _nodeStatsManager, peerStorage, peerLoader, networkConfig, _logManager, _staticNodesManager);
_peerManager.Init();
}
private void InitDiscovery()
{
if (_ctx.NodeStatsManager == null)
{
throw new StepDependencyException(nameof(_ctx.NodeStatsManager));
}
if (_ctx.Timestamper == null)
{
throw new StepDependencyException(nameof(_ctx.Timestamper));
}
if (_ctx.NodeKey == null)
{
throw new StepDependencyException(nameof(_ctx.NodeKey));
}
if (_ctx.CryptoRandom == null)
{
throw new StepDependencyException(nameof(_ctx.CryptoRandom));
}
if (!_ctx.Config <IInitConfig>().DiscoveryEnabled)
{
_ctx.DiscoveryApp = new NullDiscoveryApp();
return;
}
IDiscoveryConfig discoveryConfig = _ctx.Config <IDiscoveryConfig>();
SameKeyGenerator privateKeyProvider = new SameKeyGenerator(_ctx.NodeKey.Unprotect());
DiscoveryMessageFactory discoveryMessageFactory = new DiscoveryMessageFactory(_ctx.Timestamper);
NodeIdResolver nodeIdResolver = new NodeIdResolver(_ctx.EthereumEcdsa);
IPResolver ipResolver = new IPResolver(_networkConfig, _ctx.LogManager);
IDiscoveryMsgSerializersProvider msgSerializersProvider = new DiscoveryMsgSerializersProvider(
_ctx._messageSerializationService,
_ctx.EthereumEcdsa,
privateKeyProvider,
discoveryMessageFactory,
nodeIdResolver);
msgSerializersProvider.RegisterDiscoverySerializers();
NodeDistanceCalculator nodeDistanceCalculator = new NodeDistanceCalculator(discoveryConfig);
NodeTable nodeTable = new NodeTable(nodeDistanceCalculator, discoveryConfig, _networkConfig, _ctx.LogManager);
EvictionManager evictionManager = new EvictionManager(nodeTable, _ctx.LogManager);
NodeLifecycleManagerFactory nodeLifeCycleFactory = new NodeLifecycleManagerFactory(
nodeTable,
discoveryMessageFactory,
evictionManager,
_ctx.NodeStatsManager,
discoveryConfig,
_ctx.LogManager);
SimpleFilePublicKeyDb discoveryDb = new SimpleFilePublicKeyDb("DiscoveryDB", DiscoveryNodesDbPath.GetApplicationResourcePath(_ctx.Config <IInitConfig>().BaseDbPath), _ctx.LogManager);
NetworkStorage discoveryStorage = new NetworkStorage(
discoveryDb,
_ctx.LogManager);
DiscoveryManager discoveryManager = new DiscoveryManager(
nodeLifeCycleFactory,
nodeTable,
discoveryStorage,
discoveryConfig,
_ctx.LogManager,
ipResolver
);
NodesLocator nodesLocator = new NodesLocator(
nodeTable,
discoveryManager,
discoveryConfig,
_ctx.LogManager);
_ctx.DiscoveryApp = new DiscoveryApp(
nodesLocator,
discoveryManager,
nodeTable,
_ctx._messageSerializationService,
_ctx.CryptoRandom,
discoveryStorage,
_networkConfig,
discoveryConfig,
_ctx.Timestamper,
_ctx.LogManager);
_ctx.DiscoveryApp.Initialize(_ctx.NodeKey.PublicKey);
}
private async Task InitPeer()
{
/* rlpx */
var eciesCipher = new EciesCipher(_cryptoRandom);
var eip8Pad = new Eip8MessagePad(_cryptoRandom);
_messageSerializationService.Register(new AuthEip8MessageSerializer(eip8Pad));
_messageSerializationService.Register(new AckEip8MessageSerializer(eip8Pad));
_messageSerializationService.Register(Assembly.GetAssembly(typeof(HelloMessageSerializer)));
var encryptionHandshakeServiceA = new EncryptionHandshakeService(_messageSerializationService, eciesCipher,
_cryptoRandom, new Ecdsa(), _nodeKey, _logManager);
_messageSerializationService.Register(Assembly.GetAssembly(typeof(HiMessageSerializer)));
var networkConfig = _configProvider.GetConfig <INetworkConfig>();
var discoveryConfig = _configProvider.GetConfig <IDiscoveryConfig>();
_sessionMonitor = new SessionMonitor(networkConfig, _logManager);
_rlpxPeer = new RlpxPeer(
_nodeKey.PublicKey,
_initConfig.P2PPort,
encryptionHandshakeServiceA,
_logManager,
_sessionMonitor);
await _rlpxPeer.Init();
_staticNodesManager = new StaticNodesManager(_initConfig.StaticNodesPath, _logManager);
await _staticNodesManager.InitAsync();
var peersDb = new SimpleFilePublicKeyDb(Path.Combine(_initConfig.BaseDbPath, PeersDbPath), _logManager);
var peerStorage = new NetworkStorage(peersDb, _logManager);
ProtocolValidator protocolValidator = new ProtocolValidator(_nodeStatsManager, _blockTree, _logManager);
_protocolsManager = new ProtocolsManager(_syncPeerPool, _syncServer, _txPool, _discoveryApp, _messageSerializationService, _rlpxPeer, _nodeStatsManager, protocolValidator, peerStorage, _perfService, _logManager);
if (!(_ndmInitializer is null))
{
if (_logger.IsInfo)
{
_logger.Info($"Initializing NDM...");
}
var capabilityConnector = await _ndmInitializer.InitAsync(_configProvider, _dbProvider,
_initConfig.BaseDbPath, _blockProcessor, _blockTree, _txPool, _txPoolInfoProvider, _specProvider,
_receiptStorage, _wallet, _timestamp, _ethereumEcdsa, _rpcModuleProvider, _keyStore, _jsonSerializer,
_cryptoRandom, _enode, _ndmConsumerChannelManager, _ndmDataPublisher, _grpcService,
_nodeStatsManager, _protocolsManager, protocolValidator, _messageSerializationService,
_initConfig.EnableUnsecuredDevWallet, _logManager);
capabilityConnector.Init();
if (_logger.IsInfo)
{
_logger.Info($"NDM initialized.");
}
}
PeerLoader peerLoader = new PeerLoader(networkConfig, discoveryConfig, _nodeStatsManager, peerStorage, _logManager);
_peerManager = new PeerManager(_rlpxPeer, _discoveryApp, _nodeStatsManager, peerStorage, peerLoader, networkConfig, _logManager, _staticNodesManager);
_peerManager.Init();
}
private void InitDiscovery()
{
if (!_initConfig.DiscoveryEnabled)
{
_discoveryApp = new NullDiscoveryApp();
return;
}
IDiscoveryConfig discoveryConfig = _configProvider.GetConfig <IDiscoveryConfig>();
discoveryConfig.MasterPort = _initConfig.DiscoveryPort;
var privateKeyProvider = new SameKeyGenerator(_nodeKey);
var discoveryMessageFactory = new DiscoveryMessageFactory(_timestamp);
var nodeIdResolver = new NodeIdResolver(_ethereumEcdsa);
IDiscoveryMsgSerializersProvider msgSerializersProvider = new DiscoveryMsgSerializersProvider(
_messageSerializationService,
_ethereumEcdsa,
privateKeyProvider,
discoveryMessageFactory,
nodeIdResolver);
msgSerializersProvider.RegisterDiscoverySerializers();
var nodeDistanceCalculator = new NodeDistanceCalculator(discoveryConfig);
var nodeTable = new NodeTable(nodeDistanceCalculator,
discoveryConfig,
_logManager);
var evictionManager = new EvictionManager(
nodeTable,
_logManager);
var nodeLifeCycleFactory = new NodeLifecycleManagerFactory(
nodeTable,
discoveryMessageFactory,
evictionManager,
_nodeStatsManager,
discoveryConfig,
_logManager);
var discoveryDb = new SimpleFilePublicKeyDb(Path.Combine(_initConfig.BaseDbPath, DiscoveryNodesDbPath), _logManager);
var discoveryStorage = new NetworkStorage(
discoveryDb,
_logManager);
var discoveryManager = new DiscoveryManager(
nodeLifeCycleFactory,
nodeTable,
discoveryStorage,
discoveryConfig,
_logManager);
var nodesLocator = new NodesLocator(
nodeTable,
discoveryManager,
discoveryConfig,
_logManager);
_discoveryApp = new DiscoveryApp(
nodesLocator,
discoveryManager,
nodeTable,
_messageSerializationService,
_cryptoRandom,
discoveryStorage,
discoveryConfig,
_timestamp,
_logManager, _perfService);
_discoveryApp.Initialize(_nodeKey.PublicKey);
}
private async Task InitPeer()
{
if (_context.DbProvider == null)
{
throw new StepDependencyException(nameof(_context.DbProvider));
}
if (_context.BlockTree == null)
{
throw new StepDependencyException(nameof(_context.BlockTree));
}
if (_context.ReceiptStorage == null)
{
throw new StepDependencyException(nameof(_context.ReceiptStorage));
}
if (_context.BlockValidator == null)
{
throw new StepDependencyException(nameof(_context.BlockValidator));
}
if (_context.SyncPeerPool == null)
{
throw new StepDependencyException(nameof(_context.SyncPeerPool));
}
if (_context.Synchronizer == null)
{
throw new StepDependencyException(nameof(_context.Synchronizer));
}
if (_context.Enode == null)
{
throw new StepDependencyException(nameof(_context.Enode));
}
if (_context.NodeKey == null)
{
throw new StepDependencyException(nameof(_context.NodeKey));
}
if (_context.MainBlockProcessor == null)
{
throw new StepDependencyException(nameof(_context.MainBlockProcessor));
}
if (_context.NodeStatsManager == null)
{
throw new StepDependencyException(nameof(_context.NodeStatsManager));
}
if (_context.KeyStore == null)
{
throw new StepDependencyException(nameof(_context.KeyStore));
}
if (_context.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_context.RpcModuleProvider));
}
if (_context.Wallet == null)
{
throw new StepDependencyException(nameof(_context.Wallet));
}
if (_context.EthereumEcdsa == null)
{
throw new StepDependencyException(nameof(_context.EthereumEcdsa));
}
if (_context.SpecProvider == null)
{
throw new StepDependencyException(nameof(_context.SpecProvider));
}
if (_context.TxPool == null)
{
throw new StepDependencyException(nameof(_context.TxPool));
}
if (_context.EthereumJsonSerializer == null)
{
throw new StepDependencyException(nameof(_context.EthereumJsonSerializer));
}
/* rlpx */
EciesCipher eciesCipher = new EciesCipher(_context.CryptoRandom);
Eip8MessagePad eip8Pad = new Eip8MessagePad(_context.CryptoRandom);
_context._messageSerializationService.Register(new AuthEip8MessageSerializer(eip8Pad));
_context._messageSerializationService.Register(new AckEip8MessageSerializer(eip8Pad));
_context._messageSerializationService.Register(Assembly.GetAssembly(typeof(HelloMessageSerializer)));
_context._messageSerializationService.Register(new ReceiptsMessageSerializer(_context.SpecProvider));
HandshakeService encryptionHandshakeServiceA = new HandshakeService(_context._messageSerializationService, eciesCipher,
_context.CryptoRandom, new Ecdsa(), _context.NodeKey, _context.LogManager);
_context._messageSerializationService.Register(Assembly.GetAssembly(typeof(HiMessageSerializer)));
IDiscoveryConfig discoveryConfig = _context.Config <IDiscoveryConfig>();
IInitConfig initConfig = _context.Config <IInitConfig>();
_context.SessionMonitor = new SessionMonitor(_networkConfig, _context.LogManager);
_context.RlpxPeer = new RlpxPeer(
_context._messageSerializationService,
_context.NodeKey.PublicKey,
_networkConfig.P2PPort,
encryptionHandshakeServiceA,
_context.LogManager,
_context.SessionMonitor);
await _context.RlpxPeer.Init();
_context.StaticNodesManager = new StaticNodesManager(initConfig.StaticNodesPath, _context.LogManager);
await _context.StaticNodesManager.InitAsync();
SimpleFilePublicKeyDb peersDb = new SimpleFilePublicKeyDb("PeersDB", PeersDbPath.GetApplicationResourcePath(initConfig.BaseDbPath), _context.LogManager);
NetworkStorage peerStorage = new NetworkStorage(peersDb, _context.LogManager);
ProtocolValidator protocolValidator = new ProtocolValidator(_context.NodeStatsManager, _context.BlockTree, _context.LogManager);
_context.ProtocolsManager = new ProtocolsManager(_context.SyncPeerPool, _context.SyncServer, _context.TxPool, _context.DiscoveryApp, _context._messageSerializationService, _context.RlpxPeer, _context.NodeStatsManager, protocolValidator, peerStorage, _context.LogManager);
if (!(_context.NdmInitializer is null))
{
if (_context.WebSocketsManager == null)
{
throw new StepDependencyException(nameof(_context.WebSocketsManager));
}
if (_context.GrpcServer == null)
{
throw new StepDependencyException(nameof(_context.GrpcServer));
}
if (_context.NdmDataPublisher == null)
{
throw new StepDependencyException(nameof(_context.NdmDataPublisher));
}
if (_context.NdmConsumerChannelManager == null)
{
throw new StepDependencyException(nameof(_context.NdmConsumerChannelManager));
}
if (_context.BloomStorage == null)
{
throw new StepDependencyException(nameof(_context.BloomStorage));
}
if (_logger.IsInfo)
{
_logger.Info($"Initializing NDM...");
}
_context.HttpClient = new DefaultHttpClient(new HttpClient(), _context.EthereumJsonSerializer, _context.LogManager);
INdmConfig ndmConfig = _context.Config <INdmConfig>();
if (ndmConfig.ProxyEnabled)
{
_context.JsonRpcClientProxy = new JsonRpcClientProxy(_context.HttpClient, ndmConfig.JsonRpcUrlProxies,
_context.LogManager);
_context.EthJsonRpcClientProxy = new EthJsonRpcClientProxy(_context.JsonRpcClientProxy);
}
FilterStore filterStore = new FilterStore();
FilterManager filterManager = new FilterManager(filterStore, _context.MainBlockProcessor, _context.TxPool, _context.LogManager);
INdmCapabilityConnector capabilityConnector = await _context.NdmInitializer.InitAsync(
_context.ConfigProvider,
_context.DbProvider,
initConfig.BaseDbPath,
_context.BlockTree,
_context.TxPool,
_context.SpecProvider,
_context.ReceiptStorage,
_context.Wallet,
filterStore,
filterManager,
_context.Timestamper,
_context.EthereumEcdsa,
_context.RpcModuleProvider,
_context.KeyStore,
_context.EthereumJsonSerializer,
_context.CryptoRandom,
_context.Enode,
_context.NdmConsumerChannelManager,
_context.NdmDataPublisher,
_context.GrpcServer,
_context.NodeStatsManager,
_context.ProtocolsManager,
protocolValidator,
_context._messageSerializationService,
initConfig.EnableUnsecuredDevWallet,
_context.WebSocketsManager,
_context.LogManager,
_context.MainBlockProcessor,
_context.JsonRpcClientProxy,
_context.EthJsonRpcClientProxy,
_context.HttpClient,
_context.MonitoringService,
_context.BloomStorage);
capabilityConnector.Init();
if (_logger.IsInfo)
{
_logger.Info($"NDM initialized.");
}
}
PeerLoader peerLoader = new PeerLoader(_networkConfig, discoveryConfig, _context.NodeStatsManager, peerStorage, _context.LogManager);
_context.PeerManager = new PeerManager(_context.RlpxPeer, _context.DiscoveryApp, _context.NodeStatsManager, peerStorage, peerLoader, _networkConfig, _context.LogManager, _context.StaticNodesManager);
_context.PeerManager.Init();
}
