NethermindEth
diff --git a/‎cspell.json‎
Lines changed: 13 additions & 0 deletions b/‎cspell.json‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎src/Nethermind/Nethermind.Api/IBasicApi.cs‎
Lines changed: 1 addition & 1 deletion b/‎src/Nethermind/Nethermind.Api/IBasicApi.cs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/Nethermind/Nethermind.Api/NethermindApi.cs‎
Lines changed: 2 additions & 2 deletions b/‎src/Nethermind/Nethermind.Api/NethermindApi.cs‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs‎
Lines changed: 24 additions & 6 deletions b/‎src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs‎
Lines changed: 24 additions & 6 deletions
diff --git a/‎src/Nethermind/Nethermind.Blockchain.Test/Proofs/ReceiptTrieTests.cs‎
Lines changed: 22 additions & 0 deletions b/‎src/Nethermind/Nethermind.Blockchain.Test/Proofs/ReceiptTrieTests.cs‎
Lines changed: 22 additions & 0 deletions
diff --git a/‎src/Nethermind/Nethermind.Blockchain.Test/Proofs/TxTrieTests.cs‎
Lines changed: 21 additions & 0 deletions b/‎src/Nethermind/Nethermind.Blockchain.Test/Proofs/TxTrieTests.cs‎
Lines changed: 21 additions & 0 deletions
diff --git a/‎src/Nethermind/Nethermind.Consensus/Processing/BlockchainProcessor.cs‎
Lines changed: 3 additions & 1 deletion b/‎src/Nethermind/Nethermind.Consensus/Processing/BlockchainProcessor.cs‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎src/Nethermind/Nethermind.Core.Test/Json/ByteArrayConverterTests.cs‎
Lines changed: 65 additions & 0 deletions b/‎src/Nethermind/Nethermind.Core.Test/Json/ByteArrayConverterTests.cs‎
Lines changed: 65 additions & 0 deletions
diff --git a/‎src/Nethermind/Nethermind.Core.Test/Json/Hash256ConverterTests.cs‎
Lines changed: 63 additions & 0 deletions b/‎src/Nethermind/Nethermind.Core.Test/Json/Hash256ConverterTests.cs‎
Lines changed: 63 additions & 0 deletions
@@ -50,6 +50,7 @@
     "autofac",
     "autogen",
     "auxdata",
+    "backpressure",
     "badreq",
     "barebone",
     "baseblock",
@@ -160,6 +161,7 @@
     "coef",
     "collectd",
     "colour",
+    "CORINFO",
     "commitset",
     "comparand",
     "concurrenc",
@@ -199,6 +201,7 @@
     "deque",
     "deserialised",
     "dests",
+    "devirtualization",
     "devirtualize",
     "devirtualized",
     "devnet",
@@ -327,6 +330,7 @@
     "highbits",
     "hiveon",
     "hmac",
+    "hmacsha",
     "holesky",
     "hoodi",
     "hostnames",
@@ -404,6 +408,7 @@
     "longdate",
     "lookback",
     "lukasz",
+    "lzcnt",
     "machdep",
     "machinename",
     "madv",
@@ -416,6 +421,7 @@
     "masternode",
     "masternodes",
     "masterodes",
+    "materialisation",
     "maxcandidatepeercount",
     "maxcandidatepercount",
     "maxfee",
@@ -461,6 +467,7 @@
     "modexpprecompile",
     "morden",
     "movbe",
+    "movsxd",
     "movzx",
     "mres",
     "mscorlib",
@@ -577,6 +584,7 @@
     "prioritise",
     "protoc",
     "prysm",
+    "pshufb",
     "ptree",
     "pushgateway",
     "pwas",
@@ -706,6 +714,7 @@
     "stfld",
     "stoppables",
     "storagefuzz",
+    "streamable",
     "stree",
     "strs",
     "stylesheet",
@@ -810,7 +819,10 @@
     "voteₙ",
     "vpaddd",
     "vpcbr",
+    "vpermb",
+    "vpermi",
     "vpor",
+    "vpshufb",
     "vptest",
     "vpxor",
     "vzeroupper",
@@ -834,6 +846,7 @@
     "xmmword",
     "xmlstarlet",
     "xnpool",
+    "xvcj",
     "yellowpaper",
     "ymmword",
     "yparity",
 
@@ -32,7 +32,7 @@ public interface IBasicApi
         IDbProvider DbProvider { get; }
         IEthereumEcdsa EthereumEcdsa { get; }
         [SkipServiceCollection]
