public SyncingContext(SynchronizerType synchronizerType) { _logger = _logManager.GetClassLogger(); ISyncConfig syncConfig = new SyncConfig(); syncConfig.FastSync = synchronizerType == SynchronizerType.Fast; ISnapshotableDb stateDb = new StateDb(); ISnapshotableDb codeDb = new StateDb(); BlockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), new SingleReleaseSpecProvider(Constantinople.Instance, 1), NullTxPool.Instance, _logManager); var stats = new NodeStatsManager(new StatsConfig(), _logManager); SyncPeerPool = new EthSyncPeerPool(BlockTree, stats, syncConfig, _logManager); NodeDataFeed feed = new NodeDataFeed(codeDb, stateDb, _logManager); NodeDataDownloader nodeDataDownloader = new NodeDataDownloader(SyncPeerPool, feed, _logManager); Synchronizer = new Synchronizer(BlockTree, TestBlockValidator.AlwaysValid, TestSealValidator.AlwaysValid, SyncPeerPool, syncConfig, nodeDataDownloader, _logManager); SyncServer = new SyncServer(stateDb, codeDb, BlockTree, NullReceiptStorage.Instance, TestSealValidator.AlwaysValid, SyncPeerPool, Synchronizer, _logManager); SyncPeerPool.Start(); Synchronizer.Start(); Synchronizer.SyncEvent += SynchronizerOnSyncEvent; AllInstances.Add(this); }
private NodeDataDownloader PrepareDownloader(ISyncPeer syncPeer) { DbContext dbContext = new DbContext(_logger); BlockTree blockTree = Build.A.BlockTree().OfChainLength((int)BlockTree.BestSuggestedHeader.Number).TestObject; _pool = new EthSyncPeerPool(blockTree, new NodeStatsManager(new StatsConfig(), LimboLogs.Instance), 25, LimboLogs.Instance); _pool.Start(); _pool.AddPeer(syncPeer); NodeDataFeed feed = new NodeDataFeed(dbContext.LocalCodeDb, dbContext.LocalStateDb, _logManager); NodeDataDownloader downloader = new NodeDataDownloader(_pool, feed, NullDataConsumer.Instance, _logManager); return(downloader); }
private SyncTestContext CreateSyncManager(int index) { Rlp.RegisterDecoders(typeof(ParityTraceDecoder).Assembly); var logManager = NoErrorLimboLogs.Instance; ConsoleAsyncLogger logger = new ConsoleAsyncLogger(LogLevel.Debug, "PEER " + index + " "); // var logManager = new OneLoggerLogManager(logger); var specProvider = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, MainNetSpecProvider.Instance.ChainId); MemDb traceDb = new MemDb(); MemDb blockDb = new MemDb(); MemDb headerDb = new MemDb(); MemDb blockInfoDb = new MemDb(); StateDb codeDb = new StateDb(); StateDb stateDb = new StateDb(); var stateProvider = new StateProvider(stateDb, codeDb, logManager); stateProvider.CreateAccount(TestItem.AddressA, 10000.Ether()); stateProvider.Commit(specProvider.GenesisSpec); stateProvider.CommitTree(); stateDb.Commit(); var storageProvider = new StorageProvider(stateDb, stateProvider, logManager); var receiptStorage = new InMemoryReceiptStorage(); var ecdsa = new EthereumEcdsa(specProvider, logManager); var txPool = new TxPool(new InMemoryTransactionStorage(), new PendingTransactionThresholdValidator(), new Timestamp(), ecdsa, specProvider, logManager); var tree = new BlockTree(blockDb, headerDb, blockInfoDb, specProvider, txPool, logManager); var blockhashProvider = new BlockhashProvider(tree, LimboLogs.Instance); var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, logManager); var sealValidator = TestSealValidator.AlwaysValid; var headerValidator = new HeaderValidator(tree, sealValidator, specProvider, logManager); var txValidator = TestTxValidator.AlwaysValid; var ommersValidator = new OmmersValidator(tree, headerValidator, logManager); var blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, logManager); // var blockValidator = TestBlockValidator.AlwaysValid; SyncConfig syncConfig = new SyncConfig(); syncConfig.FastSync = _synchronizerType == SynchronizerType.Fast; var rewardCalculator = new RewardCalculator(specProvider); var txProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, logManager); var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, txProcessor, stateDb, codeDb, traceDb, stateProvider, storageProvider, txPool, receiptStorage, syncConfig, logManager); var step = new TxSignaturesRecoveryStep(ecdsa, txPool, logManager); var processor = new BlockchainProcessor(tree, blockProcessor, step, logManager, true, true); var nodeStatsManager = new NodeStatsManager(new StatsConfig(), logManager); var syncPeerPool = new EthSyncPeerPool(tree, nodeStatsManager, syncConfig, logManager); StateProvider devState = new StateProvider(stateDb, codeDb, logManager); StorageProvider devStorage = new StorageProvider(stateDb, devState, logManager); var devEvm = new VirtualMachine(devState, devStorage, blockhashProvider, logManager); var devTxProcessor = new TransactionProcessor(specProvider, devState, devStorage, devEvm, logManager); var devBlockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, devTxProcessor, stateDb, codeDb, traceDb, devState, devStorage, txPool, receiptStorage, syncConfig, logManager); var devChainProcessor = new BlockchainProcessor(tree, devBlockProcessor, step, logManager, false, false); var producer = new DevBlockProducer(txPool, devChainProcessor, tree, new Timestamp(), logManager); NodeDataFeed feed = new NodeDataFeed(codeDb, stateDb, logManager); NodeDataDownloader downloader = new NodeDataDownloader(syncPeerPool, feed, logManager); Synchronizer synchronizer = new Synchronizer( tree, blockValidator, sealValidator, syncPeerPool, syncConfig, downloader, logManager); var syncServer = new SyncServer(stateDb, codeDb, tree, receiptStorage, TestSealValidator.AlwaysValid, syncPeerPool, synchronizer, logManager); ManualResetEventSlim waitEvent = new ManualResetEventSlim(); tree.NewHeadBlock += (s, e) => waitEvent.Set(); if (index == 0) { _genesis = Build.A.Block.Genesis.WithStateRoot(stateProvider.StateRoot).TestObject; producer.Start(); } syncPeerPool.Start(); synchronizer.Start(); processor.Start(); tree.SuggestBlock(_genesis); if (!waitEvent.Wait(1000)) { throw new Exception("No genesis"); } SyncTestContext context = new SyncTestContext(); context.Ecdsa = ecdsa; context.BlockchainProcessor = processor; context.PeerPool = syncPeerPool; context.StateProvider = stateProvider; context.Synchronizer = synchronizer; context.SyncServer = syncServer; context.Tree = tree; context.BlockProducer = producer; context.TxPool = txPool; context.Logger = logger; return(context); }
private async Task InitializeNetwork( IReceiptStorage receiptStorage, ISealValidator sealValidator, TxValidator txValidator) { ISyncConfig syncConfig = _configProvider.GetConfig <ISyncConfig>(); _syncPeerPool = new EthSyncPeerPool(_blockTree, _nodeStatsManager, syncConfig, _logManager); NodeDataFeed feed = new NodeDataFeed(_dbProvider.CodeDb, _dbProvider.StateDb, _logManager); NodeDataDownloader nodeDataDownloader = new NodeDataDownloader(_syncPeerPool, feed, _logManager); _synchronizer = new Synchronizer(_blockTree, _blockValidator, _sealValidator, _syncPeerPool, syncConfig, nodeDataDownloader, _logManager); _syncServer = new SyncServer( _dbProvider.StateDb, _dbProvider.CodeDb, _blockTree, _receiptStorage, sealValidator, _syncPeerPool, _synchronizer, _logManager); InitDiscovery(); await InitPeer().ContinueWith(initPeerTask => { if (initPeerTask.IsFaulted) { _logger.Error("Unable to init the peer manager.", initPeerTask.Exception); } }); ; await StartSync().ContinueWith(initNetTask => { if (initNetTask.IsFaulted) { _logger.Error("Unable to start the synchronizer.", initNetTask.Exception); } }); await StartDiscovery().ContinueWith(initDiscoveryTask => { if (initDiscoveryTask.IsFaulted) { _logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception); } }); try { StartPeer(); } catch (Exception e) { _logger.Error("Unable to start the peer manager.", e); } ; if (_logger.IsInfo) { _logger.Info($"Ethereum : tcp://{_enode.IpAddress}:{_enode.P2PPort}"); } if (_logger.IsInfo) { _logger.Info($"Version : {ClientVersion.Description}"); } if (_logger.IsInfo) { _logger.Info($"This node : {_enode.Info}"); } if (_logger.IsInfo) { _logger.Info($"Node address : {_enode.Address} (do not use as an account)"); } }
private async Task Initialize() { 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.SealValidator == null) { throw new StepDependencyException(nameof(_context.SealValidator)); } if (_context.Enode == null) { throw new StepDependencyException(nameof(_context.Enode)); } if (_networkConfig.DiagTracerEnabled) { NetworkDiagTracer.IsEnabled = true; NetworkDiagTracer.Start(); } // Environment.SetEnvironmentVariable("io.netty.allocator.pageSize", "8192"); Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString()); int maxPeersCount = _networkConfig.ActivePeersMaxCount; _context.SyncPeerPool = new EthSyncPeerPool(_context.BlockTree, _context.NodeStatsManager, maxPeersCount, _context.LogManager); _context.DisposeStack.Push(_context.SyncPeerPool); NodeDataFeed feed = new NodeDataFeed(_context.DbProvider.CodeDb, _context.DbProvider.StateDb, _context.LogManager); NodeDataDownloader nodeDataDownloader = new NodeDataDownloader(_context.SyncPeerPool, feed, _context.NodeDataConsumer, _context.LogManager); _context.Synchronizer = new Synchronizer(_context.SpecProvider, _context.BlockTree, _context.ReceiptStorage, _context.BlockValidator, _context.SealValidator, _context.SyncPeerPool, _context.Config <ISyncConfig>(), nodeDataDownloader, _context.NodeStatsManager, _context.LogManager); _context.DisposeStack.Push(_context.Synchronizer); _context.SyncServer = new SyncServer( _context.DbProvider.StateDb, _context.DbProvider.CodeDb, _context.BlockTree, _context.ReceiptStorage, _context.BlockValidator, _context.SealValidator, _context.SyncPeerPool, _context.Synchronizer, _context.Config <ISyncConfig>(), _context.LogManager); InitDiscovery(); await InitPeer().ContinueWith(initPeerTask => { if (initPeerTask.IsFaulted) { _logger.Error("Unable to init the peer manager.", initPeerTask.Exception); } }); await StartSync().ContinueWith(initNetTask => { if (initNetTask.IsFaulted) { _logger.Error("Unable to start the synchronizer.", initNetTask.Exception); } }); await StartDiscovery().ContinueWith(initDiscoveryTask => { if (initDiscoveryTask.IsFaulted) { _logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception); } }); try { StartPeer(); } catch (Exception e) { _logger.Error("Unable to start the peer manager.", e); } ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_context.Enode.HostIp}:{_context.Enode.Port}"); ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}"); ThisNodeInfo.AddInfo("This node :", $"{_context.Enode.Info}"); ThisNodeInfo.AddInfo("Node address :", $"{_context.Enode.Address} (do not use as an account)"); }