Block Level Access Lists

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

@@ -20,6 +20,7 @@ public class BlockchainTest : EthereumTest
 
         public TestBlockJson[]? Blocks { get; set; }
         public TestBlockHeaderJson? GenesisBlockHeader { get; set; }
+        public TestEngineNewPayloadsJson[]? EngineNewPayloads { get; set; }
 
         public Dictionary<Address, AccountState>? Pre { get; set; }
         public Dictionary<Address, AccountState>? PostState { get; set; }

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

@@ -9,7 +9,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Autofac;
-using Nethermind.Api;
 using Nethermind.Blockchain;
 using Nethermind.Blockchain.Find;
 using Nethermind.Config;
@@ -30,26 +29,25 @@
 using Nethermind.Specs;
 using Nethermind.Specs.Forks;
 using Nethermind.Specs.Test;
-using Nethermind.State;
 using Nethermind.Evm.State;
 using Nethermind.Init.Modules;
 using Nethermind.TxPool;
 using NUnit.Framework;
+using Nethermind.Merge.Plugin.Data;
+using Nethermind.Merge.Plugin;
+using Nethermind.JsonRpc;
 
 namespace Ethereum.Test.Base;
 
 public abstract class BlockchainTestBase
 {
-    private static ILogger _logger;
-    private static ILogManager _logManager = new TestLogManager(LogLevel.Warn);
-    private static ISealValidator Sealer { get; }
+    private static readonly ILogger _logger;
+    private static readonly ILogManager _logManager = new TestLogManager(LogLevel.Warn);
     private static DifficultyCalculatorWrapper DifficultyCalculator { get; }
 
     static BlockchainTestBase()
     {
         DifficultyCalculator = new DifficultyCalculatorWrapper();
-        Sealer = new EthashSealValidator(_logManager, DifficultyCalculator, new CryptoRandom(), new Ethash(_logManager), Timestamper.Default); // temporarily keep reusing the same one as otherwise it would recreate cache for each test
-
         _logManager ??= LimboLogs.Instance;
         _logger = _logManager.GetClassLogger();
     }
@@ -129,6 +127,7 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
         // configProvider.GetConfig<IBlocksConfig>().PreWarmStateOnBlockProcessing = false;
         await using IContainer container = new ContainerBuilder()
             .AddModule(new TestNethermindModule(configProvider))
+            .AddModule(new TestMergeModule(configProvider))
             .AddSingleton(specProvider)
             .AddSingleton(_logManager)
             .AddSingleton(rewardCalculator)
@@ -141,6 +140,7 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
         IBlockchainProcessor blockchainProcessor = mainBlockProcessingContext.BlockchainProcessor;
         IBlockTree blockTree = container.Resolve<IBlockTree>();
         IBlockValidator blockValidator = container.Resolve<IBlockValidator>();
+        IEngineRpcModule engineRpcModule = container.Resolve<IEngineRpcModule>();
         blockchainProcessor.Start();
 
         BlockHeader parentHeader;
@@ -154,6 +154,7 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
             test.GenesisRlp ??= Rlp.Encode(new Block(JsonToEthereumTest.Convert(test.GenesisBlockHeader)));
 
             Block genesisBlock = Rlp.Decode<Block>(test.GenesisRlp.Bytes);
+            // Console.WriteLine(genesisBlock.ToString(Block.Format.Full));
             Assert.That(genesisBlock.Header.Hash, Is.EqualTo(new Hash256(test.GenesisBlockHeader.Hash)));
 
             ManualResetEvent genesisProcessed = new(false);
@@ -162,7 +163,7 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
             {
                 if (args.Block.Number == 0)
                 {
-                    Assert.That(stateProvider.HasStateForBlock(genesisBlock.Header), Is.EqualTo(true));
+                    Assert.That(stateProvider.HasStateForBlock(genesisBlock.Header), Is.True);
                     genesisProcessed.Set();
                 }
             };
@@ -172,6 +173,76 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
             parentHeader = genesisBlock.Header;
         }
 