-        IJsonSerializer EthereumJsonSerializer { get; }
+        EthereumJsonSerializer EthereumJsonSerializer { get; }
         IFileSystem FileSystem { get; }
         IKeyStore? KeyStore { get; set; }
         [SkipServiceCollection]
 
@@ -45,7 +45,7 @@ public class NethermindApi(NethermindApi.Dependencies dependencies) : INethermin
         // A simple class to prevent having to modify subclass of NethermindApi many times
         public record Dependencies(
             IConfigProvider ConfigProvider,
-            IJsonSerializer JsonSerializer,
+            EthereumJsonSerializer JsonSerializer,
             ILogManager LogManager,
             ChainSpec ChainSpec,
             ISpecProvider SpecProvider,
@@ -78,7 +78,7 @@ ILifetimeScope Context
             new BuildBlocksWhenRequested();
 
         public IIPResolver IpResolver => Context.Resolve<IIPResolver>();
-        public IJsonSerializer EthereumJsonSerializer => _dependencies.JsonSerializer;
+        public EthereumJsonSerializer EthereumJsonSerializer => _dependencies.JsonSerializer;
         public IKeyStore? KeyStore { get; set; }
         public ILogManager LogManager => _dependencies.LogManager;
         public IMessageSerializationService MessageSerializationService => Context.Resolve<IMessageSerializationService>();
 
@@ -284,11 +284,30 @@ public AfterBlock ProcessedFail(Block block)
 
         public ProcessingTestContext Suggested(Block block, BlockTreeSuggestOptions options = BlockTreeSuggestOptions.ShouldProcess)
         {
-            AddBlockResult result = _blockTree.SuggestBlock(block, options);
-            if (result != AddBlockResult.Added)
+            if ((options & BlockTreeSuggestOptions.ShouldProcess) != 0)
             {
-                _logger.Info($"Finished waiting for {block.ToString(Block.Format.Short)} as block was ignored");
-                _resetEvent.Set();
+                // Use Task.Run to avoid blocking when AllowSynchronousContinuations
+                // causes inline processing on the calling thread
+                Task.Run(() =>
+                {
+                    AddBlockResult result = _blockTree.SuggestBlock(block, options);
+                    if (result != AddBlockResult.Added)
+                    {
+                        _logger.Info($"Finished waiting for {block.ToString(Block.Format.Short)} as block was ignored");
+                        _resetEvent.Set();
+                    }
+                });
+                // Wait for block to be in the tree before returning
+                SpinWait.SpinUntil(() => _blockTree.IsKnownBlock(block.Number, block.Hash!), ProcessingWait);
+            }
+            else
+            {
+                AddBlockResult result = _blockTree.SuggestBlock(block, options);
+                if (result != AddBlockResult.Added)
+                {
+                    _logger.Info($"Finished waiting for {block.ToString(Block.Format.Short)} as block was ignored");
+                    _resetEvent.Set();
+                }
             }
 
             return this;
@@ -329,8 +348,7 @@ public ProcessingTestContext Recovered(Block block)
 
         public ProcessingTestContext CountIs(int expectedCount)
         {
-            var count = ((IBlockProcessingQueue)_processor).Count;
-            Assert.That(expectedCount, Is.EqualTo(count));
+            Assert.That(() => ((IBlockProcessingQueue)_processor).Count, Is.EqualTo(expectedCount).After(ProcessingWait, 10));
             return this;
         }
 
 
@@ -58,6 +58,28 @@ public void Can_collect_proof_with_branch()
         VerifyProof(proof, trie.RootHash);
     }
 
+    [Test, MaxTime(Timeout.MaxTestTime)]
+    public void Parallel_and_non_parallel_root_hashing_produce_same_root()
+    {
+        const int receiptCount = 100;
+        IReleaseSpec spec = MainnetSpecProvider.Instance.GetSpec((MainnetSpecProvider.MuirGlacierBlockNumber, null));
+        TxReceipt[] receipts = new TxReceipt[receiptCount];
+        for (int i = 0; i < receiptCount; i++)
+        {
+            receipts[i] = Build.A.Receipt.WithAllFieldsFilled.WithGasUsedTotal(1000 + i).TestObject;
+        }
+
+        using TrackingCappedArrayPool parallelPool = new(receiptCount * 4, canBeParallel: true);
+        ReceiptTrie parallelTrie = new(spec, receipts, _decoder, parallelPool, canBeParallel: true);
+        Hash256 parallelRoot = parallelTrie.RootHash;
+
+        using TrackingCappedArrayPool sequentialPool = new(receiptCount * 4, canBeParallel: false);
+        ReceiptTrie sequentialTrie = new(spec, receipts, _decoder, sequentialPool, canBeParallel: false);
+        Hash256 sequentialRoot = sequentialTrie.RootHash;
+
+        Assert.That(sequentialRoot, Is.EqualTo(parallelRoot));
+    }
+
     private void VerifyProof(byte[][] proof, Hash256 receiptRoot)
     {
         TrieNode node = new(NodeType.Unknown, proof.Last());
 
@@ -7,6 +7,7 @@
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Specs;
 using Nethermind.Core.Test.Builders;
+using Nethermind.Int256;
 using Nethermind.Serialization.Rlp;
 using Nethermind.Specs.Forks;
 using Nethermind.State.Proofs;
@@ -99,6 +100,26 @@ public void Encoded_and_decoded_transaction_paths_have_same_root()
         Assert.That(encodedRoot, Is.EqualTo(decodedRoot));
     }
 
+    [Test, MaxTime(Timeout.MaxTestTime)]
+    public void Parallel_and_non_parallel_root_hashing_produce_same_root()
+    {
+        const int txCount = 100;
+        Transaction[] transactions = new Transaction[txCount];
+        for (int i = 0; i < txCount; i++)
+        {
+            transactions[i] = Build.A.Transaction.WithNonce((UInt256)(i + 1)).Signed().TestObject;
+        }
+
+        using TrackingCappedArrayPool pool = new();
+        TxTrie txTrie = new(transactions, canBuildProof: false, pool);
+        Hash256 parallelRoot = txTrie.RootHash;
+
+        txTrie.UpdateRootHash(canBeParallel: false);
+        Hash256 nonParallelRoot = txTrie.RootHash;
+
+        Assert.That(nonParallelRoot, Is.EqualTo(parallelRoot));
+    }
+
     private static void VerifyProof(byte[][] proof, Hash256 txRoot)
     {
         for (int i = proof.Length; i > 0; i--)
 
@@ -57,7 +57,9 @@ public sealed class BlockchainProcessor : IBlockchainProcessor, IBlockProcessing
         new BoundedChannelOptions(MaxProcessingQueueSize)
         {
             // Optimize for single reader concurrency
-            SingleReader = true
+            SingleReader = true,
+            // If queues are empty we want the block processing to continue on NewPayload thread and inherit its priority
+            AllowSynchronousContinuations = true,
         });
 
     private bool _recoveryComplete = false;
 
@@ -296,6 +296,71 @@ public void Fuzz_RandomHex_SegmentationInvariant()
         }
     }
 
