public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = false)
{
if (_logger.IsInfo)
{
_logger.Info($"CREATING NODE {privateKey.Address}");
}
_logManagers[privateKey] = LimboLogs.Instance;
// _logManagers[privateKey] = new OneLoggerLogManager(new ConsoleAsyncLogger(LogLevel.Debug, $"{privateKey.Address} "));
var nodeLogManager = _logManagers[privateKey];
AutoResetEvent newHeadBlockEvent = new AutoResetEvent(false);
_blockEvents.Add(privateKey, newHeadBlockEvent);
MemDb blocksDb = new MemDb();
MemDb headersDb = new MemDb();
MemDb blockInfoDb = new MemDb();
MemDb stateDb = new MemDb();
MemDb codeDb = new MemDb();
ISpecProvider specProvider = RinkebySpecProvider.Instance;
var trieStore = new TrieStore(stateDb, nodeLogManager);
StateReader stateReader = new StateReader(trieStore, codeDb, nodeLogManager);
StateProvider stateProvider = new StateProvider(trieStore, codeDb, nodeLogManager);
stateProvider.CreateAccount(TestItem.PrivateKeyD.Address, 100.Ether());
GoerliSpecProvider goerliSpecProvider = GoerliSpecProvider.Instance;
stateProvider.Commit(goerliSpecProvider.GenesisSpec);
stateProvider.CommitTree(0);
BlockTree blockTree = new BlockTree(blocksDb, headersDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), goerliSpecProvider, NullBloomStorage.Instance, nodeLogManager);
blockTree.NewHeadBlock += (sender, args) => { _blockEvents[privateKey].Set(); };
ITransactionComparerProvider transactionComparerProvider =
new TransactionComparerProvider(specProvider, blockTree);
TxPool.TxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), _ethereumEcdsa, new ChainHeadInfoProvider(new FixedBlockChainHeadSpecProvider(GoerliSpecProvider.Instance), blockTree, stateProvider), new TxPoolConfig(), new TxValidator(goerliSpecProvider.ChainId), _logManager, transactionComparerProvider.GetDefaultComparer());
_pools[privateKey] = txPool;
BlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_blockTrees.Add(privateKey, blockTree);
SnapshotManager snapshotManager = new SnapshotManager(_cliqueConfig, blocksDb, blockTree, _ethereumEcdsa, nodeLogManager);
_snapshotManager[privateKey] = snapshotManager;
CliqueSealer cliqueSealer = new CliqueSealer(new Signer(ChainId.Goerli, privateKey, LimboLogs.Instance), _cliqueConfig, snapshotManager, nodeLogManager);
_genesis.Header.StateRoot = _genesis3Validators.Header.StateRoot = stateProvider.StateRoot;
_genesis.Header.Hash = _genesis.Header.CalculateHash();
_genesis3Validators.Header.Hash = _genesis3Validators.Header.CalculateHash();
StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, nodeLogManager);
TransactionProcessor transactionProcessor = new TransactionProcessor(goerliSpecProvider, stateProvider, storageProvider, new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, nodeLogManager), nodeLogManager);
BlockProcessor blockProcessor = new BlockProcessor(
goerliSpecProvider,
Always.Valid,
NoBlockRewards.Instance,
transactionProcessor,
stateProvider,
storageProvider,
txPool,
NullReceiptStorage.Instance,
NullWitnessCollector.Instance,
nodeLogManager);
BlockchainProcessor processor = new BlockchainProcessor(blockTree, blockProcessor, new AuthorRecoveryStep(snapshotManager), nodeLogManager, BlockchainProcessor.Options.NoReceipts);
processor.Start();
var minerTrieStore = trieStore.AsReadOnly();
StateProvider minerStateProvider = new StateProvider(minerTrieStore, codeDb, nodeLogManager);
StorageProvider minerStorageProvider = new StorageProvider(minerTrieStore, minerStateProvider, nodeLogManager);
VirtualMachine minerVirtualMachine = new VirtualMachine(minerStateProvider, minerStorageProvider, blockhashProvider, specProvider, nodeLogManager);
TransactionProcessor minerTransactionProcessor = new TransactionProcessor(goerliSpecProvider, minerStateProvider, minerStorageProvider, minerVirtualMachine, nodeLogManager);
BlockProcessor minerBlockProcessor = new BlockProcessor(
goerliSpecProvider,
Always.Valid,
NoBlockRewards.Instance,
minerTransactionProcessor,
minerStateProvider,
minerStorageProvider,
txPool,
NullReceiptStorage.Instance,
NullWitnessCollector.Instance,
nodeLogManager);
BlockchainProcessor minerProcessor = new BlockchainProcessor(blockTree, minerBlockProcessor, new AuthorRecoveryStep(snapshotManager), nodeLogManager, BlockchainProcessor.Options.NoReceipts);
if (withGenesisAlreadyProcessed)
{
ProcessGenesis(privateKey);
}
ITxFilterPipeline txFilterPipeline = TxFilterPipelineBuilder.CreateStandardFilteringPipeline(nodeLogManager, specProvider);
TxPoolTxSource txPoolTxSource = new TxPoolTxSource(txPool, stateReader, specProvider, transactionComparerProvider, nodeLogManager, txFilterPipeline);
CliqueBlockProducer blockProducer = new CliqueBlockProducer(
txPoolTxSource,
minerProcessor,
minerStateProvider,
blockTree,
_timestamper,
new CryptoRandom(),
snapshotManager,
cliqueSealer,
new TargetAdjustedGasLimitCalculator(goerliSpecProvider, new MiningConfig()),
MainnetSpecProvider.Instance,
_cliqueConfig,
nodeLogManager);
blockProducer.Start();
_producers.Add(privateKey, blockProducer);
return(this);
}
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, LogManager);
ITxStorage txStorage = new InMemoryTxStorage();
DbProvider = await TestMemDbProvider.InitAsync();
TrieStore = new TrieStore(StateDb.Innermost, LogManager);
State = new StateProvider(TrieStore, DbProvider.CodeDb, LogManager);
State.CreateAccount(TestItem.AddressA, (initialValues ?? InitialValue));
State.CreateAccount(TestItem.AddressB, (initialValues ?? InitialValue));
State.CreateAccount(TestItem.AddressC, (initialValues ?? InitialValue));
byte[] code = Bytes.FromHexString("0xabcd");
Keccak codeHash = Keccak.Compute(code);
State.UpdateCode(code);
State.UpdateCodeHash(TestItem.AddressA, codeHash, SpecProvider.GenesisSpec);
Storage = new StorageProvider(TrieStore, State, LogManager);
Storage.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
Storage.Commit();
State.Commit(SpecProvider.GenesisSpec);
State.CommitTree(0);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
BlockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), SpecProvider, NullBloomStorage.Instance, LimboLogs.Instance);
TransactionComparerProvider = new TransactionComparerProvider(specProvider, BlockTree);
TxPool = CreateTxPool(txStorage);
new OnChainTxWatcher(BlockTree, TxPool, SpecProvider, LimboLogs.Instance);
ReceiptStorage = new InMemoryReceiptStorage();
VirtualMachine virtualMachine = new VirtualMachine(State, Storage, new BlockhashProvider(BlockTree, LogManager), SpecProvider, LogManager);
TxProcessor = new TransactionProcessor(SpecProvider, State, Storage, virtualMachine, LogManager);
BlockProcessor = CreateBlockProcessor();
BlockPreprocessorStep = new RecoverSignatures(EthereumEcdsa, TxPool, SpecProvider, LogManager);
BlockchainProcessor chainProcessor = new BlockchainProcessor(BlockTree, BlockProcessor, BlockPreprocessorStep, LogManager, Nethermind.Blockchain.Processing.BlockchainProcessor.Options.Default);
BlockchainProcessor = chainProcessor;
BlockProcessingQueue = chainProcessor;
chainProcessor.Start();
ReadOnlyTrieStore = TrieStore.AsReadOnly();
StateReader = new StateReader(ReadOnlyTrieStore, CodeDb, LogManager);
TxPoolTxSource txPoolTxSource = CreateTxPoolTxSource();
ISealer sealer = new NethDevSealEngine(TestItem.AddressD);
IStateProvider producerStateProvider = new StateProvider(ReadOnlyTrieStore, CodeDb, LogManager);
BlockProducer = CreateTestBlockProducer(txPoolTxSource, chainProcessor, producerStateProvider, sealer);
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 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);
}
protected override TxPoolTxSource CreateTxPoolTxSource()
{
TxPoolTxSource txPoolTxSource = base.CreateTxPoolTxSource();
TxPriorityContract = new TxPriorityContract(new AbiEncoder(), TestItem.AddressA,
new ReadOnlyTxProcessingEnv(DbProvider, TrieStore.AsReadOnly(), BlockTree, SpecProvider, LimboLogs.Instance));
Priorities = new DictionaryContractDataStore <TxPriorityContract.Destination>(
new TxPriorityContract.DestinationSortedListContractDataStoreCollection(),
TxPriorityContract.Priorities,
BlockTree,
ReceiptStorage,
LimboLogs.Instance,
GetPrioritiesLocalDataStore());
MinGasPrices = new DictionaryContractDataStore <TxPriorityContract.Destination>(
new TxPriorityContract.DestinationSortedListContractDataStoreCollection(),
TxPriorityContract.MinGasPrices,
BlockTree,
ReceiptStorage,
LimboLogs.Instance,
GetMinGasPricesLocalDataStore());
SendersWhitelist = new ContractDataStoreWithLocalData <Address>(new HashSetContractDataStoreCollection <Address>(),
TxPriorityContract.SendersWhitelist,
BlockTree,
ReceiptStorage,
LimboLogs.Instance,
GetWhitelistLocalDataStore());
return(txPoolTxSource);
}