+        if (test.Blocks is not null)
+        {
+            // blockchain test
+            parentHeader = SuggestBlocks(test, failOnInvalidRlp, blockValidator, blockTree, parentHeader);
+        }
+        else if (test.EngineNewPayloads is not null)
+        {
+            (ExecutionPayload, string[]?, string[]?, string?)[] payloads = [.. JsonToEthereumTest.Convert(test.EngineNewPayloads)];
+
+            // blockchain test engine
+            foreach ((ExecutionPayload executionPayload, string[]? blobVersionedHashes, string[]? validationError, string? newPayloadVersion) in payloads)
+            {
+                ResultWrapper<PayloadStatusV1> res;
+                byte[]?[] hashes = blobVersionedHashes is null ? null : [.. blobVersionedHashes.Select(x => Bytes.FromHexString(x))];
+
+                switch (newPayloadVersion ?? "5")
+                {
+                    case "1":
+                        res = await engineRpcModule.engine_newPayloadV1(executionPayload);
+                        break;
+                    case "2":
+                        res = await engineRpcModule.engine_newPayloadV2(executionPayload);
+                        break;
+                    case "3":
+                        res = await engineRpcModule.engine_newPayloadV3((ExecutionPayloadV3)executionPayload, [], executionPayload.ParentBeaconBlockRoot);
+                        break;
+                    case "4":
+                        res = await engineRpcModule.engine_newPayloadV4((ExecutionPayloadV3)executionPayload, hashes, executionPayload.ParentBeaconBlockRoot, []);
+                        break;
+                    case "5":
+                        res = await engineRpcModule.engine_newPayloadV4((ExecutionPayloadV3)executionPayload, hashes, executionPayload.ParentBeaconBlockRoot, []);
+                        break;
+                    default:
+                        Assert.Fail("Invalid blockchain engine test, version not recognised.");
+                        break;
+                }
+            }
+        }
+        else
+        {
+            Assert.Fail("Invalid blockchain test, did not contain blocks or new payloads.");
+        }
+
+        await blockchainProcessor.StopAsync(true);
+        stopwatch?.Stop();
+
+        IBlockCachePreWarmer? preWarmer = container.Resolve<MainProcessingContext>().LifetimeScope.ResolveOptional<IBlockCachePreWarmer>();
+
+        // Caches are cleared async, which is a problem as read for the MainWorldState with prewarmer is not correct if its not cleared.
+        preWarmer?.ClearCaches();
+
+        Block? headBlock = blockTree.RetrieveHeadBlock();
+        List<string> differences;
+        using (stateProvider.BeginScope(headBlock.Header))
+        {
+            differences = RunAssertions(test, blockTree.RetrieveHeadBlock(), stateProvider);
+        }
+
+        Assert.That(differences, Is.Empty, "differences");
+
+        return new EthereumTestResult
+        (
+            test.Name,
+            null,
+            differences.Count == 0
+        );
+    }
+
+    private static BlockHeader SuggestBlocks(BlockchainTest test, bool failOnInvalidRlp, IBlockValidator blockValidator, IBlockTree blockTree, BlockHeader parentHeader)
+    {
         List<(Block Block, string ExpectedException)> correctRlp = DecodeRlps(test, failOnInvalidRlp);
         for (int i = 0; i < correctRlp.Count; i++)
         {
@@ -211,43 +282,22 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
             parentHeader = correctRlp[i].Block.Header;
         }
 
-        await blockchainProcessor.StopAsync(true);
-        stopwatch?.Stop();
-
-        IBlockCachePreWarmer? preWarmer = container.Resolve<MainProcessingContext>().LifetimeScope.ResolveOptional<IBlockCachePreWarmer>();
-        if (preWarmer is not null)
-        {
-            // Caches are cleared async, which is a problem as read for the MainWorldState with prewarmer is not correct if its not cleared.
-            preWarmer.ClearCaches();
-        }
-
-        Block? headBlock = blockTree.RetrieveHeadBlock();
-        List<string> differences;
-        using (stateProvider.BeginScope(headBlock.Header))
-        {
-            differences = RunAssertions(test, blockTree.RetrieveHeadBlock(), stateProvider);
-        }
-
-        Assert.That(differences.Count, Is.Zero, "differences");
-
-        return new EthereumTestResult
-        (
-            test.Name,
-            null,
-            differences.Count == 0
-        );
+        return parentHeader;
     }
 
