Feature/t8n

src/Nethermind/Ethereum.Test.Base/AccountState.cs

@@ -4,13 +4,17 @@
 using System.Collections.Generic;
 using Nethermind.Int256;
 
-namespace Ethereum.Test.Base
+namespace Ethereum.Test.Base;
+
+public class AccountState
 {
-    public class AccountState
+    public byte[]? Code { get; set; }
+    public UInt256 Balance { get; set; }
+    public UInt256 Nonce { get; set; }
+    public Dictionary<UInt256, byte[]>? Storage { get; set; }
+
+    public bool IsEmptyAccount()
     {
-        public byte[] Code { get; set; }
-        public UInt256 Balance { get; set; }
-        public UInt256 Nonce { get; set; }
-        public Dictionary<UInt256, byte[]> Storage { get; set; }
+        return Balance.IsZero && Nonce.IsZero && (Code == null || Code.Length == 0) && (Storage == null || Storage.Count == 0);
     }
 }

src/Nethermind/Ethereum.Test.Base/AccountStateConverter.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Linq;
+using Nethermind.Core.Extensions;
+
+namespace Ethereum.Test.Base;
+
+using Nethermind.Int256;
+using Nethermind.Serialization.Json;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+public class AccountStateConverter : JsonConverter<AccountState>
+{
+    private EthereumJsonSerializer _ethereumJsonSerializer = new();
+
+    public override AccountState? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        return _ethereumJsonSerializer.Deserialize<AccountState>(ref reader);
+    }
+
+    public override void Write(Utf8JsonWriter writer, AccountState value, JsonSerializerOptions options)
+    {
+        NumberConversion? previousValue = ForcedNumberConversion.ForcedConversion.Value;
+        try
+        {
+            writer.WriteStartObject();
+
+            ForcedNumberConversion.ForcedConversion.Value = NumberConversion.Hex;
+            if (value.Balance != UInt256.Zero)
+            {
+                writer.WritePropertyName("balance"u8);
+                JsonSerializer.Serialize(writer, value.Balance, options);
+            }
+
+            ForcedNumberConversion.ForcedConversion.Value = NumberConversion.Hex;
+            if (value.Nonce != UInt256.Zero)
+            {
+                writer.WritePropertyName("nonce"u8);
+                JsonSerializer.Serialize(writer, value.Nonce, options);
+            }
+
+            if (value.Code is not null)
+            {
+                writer.WritePropertyName("code"u8);
+                JsonSerializer.Serialize(writer, value.Code, options);
+            }
+
+            ForcedNumberConversion.ForcedConversion.Value = NumberConversion.ZeroPaddedHex;
+            if (value.Storage?.Count > 0)
+            {
+                Dictionary<UInt256, UInt256> storage =
+                    value.Storage.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToUInt256());
+                writer.WritePropertyName("storage"u8);
+                JsonSerializer.Serialize(writer, storage, options);
+            }
+
+            writer.WriteEndObject();
+        }
+        finally
+        {
+            ForcedNumberConversion.ForcedConversion.Value = previousValue;
+        }
+    }
+}

src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs

