public async Task Can_keep_returning_nulls_after_all_batches_were_prepared() { IDbProvider memDbProvider = await TestMemDbProvider.InitAsync(); BlockTree blockTree = new(memDbProvider, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance); ISyncConfig syncConfig = new SyncConfig { FastSync = true, FastBlocks = true, PivotNumber = "1000", PivotHash = Keccak.Zero.ToString(), PivotTotalDifficulty = "1000" }; PoSSwitcher poSSwitcher = new(new MergeConfig(), syncConfig, memDbProvider.MetadataDb, blockTree !, MainnetSpecProvider.Instance, LimboLogs.Instance); IBeaconPivot pivot = PreparePivot(2000, syncConfig, blockTree); BeaconHeadersSyncFeed feed = new(poSSwitcher, Substitute.For <ISyncModeSelector>(), blockTree, Substitute.For <ISyncPeerPool>(), syncConfig, Substitute.For <ISyncReport>(), pivot, new MergeConfig() { Enabled = true }, new NoopInvalidChainTracker(), LimboLogs.Instance); feed.InitializeFeed(); for (int i = 0; i < 6; i++) { await feed.PrepareRequest(); } HeadersSyncBatch?result = await feed.PrepareRequest(); result.Should().BeNull(); }
public void Setup() { IDbProvider memDbProvider = TestMemDbProvider.Init(); TrieStore trieStore = new (new MemDb(), LimboLogs.Instance); StateProvider stateProvider = new (trieStore, memDbProvider.CodeDb, LimboLogs.Instance); StorageProvider storageProvider = new (trieStore, stateProvider, LimboLogs.Instance); ChainLevelInfoRepository chainLevelInfoRepository = new (memDbProvider); ISpecProvider specProvider = MainnetSpecProvider.Instance; IBloomStorage bloomStorage = NullBloomStorage.Instance; EthereumEcdsa ecdsa = new (1, LimboLogs.Instance); ITransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, _blockTree); _blockTree = new BlockTree( memDbProvider, chainLevelInfoRepository, specProvider, bloomStorage, new SyncConfig(), LimboLogs.Instance); TxPool.TxPool txPool = new ( ecdsa, new ChainHeadInfoProvider(specProvider, _blockTree, stateProvider), new TxPoolConfig(), new TxValidator(specProvider.ChainId), LimboLogs.Instance, transactionComparerProvider.GetDefaultComparer()); BlockhashProvider blockhashProvider = new (_blockTree, LimboLogs.Instance); VirtualMachine virtualMachine = new( blockhashProvider, specProvider, LimboLogs.Instance); TransactionProcessor transactionProcessor = new ( specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance); BlockProcessor blockProcessor = new ( MainnetSpecProvider.Instance, Always.Valid, new RewardCalculator(specProvider), new BlockProcessor.BlockValidationTransactionsExecutor(transactionProcessor, stateProvider), stateProvider, storageProvider, NullReceiptStorage.Instance, new WitnessCollector(memDbProvider.StateDb, LimboLogs.Instance), LimboLogs.Instance); _blockchainProcessor = new BlockchainProcessor( _blockTree, blockProcessor, new RecoverSignatures( ecdsa, txPool, specProvider, LimboLogs.Instance), LimboLogs.Instance, BlockchainProcessor.Options.Default); }
public static INdmBlockchainBridge BuildABridge() { IDbProvider memDbProvider = TestMemDbProvider.Init(); StateReader stateReader = new StateReader(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance); StateProvider stateProvider = new StateProvider(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance); IEthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance); ITxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), ecdsa, MainnetSpecProvider.Instance, new TxPoolConfig(), stateProvider, LimboLogs.Instance); BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject; IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance); ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(ecdsa, MainnetSpecProvider.Instance); LogFinder logFinder = new LogFinder(blockTree, new InMemoryReceiptStorage(), NullBloomStorage.Instance, LimboLogs.Instance, receiptsRecovery, 1024); ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv( new ReadOnlyDbProvider(memDbProvider, false), new ReadOnlyBlockTree(blockTree), MainnetSpecProvider.Instance, LimboLogs.Instance); BlockchainBridge blockchainBridge = new BlockchainBridge( processingEnv, txPool, new InMemoryReceiptStorage(), NullFilterStore.Instance, NullFilterManager.Instance, ecdsa, Timestamper.Default, logFinder, false, false); WalletTxSigner txSigner = new WalletTxSigner(wallet, ChainId.Mainnet); ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper.Default); ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper.Default, txPool); ITxSender txSender = new TxPoolSender(txPool, txSealer0, txSealer1); return(new NdmBlockchainBridge(blockchainBridge, blockTree, stateReader, txSender)); }
public async Task SetUp() { _dbProvider = await TestMemDbProvider.InitAsync(); _timestamper = new ManualTimestamper(); _blockTree = Substitute.For <IBlockTree>(); _txPool = Substitute.For <ITxPool>(); _receiptStorage = Substitute.For <IReceiptStorage>(); _filterStore = Substitute.For <IFilterStore>(); _filterManager = Substitute.For <IFilterManager>(); _transactionProcessor = Substitute.For <ITransactionProcessor>(); _ethereumEcdsa = Substitute.For <IEthereumEcdsa>(); _specProvider = MainnetSpecProvider.Instance; ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv( new ReadOnlyDbProvider(_dbProvider, false), new TrieStore(_dbProvider.StateDb, LimboLogs.Instance).AsReadOnly(), new ReadOnlyBlockTree(_blockTree), _specProvider, LimboLogs.Instance); processingEnv.TransactionProcessor = _transactionProcessor; _blockchainBridge = new BlockchainBridge( processingEnv, _txPool, _receiptStorage, _filterStore, _filterManager, _ethereumEcdsa, _timestamper, Substitute.For <ILogFinder>(), false, false); }
public async Task Initialize() { ISpecProvider specProvider = MainnetSpecProvider.Instance; ITxPool txPool = NullTxPool.Instance; IDbProvider dbProvider = await TestMemDbProvider.InitAsync(); BlockTree blockTree = new BlockTree( dbProvider.BlocksDb, dbProvider.HeadersDb, dbProvider.BlockInfosDb, new ChainLevelInfoRepository(dbProvider.BlockInfosDb), specProvider, new BloomStorage(new BloomConfig(), dbProvider.HeadersDb, new InMemoryDictionaryFileStoreFactory()), new SyncConfig(), LimboLogs.Instance); _modulePool = new BoundedModulePool <IEthModule>(new EthModuleFactory( txPool, Substitute.For <ITxSender>(), NullWallet.Instance, blockTree, new JsonRpcConfig(), LimboLogs.Instance, Substitute.For <IStateReader>(), Substitute.For <IBlockchainBridgeFactory>()), 1, 1000); }
public static Runner.Ethereum.Api.NethermindApi ContextWithMocks() => new Runner.Ethereum.Api.NethermindApi(Substitute.For <IConfigProvider>(), new EthereumJsonSerializer(), LimboLogs.Instance) { Enode = Substitute.For <IEnode>(), TxPool = Substitute.For <ITxPool>(), Wallet = Substitute.For <IWallet>(), BlockTree = Substitute.For <IBlockTree>(), SyncServer = Substitute.For <ISyncServer>(), DbProvider = TestMemDbProvider.Init(), PeerManager = Substitute.For <IPeerManager>(), SpecProvider = Substitute.For <ISpecProvider>(), EthereumEcdsa = Substitute.For <IEthereumEcdsa>(), MainBlockProcessor = Substitute.For <IBlockProcessor>(), ReceiptStorage = Substitute.For <IReceiptStorage>(), ReceiptFinder = Substitute.For <IReceiptFinder>(), BlockValidator = Substitute.For <IBlockValidator>(), RewardCalculatorSource = Substitute.For <IRewardCalculatorSource>(), TxPoolInfoProvider = Substitute.For <ITxPoolInfoProvider>(), StaticNodesManager = Substitute.For <IStaticNodesManager>(), BloomStorage = Substitute.For <IBloomStorage>(), Sealer = Substitute.For <ISealer>(), Synchronizer = Substitute.For <ISynchronizer>(), BlockchainProcessor = Substitute.For <IBlockchainProcessor>(), BlockProducer = Substitute.For <IBlockProducer>(), ConfigProvider = Substitute.For <IConfigProvider>(), DiscoveryApp = Substitute.For <IDiscoveryApp>(), EngineSigner = Substitute.For <ISigner>(), FileSystem = Substitute.For <IFileSystem>(), FilterManager = Substitute.For <IFilterManager>(), FilterStore = Substitute.For <IFilterStore>(), GrpcServer = Substitute.For <IGrpcServer>(), HeaderValidator = Substitute.For <IHeaderValidator>(), IpResolver = Substitute.For <IIPResolver>(), KeyStore = Substitute.For <IKeyStore>(), LogFinder = Substitute.For <ILogFinder>(), MonitoringService = Substitute.For <IMonitoringService>(), ProtocolsManager = Substitute.For <IProtocolsManager>(), ProtocolValidator = Substitute.For <IProtocolValidator>(), RlpxPeer = Substitute.For <IRlpxPeer>(), SealValidator = Substitute.For <ISealValidator>(), SessionMonitor = Substitute.For <ISessionMonitor>(), StateProvider = Substitute.For <IStateProvider>(), StateReader = Substitute.For <IStateReader>(), StorageProvider = Substitute.For <IStorageProvider>(), TransactionProcessor = Substitute.For <ITransactionProcessor>(), TxSender = Substitute.For <ITxSender>(), BlockProcessingQueue = Substitute.For <IBlockProcessingQueue>(), EngineSignerStore = Substitute.For <ISignerStore>(), EthereumJsonSerializer = Substitute.For <IJsonSerializer>(), NodeStatsManager = Substitute.For <INodeStatsManager>(), RpcModuleProvider = Substitute.For <IRpcModuleProvider>(), SyncModeSelector = Substitute.For <ISyncModeSelector>(), SyncPeerPool = Substitute.For <ISyncPeerPool>(), WebSocketsManager = Substitute.For <IWebSocketsManager>(), ChainLevelInfoRepository = Substitute.For <IChainLevelInfoRepository>(), TrieStore = Substitute.For <ITrieStore>(), ReadOnlyTrieStore = Substitute.For <IReadOnlyTrieStore>(), ChainSpec = new ChainSpec(), };
public async Task Will_fail_if_launched_without_fast_blocks_enabled() { IDbProvider memDbProvider = await TestMemDbProvider.InitAsync(); BlockTree blockTree = new(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance); Assert.Throws <InvalidOperationException>(() => new HeadersSyncFeed(blockTree, Substitute.For <ISyncPeerPool>(), new SyncConfig(), Substitute.For <ISyncReport>(), LimboLogs.Instance)); }
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); }
private PruningContext(IPruningStrategy pruningStrategy, IPersistenceStrategy persistenceStrategy) { _logManager = new TestLogManager(LogLevel.Trace); _logger = _logManager.GetClassLogger(); _dbProvider = TestMemDbProvider.Init(); _persistenceStrategy = persistenceStrategy; _pruningStrategy = pruningStrategy; _trieStore = new TrieStore(_dbProvider.StateDb, _pruningStrategy, _persistenceStrategy, _logManager); _stateProvider = new StateProvider(_trieStore, _dbProvider.CodeDb, _logManager); _storageProvider = new StorageProvider(_trieStore, _stateProvider, _logManager); _stateReader = new StateReader(_trieStore, _dbProvider.CodeDb, _logManager); }
public async Task ProviderInitTests_BeamSyncDbProvider() { var syncModeSelector = Substitute.For <ISyncModeSelector>(); var dbProvider = TestMemDbProvider.Init(); var rocksDbFactory = new RocksDbFactory(new DbConfig(), LimboLogs.Instance, Path.Combine(_folderWithDbs, "beam")); IDbProvider beamSyncDbProvider = new BeamSyncDbProvider(syncModeSelector, dbProvider, new SyncConfig(), LimboLogs.Instance); var initializer = new BaselineDbInitializer(beamSyncDbProvider, new BaselineConfig(), rocksDbFactory, new MemDbFactory()); await initializer.Init(); Assert.NotNull(beamSyncDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTree)); Assert.NotNull(beamSyncDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTreeMetadata)); Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTree) is MemDb); Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(BaselineDbNames.BaselineTreeMetadata) is MemDb); }
public async Task Can_prepare_3_requests_in_a_row() { IDbProvider memDbProvider = await TestMemDbProvider.InitAsync(); BlockTree blockTree = new(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance); HeadersSyncFeed feed = new(blockTree, Substitute.For <ISyncPeerPool>(), new SyncConfig { FastSync = true, FastBlocks = true, PivotNumber = "1000", PivotHash = Keccak.Zero.ToString(), PivotTotalDifficulty = "1000" }, Substitute.For <ISyncReport>(), LimboLogs.Instance); HeadersSyncBatch batch1 = await feed.PrepareRequest(); HeadersSyncBatch batch2 = await feed.PrepareRequest(); HeadersSyncBatch batch3 = await feed.PrepareRequest(); }
private async Task SetupBeamProcessor(ISyncModeSelector syncModeSelector = null) { IDbProvider memDbProvider = await TestMemDbProvider.InitAsync(); _beamBlockchainProcessor = new BeamBlockchainProcessor( new ReadOnlyDbProvider(memDbProvider, false), _blockTree, MainnetSpecProvider.Instance, LimboLogs.Instance, _validator, NullRecoveryStep.Instance, NoBlockRewards.Instance, _blockchainProcessingQueue, syncModeSelector ?? new StaticSelector(SyncMode.Beam) ); }
public async Task ProviderInitTests_BeamSyncDbProvider() { var syncModeSelector = Substitute.For <ISyncModeSelector>(); var dbProvider = await TestMemDbProvider.InitAsync(); var rocksDbFactory = new RocksDbFactory(new DbConfig(), LimboLogs.Instance, Path.Combine(_folderWithDbs, "beam")); IDbProvider beamSyncDbProvider = new BeamSyncDbProvider(syncModeSelector, dbProvider, new SyncConfig(), LimboLogs.Instance); var initializer = new ConsumerNdmDbInitializer(beamSyncDbProvider, new NdmConfig(), rocksDbFactory, new MemDbFactory()); initializer.Reset(); await initializer.InitAsync(); Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerDepositApprovals) is MemDb); Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerReceipts) is MemDb); Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerSessions) is MemDb); Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.Deposits) is MemDb); }
public async Task Can_keep_returning_nulls_after_all_batches_were_prepared() { IDbProvider memDbProvider = await TestMemDbProvider.InitAsync(); BlockTree blockTree = new(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance); HeadersSyncFeed feed = new(blockTree, Substitute.For <ISyncPeerPool>(), new SyncConfig { FastSync = true, FastBlocks = true, PivotNumber = "1000", PivotHash = Keccak.Zero.ToString(), PivotTotalDifficulty = "1000" }, Substitute.For <ISyncReport>(), LimboLogs.Instance); for (int i = 0; i < 10; i++) { await feed.PrepareRequest(); } var result = await feed.PrepareRequest(); result.Should().BeNull(); }
public async Task Setup() { InMemoryReceiptStorage receiptStorage = new(); _specProvider = new TestSpecProvider(London.Instance); _blockTree = Build.A.BlockTree().WithTransactions(receiptStorage, _specProvider).OfChainLength(10).TestObject; _dbProvider = await TestMemDbProvider.InitAsync(); ProofModuleFactory moduleFactory = new( _dbProvider, _blockTree, new TrieStore(_dbProvider.StateDb, LimboLogs.Instance).AsReadOnly(), new CompositeBlockPreprocessorStep(new RecoverSignatures(new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance), NullTxPool.Instance, _specProvider, LimboLogs.Instance)), receiptStorage, _specProvider, LimboLogs.Instance); _proofRpcModule = moduleFactory.Create(); }
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 async Task Initialize() { ISpecProvider specProvider = MainnetSpecProvider.Instance; ITxPool txPool = NullTxPool.Instance; IDbProvider dbProvider = await TestMemDbProvider.InitAsync(); BlockTree blockTree = new(dbProvider.BlocksDb, dbProvider.HeadersDb, dbProvider.BlockInfosDb, new ChainLevelInfoRepository(dbProvider.BlockInfosDb), specProvider, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance); _factory = new EthModuleFactory( txPool, Substitute.For <ITxSender>(), NullWallet.Instance, blockTree, new JsonRpcConfig(), LimboLogs.Instance, Substitute.For <IStateReader>(), Substitute.For <IBlockchainBridgeFactory>(), Substitute.For <ISpecProvider>(), Substitute.For <IReceiptStorage>(), Substitute.For <IGasPriceOracle>(), Substitute.For <IEthSyncingInfo>()); }
public void Setup() { IDbProvider dbProvider = TestMemDbProvider.Init(); ChainLevelInfoRepository repository = new ChainLevelInfoRepository(dbProvider); ISpecProvider specProvider = MainnetSpecProvider.Instance; _blockTree = new BlockTree(dbProvider, repository, specProvider, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance); TrieStore trieStore = new TrieStore(dbProvider.StateDb, LimboLogs.Instance); StateProvider stateProvider = new StateProvider(trieStore, dbProvider.CodeDb, LimboLogs.Instance); StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, LimboLogs.Instance); BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance); VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, LimboLogs.Instance); TransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance); BlockProcessor blockProcessor = new BlockProcessor( specProvider, TestBlockValidator.AlwaysValid, NoBlockRewards.Instance, transactionProcessor, stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, NullWitnessCollector.Instance, LimboLogs.Instance); _processor = new BlockchainProcessor(_blockTree, blockProcessor, new CompositeBlockPreprocessorStep(), LimboLogs.Instance, BlockchainProcessor.Options.NoReceipts); Block genesis = Build.A.Block.Genesis.TestObject; _blockTree.SuggestBlock(genesis); _processor.Process(genesis, ProcessingOptions.None, NullBlockTracer.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() { FastSync = false }; ITimerFactory timerFactory = Substitute.For <ITimerFactory>(); NodeStatsManager stats = new(timerFactory, LimboLogs.Instance); _pool = new SyncPeerPool(_blockTree, stats, new TotalDifficultyBetterPeerStrategy(LimboLogs.Instance), 25, LimboLogs.Instance); SyncConfig syncConfig = new(); ProgressTracker progressTracker = new(_blockTree, dbProvider.StateDb, LimboLogs.Instance); SnapProvider snapProvider = new(progressTracker, dbProvider, LimboLogs.Instance); TrieStore trieStore = new(_stateDb, LimboLogs.Instance); SyncProgressResolver resolver = new( _blockTree, _receiptStorage, _stateDb, trieStore, progressTracker, syncConfig, LimboLogs.Instance); TotalDifficultyBetterPeerStrategy bestPeerStrategy = new(LimboLogs.Instance); MultiSyncModeSelector syncModeSelector = new(resolver, _pool, syncConfig, No.BeaconSync, bestPeerStrategy, LimboLogs.Instance); Pivot pivot = new (syncConfig); SyncReport syncReport = new(_pool, stats, syncModeSelector, syncConfig, pivot, LimboLogs.Instance); BlockDownloaderFactory blockDownloaderFactory = new( MainnetSpecProvider.Instance, _blockTree, _receiptStorage, Always.Valid, Always.Valid, _pool, new TotalDifficultyBetterPeerStrategy(LimboLogs.Instance), syncReport, LimboLogs.Instance); _synchronizer = new Synchronizer( dbProvider, MainnetSpecProvider.Instance, _blockTree, _receiptStorage, _pool, stats, syncModeSelector, syncConfig, snapProvider, blockDownloaderFactory, pivot, syncReport, LimboLogs.Instance); _syncServer = new SyncServer( trieStore, _codeDb, _blockTree, _receiptStorage, Always.Valid, Always.Valid, _pool, syncModeSelector, quickConfig, new WitnessCollector(new MemDb(), LimboLogs.Instance), Policy.FullGossip, MainnetSpecProvider.Instance, LimboLogs.Instance); }
protected virtual async Task <TestBlockchain> Build(ISpecProvider specProvider = null, UInt256?initialValues = null) { Timestamper = new ManualTimestamper(new DateTime(2020, 2, 15, 12, 50, 30, DateTimeKind.Utc)); JsonSerializer = new EthereumJsonSerializer(); SpecProvider = specProvider ?? MainnetSpecProvider.Instance; EthereumEcdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance); ITxStorage txStorage = new InMemoryTxStorage(); DbProvider = await TestMemDbProvider.InitAsync(); State = new StateProvider(StateDb, CodeDb, LimboLogs.Instance); State.CreateAccount(TestItem.AddressA, (initialValues ?? 1000.Ether())); State.CreateAccount(TestItem.AddressB, (initialValues ?? 1000.Ether())); State.CreateAccount(TestItem.AddressC, (initialValues ?? 1000.Ether())); byte[] code = Bytes.FromHexString("0xabcd"); Keccak codeHash = Keccak.Compute(code); State.UpdateCode(code); State.UpdateCodeHash(TestItem.AddressA, codeHash, SpecProvider.GenesisSpec); Storage = new StorageProvider(StateDb, State, LimboLogs.Instance); Storage.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef")); Storage.Commit(); State.Commit(SpecProvider.GenesisSpec); State.CommitTree(); TxPool = new TxPool.TxPool( txStorage, EthereumEcdsa, SpecProvider, new TxPoolConfig(), new StateProvider(StateDb, CodeDb, LimboLogs.Instance), LimboLogs.Instance); IDb blockDb = new MemDb(); IDb headerDb = new MemDb(); IDb blockInfoDb = new MemDb(); BlockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockDb), SpecProvider, NullBloomStorage.Instance, LimboLogs.Instance); new OnChainTxWatcher(BlockTree, TxPool, SpecProvider, LimboLogs.Instance); ReceiptStorage = new InMemoryReceiptStorage(); VirtualMachine virtualMachine = new VirtualMachine(State, Storage, new BlockhashProvider(BlockTree, LimboLogs.Instance), SpecProvider, LimboLogs.Instance); TxProcessor = new TransactionProcessor(SpecProvider, State, Storage, virtualMachine, LimboLogs.Instance); BlockProcessor = CreateBlockProcessor(); BlockchainProcessor chainProcessor = new BlockchainProcessor(BlockTree, BlockProcessor, new RecoverSignatures(EthereumEcdsa, TxPool, SpecProvider, LimboLogs.Instance), LimboLogs.Instance, Nethermind.Blockchain.Processing.BlockchainProcessor.Options.Default); BlockchainProcessor = chainProcessor; chainProcessor.Start(); StateReader = new StateReader(StateDb, CodeDb, LimboLogs.Instance); TxPoolTxSource txPoolTxSource = CreateTxPoolTxSource(); ISealer sealer = new NethDevSealEngine(TestItem.AddressD); BlockProducer = new TestBlockProducer(txPoolTxSource, chainProcessor, State, sealer, BlockTree, chainProcessor, Timestamper, LimboLogs.Instance); BlockProducer.Start(); _resetEvent = new SemaphoreSlim(0); _suggestedBlockResetEvent = new ManualResetEvent(true); BlockTree.NewHeadBlock += (s, e) => { _resetEvent.Release(1); }; BlockProducer.LastProducedBlockChanged += (s, e) => { _suggestedBlockResetEvent.Set(); }; var genesis = GetGenesisBlock(); BlockTree.SuggestBlock(genesis); await _resetEvent.WaitAsync(); //if (!await _resetEvent.WaitAsync(1000)) // { // throw new InvalidOperationException("Failed to process genesis in 1s."); // } await AddBlocksOnStart(); return(this); }
public async Task Get_storage() { IDbProvider dbProvider = await TestMemDbProvider.InitAsync(); /* all testing will be touching just a single storage cell */ StorageCell storageCell = new StorageCell(_address1, UInt256.One); TrieStore trieStore = new TrieStore(dbProvider.StateDb, Logger); StateProvider state = new StateProvider(trieStore, dbProvider.CodeDb, Logger); StorageProvider storage = new StorageProvider(trieStore, state, Logger); /* to start with we need to create an account that we will be setting storage at */ state.CreateAccount(storageCell.Address, UInt256.One); state.Commit(MuirGlacier.Instance); state.CommitTree(1); /* at this stage we have an account with empty storage at the address that we want to test */ byte[] initialValue = new byte[] { 1, 2, 3 }; storage.Set(storageCell, initialValue); storage.Commit(); storage.CommitTrees(2); state.Commit(MuirGlacier.Instance); state.CommitTree(2); StateReader reader = new StateReader( new TrieStore(dbProvider.StateDb, LimboLogs.Instance), dbProvider.CodeDb, Logger); var account = reader.GetAccount(state.StateRoot, _address1); var retrieved = reader.GetStorage(account.StorageRoot, storageCell.Index); retrieved.Should().BeEquivalentTo(initialValue); /* at this stage we set the value in storage to 1,2,3 at the tested storage cell */ /* Now we are testing scenario where the storage is being changed by the block processor. * To do that we create some different storage / state access stack that represents the processor. * It is a different stack of objects than the one that is used by the blockchain bridge. */ byte[] newValue = new byte[] { 1, 2, 3, 4, 5 }; StateProvider processorStateProvider = new StateProvider(trieStore, new MemDb(), LimboLogs.Instance); processorStateProvider.StateRoot = state.StateRoot; StorageProvider processorStorageProvider = new StorageProvider(trieStore, processorStateProvider, LimboLogs.Instance); processorStorageProvider.Set(storageCell, newValue); processorStorageProvider.Commit(); processorStorageProvider.CommitTrees(3); processorStateProvider.Commit(MuirGlacier.Instance); processorStateProvider.CommitTree(3); /* At this stage the DB should have the storage value updated to 5. * We will try to retrieve the value by taking the state root from the processor.*/ retrieved = reader.GetStorage(processorStateProvider.GetStorageRoot(storageCell.Address), storageCell.Index); retrieved.Should().BeEquivalentTo(newValue); /* If it failed then it means that the blockchain bridge cached the previous call value */ }
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); }
public void GlobalSetup() { var dbProvider = TestMemDbProvider.Init(); IDb codeDb = dbProvider.CodeDb; IDb stateDb = dbProvider.StateDb; IDb blockInfoDb = new MemDb(10, 5); ISpecProvider specProvider = MainnetSpecProvider.Instance; IReleaseSpec spec = MainnetSpecProvider.Instance.GenesisSpec; var trieStore = new TrieStore(stateDb, LimboLogs.Instance); StateProvider stateProvider = new(trieStore, codeDb, LimboLogs.Instance); stateProvider.CreateAccount(Address.Zero, 1000.Ether()); stateProvider.Commit(spec); StorageProvider storageProvider = new(trieStore, stateProvider, LimboLogs.Instance); StateReader stateReader = new(trieStore, codeDb, LimboLogs.Instance); ChainLevelInfoRepository chainLevelInfoRepository = new (blockInfoDb); BlockTree blockTree = new(dbProvider, chainLevelInfoRepository, specProvider, NullBloomStorage.Instance, LimboLogs.Instance); _blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance); _virtualMachine = new VirtualMachine(_blockhashProvider, specProvider, LimboLogs.Instance); Block genesisBlock = Build.A.Block.Genesis.TestObject; blockTree.SuggestBlock(genesisBlock); Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject; blockTree.SuggestBlock(block1); TransactionProcessor transactionProcessor = new(MainnetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance); IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor = new BlockProcessor.BlockValidationTransactionsExecutor(transactionProcessor, stateProvider); BlockProcessor blockProcessor = new(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionsExecutor, stateProvider, storageProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, LimboLogs.Instance); EthereumEcdsa ecdsa = new(specProvider.ChainId, LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new( blockTree, blockProcessor, new RecoverSignatures( ecdsa, NullTxPool.Instance, specProvider, LimboLogs.Instance), LimboLogs.Instance, BlockchainProcessor.Options.NoReceipts); blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance); blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance); IBloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory()); LogFinder logFinder = new( blockTree, new InMemoryReceiptStorage(), bloomStorage, LimboLogs.Instance, new ReceiptsRecovery(ecdsa, specProvider)); BlockchainBridge bridge = new( new ReadOnlyTxProcessingEnv( new ReadOnlyDbProvider(dbProvider, false), trieStore.AsReadOnly(), new ReadOnlyBlockTree(blockTree), specProvider, LimboLogs.Instance), NullTxPool.Instance, NullReceiptStorage.Instance, NullFilterStore.Instance, NullFilterManager.Instance, ecdsa, Timestamper.Default, logFinder, specProvider, false); GasPriceOracle gasPriceOracle = new(blockTree, specProvider); FeeHistoryOracle feeHistoryOracle = new(blockTree, NullReceiptStorage.Instance, specProvider); EthSyncingInfo ethSyncingInfo = new(blockTree); _ethModule = new EthRpcModule( new JsonRpcConfig(), bridge, blockTree, stateReader, NullTxPool.Instance, NullTxSender.Instance, NullWallet.Instance, Substitute.For <IReceiptFinder>(), LimboLogs.Instance, specProvider, gasPriceOracle, ethSyncingInfo, feeHistoryOracle); }
private SyncTestContext CreateSyncManager(int index) { NoErrorLimboLogs logManager = NoErrorLimboLogs.Instance; ConsoleAsyncLogger logger = new(LogLevel.Debug, "PEER " + index + " "); // var logManager = new OneLoggerLogManager(logger); SingleReleaseSpecProvider specProvider = new(ConstantinopleFix.Instance, MainnetSpecProvider.Instance.ChainId); IDbProvider dbProvider = TestMemDbProvider.Init(); IDb blockDb = dbProvider.BlocksDb; IDb headerDb = dbProvider.HeadersDb; IDb blockInfoDb = dbProvider.BlockInfosDb; IDb codeDb = dbProvider.CodeDb; IDb stateDb = dbProvider.StateDb; TrieStore trieStore = new(stateDb, LimboLogs.Instance); StateReader stateReader = new(trieStore, codeDb, logManager); StateProvider stateProvider = new(trieStore, codeDb, logManager); stateProvider.CreateAccount(TestItem.AddressA, 10000.Ether()); stateProvider.Commit(specProvider.GenesisSpec); stateProvider.CommitTree(0); stateProvider.RecalculateStateRoot(); StorageProvider storageProvider = new(trieStore, stateProvider, logManager); InMemoryReceiptStorage receiptStorage = new(); EthereumEcdsa ecdsa = new(specProvider.ChainId, logManager); BlockTree tree = new(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, NullBloomStorage.Instance, logManager); ITransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, tree); TxPool.TxPool txPool = new(new InMemoryTxStorage(), ecdsa, new ChainHeadInfoProvider(specProvider, tree, stateReader), new TxPoolConfig(), new TxValidator(specProvider.ChainId), logManager, transactionComparerProvider.GetDefaultComparer()); BlockhashProvider blockhashProvider = new(tree, LimboLogs.Instance); VirtualMachine virtualMachine = new(stateProvider, storageProvider, blockhashProvider, specProvider, logManager); Always sealValidator = Always.Valid; HeaderValidator headerValidator = new(tree, sealValidator, specProvider, logManager); Always txValidator = Always.Valid; OmmersValidator ommersValidator = new(tree, headerValidator, logManager); BlockValidator blockValidator = new(txValidator, headerValidator, ommersValidator, specProvider, logManager); ISyncConfig syncConfig = _synchronizerType == SynchronizerType.Fast ? SyncConfig.WithFastSync : SyncConfig.WithFullSyncOnly; RewardCalculator rewardCalculator = new(specProvider); TransactionProcessor txProcessor = new(specProvider, stateProvider, storageProvider, virtualMachine, logManager); BlockProcessor blockProcessor = new( specProvider, blockValidator, rewardCalculator, txProcessor, stateProvider, storageProvider, txPool, receiptStorage, NullWitnessCollector.Instance, logManager); RecoverSignatures step = new(ecdsa, txPool, specProvider, logManager); BlockchainProcessor processor = new(tree, blockProcessor, step, logManager, BlockchainProcessor.Options.Default); ITimerFactory timerFactory = Substitute.For <ITimerFactory>(); NodeStatsManager nodeStatsManager = new(timerFactory, logManager); SyncPeerPool syncPeerPool = new(tree, nodeStatsManager, 25, logManager); StateProvider devState = new(trieStore, codeDb, logManager); StorageProvider devStorage = new(trieStore, devState, logManager); VirtualMachine devEvm = new(devState, devStorage, blockhashProvider, specProvider, logManager); TransactionProcessor devTxProcessor = new(specProvider, devState, devStorage, devEvm, logManager); BlockProcessor devBlockProcessor = new( specProvider, blockValidator, rewardCalculator, devTxProcessor, devState, devStorage, txPool, receiptStorage, NullWitnessCollector.Instance, logManager); BlockchainProcessor devChainProcessor = new(tree, devBlockProcessor, step, logManager, BlockchainProcessor.Options.NoReceipts); ITxFilterPipeline txFilterPipeline = TxFilterPipelineBuilder.CreateStandardFilteringPipeline(LimboLogs.Instance, specProvider); TxPoolTxSource transactionSelector = new(txPool, stateReader, specProvider, transactionComparerProvider, logManager, txFilterPipeline); DevBlockProducer producer = new( transactionSelector, devChainProcessor, stateProvider, tree, processor, new BuildBlocksRegularly(TimeSpan.FromMilliseconds(50)).IfPoolIsNotEmpty(txPool), Timestamper.Default, specProvider, new MiningConfig(), logManager); SyncProgressResolver resolver = new( tree, receiptStorage, stateDb, new MemDb(), NullTrieNodeResolver.Instance, syncConfig, logManager); MultiSyncModeSelector selector = new(resolver, syncPeerPool, syncConfig, logManager); Synchronizer synchronizer = new( dbProvider, MainnetSpecProvider.Instance, tree, NullReceiptStorage.Instance, blockValidator, sealValidator, syncPeerPool, nodeStatsManager, StaticSelector.Full, syncConfig, logManager); SyncServer syncServer = new( stateDb, codeDb, tree, receiptStorage, Always.Valid, Always.Valid, syncPeerPool, selector, syncConfig, NullWitnessCollector.Instance, logManager); ManualResetEventSlim waitEvent = new(); tree.NewHeadBlock += (_, _) => 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(); 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(bool auRa = false) { IDbProvider dbProvider = await TestMemDbProvider.InitAsync(); ISpecProvider specProvider = MainnetSpecProvider.Instance; _jsonRpcConfig = new JsonRpcConfig(); IEthereumEcdsa ethereumEcdsa = new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance); ITxStorage txStorage = new InMemoryTxStorage(); _stateDb = new StateDb(); _stateProvider = new StateProvider(dbProvider, LimboLogs.Instance); _stateProvider.CreateAccount(TestItem.AddressA, 1000.Ether()); _stateProvider.CreateAccount(TestItem.AddressB, 1000.Ether()); _stateProvider.CreateAccount(TestItem.AddressC, 1000.Ether()); byte[] code = Bytes.FromHexString("0xabcd"); Keccak codeHash = Keccak.Compute(code); _stateProvider.UpdateCode(code); _stateProvider.UpdateCodeHash(TestItem.AddressA, codeHash, specProvider.GenesisSpec); IStorageProvider storageProvider = new StorageProvider(_stateDb, _stateProvider, LimboLogs.Instance); storageProvider.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef")); storageProvider.Commit(); _stateProvider.Commit(specProvider.GenesisSpec); _stateProvider.CommitTree(); ITxPool txPool = new TxPool.TxPool(txStorage, ethereumEcdsa, specProvider, new TxPoolConfig(), _stateProvider, LimboLogs.Instance); IChainLevelInfoRepository chainLevels = new ChainLevelInfoRepository(dbProvider); IBlockTree blockTree = new BlockTree(dbProvider, chainLevels, specProvider, NullBloomStorage.Instance, LimboLogs.Instance); IReceiptStorage receiptStorage = new InMemoryReceiptStorage(); VirtualMachine virtualMachine = new VirtualMachine(_stateProvider, storageProvider, new BlockhashProvider(blockTree, LimboLogs.Instance), specProvider, LimboLogs.Instance); TransactionProcessor txProcessor = new TransactionProcessor(specProvider, _stateProvider, storageProvider, virtualMachine, LimboLogs.Instance); IBlockProcessor blockProcessor = new BlockProcessor( specProvider, Always.Valid, new RewardCalculator(specProvider), txProcessor, dbProvider.StateDb, dbProvider.CodeDb, _stateProvider, storageProvider, txPool, receiptStorage, LimboLogs.Instance); var signatureRecovery = new RecoverSignatures(ethereumEcdsa, txPool, specProvider, LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, signatureRecovery, LimboLogs.Instance, BlockchainProcessor.Options.Default); blockchainProcessor.Start(); ManualResetEventSlim resetEvent = new ManualResetEventSlim(false); blockTree.NewHeadBlock += (s, e) => { Console.WriteLine(e.Block.Header.Hash); if (e.Block.Number == 9) { resetEvent.Set(); } }; var genesisBlockBuilder = Build.A.Block.Genesis.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f")); if (auRa) { genesisBlockBuilder.WithAura(0, new byte[65]); } Block genesis = genesisBlockBuilder.TestObject; blockTree.SuggestBlock(genesis); Block previousBlock = genesis; for (int i = 1; i < 10; i++) { List <Transaction> transactions = new List <Transaction>(); for (int j = 0; j < i; j++) { transactions.Add(Build.A.Transaction.WithNonce((UInt256)j).SignedAndResolved().TestObject); } BlockBuilder builder = Build.A.Block.WithNumber(i).WithParent(previousBlock).WithTransactions(transactions.ToArray()).WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f")); if (auRa) { builder.WithAura(i, i.ToByteArray()); } Block block = builder.TestObject; blockTree.SuggestBlock(block); previousBlock = block; } ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance), specProvider); IReceiptFinder receiptFinder = new FullInfoReceiptFinder(receiptStorage, receiptsRecovery, blockTree); resetEvent.Wait(2000); _traceModule = new TraceModule(receiptFinder, new Tracer(_stateProvider, blockchainProcessor), blockTree, _jsonRpcConfig); }
public static NethermindApi ContextWithMocks() => new NethermindApi() { LogManager = LimboLogs.Instance, Enode = Substitute.For <IEnode>(), TxPool = Substitute.For <ITxPool>(), Wallet = Substitute.For <IWallet>(), BlockTree = Substitute.For <IBlockTree>(), SyncServer = Substitute.For <ISyncServer>(), DbProvider = TestMemDbProvider.Init(), PeerManager = Substitute.For <IPeerManager>(), PeerPool = Substitute.For <IPeerPool>(), SpecProvider = Substitute.For <ISpecProvider>(), EthereumEcdsa = Substitute.For <IEthereumEcdsa>(), MainBlockProcessor = Substitute.For <IBlockProcessor>(), ReceiptStorage = Substitute.For <IReceiptStorage>(), ReceiptFinder = Substitute.For <IReceiptFinder>(), BlockValidator = Substitute.For <IBlockValidator>(), RewardCalculatorSource = Substitute.For <IRewardCalculatorSource>(), TxPoolInfoProvider = Substitute.For <ITxPoolInfoProvider>(), StaticNodesManager = Substitute.For <IStaticNodesManager>(), BloomStorage = Substitute.For <IBloomStorage>(), Sealer = Substitute.For <ISealer>(), Synchronizer = Substitute.For <ISynchronizer>(), BlockchainProcessor = Substitute.For <IBlockchainProcessor>(), BlockProducer = Substitute.For <IBlockProducer>(), ConfigProvider = Substitute.For <IConfigProvider>(), DiscoveryApp = Substitute.For <IDiscoveryApp>(), EngineSigner = Substitute.For <ISigner>(), FileSystem = Substitute.For <IFileSystem>(), FilterManager = Substitute.For <IFilterManager>(), FilterStore = Substitute.For <IFilterStore>(), GrpcServer = Substitute.For <IGrpcServer>(), HeaderValidator = Substitute.For <IHeaderValidator>(), IpResolver = Substitute.For <IIPResolver>(), KeyStore = Substitute.For <IKeyStore>(), LogFinder = Substitute.For <ILogFinder>(), MonitoringService = Substitute.For <IMonitoringService>(), ProtocolsManager = Substitute.For <IProtocolsManager>(), ProtocolValidator = Substitute.For <IProtocolValidator>(), RlpxPeer = Substitute.For <IRlpxHost>(), SealValidator = Substitute.For <ISealValidator>(), SessionMonitor = Substitute.For <ISessionMonitor>(), SnapProvider = Substitute.For <ISnapProvider>(), StateProvider = Substitute.For <IStateProvider>(), StateReader = Substitute.For <IStateReader>(), StorageProvider = Substitute.For <IStorageProvider>(), TransactionProcessor = Substitute.For <ITransactionProcessor>(), TxSender = Substitute.For <ITxSender>(), BlockProcessingQueue = Substitute.For <IBlockProcessingQueue>(), EngineSignerStore = Substitute.For <ISignerStore>(), EthereumJsonSerializer = Substitute.For <IJsonSerializer>(), NodeStatsManager = Substitute.For <INodeStatsManager>(), RpcModuleProvider = Substitute.For <IRpcModuleProvider>(), SyncModeSelector = Substitute.For <ISyncModeSelector>(), SyncPeerPool = Substitute.For <ISyncPeerPool>(), PeerDifficultyRefreshPool = Substitute.For <IPeerDifficultyRefreshPool>(), WebSocketsManager = Substitute.For <IWebSocketsManager>(), ChainLevelInfoRepository = Substitute.For <IChainLevelInfoRepository>(), TrieStore = Substitute.For <ITrieStore>(), ReadOnlyTrieStore = Substitute.For <IReadOnlyTrieStore>(), ChainSpec = new ChainSpec(), BlockProducerEnvFactory = Substitute.For <IBlockProducerEnvFactory>(), TransactionComparerProvider = Substitute.For <ITransactionComparerProvider>(), GasPriceOracle = Substitute.For <IGasPriceOracle>(), EthSyncingInfo = Substitute.For <IEthSyncingInfo>(), HealthHintService = Substitute.For <IHealthHintService>(), TxValidator = new TxValidator(MainnetSpecProvider.Instance.ChainId), UnclesValidator = Substitute.For <IUnclesValidator>(), BlockProductionPolicy = Substitute.For <IBlockProductionPolicy>(), SyncProgressResolver = Substitute.For <ISyncProgressResolver>(), BetterPeerStrategy = Substitute.For <IBetterPeerStrategy>(), ReceiptMonitor = Substitute.For <IReceiptMonitor>(), WitnessRepository = Substitute.For <IWitnessRepository>() };