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); }