public SyncingContext(SynchronizerType synchronizerType)
{
_logger = _logManager.GetClassLogger();
ISyncConfig syncConfig = synchronizerType == SynchronizerType.Fast ? SyncConfig.WithFastSync : SyncConfig.WithFullSyncOnly;
IDbProvider dbProvider = TestMemDbProvider.Init();
IDb stateDb = new MemDb();
IDb codeDb = dbProvider.CodeDb;
MemDb blockInfoDb = new MemDb();
BlockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), new SingleReleaseSpecProvider(Constantinople.Instance, 1), NullBloomStorage.Instance, _logManager);
ITimerFactory timerFactory = Substitute.For <ITimerFactory>();
NodeStatsManager stats = new NodeStatsManager(timerFactory, _logManager);
SyncPeerPool = new SyncPeerPool(BlockTree, stats, 25, _logManager);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(
BlockTree,
NullReceiptStorage.Instance,
stateDb,
new MemDb(),
new TrieStore(stateDb, LimboLogs.Instance),
syncConfig,
_logManager);
MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(syncProgressResolver, SyncPeerPool, syncConfig, _logManager);
Synchronizer = new Synchronizer(
dbProvider,
MainnetSpecProvider.Instance,
BlockTree,
NullReceiptStorage.Instance,
Always.Valid,
Always.Valid,
SyncPeerPool,
stats,
syncModeSelector,
syncConfig,
_logManager);
SyncServer = new SyncServer(
stateDb,
codeDb,
BlockTree,
NullReceiptStorage.Instance,
Always.Valid,
Always.Valid,
SyncPeerPool,
syncModeSelector,
syncConfig,
new WitnessCollector(new MemDb(), LimboLogs.Instance),
_logManager);
SyncPeerPool.Start();
Synchronizer.Start();
Synchronizer.SyncEvent += SynchronizerOnSyncEvent;
AllInstances.Add(this);
}
public async Task Can_read_dependent_items_from_state_db_while_waiting_for_dependencies()
{
StateDb codeDb = new StateDb();
StateDb stateDB = new StateDb();
MemDb tempDb = new MemDb();
SyncConfig syncConfig = new SyncConfig();
syncConfig.FastSync = true;
IBlockTree blockTree = Substitute.For <IBlockTree>();
ISyncPeerPool pool = Substitute.For <ISyncPeerPool>();
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, NullReceiptStorage.Instance, stateDB, new MemDb(), syncConfig, LimboLogs.Instance);
ISyncModeSelector syncModeSelector = new MultiSyncModeSelector(syncProgressResolver, pool, syncConfig, LimboLogs.Instance);
StateSyncFeed stateSyncFeed = new StateSyncFeed(codeDb, stateDB, tempDb, syncModeSelector, blockTree, LimboLogs.Instance);
// so we want to setup a trie in a structure of -> branch into two leaves
// so we can respond with the branch node and with leaves missing
// and we can prove that we can read the branch from the temp DB while it is still missing from the State DB
AccountDecoder accountDecoder = new AccountDecoder();
TrieNode leaf = TrieNodeFactory.CreateLeaf(new HexPrefix(true, new byte[] { 1, 2, 3 }), accountDecoder.Encode(Account.TotallyEmpty).Bytes);
TrieNode branch = TrieNodeFactory.CreateBranch();
branch.SetChild(1, leaf);
branch.ResolveKey(true);
// PatriciaTree tree = new PatriciaTree();
// tree = new PatriciaTree();
// tree.Set(branch.Keccak.Bytes, branch.Value);
stateSyncFeed.ResetStateRoot(0, branch.Keccak);
var request = await stateSyncFeed.PrepareRequest();
BuildRequestAndHandleResponse(branch, request, stateSyncFeed);
byte[] value = tempDb.Get(branch.Keccak);
value.Should().BeEquivalentTo(branch.FullRlp);
byte[] valueFromState = stateDB.Get(branch.Keccak);
valueFromState.Should().BeNull();
request = await stateSyncFeed.PrepareRequest();
BuildRequestAndHandleResponse(leaf, request, stateSyncFeed);
value = tempDb.Get(branch.Keccak);
value.Should().BeNull();
valueFromState = stateDB.Get(branch.Keccak);
valueFromState.Should().BeEquivalentTo(branch.FullRlp);
}
public Context(
IBlockTree?blockTree = null,
ISyncConfig?syncConfig = null,
IBeaconPivot?beaconPivot = null,
IDb?metadataDb = null,
IMergeConfig?mergeConfig = null)
{
if (blockTree == null)
{
IDb blockInfoDb = new MemDb();
Block genesis = Build.A.Block.Genesis.TestObject;
BlockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
BlockTree.SuggestBlock(genesis);
}
else
{
BlockTree = blockTree;
}
ISyncPeerPool peerPool = Substitute.For <ISyncPeerPool>();
ISyncReport report = Substitute.For <ISyncReport>();
MeasuredProgress measuredProgress = new MeasuredProgress();
report.BeaconHeaders.Returns(measuredProgress);
report.HeadersInQueue.Returns(measuredProgress);
MemDb stateDb = new();
_syncConfig = syncConfig ?? new SyncConfig();
_mergeConfig = mergeConfig ?? new MergeConfig();
_metadataDb = metadataDb ?? new MemDb();
PoSSwitcher poSSwitcher = new(_mergeConfig, _syncConfig, _metadataDb, blockTree !,
MainnetSpecProvider.Instance, LimboLogs.Instance);
ProgressTracker progressTracker = new(BlockTree, stateDb, LimboLogs.Instance);
SyncProgressResolver syncProgressResolver = new(
BlockTree,
NullReceiptStorage.Instance,
stateDb,
new TrieStore(stateDb, LimboLogs.Instance),
progressTracker,
_syncConfig,
LimboLogs.Instance);
TotalDifficultyBetterPeerStrategy bestPeerStrategy = new (LimboLogs.Instance);
BeaconPivot = beaconPivot ?? new BeaconPivot(_syncConfig, _metadataDb, BlockTree, LimboLogs.Instance);
BeaconSync = new(BeaconPivot, BlockTree, _syncConfig, new BlockCacheService(), LimboLogs.Instance);
ISyncModeSelector selector = new MultiSyncModeSelector(syncProgressResolver, peerPool, _syncConfig, BeaconSync, bestPeerStrategy, LimboLogs.Instance);
Feed = new BeaconHeadersSyncFeed(poSSwitcher, selector, blockTree, peerPool, _syncConfig, report, BeaconPivot, _mergeConfig,
new NoopInvalidChainTracker(), LimboLogs.Instance);
}
public async Task Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
_stateDb = dbProvider.StateDb;
_codeDb = dbProvider.CodeDb;
_receiptStorage = Substitute.For <IReceiptStorage>();
SyncConfig quickConfig = new SyncConfig();
quickConfig.FastSync = false;
ITimerFactory timerFactory = Substitute.For <ITimerFactory>();
var stats = new NodeStatsManager(timerFactory, LimboLogs.Instance);
_pool = new SyncPeerPool(_blockTree, stats, 25, LimboLogs.Instance);
SyncConfig syncConfig = new SyncConfig();
SyncProgressResolver resolver = new SyncProgressResolver(
_blockTree,
_receiptStorage,
_stateDb,
dbProvider.BeamTempDb,
new TrieStore(_stateDb, LimboLogs.Instance),
syncConfig,
LimboLogs.Instance);
MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(resolver, _pool, syncConfig, LimboLogs.Instance);
_synchronizer = new Synchronizer(dbProvider, MainnetSpecProvider.Instance, _blockTree, _receiptStorage, Always.Valid, Always.Valid, _pool, stats, syncModeSelector, syncConfig, LimboLogs.Instance);
_syncServer = new SyncServer(
_stateDb,
_codeDb,
_blockTree,
_receiptStorage,
Always.Valid,
Always.Valid,
_pool,
syncModeSelector,
quickConfig,
new WitnessCollector(new MemDb(), LimboLogs.Instance),
LimboLogs.Instance);
}
public void TheSyncModeShouldBe(SyncMode syncMode)
{
void Test()
{
foreach (Action overwrite in _overwrites)
{
overwrite.Invoke();
}
MultiSyncModeSelector selector = new MultiSyncModeSelector(SyncProgressResolver, SyncPeerPool, SyncConfig, LimboLogs.Instance, false);
selector.DisableTimer();
selector.Update();
selector.Current.Should().Be(syncMode);
}
SetDefaults();
foreach (Func <string> syncProgressSetup in _syncProgressSetups)
{
foreach (Func <string> peeringSetup in _peeringSetups)
{
foreach (Func <string> configSetups in _configActions)
{
string syncProgressSetupName = syncProgressSetup.Invoke();
string peeringSetupName = peeringSetup.Invoke();
string configSetupName = configSetups.Invoke();
Console.WriteLine("=====================");
Console.WriteLine(syncProgressSetupName);
Console.WriteLine(peeringSetupName);
Console.WriteLine(configSetupName);
Test();
Console.WriteLine("=====================");
}
}
}
}
public void Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
MemDbProvider dbProvider = new MemDbProvider();
_stateDb = dbProvider.StateDb;
_codeDb = dbProvider.CodeDb;
_receiptsDb = dbProvider.ReceiptsDb;
_receiptStorage = Substitute.For <IReceiptStorage>();
SyncConfig quickConfig = new SyncConfig();
quickConfig.FastSync = false;
var stats = new NodeStatsManager(new StatsConfig(), LimboLogs.Instance);
_pool = new SyncPeerPool(_blockTree, stats, 25, LimboLogs.Instance);
SyncConfig syncConfig = new SyncConfig();
SyncProgressResolver resolver = new SyncProgressResolver(_blockTree, _receiptStorage, _stateDb, dbProvider.BeamStateDb, syncConfig, LimboLogs.Instance);
MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(resolver, _pool, syncConfig, LimboLogs.Instance);
_synchronizer = new Synchronizer(dbProvider, MainnetSpecProvider.Instance, _blockTree, _receiptStorage, Always.Valid, Always.Valid, _pool, stats, syncModeSelector, syncConfig, LimboLogs.Instance);
_syncServer = new SyncServer(_stateDb, _codeDb, _blockTree, _receiptStorage, Always.Valid, Always.Valid, _pool, syncModeSelector, quickConfig, LimboLogs.Instance);
}
private SyncTestContext CreateSyncManager(int index)
{
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);
var dbProvider = TestMemDbProvider.Init();
IDb blockDb = dbProvider.BlocksDb;
IDb headerDb = dbProvider.HeadersDb;
IDb blockInfoDb = dbProvider.BlockInfosDb;
ISnapshotableDb codeDb = dbProvider.CodeDb;
ISnapshotableDb stateDb = dbProvider.StateDb;
var stateReader = new StateReader(stateDb, codeDb, logManager);
var stateProvider = new StateProvider(stateDb, codeDb, logManager);
stateProvider.CreateAccount(TestItem.AddressA, 10000.Ether());
stateProvider.Commit(specProvider.GenesisSpec);
stateProvider.CommitTree();
stateProvider.RecalculateStateRoot();
stateDb.Commit();
var storageProvider = new StorageProvider(stateDb, stateProvider, logManager);
var receiptStorage = new InMemoryReceiptStorage();
var ecdsa = new EthereumEcdsa(specProvider.ChainId, logManager);
var txPool = new TxPool.TxPool(new InMemoryTxStorage(), ecdsa, specProvider, new TxPoolConfig(), stateProvider, logManager);
var tree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, NullBloomStorage.Instance, logManager);
var blockhashProvider = new BlockhashProvider(tree, LimboLogs.Instance);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, logManager);
var sealValidator = Always.Valid;
var headerValidator = new HeaderValidator(tree, sealValidator, specProvider, logManager);
var txValidator = Always.Valid;
var ommersValidator = new OmmersValidator(tree, headerValidator, logManager);
var blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, logManager);
ISyncConfig syncConfig = _synchronizerType == SynchronizerType.Fast ? SyncConfig.WithFastSync : SyncConfig.WithFullSyncOnly;
var rewardCalculator = new RewardCalculator(specProvider);
var txProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, logManager);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, txProcessor, stateDb, codeDb, stateProvider, storageProvider, txPool, receiptStorage, logManager);
var step = new RecoverSignatures(ecdsa, txPool, specProvider, logManager);
var processor = new BlockchainProcessor(tree, blockProcessor, step, logManager, BlockchainProcessor.Options.Default);
var nodeStatsManager = new NodeStatsManager(logManager);
var syncPeerPool = new SyncPeerPool(tree, nodeStatsManager, 25, logManager);
StateProvider devState = new StateProvider(stateDb, codeDb, logManager);
StorageProvider devStorage = new StorageProvider(stateDb, devState, logManager);
var devEvm = new VirtualMachine(devState, devStorage, blockhashProvider, specProvider, logManager);
var devTxProcessor = new TransactionProcessor(specProvider, devState, devStorage, devEvm, logManager);
var devBlockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, devTxProcessor, stateDb, codeDb, devState, devStorage, txPool, receiptStorage, logManager);
var devChainProcessor = new BlockchainProcessor(tree, devBlockProcessor, step, logManager, BlockchainProcessor.Options.NoReceipts);
var transactionSelector = new TxPoolTxSource(txPool, stateReader, logManager);
var producer = new DevBlockProducer(
transactionSelector,
devChainProcessor,
stateProvider, tree,
processor,
txPool,
Timestamper.Default,
logManager);
SyncProgressResolver resolver = new SyncProgressResolver(tree, receiptStorage, stateDb, new MemDb(), syncConfig, logManager);
MultiSyncModeSelector selector = new MultiSyncModeSelector(resolver, syncPeerPool, syncConfig, logManager);
Synchronizer synchronizer = new Synchronizer(
dbProvider,
MainnetSpecProvider.Instance,
tree,
NullReceiptStorage.Instance,
blockValidator,
sealValidator,
syncPeerPool,
nodeStatsManager,
StaticSelector.Full,
syncConfig,
logManager);
var syncServer = new SyncServer(stateDb, codeDb, tree, receiptStorage, Always.Valid, Always.Valid, syncPeerPool, selector, syncConfig, 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 Initialize(CancellationToken cancellationToken)
{
if (_networkConfig.DiagTracerEnabled)
{
NetworkDiagTracer.IsEnabled = true;
NetworkDiagTracer.Start();
}
Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString());
var cht = new CanonicalHashTrie(_api.DbProvider !.ChtDb);
int maxPeersCount = _networkConfig.ActivePeersMaxCount;
_api.SyncPeerPool = new SyncPeerPool(_api.BlockTree !, _api.NodeStatsManager !, maxPeersCount, _api.LogManager);
_api.DisposeStack.Push(_api.SyncPeerPool);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(_api.BlockTree !, _api.ReceiptStorage !, _api.DbProvider.StateDb, _api.DbProvider.BeamStateDb, _syncConfig, _api.LogManager);
MultiSyncModeSelector syncModeSelector = CreateMultiSyncModeSelector(syncProgressResolver);
if (_api.SyncModeSelector != null)
{
// this is really bad and is a result of lack of proper dependency management
PendingSyncModeSelector pendingOne = (PendingSyncModeSelector)_api.SyncModeSelector;
pendingOne.SetActual(syncModeSelector);
}
_api.SyncModeSelector = syncModeSelector;
_api.DisposeStack.Push(syncModeSelector);
_api.Synchronizer = new Synchronizer(
_api.DbProvider,
_api.SpecProvider !,
_api.BlockTree !,
_api.ReceiptStorage !,
_api.BlockValidator !,
_api.SealValidator !,
_api.SyncPeerPool,
_api.NodeStatsManager !,
_api.SyncModeSelector,
_syncConfig,
_api.LogManager);
_api.DisposeStack.Push(_api.Synchronizer);
_api.SyncServer = new SyncServer(
_api.DbProvider.StateDb,
_api.DbProvider.CodeDb,
_api.BlockTree !,
_api.ReceiptStorage !,
_api.BlockValidator !,
_api.SealValidator !,
_api.SyncPeerPool,
_api.SyncModeSelector,
_api.Config <ISyncConfig>(),
_api.LogManager,
cht);
_ = _api.SyncServer.BuildCHT();
_api.DisposeStack.Push(_api.SyncServer);
InitDiscovery();
if (cancellationToken.IsCancellationRequested)
{
return;
}
await InitPeer().ContinueWith(initPeerTask =>
{
if (initPeerTask.IsFaulted)
{
_logger.Error("Unable to init the peer manager.", initPeerTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartSync().ContinueWith(initNetTask =>
{
if (initNetTask.IsFaulted)
{
_logger.Error("Unable to start the synchronizer.", initNetTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartDiscovery().ContinueWith(initDiscoveryTask =>
{
if (initDiscoveryTask.IsFaulted)
{
_logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception);
}
});
try
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
StartPeer();
}
catch (Exception e)
{
_logger.Error("Unable to start the peer manager.", e);
}
if (_api.Enode == null)
{
throw new InvalidOperationException("Cannot initialize network without knowing own enode");
}
ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_api.Enode.HostIp}:{_api.Enode.Port}");
ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}");
ThisNodeInfo.AddInfo("This node :", $"{_api.Enode.Info}");
ThisNodeInfo.AddInfo("Node address :", $"{_api.Enode.Address} (do not use as an account)");
}
private async Task Initialize(CancellationToken cancellationToken)
{
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.SealValidator == null)
{
throw new StepDependencyException(nameof(_ctx.SealValidator));
}
if (_ctx.Enode == null)
{
throw new StepDependencyException(nameof(_ctx.Enode));
}
if (_networkConfig.DiagTracerEnabled)
{
NetworkDiagTracer.IsEnabled = true;
NetworkDiagTracer.Start();
}
ThisNodeInfo.AddInfo("Mem est netty:", $"{NettyMemoryEstimator.Estimate((uint)Environment.ProcessorCount, _networkConfig.NettyArenaOrder) / 1000 / 1000}MB".PadLeft(8));
ThisNodeInfo.AddInfo("Mem est peers:", $"{_networkConfig.ActivePeersMaxCount}MB".PadLeft(8));
Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString());
int maxPeersCount = _networkConfig.ActivePeersMaxCount;
_ctx.SyncPeerPool = new SyncPeerPool(_ctx.BlockTree, _ctx.NodeStatsManager, maxPeersCount, _ctx.LogManager);
_ctx.DisposeStack.Push(_ctx.SyncPeerPool);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(_ctx.BlockTree, _ctx.ReceiptStorage, _ctx.DbProvider.StateDb, _ctx.DbProvider.BeamStateDb, _syncConfig, _ctx.LogManager);
MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(syncProgressResolver, _ctx.SyncPeerPool, _syncConfig, _ctx.LogManager);
if (_ctx.SyncModeSelector != null)
{
// this is really bad and is a result of lack of proper dependency management
PendingSyncModeSelector pendingOne = (PendingSyncModeSelector)_ctx.SyncModeSelector;
pendingOne.SetActual(syncModeSelector);
}
_ctx.SyncModeSelector = syncModeSelector;
_ctx.DisposeStack.Push(syncModeSelector);
_ctx.Synchronizer = new Synchronizer(
_ctx.DbProvider,
_ctx.SpecProvider,
_ctx.BlockTree,
_ctx.ReceiptStorage,
_ctx.BlockValidator,
_ctx.SealValidator,
_ctx.SyncPeerPool,
_ctx.NodeStatsManager,
_ctx.SyncModeSelector,
_syncConfig,
_ctx.LogManager);
_ctx.DisposeStack.Push(_ctx.Synchronizer);
_ctx.SyncServer = new SyncServer(
_ctx.DbProvider.StateDb,
_ctx.DbProvider.CodeDb,
_ctx.BlockTree,
_ctx.ReceiptStorage,
_ctx.BlockValidator,
_ctx.SealValidator,
_ctx.SyncPeerPool,
_ctx.SyncModeSelector,
_ctx.Config <ISyncConfig>(),
_ctx.LogManager);
_ctx.DisposeStack.Push(_ctx.SyncServer);
InitDiscovery();
if (cancellationToken.IsCancellationRequested)
{
return;
}
await InitPeer().ContinueWith(initPeerTask =>
{
if (initPeerTask.IsFaulted)
{
_logger.Error("Unable to init the peer manager.", initPeerTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartSync().ContinueWith(initNetTask =>
{
if (initNetTask.IsFaulted)
{
_logger.Error("Unable to start the synchronizer.", initNetTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartDiscovery().ContinueWith(initDiscoveryTask =>
{
if (initDiscoveryTask.IsFaulted)
{
_logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception);
}
});
try
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
StartPeer();
}
catch (Exception e)
{
_logger.Error("Unable to start the peer manager.", e);
}
ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_ctx.Enode.HostIp}:{_ctx.Enode.Port}");
ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}");
ThisNodeInfo.AddInfo("This node :", $"{_ctx.Enode.Info}");
ThisNodeInfo.AddInfo("Node address :", $"{_ctx.Enode.Address} (do not use as an account)");
}
