public async Task StopAsync()
{
await(BlockchainProcessor?.StopAsync() ?? Task.CompletedTask);
await(BlockProducer?.StopAsync() ?? Task.CompletedTask);
await(PeerPool?.StopAsync() ?? Task.CompletedTask);
await(Synchronizer?.StopAsync() ?? Task.CompletedTask);
Logger?.Flush();
}
protected async Task RunTest(LegacyBlockchainTest test, Stopwatch stopwatch = null)
{
TestContext.Write($"Running {test.Name} at {DateTime.UtcNow:HH:mm:ss.ffffff}");
Assert.IsNull(test.LoadFailure, "test data loading failure");
ISnapshotableDb stateDb = new StateDb();
ISnapshotableDb codeDb = new StateDb();
IDb traceDb = new MemDb();
ISpecProvider specProvider;
if (test.NetworkAfterTransition != null)
{
specProvider = new CustomSpecProvider(
(0, Frontier.Instance),
(1, test.Network),
(test.TransitionBlockNumber, test.NetworkAfterTransition));
}
else
{
specProvider = new CustomSpecProvider(
(0, Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
(1, test.Network));
}
if (specProvider.GenesisSpec != Frontier.Instance)
{
Assert.Fail("Expected genesis spec to be Frontier for blockchain tests");
}
DifficultyCalculator.Wrapped = new DifficultyCalculator(specProvider);
IRewardCalculator rewardCalculator = new RewardCalculator(specProvider);
IEthereumEcdsa ecdsa = new EthereumEcdsa(specProvider, _logManager);
IStateProvider stateProvider = new StateProvider(stateDb, codeDb, _logManager);
ITxPool transactionPool = new TxPool(NullTxStorage.Instance, new Timestamper(), ecdsa, specProvider, new TxPoolConfig(), stateProvider, _logManager);
IReceiptStorage receiptStorage = NullReceiptStorage.Instance;
var blockInfoDb = new MemDb();
IBlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, transactionPool, _logManager);
IBlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, _logManager);
ITxValidator txValidator = new TxValidator(ChainId.MainNet);
IHeaderValidator headerValidator = new HeaderValidator(blockTree, Sealer, specProvider, _logManager);
IOmmersValidator ommersValidator = new OmmersValidator(blockTree, headerValidator, _logManager);
IBlockValidator blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, _logManager);
IStorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, _logManager);
IVirtualMachine virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
specProvider,
_logManager);
IBlockProcessor blockProcessor = new BlockProcessor(
specProvider,
blockValidator,
rewardCalculator,
new TransactionProcessor(
specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager),
stateDb,
codeDb,
traceDb,
stateProvider,
storageProvider,
transactionPool,
receiptStorage,
_logManager);
IBlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new TxSignaturesRecoveryStep(ecdsa, NullTxPool.Instance, _logManager),
_logManager,
false,
false);
InitializeTestState(test, stateProvider, storageProvider, specProvider);
List <(Block Block, string ExpectedException)> correctRlpsBlocks = new List <(Block, string)>();
for (int i = 0; i < test.Blocks.Length; i++)
{
try
{
TestBlockJson testBlockJson = test.Blocks[i];
var rlpContext = Bytes.FromHexString(testBlockJson.Rlp).AsRlpStream();
Block suggestedBlock = Rlp.Decode <Block>(rlpContext);
suggestedBlock.Header.SealEngineType = test.SealEngineUsed ? SealEngineType.Ethash : SealEngineType.None;
Assert.AreEqual(new Keccak(testBlockJson.BlockHeader.Hash), suggestedBlock.Header.Hash, "hash of the block");
for (int ommerIndex = 0; ommerIndex < suggestedBlock.Ommers.Length; ommerIndex++)
{
Assert.AreEqual(new Keccak(testBlockJson.UncleHeaders[ommerIndex].Hash), suggestedBlock.Ommers[ommerIndex].Hash, "hash of the ommer");
}
correctRlpsBlocks.Add((suggestedBlock, testBlockJson.ExpectedException));
}
catch (Exception)
{
_logger?.Info($"Invalid RLP ({i})");
}
}
if (correctRlpsBlocks.Count == 0)
{
Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), test.LastBlockHash);
return;
}
if (test.GenesisRlp == null)
{
test.GenesisRlp = Rlp.Encode(new Block(JsonToBlockchainTest.Convert(test.GenesisBlockHeader)));
}
Block genesisBlock = Rlp.Decode <Block>(test.GenesisRlp.Bytes);
Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), genesisBlock.Header.Hash, "genesis header hash");
ManualResetEvent genesisProcessed = new ManualResetEvent(false);
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 0)
{
Assert.AreEqual(genesisBlock.Header.StateRoot, stateProvider.StateRoot, "genesis state root");
genesisProcessed.Set();
}
};
blockchainProcessor.Start();
blockTree.SuggestBlock(genesisBlock);
genesisProcessed.WaitOne();
for (int i = 0; i < correctRlpsBlocks.Count; i++)
{
stopwatch?.Start();
try
{
if (correctRlpsBlocks[i].ExpectedException != null)
{
_logger.Info($"Expecting block exception: {correctRlpsBlocks[i].ExpectedException}");
}
if (correctRlpsBlocks[i].Block.Hash == null)
{
throw new Exception($"null hash in {test.Name} block {i}");
}
// TODO: mimic the actual behaviour where block goes through validating sync manager?
if (!test.SealEngineUsed || blockValidator.ValidateSuggestedBlock(correctRlpsBlocks[i].Block))
{
blockTree.SuggestBlock(correctRlpsBlocks[i].Block);
}
else
{
Console.WriteLine("Invalid block");
}
}
catch (InvalidBlockException)
{
}
catch (Exception ex)
{
_logger?.Info(ex.ToString());
}
}
await blockchainProcessor.StopAsync(true);
stopwatch?.Stop();
List <string> differences = RunAssertions(test, blockTree.RetrieveHeadBlock(), storageProvider, stateProvider);
// if (differences.Any())
// {
// BlockTrace blockTrace = blockchainProcessor.TraceBlock(blockTree.BestSuggested.Hash);
// _logger.Info(new UnforgivingJsonSerializer().Serialize(blockTrace, true));
// }
Assert.Zero(differences.Count, "differences");
}
private static async Task RunBenchmarkBlocks()
{
Rlp.RegisterDecoders(typeof(ParityTraceDecoder).Assembly);
/* logging & instrumentation */
_logManager = new NLogManager("perfTest.logs.txt", null);
_logger = _logManager.GetClassLogger();
if (_logger.IsInfo)
{
_logger.Info("Deleting state DBs");
}
DeleteDb(FullStateDbPath);
DeleteDb(FullCodeDbPath);
DeleteDb(FullReceiptsDbPath);
DeleteDb(FullPendingTxsDbPath);
if (_logger.IsInfo)
{
_logger.Info("State DBs deleted");
}
/* load spec */
ChainSpecLoader loader = new ChainSpecLoader(new EthereumJsonSerializer());
string path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"chainspec", "ropsten.json"));
_logger.Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllText(path));
_logger.Info($"ChainSpec loaded");
var specProvider = new ChainSpecBasedSpecProvider(chainSpec);
IRewardCalculator rewardCalculator = new RewardCalculator(specProvider);
var dbProvider = new RocksDbProvider(DbBasePath, DbConfig.Default, _logManager, true, true);
var stateDb = dbProvider.StateDb;
var codeDb = dbProvider.CodeDb;
var traceDb = dbProvider.TraceDb;
var blocksDb = dbProvider.BlocksDb;
var headersDb = dbProvider.HeadersDb;
var blockInfosDb = dbProvider.BlockInfosDb;
var receiptsDb = dbProvider.ReceiptsDb;
/* state & storage */
var stateProvider = new StateProvider(stateDb, codeDb, _logManager);
var storageProvider = new StorageProvider(stateDb, stateProvider, _logManager);
var ethereumSigner = new EthereumEcdsa(specProvider, _logManager);
var transactionPool = new TxPool(
NullTxStorage.Instance,
Timestamper.Default,
ethereumSigner,
specProvider,
new TxPoolConfig(),
stateProvider,
_logManager);
var blockInfoRepository = new ChainLevelInfoRepository(blockInfosDb);
var blockTree = new UnprocessedBlockTreeWrapper(new BlockTree(blocksDb, headersDb, blockInfosDb, blockInfoRepository, specProvider, transactionPool, _logManager));
var receiptStorage = new InMemoryReceiptStorage();
IBlockDataRecoveryStep recoveryStep = new TxSignaturesRecoveryStep(ethereumSigner, transactionPool, _logManager);
/* blockchain processing */
IList <IAdditionalBlockProcessor> blockProcessors = new List <IAdditionalBlockProcessor>();
var blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, _logManager);
var processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, _logManager);
ISealValidator sealValidator;
if (specProvider.ChainId == RopstenSpecProvider.Instance.ChainId)
{
var difficultyCalculator = new DifficultyCalculator(specProvider);
sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
}
else if (chainSpec.SealEngineType == SealEngineType.Clique)
{
var snapshotManager = new SnapshotManager(CliqueConfig.Default, blocksDb, blockTree, ethereumSigner, _logManager);
sealValidator = new CliqueSealValidator(CliqueConfig.Default, snapshotManager, _logManager);
rewardCalculator = NoBlockRewards.Instance;
recoveryStep = new CompositeDataRecoveryStep(recoveryStep, new AuthorRecoveryStep(snapshotManager));
}
else if (chainSpec.SealEngineType == SealEngineType.AuRa)
{
var abiEncoder = new AbiEncoder();
var validatorProcessor = new AuRaAdditionalBlockProcessorFactory(dbProvider.StateDb, stateProvider, abiEncoder, processor, blockTree, receiptStorage, _logManager)
.CreateValidatorProcessor(chainSpec.AuRa.Validators);
sealValidator = new AuRaSealValidator(chainSpec.AuRa, new AuRaStepCalculator(chainSpec.AuRa.StepDuration, new Timestamper()), validatorProcessor, ethereumSigner, _logManager);
rewardCalculator = new AuRaRewardCalculator(chainSpec.AuRa, abiEncoder, processor);
blockProcessors.Add(validatorProcessor);
}
else
{
throw new NotSupportedException();
}
/* store & validation */
var headerValidator = new HeaderValidator(blockTree, sealValidator, specProvider, _logManager);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, _logManager);
var transactionValidator = new TxValidator(chainSpec.ChainId);
var blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, _logManager);
/* blockchain processing */
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, processor, stateDb, codeDb, traceDb, stateProvider, storageProvider, transactionPool, receiptStorage, _logManager, blockProcessors);
var blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, recoveryStep, _logManager, true, false);
if (chainSpec.SealEngineType == SealEngineType.AuRa)
{
stateProvider.CreateAccount(Address.Zero, UInt256.Zero);
storageProvider.Commit();
stateProvider.Commit(Homestead.Instance);
var finalizationManager = new AuRaBlockFinalizationManager(blockTree, blockInfoRepository, blockProcessor, blockProcessors.OfType <IAuRaValidator>().First(), _logManager);
}
foreach ((Address address, ChainSpecAllocation allocation) in chainSpec.Allocations)
{
stateProvider.CreateAccount(address, allocation.Balance);
if (allocation.Code != null)
{
Keccak codeHash = stateProvider.UpdateCode(allocation.Code);
stateProvider.UpdateCodeHash(address, codeHash, specProvider.GenesisSpec);
}
if (allocation.Constructor != null)
{
Transaction constructorTransaction = new Transaction(true)
{
SenderAddress = address,
Init = allocation.Constructor,
GasLimit = chainSpec.Genesis.GasLimit
};
processor.Execute(constructorTransaction, chainSpec.Genesis.Header, NullTxTracer.Instance);
}
}
_logger.Info($"Allocations configured, committing...");
stateProvider.Commit(specProvider.GenesisSpec);
_logger.Info($"Finalizing genesis...");
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot;
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != blockTree.Genesis.Hash)
{
throw new Exception("Unexpected genesis hash");
}
_logger.Info($"Starting benchmark processor...");
/* start processing */
BigInteger totalGas = BigInteger.Zero;
Stopwatch stopwatch = new Stopwatch();
Block currentHead;
long maxMemory = 0;
blockTree.NewHeadBlock += (sender, args) =>
{
currentHead = args.Block;
if (currentHead.Number == 0)
{
return;
}
maxMemory = Math.Max(maxMemory, GC.GetTotalMemory(false));
totalGas += currentHead.GasUsed;
if ((BigInteger)args.Block.Number % 10000 == 9999)
{
stopwatch.Stop();
long ms = 1_000L * stopwatch.ElapsedTicks / Stopwatch.Frequency;
BigInteger number = args.Block.Number + 1;
_logger.Warn($"TOTAL after {number} (ms) : " + ms);
_logger.Warn($"TOTAL after {number} blocks/s : {(decimal) currentHead.Number / (ms / 1000m),5}");
_logger.Warn($"TOTAL after {number} Mgas/s : {((decimal) totalGas / 1000000) / (ms / 1000m),5}");
_logger.Warn($"TOTAL after {number} max mem : {maxMemory}");
_logger.Warn($"TOTAL after {number} GC (0/1/2) : {GC.CollectionCount(0)}/{GC.CollectionCount(1)}/{GC.CollectionCount(2)}");
_logger.Warn($"Is server GC {number} : {System.Runtime.GCSettings.IsServerGC}");
_logger.Warn($"GC latency mode {number} : {System.Runtime.GCSettings.LatencyMode}");
_logger.Warn($"TOTAL after {number} blocks DB reads : {Store.Metrics.BlocksDbReads}");
_logger.Warn($"TOTAL after {number} blocks DB writes : {Store.Metrics.BlocksDbWrites}");
_logger.Warn($"TOTAL after {number} infos DB reads : {Store.Metrics.BlockInfosDbReads}");
_logger.Warn($"TOTAL after {number} infos DB writes : {Store.Metrics.BlockInfosDbWrites}");
_logger.Warn($"TOTAL after {number} state tree reads : {Store.Metrics.StateTreeReads}");
_logger.Warn($"TOTAL after {number} state tree writes : {Store.Metrics.StateTreeWrites}");
_logger.Warn($"TOTAL after {number} state DB reads : {Store.Metrics.StateDbReads}");
_logger.Warn($"TOTAL after {number} state DB writes : {Store.Metrics.StateDbWrites}");
_logger.Warn($"TOTAL after {number} storage tree reads : {Store.Metrics.StorageTreeReads}");
_logger.Warn($"TOTAL after {number} storage tree writes : {Store.Metrics.StorageTreeWrites}");
_logger.Warn($"TOTAL after {number} tree node hash : {Store.Metrics.TreeNodeHashCalculations}");
_logger.Warn($"TOTAL after {number} tree node RLP decode : {Store.Metrics.TreeNodeRlpDecodings}");
_logger.Warn($"TOTAL after {number} tree node RLP encode : {Store.Metrics.TreeNodeRlpEncodings}");
_logger.Warn($"TOTAL after {number} code DB reads : {Store.Metrics.CodeDbReads}");
_logger.Warn($"TOTAL after {number} code DB writes : {Store.Metrics.CodeDbWrites}");
_logger.Warn($"TOTAL after {number} receipts DB reads : {Store.Metrics.ReceiptsDbReads}");
_logger.Warn($"TOTAL after {number} receipts DB writes : {Store.Metrics.ReceiptsDbWrites}");
_logger.Warn($"TOTAL after {number} other DB reads : {Store.Metrics.OtherDbReads}");
_logger.Warn($"TOTAL after {number} other DB writes : {Store.Metrics.OtherDbWrites}");
_logger.Warn($"TOTAL after {number} EVM exceptions : {Evm.Metrics.EvmExceptions}");
_logger.Warn($"TOTAL after {number} SLOAD opcodes : {Evm.Metrics.SloadOpcode}");
_logger.Warn($"TOTAL after {number} SSTORE opcodes : {Evm.Metrics.SstoreOpcode}");
_logger.Warn($"TOTAL after {number} EXP opcodes : {Evm.Metrics.ModExpOpcode}");
_logger.Warn($"TOTAL after {number} BLOCKHASH opcodes : {Evm.Metrics.BlockhashOpcode}");
_logger.Warn($"TOTAL after {number} EVM calls : {Evm.Metrics.Calls}");
_logger.Warn($"TOTAL after {number} RIPEMD Precompiles : {Evm.Metrics.Ripemd160Precompile}");
_logger.Warn($"TOTAL after {number} SHA256 Precompiles : {Evm.Metrics.Sha256Precompile}");
// disk space
stopwatch.Start();
}
};
bool isStarted = false;
TaskCompletionSource <object> completionSource = new TaskCompletionSource <object>();
blockTree.NewBestSuggestedBlock += (sender, args) =>
{
if (!isStarted)
{
blockchainProcessor.Process(blockTree.FindBlock(blockTree.Genesis.Hash, BlockTreeLookupOptions.RequireCanonical), ProcessingOptions.None, NullBlockTracer.Instance);
stopwatch.Start();
blockchainProcessor.Start();
isStarted = true;
}
if (args.Block.Number == BlocksToLoad)
{
completionSource.SetResult(null);
}
};
await Task.WhenAny(completionSource.Task, blockTree.LoadBlocksFromDb(CancellationToken.None, 0, 10000, BlocksToLoad));
await blockchainProcessor.StopAsync(true).ContinueWith(
t =>
{
if (t.IsFaulted)
{
_logger.Error("processing failed", t.Exception);
_logger.Error("inner", t.Exception.InnerException);
Console.ReadLine();
}
_logger.Info("Block processing completed.");
});
stopwatch.Stop();
Console.ReadLine();
}
protected async Task <EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?stopwatch = null)
{
TestContext.Write($"Running {test.Name} at {DateTime.UtcNow:HH:mm:ss.ffffff}");
Assert.IsNull(test.LoadFailure, "test data loading failure");
IDb stateDb = new MemDb();
IDb codeDb = new MemDb();
ISpecProvider specProvider;
if (test.NetworkAfterTransition != null)
{
specProvider = new CustomSpecProvider(1,
(0, Frontier.Instance),
(1, test.Network),
(test.TransitionBlockNumber, test.NetworkAfterTransition));
}
else
{
specProvider = new CustomSpecProvider(1,
(0, Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
(1, test.Network));
}
if (specProvider.GenesisSpec != Frontier.Instance)
{
Assert.Fail("Expected genesis spec to be Frontier for blockchain tests");
}
bool isNetworkAfterTransitionLondon = test.NetworkAfterTransition == London.Instance;
HeaderDecoder.Eip1559TransitionBlock = isNetworkAfterTransitionLondon ? test.TransitionBlockNumber : long.MaxValue;
DifficultyCalculator.Wrapped = new EthashDifficultyCalculator(specProvider);
IRewardCalculator rewardCalculator = new RewardCalculator(specProvider);
IEthereumEcdsa ecdsa = new EthereumEcdsa(specProvider.ChainId, _logManager);
TrieStore trieStore = new(stateDb, _logManager);
IStateProvider stateProvider = new StateProvider(trieStore, codeDb, _logManager);
MemDb blockInfoDb = new MemDb();
IBlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, NullBloomStorage.Instance, _logManager);
ITransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, blockTree);
IStateReader stateReader = new StateReader(trieStore, codeDb, _logManager);
IChainHeadInfoProvider chainHeadInfoProvider = new ChainHeadInfoProvider(specProvider, blockTree, stateReader);
ITxPool transactionPool = new TxPool(ecdsa, chainHeadInfoProvider, new TxPoolConfig(), new TxValidator(specProvider.ChainId), _logManager, transactionComparerProvider.GetDefaultComparer());
IReceiptStorage receiptStorage = NullReceiptStorage.Instance;
IBlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, _logManager);
ITxValidator txValidator = new TxValidator(ChainId.Mainnet);
IHeaderValidator headerValidator = new HeaderValidator(blockTree, Sealer, specProvider, _logManager);
IUnclesValidator unclesValidator = new UnclesValidator(blockTree, headerValidator, _logManager);
IBlockValidator blockValidator = new BlockValidator(txValidator, headerValidator, unclesValidator, specProvider, _logManager);
IStorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, _logManager);
IVirtualMachine virtualMachine = new VirtualMachine(
blockhashProvider,
specProvider,
_logManager);
IBlockProcessor blockProcessor = new BlockProcessor(
specProvider,
blockValidator,
rewardCalculator,
new BlockProcessor.BlockValidationTransactionsExecutor(
new TransactionProcessor(
specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager),
stateProvider),
stateProvider,
storageProvider,
receiptStorage,
NullWitnessCollector.Instance,
_logManager);
IBlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new RecoverSignatures(ecdsa, NullTxPool.Instance, specProvider, _logManager),
_logManager,
BlockchainProcessor.Options.NoReceipts);
InitializeTestState(test, stateProvider, storageProvider, specProvider);
List <(Block Block, string ExpectedException)> correctRlp = new();
for (int i = 0; i < test.Blocks.Length; i++)
{
try
{
TestBlockJson testBlockJson = test.Blocks[i];
var rlpContext = Bytes.FromHexString(testBlockJson.Rlp).AsRlpStream();
Block suggestedBlock = Rlp.Decode <Block>(rlpContext);
suggestedBlock.Header.SealEngineType = test.SealEngineUsed ? SealEngineType.Ethash : SealEngineType.None;
Assert.AreEqual(new Keccak(testBlockJson.BlockHeader.Hash), suggestedBlock.Header.Hash, "hash of the block");
for (int uncleIndex = 0; uncleIndex < suggestedBlock.Uncles.Length; uncleIndex++)
{
Assert.AreEqual(new Keccak(testBlockJson.UncleHeaders[uncleIndex].Hash), suggestedBlock.Uncles[uncleIndex].Hash, "hash of the uncle");
}
correctRlp.Add((suggestedBlock, testBlockJson.ExpectedException));
}
catch (Exception)
{
_logger?.Info($"Invalid RLP ({i})");
}
}
if (correctRlp.Count == 0)
{
EthereumTestResult result;
if (test.GenesisBlockHeader is null)
{
result = new EthereumTestResult(test.Name, "Genesis block header missing in the test spec.");
}
else if (!new Keccak(test.GenesisBlockHeader.Hash).Equals(test.LastBlockHash))
{
result = new EthereumTestResult(test.Name, "Genesis hash mismatch");
}
else
{
result = new EthereumTestResult(test.Name, null, true);
}
return(result);
}
if (test.GenesisRlp == null)
{
test.GenesisRlp = Rlp.Encode(new Block(JsonToEthereumTest.Convert(test.GenesisBlockHeader)));
}
Block genesisBlock = Rlp.Decode <Block>(test.GenesisRlp.Bytes);
Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), genesisBlock.Header.Hash, "genesis header hash");
ManualResetEvent genesisProcessed = new(false);
blockTree.NewHeadBlock += (_, args) =>
{
if (args.Block.Number == 0)
{
Assert.AreEqual(genesisBlock.Header.StateRoot, stateProvider.StateRoot, "genesis state root");
genesisProcessed.Set();
}
};
blockchainProcessor.Start();
blockTree.SuggestBlock(genesisBlock);
genesisProcessed.WaitOne();
for (int i = 0; i < correctRlp.Count; i++)
{
stopwatch?.Start();
try
{
if (correctRlp[i].ExpectedException != null)
{
_logger.Info($"Expecting block exception: {correctRlp[i].ExpectedException}");
}
if (correctRlp[i].Block.Hash == null)
{
throw new Exception($"null hash in {test.Name} block {i}");
}
// TODO: mimic the actual behaviour where block goes through validating sync manager?
if (!test.SealEngineUsed || blockValidator.ValidateSuggestedBlock(correctRlp[i].Block))
{
blockTree.SuggestBlock(correctRlp[i].Block);
}
else
{
Console.WriteLine("Invalid block");
}
}
catch (InvalidBlockException)
{
}
catch (Exception ex)
{
_logger?.Info(ex.ToString());
}
}
await blockchainProcessor.StopAsync(true);
stopwatch?.Stop();
List <string> differences = RunAssertions(test, blockTree.RetrieveHeadBlock(), storageProvider, stateProvider);
// if (differences.Any())
// {
// BlockTrace blockTrace = blockchainProcessor.TraceBlock(blockTree.BestSuggested.Hash);
// _logger.Info(new UnforgivingJsonSerializer().Serialize(blockTrace, true));
// }
Assert.Zero(differences.Count, "differences");
return(new EthereumTestResult
(
test.Name,
null,
differences.Count == 0
));
}
protected async Task RunTest(BlockchainTest test, Stopwatch stopwatch = null)
{
LoggingTraceListener traceListener = new LoggingTraceListener();
// TODO: not supported in .NET Core, need to replace?
// Debug.Listeners.Clear();
// Debug.Listeners.Add(traceListener);
IDbProvider dbProvider = new MemDbProvider(_logManager);
StateTree stateTree = new StateTree(dbProvider.GetOrCreateStateDb());
ISpecProvider specProvider;
if (test.NetworkAfterTransition != null)
{
specProvider = new CustomSpecProvider(
(0, Frontier.Instance),
(1, test.Network),
(test.TransitionBlockNumber, test.NetworkAfterTransition));
}
else
{
specProvider = new CustomSpecProvider(
(0, Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
(1, test.Network));
}
if (specProvider.GenesisSpec != Frontier.Instance)
{
Assert.Fail("Expected genesis spec to be Frontier for blockchain tests");
}
IDifficultyCalculator difficultyCalculator = new DifficultyCalculator(specProvider);
IRewardCalculator rewardCalculator = new RewardCalculator(specProvider);
IBlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, _logManager);
IBlockhashProvider blockhashProvider = new BlockhashProvider(blockTree);
ISignatureValidator signatureValidator = new SignatureValidator(ChainId.MainNet);
ITransactionValidator transactionValidator = new TransactionValidator(signatureValidator);
IHeaderValidator headerValidator = new HeaderValidator(difficultyCalculator, blockTree, SealEngine, specProvider, _logManager);
IOmmersValidator ommersValidator = new OmmersValidator(blockTree, headerValidator, _logManager);
IBlockValidator blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, _logManager);
IStateProvider stateProvider = new StateProvider(stateTree, dbProvider.GetOrCreateCodeDb(), _logManager);
IStorageProvider storageProvider = new StorageProvider(dbProvider, stateProvider, _logManager);
IVirtualMachine virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
ISealEngine sealEngine = new EthashSealEngine(new Ethash(_logManager), _logManager);
ITransactionStore transactionStore = new TransactionStore();
IEthereumSigner signer = new EthereumSigner(specProvider, _logManager);
IBlockProcessor blockProcessor = new BlockProcessor(
specProvider,
blockValidator,
rewardCalculator,
new TransactionProcessor(
specProvider,
stateProvider,
storageProvider,
virtualMachine,
NullTracer.Instance,
_logManager),
dbProvider,
stateProvider,
storageProvider,
transactionStore,
_logManager);
IBlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree,
sealEngine,
transactionStore, difficultyCalculator, blockProcessor, signer, _logManager);
InitializeTestState(test, stateProvider, storageProvider, specProvider);
List <(Block Block, string ExpectedException)> correctRlpsBlocks = new List <(Block, string)>();
for (int i = 0; i < test.Blocks.Length; i++)
{
try
{
TestBlockJson testBlockJson = test.Blocks[i];
var rlpContext = Hex.ToBytes(testBlockJson.Rlp).AsRlpContext();
Block suggestedBlock = Rlp.Decode <Block>(rlpContext);
Assert.AreEqual(new Keccak(testBlockJson.BlockHeader.Hash), suggestedBlock.Header.Hash, "hash of the block");
for (int ommerIndex = 0; ommerIndex < suggestedBlock.Ommers.Length; ommerIndex++)
{
Assert.AreEqual(new Keccak(testBlockJson.UncleHeaders[ommerIndex].Hash), suggestedBlock.Ommers[ommerIndex].Hash, "hash of the ommer");
}
correctRlpsBlocks.Add((suggestedBlock, testBlockJson.ExpectedException));
}
catch (Exception e)
{
_logger?.Info($"Invalid RLP ({i})");
}
}
if (correctRlpsBlocks.Count == 0)
{
Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), test.LastBlockHash);
return;
}
if (test.GenesisRlp == null)
{
test.GenesisRlp = Rlp.Encode(new Block(Convert(test.GenesisBlockHeader)));
}
Block genesisBlock = Rlp.Decode <Block>(test.GenesisRlp.Bytes);
Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), genesisBlock.Header.Hash, "genesis header hash");
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 0)
{
Assert.AreEqual(genesisBlock.Header.StateRoot, stateTree.RootHash, "genesis state root");
}
};
blockchainProcessor.Start();
blockTree.SuggestBlock(genesisBlock);
for (int i = 0; i < correctRlpsBlocks.Count; i++)
{
stopwatch?.Start();
try
{
if (correctRlpsBlocks[i].ExpectedException != null)
{
_logger.Info($"Expecting block exception: {correctRlpsBlocks[i].ExpectedException}");
}
if (correctRlpsBlocks[i].Block.Hash == null)
{
throw new Exception($"null hash in {test.Name} block {i}");
}
// TODO: mimic the actual behaviour where block goes through validating sync manager?
if (blockValidator.ValidateSuggestedBlock(correctRlpsBlocks[i].Block))
{
blockTree.SuggestBlock(correctRlpsBlocks[i].Block);
}
else
{
Console.WriteLine("Invalid block");
}
}
catch (InvalidBlockException ex)
{
}
catch (Exception ex)
{
_logger?.Info(ex.ToString());
}
}
await blockchainProcessor.StopAsync(true);
stopwatch?.Stop();
RunAssertions(test, blockTree.RetrieveHeadBlock(), storageProvider, stateProvider);
}
public async Task Build_some_chain()
{
/* logging & instrumentation */
var logger = new OneLoggerLogManager(new SimpleConsoleLogger());
/* spec */
var blockMiningTime = TimeSpan.FromMilliseconds(500);
var sealEngine = new FakeSealEngine(blockMiningTime);
var specProvider = RopstenSpecProvider.Instance;
/* store & validation */
var blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, logger);
var difficultyCalculator = new DifficultyCalculator(specProvider);
var headerValidator = new HeaderValidator(difficultyCalculator, blockTree, sealEngine, specProvider, logger);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, logger);
var transactionValidator = new TransactionValidator(new SignatureValidator(ChainId.Ropsten));
var blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, logger);
/* state & storage */
var dbProvider = new MemDbProvider(logger);
var stateTree = new StateTree(dbProvider.GetOrCreateStateDb());
var stateProvider = new StateProvider(stateTree, dbProvider.GetOrCreateCodeDb(), logger);
var storageProvider = new StorageProvider(dbProvider, stateProvider, logger);
/* blockchain processing */
var ethereumSigner = new EthereumSigner(specProvider, logger);
var transactionStore = new TransactionStore();
var blockhashProvider = new BlockhashProvider(blockTree);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, logger);
var processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, NullTracer.Instance, logger);
var rewardCalculator = new RewardCalculator(specProvider);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, processor, dbProvider, stateProvider, storageProvider, transactionStore, logger);
var blockchainProcessor = new BlockchainProcessor(blockTree, sealEngine, transactionStore, difficultyCalculator, blockProcessor, ethereumSigner, logger);
/* load ChainSpec and init */
ChainSpecLoader loader = new ChainSpecLoader(new UnforgivingJsonSerializer());
string path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..\Chains", "ropsten.json"));
logger.GetClassLogger().Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllBytes(path));
foreach (KeyValuePair <Address, BigInteger> allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value);
}
stateProvider.Commit(specProvider.GenesisSpec);
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot; // TODO: shall it be HeaderSpec and not BlockHeader?
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != new Keccak("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"))
{
throw new Exception("Unexpected genesis hash");
}
/* start processing */
sealEngine.IsMining = true;
var testTransactionsGenerator = new TestTransactionsGenerator(transactionStore, ethereumSigner, blockMiningTime, logger);
testTransactionsGenerator.Start();
blockchainProcessor.Start();
blockTree.SuggestBlock(chainSpec.Genesis);
BigInteger roughlyNumberOfBlocks = 6;
Thread.Sleep(blockMiningTime * (int)roughlyNumberOfBlocks);
await blockchainProcessor.StopAsync(false);
Assert.GreaterOrEqual(blockTree.Head.Number, roughlyNumberOfBlocks - 2, "number of blocks");
Assert.GreaterOrEqual(blockTree.Head.TotalTransactions, roughlyNumberOfBlocks - 2, "number of transactions");
}
public async Task Test()
{
TimeSpan miningDelay = TimeSpan.FromMilliseconds(50);
/* logging & instrumentation */
var logger = new OneLoggerLogManager(new SimpleConsoleLogger(true));
/* spec */
var sealEngine = new FakeSealEngine(miningDelay);
sealEngine.IsMining = true;
var specProvider = RopstenSpecProvider.Instance;
/* store & validation */
var blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, logger);
var difficultyCalculator = new DifficultyCalculator(specProvider);
var headerValidator = new HeaderValidator(difficultyCalculator, blockTree, sealEngine, specProvider, logger);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, logger);
var transactionValidator = new TransactionValidator(new SignatureValidator(ChainId.Ropsten));
var blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, logger);
/* state & storage */
var codeDb = new MemDb();
var stateDb = new MemDb();
var stateTree = new StateTree(stateDb);
var stateProvider = new StateProvider(stateTree, codeDb, logger);
var storageDbProvider = new MemDbProvider(logger);
var storageProvider = new StorageProvider(storageDbProvider, stateProvider, logger);
/* blockchain processing */
var ethereumSigner = new EthereumSigner(specProvider, logger);
var transactionStore = new TransactionStore();
var blockhashProvider = new BlockhashProvider(blockTree);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, logger);
var processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, NullTracer.Instance, logger);
var rewardCalculator = new RewardCalculator(specProvider);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, processor, storageDbProvider, stateProvider, storageProvider, transactionStore, logger);
var blockchainProcessor = new BlockchainProcessor(blockTree, sealEngine, transactionStore, difficultyCalculator, blockProcessor, ethereumSigner, logger, new PerfService(NullLogManager.Instance));
/* load ChainSpec and init */
ChainSpecLoader loader = new ChainSpecLoader(new UnforgivingJsonSerializer());
string path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..\Chains", "ropsten.json"));
logger.GetClassLogger().Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllBytes(path));
foreach (KeyValuePair <Address, UInt256> allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value);
}
stateProvider.Commit(specProvider.GenesisSpec);
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot; // TODO: shall it be HeaderSpec and not BlockHeader?
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != new Keccak("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"))
{
throw new Exception("Unexpected genesis hash");
}
/* start processing */
blockTree.SuggestBlock(chainSpec.Genesis);
blockchainProcessor.Start();
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 6)
{
manualResetEvent.Set();
}
};
manualResetEvent.WaitOne(miningDelay * 12);
await blockchainProcessor.StopAsync(true).ContinueWith(
t =>
{
if (t.IsFaulted)
{
throw t.Exception;
}
Assert.GreaterOrEqual((int)blockTree.Head.Number, 6);
});
}