+    [TestCase(new byte[] { 0xab, 0xcd }, true, true, "\"0xabcd\"")]
+    [TestCase(new byte[] { 0xab, 0xcd }, false, true, "\"0xabcd\"")]
+    [TestCase(new byte[] { 0x00, 0xab }, true, true, "\"0xab\"")]
+    [TestCase(new byte[] { 0x00, 0xab }, false, true, "\"0x00ab\"")]
+    [TestCase(new byte[] { 0x00, 0x00 }, true, true, "\"0x0\"")]
+    [TestCase(new byte[] { 0x00, 0x00 }, false, true, "\"0x0000\"")]
+    [TestCase(new byte[] { 0xab }, true, false, "\"ab\"")]
+    [TestCase(new byte[] { 0xab }, false, false, "\"ab\"")]
+    [TestCase(new byte[] { 0x0a }, true, true, "\"0xa\"")]
+    [TestCase(new byte[] { 0x0a }, false, true, "\"0x0a\"")]
+    public void Write_OutputFormat(byte[] input, bool skipLeadingZeros, bool addHexPrefix, string expected)
+    {
+        using System.IO.MemoryStream ms = new();
+        using Utf8JsonWriter writer = new(ms);
+        ByteArrayConverter.Convert(writer, input, skipLeadingZeros, addHexPrefix);
+        writer.Flush();
+        Encoding.UTF8.GetString(ms.ToArray()).Should().Be(expected);
+    }
+
+    [Test]
+    public void Write_LargeOutput_UsesArrayPool()
+    {
+        // 200 bytes = 400 hex chars + "0x" prefix + quotes > 256 byte InlineArray threshold
+        byte[] input = new byte[200];
+        for (int i = 0; i < input.Length; i++) input[i] = (byte)(i & 0xFF);
+
+        using System.IO.MemoryStream ms = new();
+        using Utf8JsonWriter writer = new(ms);
+        ByteArrayConverter.Convert(writer, input, skipLeadingZeros: false);
+        writer.Flush();
+        string output = Encoding.UTF8.GetString(ms.ToArray());
+        output.Should().StartWith("\"0x");
+        output.Should().EndWith("\"");
+        output.Length.Should().Be(404); // 400 hex + 2 prefix + 2 quotes
+    }
+
+    [Test]
+    public void WriteAsPropertyName_Format()
+    {
+        ByteArrayConverter converter = new();
+        using System.IO.MemoryStream ms = new();
+        using Utf8JsonWriter writer = new(ms);
+        writer.WriteStartObject();
+        converter.WriteAsPropertyName(writer, new byte[] { 0xab, 0xcd }, JsonSerializerOptions.Default);
+        writer.WriteNumberValue(1);
+        writer.WriteEndObject();
+        writer.Flush();
+        Encoding.UTF8.GetString(ms.ToArray()).Should().Be("{\"0xabcd\":1}");
+    }
+
+    [Test]
+    public void WriteAsPropertyName_AllZeros()
+    {
+        ByteArrayConverter converter = new();
+        using System.IO.MemoryStream ms = new();
+        using Utf8JsonWriter writer = new(ms);
+        writer.WriteStartObject();
+        converter.WriteAsPropertyName(writer, new byte[] { 0x00, 0x00 }, JsonSerializerOptions.Default);
+        writer.WriteNumberValue(1);
+        writer.WriteEndObject();
+        writer.Flush();
+        // skipLeadingZeros: false preserves all zeros
+        Encoding.UTF8.GetString(ms.ToArray()).Should().Be("{\"0x0000\":1}");
+    }
+
     [Test]
     public void Test_DictionaryKey()
     {
 
@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System;
 using System.Text.Json;
 
 using Nethermind.Core.Crypto;
@@ -22,5 +23,67 @@ public void Can_read_null()
             Hash256? result = JsonSerializer.Deserialize<Hash256>("null", options);
             Assert.That(result, Is.EqualTo(null));
         }