@@ -318,9 +318,12 @@ private void InitializeTestState(BlockchainTest test, IWorldState stateProvider,
             foreach (KeyValuePair<Address, AccountState> accountState in
                 ((IEnumerable<KeyValuePair<Address, AccountState>>)test.Pre ?? Array.Empty<KeyValuePair<Address, AccountState>>()))
             {
-                foreach (KeyValuePair<UInt256, byte[]> storageItem in accountState.Value.Storage)
+                if (accountState.Value.Storage is not null)
                 {
-                    stateProvider.Set(new StorageCell(accountState.Key, storageItem.Key), storageItem.Value);
+                    foreach (KeyValuePair<UInt256, byte[]> storageItem in accountState.Value.Storage)
+                    {
+                        stateProvider.Set(new StorageCell(accountState.Key, storageItem.Key), storageItem.Value);
+                    }
                 }
 
                 stateProvider.CreateAccount(accountState.Key, accountState.Value.Balance);

src/Nethermind/Ethereum.Test.Base/BlockchainTestJson.cs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System.Collections.Generic;
+using Nethermind.Core;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Specs;
 
@@ -24,8 +25,8 @@ public class BlockchainTestJson
         public TestBlockJson[]? Blocks { get; set; }
         public TestBlockHeaderJson? GenesisBlockHeader { get; set; }
 
-        public Dictionary<string, AccountStateJson>? Pre { get; set; }
-        public Dictionary<string, AccountStateJson>? PostState { get; set; }
+        public Dictionary<Address, AccountState>? Pre { get; set; }
+        public Dictionary<Address, AccountState>? PostState { get; set; }
 
         public Hash256? PostStateHash { get; set; }
 

src/Nethermind/Ethereum.Test.Base/EthereumTestResult.cs

@@ -1,9 +1,13 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System.Collections.Generic;
 using System.Text.Json.Serialization;
-
+using Ethereum.Test.Base.T8NUtils;
+using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Evm.Tracing.GethStyle.Custom.Native.Prestate;
+using Nethermind.Int256;
 
 namespace Ethereum.Test.Base
 {
@@ -37,5 +41,20 @@ public EthereumTestResult(string? name, string? loadFailure)
         public double TimeInMs { get; set; }
 
         public Hash256 StateRoot { get; set; } = Keccak.EmptyTreeHash;
+
+        public T8NResult T8NResult { get; set; }
     }
 }
+
+public class RejectedTx
+{
+    public RejectedTx(int index, string error)
+    {
+        Index = index;
+        Error = error;
+    }
+
+    public int Index { get; set; }
+    public string? Error { get; set; }
+}
+

src/Nethermind/Ethereum.Test.Base/GeneralStateTest.cs

@@ -1,24 +1,33 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using Ethereum.Test.Base.Interfaces;
+using Nethermind.Consensus.Ethash;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Specs;
+using Nethermind.Core.Test.Builders;
+using Nethermind.Crypto;
+using Nethermind.Evm;
+using Nethermind.Evm.Tracing.GethStyle;
 using Nethermind.Int256;
+using Nethermind.Specs;
+using Nethermind.Specs.Forks;
 
 namespace Ethereum.Test.Base
 {
     public class GeneralStateTest : IEthereumTest
     {
+        public bool IsT8NTest { get; set; } = false;
         public string? Category { get; set; }
         public string? Name { get; set; }
         public IReleaseSpec? Fork { get; set; }
         public string? ForkName { get; set; }
         public Address? CurrentCoinbase { get; set; }
-        public UInt256 CurrentDifficulty { get; set; }
+        public UInt256? CurrentDifficulty { get; set; }
 
         public UInt256? CurrentBaseFee { get; set; }
         public long CurrentGasLimit { get; set; }
@@ -29,17 +38,84 @@ public class GeneralStateTest : IEthereumTest
         public Hash256? PostHash { get; set; }
         public Hash256? PostReceiptsRoot { get; set; }
         public string? LoadFailure { get; set; }
-        public Transaction? Transaction { get; set; }
+        public Transaction[] Transactions { get; set; } = [];
         public Hash256? CurrentRandom { get; set; }
         public Hash256? CurrentBeaconRoot { get; set; }
         public Hash256? CurrentWithdrawalsRoot { get; set; }
         public ulong? CurrentExcessBlobGas { get; set; }
         public UInt256? ParentBlobGasUsed { get; set; }
         public UInt256? ParentExcessBlobGas { get; set; }
 
+        public Withdrawal[] Withdrawals { get; set; } = [];
+        public ulong ParentTimestamp { get; set; } // optional?
+        public UInt256? ParentDifficulty { get; set; }
+        public Hash256? ParentUncleHash { get; set; }
+        public Hash256? ParentBeaconBlockRoot { get; set; }
+        public UInt256? ParentBaseFee { get; set; }
+        public long ParentGasUsed { get; set; }
+        public long ParentGasLimit { get; set; }
+        public Dictionary<string, Hash256> BlockHashes { get; set; } = [];
+        public Ommer[] Ommers { get; set; } = [];
+        public string? StateReward { get; set; }
+        public ulong StateChainId { get; set; } = MainnetSpecProvider.Instance.ChainId;
+        public GethTraceOptions GethTraceOptions { get; set; } = GethTraceOptions.Default;
+        public bool IsTraceEnabled { get; set; } = false;
+        public bool IsStateTest { get; set; }
+
         public override string ToString()
         {
             return $"{Path.GetFileName(Category)}.{Name}_{ForkName}";
         }
+
+        public BlockHeader GetBlockHeader()
+        {
+            BlockHeader header = new(
+                PreviousHash,
+                Keccak.OfAnEmptySequenceRlp,
+                CurrentCoinbase ?? throw new Exception("CurrentCoinbase is missing"),
+                CurrentDifficulty ?? UInt256.Zero,
+                CurrentNumber,
+                CurrentGasLimit,
+                CurrentTimestamp,
+                []);
+            header.StateRoot = PostHash;
+            header.Hash = header.CalculateHash();
+            header.IsPostMerge = Fork is Paris;
+            header.MixHash = CurrentRandom;
+            header.WithdrawalsRoot = CurrentWithdrawalsRoot;
+            header.ParentBeaconBlockRoot = CurrentBeaconRoot;
+            header.ExcessBlobGas = CurrentExcessBlobGas ?? (Fork is Cancun ? 0ul : null);
+            header.BlobGasUsed = BlobGasCalculator.CalculateBlobGas(Transactions);
+            header.ParentBeaconBlockRoot = ParentBeaconBlockRoot;
+
+            return header;
+        }
+
+        public BlockHeader? GetParentBlockHeader()
+        {
+            if (ParentBlobGasUsed is not null && ParentExcessBlobGas is not null)
+            {
+                BlockHeader parent = new(
+                    parentHash: Keccak.Zero,
+                    unclesHash: Keccak.OfAnEmptySequenceRlp,
+                    beneficiary: CurrentCoinbase,
+                    difficulty: ParentDifficulty ?? CurrentDifficulty ?? UInt256.Zero,
+                    number: CurrentNumber - 1,
+                    gasLimit: ParentGasLimit,
+                    timestamp: ParentTimestamp,
+                    extraData: []
+                )
+                {
+                    BlobGasUsed = (ulong)ParentBlobGasUsed,
+                    ExcessBlobGas = (ulong)ParentExcessBlobGas,
+                };
+                if (ParentBaseFee.HasValue) parent.BaseFeePerGas = ParentBaseFee.Value;
+                parent.GasUsed = ParentGasUsed;
+                if (ParentUncleHash != null) parent.UnclesHash = ParentUncleHash;
+                return parent;
+            }
+
+            return null;
+        }
     }
 }

src/Nethermind/Ethereum.Test.Base/GeneralStateTestJson.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Text.Json.Serialization;
+using Nethermind.Core;
 
 namespace Ethereum.Test.Base
 {
@@ -12,7 +13,7 @@ public class GeneralStateTestJson
         public GeneralStateTestInfoJson? Info { get; set; }
         public GeneralStateTestEnvJson? Env { get; set; }
         public Dictionary<string, PostStateJson[]>? Post { get; set; }
-        public Dictionary<string, AccountStateJson>? Pre { get; set; }
+        public Dictionary<Address, AccountState>? Pre { get; set; }
         public string? SealEngine { get; set; }
         public string? LoadFailure { get; set; }
         public TransactionJson? Transaction { get; set; }