-    private List<(Block Block, string ExpectedException)> DecodeRlps(BlockchainTest test, bool failOnInvalidRlp)
+    private static List<(Block Block, string ExpectedException)> DecodeRlps(BlockchainTest test, bool failOnInvalidRlp)
     {
-        List<(Block Block, string ExpectedException)> correctRlp = new();
+        List<(Block Block, string ExpectedException)> correctRlp = [];
         for (int i = 0; i < test.Blocks.Length; i++)
         {
             TestBlockJson testBlockJson = test.Blocks[i];
             try
             {
-                var rlpContext = Bytes.FromHexString(testBlockJson.Rlp).AsRlpStream();
+                RlpStream rlpContext = Bytes.FromHexString(testBlockJson.Rlp).AsRlpStream();
                 Block suggestedBlock = Rlp.Decode<Block>(rlpContext);
+                // Console.WriteLine("suggested block:");
+                // Console.WriteLine(suggestedBlock.BlockAccessList);
+                // Hash256 tmp = new(ValueKeccak.Compute(Rlp.Encode(suggestedBlock.BlockAccessList!.Value).Bytes).Bytes);
                 suggestedBlock.Header.SealEngineType =
                     test.SealEngineUsed ? SealEngineType.Ethash : SealEngineType.None;
 
@@ -288,17 +338,20 @@ protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch?
 
         if (correctRlp.Count == 0)
         {
-            Assert.That(test.GenesisBlockHeader, Is.Not.Null);
-            Assert.That(test.LastBlockHash, Is.EqualTo(new Hash256(test.GenesisBlockHeader.Hash)));
+            using (Assert.EnterMultipleScope())
+            {
+                Assert.That(test.GenesisBlockHeader, Is.Not.Null);
+                Assert.That(test.LastBlockHash, Is.EqualTo(new Hash256(test.GenesisBlockHeader.Hash)));
+            }
         }
 
         return correctRlp;
     }
 
-    private void InitializeTestState(BlockchainTest test, IWorldState stateProvider, ISpecProvider specProvider)
+    private static void InitializeTestState(BlockchainTest test, IWorldState stateProvider, ISpecProvider specProvider)
     {
         foreach (KeyValuePair<Address, AccountState> accountState in
-            ((IEnumerable<KeyValuePair<Address, AccountState>>)test.Pre ?? Array.Empty<KeyValuePair<Address, AccountState>>()))
+            (IEnumerable<KeyValuePair<Address, AccountState>>)test.Pre ?? Array.Empty<KeyValuePair<Address, AccountState>>())
         {
             foreach (KeyValuePair<UInt256, byte[]> storageItem in accountState.Value.Storage)
             {
@@ -316,18 +369,18 @@ private void InitializeTestState(BlockchainTest test, IWorldState stateProvider,
         stateProvider.Reset();
     }
 
-    private List<string> RunAssertions(BlockchainTest test, Block headBlock, IWorldState stateProvider)
+    private static List<string> RunAssertions(BlockchainTest test, Block headBlock, IWorldState stateProvider)
     {
         if (test.PostStateRoot is not null)
         {
-            return test.PostStateRoot != stateProvider.StateRoot ? new List<string> { "state root mismatch" } : Enumerable.Empty<string>().ToList();
+            return test.PostStateRoot != stateProvider.StateRoot ? ["state root mismatch"] : [];
         }
 
         TestBlockHeaderJson testHeaderJson = (test.Blocks?
                                                  .Where(b => b.BlockHeader is not null)
                                                  .SingleOrDefault(b => new Hash256(b.BlockHeader.Hash) == headBlock.Hash)?.BlockHeader) ?? test.GenesisBlockHeader;
         BlockHeader testHeader = JsonToEthereumTest.Convert(testHeaderJson);
-        List<string> differences = new();
+        List<string> differences = [];
 
         IEnumerable<KeyValuePair<Address, AccountState>> deletedAccounts = test.Pre?
             .Where(pre => !(test.PostState?.ContainsKey(pre.Key) ?? false)) ?? Array.Empty<KeyValuePair<Address, AccountState>>();
@@ -351,8 +404,8 @@ private List<string> RunAssertions(BlockchainTest test, Block headBlock, IWorldS
             }
 
             bool accountExists = stateProvider.AccountExists(acountAddress);
-            UInt256? balance = accountExists ? stateProvider.GetBalance(acountAddress) : (UInt256?)null;
-            UInt256? nonce = accountExists ? stateProvider.GetNonce(acountAddress) : (UInt256?)null;
+            UInt256? balance = accountExists ? stateProvider.GetBalance(acountAddress) : null;
+            UInt256? nonce = accountExists ? stateProvider.GetNonce(acountAddress) : null;
 
             if (accountState.Balance != balance)
             {
@@ -364,7 +417,7 @@ private List<string> RunAssertions(BlockchainTest test, Block headBlock, IWorldS
                 differences.Add($"{acountAddress} nonce exp: {accountState.Nonce}, actual: {nonce}");
             }
 
-            byte[] code = accountExists ? stateProvider.GetCode(acountAddress) : new byte[0];
+            byte[] code = accountExists ? stateProvider.GetCode(acountAddress) : [];
             if (!Bytes.AreEqual(accountState.Code, code))
             {
                 differences.Add($"{acountAddress} code exp: {accountState.Code?.Length}, actual: {code?.Length}");
@@ -377,10 +430,10 @@ private List<string> RunAssertions(BlockchainTest test, Block headBlock, IWorldS
 
             differencesBefore = differences.Count;
 
-            KeyValuePair<UInt256, byte[]>[] clearedStorages = new KeyValuePair<UInt256, byte[]>[0];
+            KeyValuePair<UInt256, byte[]>[] clearedStorages = [];
             if (test.Pre.ContainsKey(acountAddress))
             {
-                clearedStorages = test.Pre[acountAddress].Storage.Where(s => !accountState.Storage.ContainsKey(s.Key)).ToArray();
+                clearedStorages = [.. test.Pre[acountAddress].Storage.Where(s => !accountState.Storage.ContainsKey(s.Key))];
             }
 
             foreach (KeyValuePair<UInt256, byte[]> clearedStorage in clearedStorages)

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

@@ -24,6 +24,7 @@ public class BlockchainTestJson
 
         public TestBlockJson[]? Blocks { get; set; }
         public TestBlockHeaderJson? GenesisBlockHeader { get; set; }
+        public TestEngineNewPayloadsJson[]? EngineNewPayloads { get; set; }
 
         public Dictionary<Address, AccountState>? Pre { get; set; }
         public Dictionary<Address, AccountState>? PostState { get; set; }