public void Best_state_is_head_when_there_are_no_suggested_blocks()
{
IBlockTree blockTree = Substitute.For <IBlockTree>();
IReceiptStorage receiptStorage = Substitute.For <IReceiptStorage>();
IDb stateDb = Substitute.For <IDb>();
SyncConfig syncConfig = new SyncConfig();
syncConfig.PivotNumber = "1";
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, receiptStorage, stateDb, new MemDb(), syncConfig, LimboLogs.Instance);
var head = Build.A.Block.WithHeader(Build.A.BlockHeader.WithNumber(5).WithStateRoot(TestItem.KeccakA).TestObject).TestObject;
blockTree.Head.Returns(head);
blockTree.BestSuggestedHeader.Returns(head.Header);
stateDb.Get(head.StateRoot).Returns(new byte[] { 1 });
stateDb.Innermost.Returns(stateDb);
Assert.AreEqual(head.Number, syncProgressResolver.FindBestFullState());
}
public void Is_fast_block_finished_returns_false_when_blocks_not_downloaded()
{
IBlockTree blockTree = Substitute.For <IBlockTree>();
IReceiptStorage receiptStorage = Substitute.For <IReceiptStorage>();
INodeDataDownloader nodeDataDownloader = Substitute.For <INodeDataDownloader>();
SyncConfig syncConfig = new SyncConfig();
syncConfig.FastBlocks = true;
syncConfig.DownloadBodiesInFastSync = true;
syncConfig.DownloadReceiptsInFastSync = true;
blockTree.LowestInsertedHeader.Returns(Build.A.BlockHeader.WithNumber(1).TestObject);
blockTree.LowestInsertedBody.Returns(Build.A.Block.WithNumber(2).TestObject);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, receiptStorage, nodeDataDownloader, syncConfig, LimboLogs.Instance);
Assert.False(syncProgressResolver.IsFastBlocksFinished());
}
public void Is_fast_block_headers_finished_returns_false_when_headers_not_downloaded()
{
IBlockTree blockTree = Substitute.For <IBlockTree>();
IReceiptStorage receiptStorage = Substitute.For <IReceiptStorage>();
IDb stateDb = new MemDb();
SyncConfig syncConfig = new SyncConfig();
syncConfig.FastBlocks = true;
syncConfig.DownloadBodiesInFastSync = true;
syncConfig.DownloadReceiptsInFastSync = true;
syncConfig.PivotNumber = "1";
blockTree.LowestInsertedHeader.Returns(Build.A.BlockHeader.WithNumber(2).WithStateRoot(TestItem.KeccakA).TestObject);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, receiptStorage, stateDb, new MemDb(), syncConfig, LimboLogs.Instance);
Assert.False(syncProgressResolver.IsFastBlocksHeadersFinished());
}
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 ScenarioBuilder IfThisNodeHasStateThatIsFarInThePast()
{
// this is a scenario when we actually have state but the lookup depth is limiting
// our ability to find out at what level the state is
long currentBlock = ChainHead.Number - FastSyncCatchUpHeightDelta - 16;
_syncProgressSetups.Add(
() =>
{
SyncProgressResolver.FindBestHeader().Returns(ChainHead.Number);
SyncProgressResolver.FindBestFullBlock().Returns(ChainHead.Number);
SyncProgressResolver.FindBestFullState().Returns(0);
SyncProgressResolver.FindBestProcessedBlock().Returns(currentBlock);
SyncProgressResolver.IsFastBlocksFinished().Returns(true);
SyncProgressResolver.ChainDifficulty.Returns((UInt256)currentBlock);
return("fast sync catch up");
}
);
return(this);
}
public void Best_state_is_suggested_if_there_is_suggested_block_with_state()
{
IBlockTree blockTree = Substitute.For <IBlockTree>();
IReceiptStorage receiptStorage = Substitute.For <IReceiptStorage>();
IDb stateDb = Substitute.For <IDb>();
SyncConfig syncConfig = new SyncConfig();
syncConfig.PivotNumber = "1";
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, receiptStorage, stateDb, new MemDb(), syncConfig, LimboLogs.Instance);
var head = Build.A.Block.WithHeader(Build.A.BlockHeader.WithNumber(5).WithStateRoot(TestItem.KeccakA).TestObject).TestObject;
var suggested = Build.A.BlockHeader.WithNumber(6).WithStateRoot(TestItem.KeccakB).TestObject;
blockTree.Head.Returns(head);
blockTree.BestSuggestedHeader.Returns(suggested);
blockTree.FindHeader(Arg.Any <Keccak>(), BlockTreeLookupOptions.TotalDifficultyNotNeeded).Returns(head.Header);
stateDb.Get(head.StateRoot).Returns(new byte[] { 1 });
stateDb.Get(suggested.StateRoot).Returns(new byte[] { 1 });
Assert.AreEqual(suggested.Number, syncProgressResolver.FindBestFullState());
}
public void Best_state_is_suggested_if_there_is_suggested_block_with_state()
{
IBlockTree blockTree = Substitute.For <IBlockTree>();
IReceiptStorage receiptStorage = Substitute.For <IReceiptStorage>();
INodeDataDownloader nodeDataDownloader = Substitute.For <INodeDataDownloader>();
SyncConfig syncConfig = new SyncConfig();
syncConfig.PivotNumber = "1";
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, receiptStorage, nodeDataDownloader, syncConfig, LimboLogs.Instance);
var head = Build.A.BlockHeader.WithNumber(5).TestObject;
var suggested = Build.A.BlockHeader.WithNumber(6).TestObject;
blockTree.Head.Returns(head);
blockTree.BestSuggestedHeader.Returns(suggested);
blockTree.FindHeader(Arg.Any <Keccak>(), BlockTreeLookupOptions.TotalDifficultyNotNeeded).Returns(head);
nodeDataDownloader.IsFullySynced(head).Returns(true);
nodeDataDownloader.IsFullySynced(suggested).Returns(true);
Assert.AreEqual(suggested.Number, syncProgressResolver.FindBestFullState());
}
public void Is_fast_block_bodies_finished_returns_true_when_bodies_not_downloaded_and_we_do_not_want_to_download_bodies()
{
IBlockTree blockTree = Substitute.For <IBlockTree>();
IReceiptStorage receiptStorage = Substitute.For <IReceiptStorage>();
IDb stateDb = new MemDb();
SyncConfig syncConfig = new SyncConfig();
syncConfig.FastBlocks = true;
syncConfig.DownloadBodiesInFastSync = false;
syncConfig.DownloadReceiptsInFastSync = true;
syncConfig.PivotNumber = "1";
blockTree.LowestInsertedHeader.Returns(Build.A.BlockHeader.WithNumber(1).WithStateRoot(TestItem.KeccakA).TestObject);
blockTree.LowestInsertedBodyNumber.Returns(2);
receiptStorage.LowestInsertedReceiptBlockNumber.Returns(1);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(blockTree, receiptStorage, stateDb, new MemDb(), NullTrieNodeResolver.Instance, syncConfig, LimboLogs.Instance);
Assert.True(syncProgressResolver.IsFastBlocksBodiesFinished());
}
public SyncingContext(SynchronizerType synchronizerType)
{
_logger = _logManager.GetClassLogger();
ISyncConfig syncConfig = synchronizerType == SynchronizerType.Fast ? SyncConfig.WithFastSync : SyncConfig.WithFullSyncOnly;
MemDbProvider dbProvider = new MemDbProvider();
ISnapshotableDb stateDb = dbProvider.StateDb;
ISnapshotableDb 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);
NodeStatsManager stats = new NodeStatsManager(_logManager);
SyncPeerPool = new SyncPeerPool(BlockTree, stats, 25, _logManager);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(BlockTree, NullReceiptStorage.Instance, stateDb, new MemDb(), 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, _logManager);
SyncPeerPool.Start();
Synchronizer.Start();
Synchronizer.SyncEvent += SynchronizerOnSyncEvent;
AllInstances.Add(this);
}
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);
}
public SyncingContext(SynchronizerType synchronizerType)
{
ISyncConfig GetSyncConfig() =>
synchronizerType switch
{
SynchronizerType.Fast => SyncConfig.WithFastSync,
SynchronizerType.Eth2Merge => SyncConfig.WithEth2Merge,
SynchronizerType.Full => SyncConfig.WithFullSyncOnly,
_ => throw new ArgumentOutOfRangeException(nameof(synchronizerType), synchronizerType, null)
};
_logger = _logManager.GetClassLogger();
ISyncConfig syncConfig = GetSyncConfig();
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);
}
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);
}
protected virtual MultiSyncModeSelector CreateMultiSyncModeSelector(SyncProgressResolver syncProgressResolver) => new MultiSyncModeSelector(syncProgressResolver, _api.SyncPeerPool !, _syncConfig, _api.LogManager);
protected virtual MultiSyncModeSelector CreateMultiSyncModeSelector(SyncProgressResolver syncProgressResolver) => new(syncProgressResolver, _api.SyncPeerPool !, _syncConfig, _api.LogManager, _api.ChainSpec?.SealEngineType == SealEngineType.Clique);
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)");
}
public ScenarioBuilder WhenThisNodeIsLoadingBlocksFromDb()
{
_overwrites.Add(() => SyncProgressResolver.IsLoadingBlocksFromDb().Returns(true));
return(this);
}
protected override MultiSyncModeSelector CreateMultiSyncModeSelector(SyncProgressResolver syncProgressResolver) => new AuRaMultiSyncModeSelector(syncProgressResolver, _api.SyncPeerPool, _syncConfig, _api.LogManager);
public async Task Can_read_dependent_items_from_state_db_while_waiting_for_dependencies()
{
MemDb codeDb = new MemDb();
MemDb stateDB = new MemDb();
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(),
new TrieStore(stateDB.Innermost, LimboLogs.Instance),
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(NullTrieNodeResolver.Instance, 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);
}