+
+        [Test]
+        public void Writes_zero_hash()
+        {
+            Hash256 hash = new(new byte[32]);
+            string result = JsonSerializer.Serialize(hash, options);
+            Assert.That(result, Is.EqualTo("\"0x0000000000000000000000000000000000000000000000000000000000000000\""));
+        }
+
+        [Test]
+        public void Writes_all_ones_hash()
+        {
+            byte[] bytes = new byte[32];
+            Array.Fill(bytes, (byte)0xFF);
+            Hash256 hash = new(bytes);
+            string result = JsonSerializer.Serialize(hash, options);
+            Assert.That(result, Is.EqualTo("\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""));
+        }
+
+        [Test]
+        public void Writes_known_hash()
+        {
+            // Keccak256 of empty string
+            Hash256 hash = Keccak.OfAnEmptyString;
+            string result = JsonSerializer.Serialize(hash, options);
+            Assert.That(result, Is.EqualTo($"\"0x{hash.ToString(false)}\""));
+        }
+
+        [Test]
+        public void Writes_sequential_bytes()
+        {
+            byte[] bytes = new byte[32];
+            for (int i = 0; i < 32; i++) bytes[i] = (byte)i;
+            Hash256 hash = new(bytes);
+            string result = JsonSerializer.Serialize(hash, options);
+            Assert.That(result, Is.EqualTo("\"0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f\""));
+        }
+
+        [Test]
+        public void Writes_roundtrip()
+        {
+            Hash256 hash = Keccak.Compute("test data"u8);
+            string json = JsonSerializer.Serialize(hash, options);
+            Hash256? deserialized = JsonSerializer.Deserialize<Hash256>(json, options);
+            Assert.That(deserialized, Is.EqualTo(hash));
+        }
+
+        [Test]
+        public void Writes_each_nibble_value()
+        {
+            // Ensure all hex chars 0-f appear correctly
+            byte[] bytes = new byte[32];
+            for (int i = 0; i < 16; i++)
+            {
+                bytes[i * 2] = (byte)((i << 4) | i);     // 0x00, 0x11, 0x22, ..., 0xff
+                bytes[i * 2 + 1] = (byte)((i << 4) | (15 - i)); // 0x0f, 0x1e, 0x2d, ...
+            }
+            Hash256 hash = new(bytes);
+            string result = JsonSerializer.Serialize(hash, options);
+            Hash256? roundtrip = JsonSerializer.Deserialize<Hash256>(result, options);
+            Assert.That(roundtrip, Is.EqualTo(hash));
+        }
     }
 }