public void Test(BlockchainTest test)
{
if (test.Name.Contains("block504980"))
{
return;
}
Assert.True(RunTest(test).Pass);
}
public void Test(BlockchainTest test)
{
if (test.Name.Contains("CALLBlake2f_MaxRound"))
{
return;
}
Assert.True(RunTest(test).Pass);
}
public void Test(BlockchainTest test)
{
if (ignored.Any(i => test.Name.Contains(i)))
{
return;
}
Assert.True(RunTest(test).Pass);
}
public async Task Test(BlockchainTest test)
{
if (test.Name.Contains("suicideStorage"))
{
return;
}
await RunTest(test);
}
public async Task Test(BlockchainTest test)
{
bool isWindows = System.Runtime.InteropServices.RuntimeInformation
.IsOSPlatform(OSPlatform.Windows);
if (isWindows)
{
return;
}
await RunTest(test);
}
private static BlockchainTest Convert(string name, BlockchainTestJson testJson)
{
BlockchainTest test = new BlockchainTest();
test.Name = name;
test.Network = testJson.EthereumNetwork;
test.LastBlockHash = new Keccak(testJson.LastBlockHash);
test.GenesisRlp = new Rlp(Hex.ToBytes(testJson.GenesisRlp));
test.GenesisBlockHeader = testJson.GenesisBlockHeader;
test.Blocks = testJson.Blocks;
test.PostState = testJson.PostState.ToDictionary(p => new Address(p.Key), p => Convert(p.Value));
test.Pre = testJson.Pre.ToDictionary(p => new Address(p.Key), p => Convert(p.Value));
return(test);
}
private void InitializeTestState(BlockchainTest test)
{
_stateProviders[test.Network].EthereumRelease = _protocolSpecificationProvider.GetSpec(EthereumNetwork.Frontier, 0);
foreach (KeyValuePair <Address, AccountState> accountState in test.Pre)
{
foreach (KeyValuePair <BigInteger, byte[]> storageItem in accountState.Value.Storage)
{
_storageProviders[test.Network].Set(accountState.Key, storageItem.Key, storageItem.Value);
}
_stateProviders[test.Network].CreateAccount(accountState.Key, accountState.Value.Balance);
Keccak codeHash = _stateProviders[test.Network].UpdateCode(accountState.Value.Code);
_stateProviders[test.Network].UpdateCodeHash(accountState.Key, codeHash);
for (int i = 0; i < accountState.Value.Nonce; i++)
{
_stateProviders[test.Network].IncrementNonce(accountState.Key);
}
}
_storageProviders[test.Network].Commit();
_stateProviders[test.Network].Commit();
}
public async Task Test(BlockchainTest test)
{
await RunTest(test);
}
public void Test(BlockchainTest test)
{
Assert.True(RunTest(test).Pass);
}
private void RunAssertions(BlockchainTest test, Block headBlock)
{
TestBlockHeaderJson testHeaderJson = test.Blocks
.Where(b => b.BlockHeader != null)
.SingleOrDefault(b => new Keccak(b.BlockHeader.Hash) == headBlock.Hash)?.BlockHeader ?? test.GenesisBlockHeader;
BlockHeader testHeader = Convert(testHeaderJson);
List <string> differences = new List <string>();
foreach (KeyValuePair <Address, AccountState> accountState in test.PostState)
{
if (differences.Count > 8)
{
Console.WriteLine("More than 8 differences...");
break;
}
bool accountExists = _stateProviders[test.Network].AccountExists(accountState.Key);
BigInteger?balance = accountExists ? _stateProviders[test.Network].GetBalance(accountState.Key) : (BigInteger?)null;
BigInteger?nonce = accountExists ? _stateProviders[test.Network].GetNonce(accountState.Key) : (BigInteger?)null;
if (accountState.Value.Balance != balance)
{
differences.Add($"{accountState.Key} balance exp: {accountState.Value.Balance}, actual: {balance}, diff: {balance - accountState.Value.Balance}");
}
if (accountState.Value.Nonce != nonce)
{
differences.Add($"{accountState.Key} nonce exp: {accountState.Value.Nonce}, actual: {nonce}");
}
byte[] code = accountExists ? _stateProviders[test.Network].GetCode(accountState.Key) : new byte[0];
if (!Bytes.UnsafeCompare(accountState.Value.Code, code))
{
differences.Add($"{accountState.Key} code exp: {accountState.Value.Code?.Length}, actual: {code?.Length}");
}
foreach (KeyValuePair <BigInteger, byte[]> storageItem in accountState.Value.Storage)
{
byte[] value = _storageProviders[test.Network].Get(accountState.Key, storageItem.Key) ?? new byte[0];
if (!Bytes.UnsafeCompare(storageItem.Value, value))
{
differences.Add($"{accountState.Key} storage[{storageItem.Key}] exp: {Hex.FromBytes(storageItem.Value, true)}, actual: {Hex.FromBytes(value, true)}");
}
}
}
BigInteger gasUsed = headBlock.Header.GasUsed;
if ((testHeader?.GasUsed ?? 0) != gasUsed)
{
differences.Add($"GAS USED exp: {testHeader?.GasUsed ?? 0}, actual: {gasUsed}");
}
if (headBlock.Transactions.Any() && testHeader.Bloom.ToString() != headBlock.Receipts.Last().Bloom.ToString())
{
differences.Add($"BLOOM exp: {testHeader.Bloom}, actual: {headBlock.Receipts.Last().Bloom}");
}
if (testHeader.StateRoot != _stateProviders[test.Network].StateRoot)
{
differences.Add($"STATE ROOT exp: {testHeader.StateRoot}, actual: {_stateProviders[test.Network].StateRoot}");
}
if (testHeader.TransactionsRoot != headBlock.Header.TransactionsRoot)
{
differences.Add($"TRANSACTIONS ROOT exp: {testHeader.TransactionsRoot}, actual: {headBlock.Header.TransactionsRoot}");
}
if (testHeader.ReceiptsRoot != headBlock.Header.ReceiptsRoot)
{
differences.Add($"RECEIPT ROOT exp: {testHeader.ReceiptsRoot}, actual: {headBlock.Header.ReceiptsRoot}");
}
foreach (string difference in differences)
{
_logger?.Log(difference);
}
Assert.Zero(differences.Count, "differences");
}
protected void RunTest(BlockchainTest test, Stopwatch stopwatch = null)
{
LoggingTraceListener traceListener = new LoggingTraceListener(_logger);
// TODO: not supported in .NET Core, need to replace?
// Debug.Listeners.Clear();
// Debug.Listeners.Add(traceListener);
InitializeTestState(test);
// TODO: transition...
_stateProviders[test.Network].EthereumRelease = _protocolSpecificationProvider.GetSpec(test.Network, 0);
IEthereumRelease spec = _protocolSpecificationProvider.GetSpec(test.Network, 1);
IEthereumSigner signer = new EthereumSigner(spec, ChainId.MainNet);
IBlockProcessor blockProcessor = new BlockProcessor(
spec,
_chain,
_blockValidators[test.Network],
new ProtocolBasedDifficultyCalculator(spec),
new RewardCalculator(spec),
new TransactionProcessor(
spec,
_stateProviders[test.Network],
_storageProviders[test.Network],
_virtualMachines[test.Network],
signer,
ShouldLog.Processing ? _logger : null),
_multiDb,
_stateProviders[test.Network],
_storageProviders[test.Network],
new TransactionStore(),
ShouldLog.Processing ? _logger : null);
IBlockchainProcessor blockchainProcessor = new BlockchainProcessor(
test.GenesisRlp,
blockProcessor,
_chain,
ShouldLog.Processing ? _logger : null);
var rlps = test.Blocks.Select(tb => new Rlp(Hex.ToBytes(tb.Rlp))).ToArray();
for (int i = 0; i < rlps.Length; i++)
{
stopwatch?.Start();
try
{
blockchainProcessor.Process(rlps[i]);
}
catch (InvalidBlockException ex)
{
}
catch (Exception ex)
{
_logger?.Log(ex.ToString());
}
stopwatch?.Stop();
}
RunAssertions(test, blockchainProcessor.HeadBlock);
}
