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