Refactor TxDecoder

src/Nethermind/Nethermind.Blockchain.Test/Validators/TxValidatorTests.cs

@@ -171,7 +171,6 @@ public bool Before_eip_2930_has_to_be_legacy_tx(TxType txType, bool eip2930)
     [TestCase(TxType.AccessList, true, false, ExpectedResult = true)]
     [TestCase(TxType.EIP1559, true, false, ExpectedResult = false)]
     [TestCase(TxType.EIP1559, true, true, ExpectedResult = true)]
-    [TestCase((TxType)100, true, false, ExpectedResult = false)]
     public bool Before_eip_1559_has_to_be_legacy_or_access_list_tx(TxType txType, bool eip2930, bool eip1559)
     {
         byte[] sigData = new byte[65];

src/Nethermind/Nethermind.Core.Test/Encoding/ShardBlobTxDecoderTests.cs

@@ -18,7 +18,7 @@ namespace Nethermind.Core.Test.Encoding;
 [TestFixture]
 public partial class ShardBlobTxDecoderTests
 {
-    private readonly TxDecoder _txDecoder = new();
+    private readonly TxDecoder _txDecoder = TxDecoder.Instance;
 
     [SetUp]
     public static Task SetUp() => KzgPolynomialCommitments.InitializeAsync();

src/Nethermind/Nethermind.Core.Test/Encoding/TxDecoderTests.cs

@@ -22,7 +22,7 @@ namespace Nethermind.Core.Test.Encoding
     [TestFixture]
     public class TxDecoderTests
     {
-        private readonly TxDecoder _txDecoder = new();
+        private readonly TxDecoder _txDecoder = TxDecoder.Instance;
 
         public static IEnumerable<(TransactionBuilder<Transaction>, string)> TestObjectsSource()
         {
@@ -72,12 +72,11 @@ public void CanCorrectlyCalculateTxHash_when_called_concurrently((Transaction Tx
         {
             Transaction tx = testCase.Tx;
 
-            TxDecoder decoder = new TxDecoder();
-            Rlp rlp = decoder.Encode(tx);
+            Rlp rlp = TxDecoder.Instance.Encode(tx);
 
             Hash256 expectedHash = Keccak.Compute(rlp.Bytes);
 
-            Transaction decodedTx = decoder.Decode(new RlpStream(rlp.Bytes))!;
+            Transaction decodedTx = TxDecoder.Instance.Decode(new RlpStream(rlp.Bytes))!;
 
             decodedTx.SetPreHash(rlp.Bytes);
 

src/Nethermind/Nethermind.Crypto/TransactionExtensions.cs

@@ -9,7 +9,7 @@ namespace Nethermind.Crypto
 {
     public static class TransactionExtensions
     {
-        private static readonly TxDecoder _txDecoder = new();
+        private static readonly TxDecoder _txDecoder = TxDecoder.Instance;
 
         public static Hash256 CalculateHash(this Transaction transaction)
         {

src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceRpcModule.cs

@@ -38,7 +38,7 @@ public class TraceRpcModule : ITraceRpcModule
         private readonly IReceiptFinder _receiptFinder;
         private readonly ITracer _tracer;
         private readonly IBlockFinder _blockFinder;
-        private readonly TxDecoder _txDecoder = new();
+        private readonly TxDecoder _txDecoder = TxDecoder.Instance;
         private readonly IJsonRpcConfig _jsonRpcConfig;
         private readonly TimeSpan _cancellationTokenTimeout;
         private readonly IStateReader _stateReader;

src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.V3.cs

@@ -145,9 +145,8 @@ public virtual async Task NewPayloadV3_should_decline_mempool_encoding(bool inMe
 
         ExecutionPayloadV3 payload = (await rpcModule.engine_getPayloadV3(Bytes.FromHexString(payloadId!))).Data!.ExecutionPayload;
 
-        TxDecoder rlpEncoder = new();
         RlpBehaviors rlpBehaviors = (inMempoolForm ? RlpBehaviors.InMempoolForm : RlpBehaviors.None) | RlpBehaviors.SkipTypedWrapping;
-        payload.Transactions = transactions.Select(tx => rlpEncoder.Encode(tx, rlpBehaviors).Bytes).ToArray();
+        payload.Transactions = transactions.Select(tx => TxDecoder.Instance.Encode(tx, rlpBehaviors).Bytes).ToArray();
         byte[]?[] blobVersionedHashes = transactions.SelectMany(tx => tx.BlobVersionedHashes ?? Array.Empty<byte[]>()).ToArray();
 
         ResultWrapper<PayloadStatusV1> result = await rpcModule.engine_newPayloadV3(payload, blobVersionedHashes, payload.ParentBeaconBlockRoot);

src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Eth/V62/Eth62ProtocolHandlerTests.cs

@@ -27,7 +27,6 @@
 using Nethermind.Network.P2P.Subprotocols.Eth.V62.Messages;
 using Nethermind.Network.Rlpx;
 using Nethermind.Network.Test.Builders;
-using Nethermind.Serialization.Rlp;
 using Nethermind.Stats;
 using Nethermind.Stats.Model;
 using Nethermind.Synchronization;
@@ -47,7 +46,6 @@ public class Eth62ProtocolHandlerTests
         private Block _genesisBlock = null!;
         private Eth62ProtocolHandler _handler = null!;
         private IGossipPolicy _gossipPolicy = null!;
-        private readonly TxDecoder _txDecoder = new();
         private ITxGossipPolicy _txGossipPolicy = null!;
 
         [SetUp]

src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Eth/V68/Eth68ProtocolHandlerTests.cs

@@ -273,7 +273,7 @@ private void HandleZeroMessage<T>(T msg, byte messageCode) where T : MessageBase
 
     private void GenerateLists(int txCount, out ArrayPoolList<byte> types, out ArrayPoolList<int> sizes, out ArrayPoolList<Hash256> hashes)
     {
-        TxDecoder txDecoder = new();
+        TxDecoder txDecoder = TxDecoder.Instance;
         types = new(txCount);
         sizes = new(txCount);
         hashes = new(txCount);

src/Nethermind/Nethermind.Network/P2P/ProtocolHandlers/SyncPeerProtocolHandlerBase.cs

@@ -87,7 +87,7 @@ protected SyncPeerProtocolHandlerBase(ISession session,
             SyncServer = syncServer ?? throw new ArgumentNullException(nameof(syncServer));
             BackgroundTaskScheduler = new BackgroundTaskSchedulerWrapper(this, backgroundTaskScheduler ?? throw new ArgumentNullException(nameof(BackgroundTaskScheduler)));
             _timestamper = Timestamper.Default;
-            _txDecoder = new TxDecoder();
+            _txDecoder = TxDecoder.Instance;
             _headersRequests = new MessageQueue<GetBlockHeadersMessage, IOwnedReadOnlyList<BlockHeader>>(Send);
             _bodiesRequests = new MessageQueue<GetBlockBodiesMessage, (OwnedBlockBodies, long)>(Send);
 

src/Nethermind/Nethermind.Network/P2P/Subprotocols/Eth/V62/Messages/BlockBodiesMessageSerializer.cs

@@ -55,7 +55,7 @@ public BlockBodiesMessage Deserialize(IByteBuffer byteBuffer)
 
         private class BlockBodyDecoder : IRlpValueDecoder<BlockBody>
         {
-            private readonly TxDecoder _txDecoder = new();
+            private readonly TxDecoder _txDecoder = TxDecoder.Instance;
             private readonly HeaderDecoder _headerDecoder = new();
             private readonly WithdrawalDecoder _withdrawalDecoderDecoder = new();
 

src/Nethermind/Nethermind.Network/P2P/Subprotocols/Eth/V62/Messages/TransactionsMessageSerializer.cs

@@ -10,7 +10,7 @@ namespace Nethermind.Network.P2P.Subprotocols.Eth.V62.Messages
 {
     public class TransactionsMessageSerializer : IZeroInnerMessageSerializer<TransactionsMessage>
     {
-        private readonly TxDecoder _decoder = new();
+        private readonly TxDecoder _decoder = TxDecoder.Instance;
 
         public void Serialize(IByteBuffer byteBuffer, TransactionsMessage message)
         {

src/Nethermind/Nethermind.Serialization.Rlp/BlockDecoder.cs

@@ -11,7 +11,7 @@ namespace Nethermind.Serialization.Rlp
     public class BlockDecoder : IRlpValueDecoder<Block>, IRlpStreamDecoder<Block>
     {
         private readonly HeaderDecoder _headerDecoder = new();
-        private readonly TxDecoder _txDecoder = new();
+        private readonly TxDecoder _txDecoder = TxDecoder.Instance;
         private readonly WithdrawalDecoder _withdrawalDecoder = new();
 
         public Block? Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None)

src/Nethermind/Nethermind.Serialization.Rlp/MyTxDecoder/AccessListTxDecoder.cs

@@ -0,0 +1,242 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Core.Extensions;
+using Nethermind.Serialization.Rlp.Eip2930;
+
+namespace Nethermind.Serialization.Rlp.MyTxDecoder;
+
+public sealed class AccessListTxDecoder(Func<Transaction>? transactionFactory = null) : ITxDecoder
+{
+    private static readonly AccessListDecoder AccessListDecoder = new();
+    private readonly Func<Transaction> _createTransaction = transactionFactory ?? (() => new Transaction());
+
+    public Transaction? Decode(Span<byte> transactionSequence, RlpStream rlpStream, RlpBehaviors rlpBehaviors)
+    {
+        Transaction transaction = _createTransaction();
+        transaction.Type = TxType.AccessList;
+
+        int transactionLength = rlpStream.ReadSequenceLength();
+        int lastCheck = rlpStream.Position + transactionLength;
+
+        DecodePayload(transaction, rlpStream, rlpBehaviors);
+
+        if (rlpStream.Position < lastCheck)
+        {
+            DecodeSignature(transaction, rlpStream, rlpBehaviors);
+        }
+
+        if ((rlpBehaviors & RlpBehaviors.AllowExtraBytes) == 0)
+        {
+            rlpStream.Check(lastCheck);
+        }
+
+        if ((rlpBehaviors & RlpBehaviors.ExcludeHashes) == 0)
+        {
+            if (transactionSequence.Length <= ITxDecoder.MaxDelayedHashTxnSize)
+            {
+                // Delay hash generation, as may be filtered as having too low gas etc
+                transaction.SetPreHashNoLock(transactionSequence);
+            }
+            else
+            {
+                // Just calculate the Hash as txn too large
+                transaction.Hash = Keccak.Compute(transactionSequence);
+            }
+        }
+
+        return transaction;
+    }
+
+    public void Decode(ref Transaction? transaction, int txSequenceStart, ReadOnlySpan<byte> transactionSequence, ref Rlp.ValueDecoderContext decoderContext, RlpBehaviors rlpBehaviors = RlpBehaviors.None)
+    {
+        transaction ??= _createTransaction();
+        transaction.Type = TxType.AccessList;
+
+        int transactionLength = decoderContext.ReadSequenceLength();
+        int lastCheck = decoderContext.Position + transactionLength;
+
+        DecodePayload(transaction, ref decoderContext, rlpBehaviors);
+
+        if (decoderContext.Position < lastCheck)
+        {
+            DecodeSignature(transaction, ref decoderContext, rlpBehaviors);
+        }
+
+        if ((rlpBehaviors & RlpBehaviors.AllowExtraBytes) == 0)
+        {
+            decoderContext.Check(lastCheck);
+        }
+
+        if ((rlpBehaviors & RlpBehaviors.ExcludeHashes) == 0)
+        {
+            if (transactionSequence.Length <= ITxDecoder.MaxDelayedHashTxnSize)
+            {
+                // Delay hash generation, as may be filtered as having too low gas etc
+                if (decoderContext.ShouldSliceMemory)
+                {
+                    // Do not copy the memory in this case.
+                    int currentPosition = decoderContext.Position;
+                    decoderContext.Position = txSequenceStart;
+                    transaction.SetPreHashMemoryNoLock(decoderContext.ReadMemory(transactionSequence.Length));
+                    decoderContext.Position = currentPosition;
+                }
+                else
+                {
+                    transaction.SetPreHashNoLock(transactionSequence);
+                }
+            }
+            else
+            {
+                // Just calculate the Hash immediately as txn too large
+                transaction.Hash = Keccak.Compute(transactionSequence);
+            }
+        }
+    }
+
+    public void Encode(Transaction transaction, RlpStream stream, RlpBehaviors rlpBehaviors = RlpBehaviors.None, bool forSigning = false, bool isEip155Enabled = false, ulong chainId = 0)
+    {
+        int contentLength = GetContentLength(transaction, forSigning);
+        int sequenceLength = Rlp.LengthOfSequence(contentLength);
+
+        if ((rlpBehaviors & RlpBehaviors.SkipTypedWrapping) == 0)
+        {
+            stream.StartByteArray(sequenceLength + 1, false);
+        }
+
+        stream.WriteByte((byte)TxType.AccessList);
+        stream.StartSequence(contentLength);
+
+        EncodePayload(transaction, stream, rlpBehaviors);
+        EncodeSignature(transaction, stream, forSigning);
+    }
+
+    public int GetLength(Transaction transaction, RlpBehaviors rlpBehaviors, bool forSigning = false, bool isEip155Enabled = false, ulong chainId = 0)
+    {
+        int txContentLength = GetContentLength(transaction, forSigning);
+        int txPayloadLength = Rlp.LengthOfSequence(txContentLength);
+
+        bool isForTxRoot = rlpBehaviors.HasFlag(RlpBehaviors.SkipTypedWrapping);
+        int result = isForTxRoot
+                ? (1 + txPayloadLength)
+                : Rlp.LengthOfSequence(1 + txPayloadLength);
+        return result;
+    }
+
+    private static void DecodePayload(Transaction transaction, RlpStream rlpStream, RlpBehaviors rlpBehaviors)
+    {
+        transaction.ChainId = rlpStream.DecodeULong();
+        transaction.Nonce = rlpStream.DecodeUInt256();
+        transaction.GasPrice = rlpStream.DecodeUInt256();
+        transaction.GasLimit = rlpStream.DecodeLong();
+        transaction.To = rlpStream.DecodeAddress();
+        transaction.Value = rlpStream.DecodeUInt256();
+        transaction.Data = rlpStream.DecodeByteArray();
+        transaction.AccessList = AccessListDecoder.Decode(rlpStream, rlpBehaviors);
+    }
+
+    private static void DecodePayload(Transaction transaction, ref Rlp.ValueDecoderContext decoderContext, RlpBehaviors rlpBehaviors)
+    {
+        transaction.ChainId = decoderContext.DecodeULong();
+        transaction.Nonce = decoderContext.DecodeUInt256();
+        transaction.GasPrice = decoderContext.DecodeUInt256();
+        transaction.GasLimit = decoderContext.DecodeLong();
+        transaction.To = decoderContext.DecodeAddress();
+        transaction.Value = decoderContext.DecodeUInt256();
+        transaction.Data = decoderContext.DecodeByteArrayMemory();
+        transaction.AccessList = AccessListDecoder.Decode(ref decoderContext, rlpBehaviors);
+    }
+
+    private static void DecodeSignature(Transaction transaction, RlpStream rlpStream, RlpBehaviors rlpBehaviors)
+    {
+        ulong v = rlpStream.DecodeULong();
+        ReadOnlySpan<byte> rBytes = rlpStream.DecodeByteArraySpan();
+        ReadOnlySpan<byte> sBytes = rlpStream.DecodeByteArraySpan();
+        transaction.Signature = SignatureBuilder.FromBytes(v + Signature.VOffset, rBytes, sBytes, rlpBehaviors) ?? transaction.Signature;
+    }
+
+    private static void DecodeSignature(Transaction transaction, ref Rlp.ValueDecoderContext decoderContext, RlpBehaviors rlpBehaviors)
+    {
+        ulong v = decoderContext.DecodeULong();
+        ReadOnlySpan<byte> rBytes = decoderContext.DecodeByteArraySpan();
+        ReadOnlySpan<byte> sBytes = decoderContext.DecodeByteArraySpan();
+        transaction.Signature = SignatureBuilder.FromBytes(v + Signature.VOffset, rBytes, sBytes, rlpBehaviors) ?? transaction.Signature;
+    }
+
+    private static void EncodePayload(Transaction transaction, RlpStream stream, RlpBehaviors rlpBehaviors)
+    {
+        stream.Encode(transaction.ChainId ?? 0);
+        stream.Encode(transaction.Nonce);
+        stream.Encode(transaction.GasPrice);
+        stream.Encode(transaction.GasLimit);
+        stream.Encode(transaction.To);
+        stream.Encode(transaction.Value);
+        stream.Encode(transaction.Data);
+        AccessListDecoder.Encode(stream, transaction.AccessList, rlpBehaviors);
+    }
+
+    private static void EncodeSignature(Transaction transaction, RlpStream stream, bool forSigning)
+    {
+        if (!forSigning)
+        {
+            if (transaction.Signature is null)
+            {
+                stream.Encode(0);
+                stream.Encode(Bytes.Empty);
+                stream.Encode(Bytes.Empty);
+            }
+            else
+            {
+                stream.Encode(transaction.Signature.RecoveryId);
+                stream.Encode(transaction.Signature.RAsSpan.WithoutLeadingZeros());
+                stream.Encode(transaction.Signature.SAsSpan.WithoutLeadingZeros());
+            }
+        }
+    }
+
+    private static int GetContentLength(Transaction transaction, bool forSigning)
+    {
+        int payloadLength = GetPayloadLength(transaction);
+        int signatureLength = GetSignatureLength(transaction, forSigning);
+
+        return payloadLength + signatureLength;
+    }
+
+    private static int GetPayloadLength(Transaction transaction)
+    {
+        return Rlp.LengthOf(transaction.Nonce)
+               + Rlp.LengthOf(transaction.GasPrice)
+               + Rlp.LengthOf(transaction.GasLimit)
+               + Rlp.LengthOf(transaction.To)
+               + Rlp.LengthOf(transaction.Value)
+               + Rlp.LengthOf(transaction.Data)
+               + Rlp.LengthOf(transaction.ChainId ?? 0)
+               + AccessListDecoder.GetLength(transaction.AccessList, RlpBehaviors.None);
+    }
+
+    private static int GetSignatureLength(Transaction transaction, bool forSigning)
+    {
+        int contentLength = 0;
+
+        if (!forSigning)
+        {
+            if (transaction.Signature is null)
+            {
+                contentLength += 1;
+                contentLength += 1;
+                contentLength += 1;
+            }
+            else
+            {
+                contentLength += Rlp.LengthOf(transaction.Signature.RecoveryId);
+                contentLength += Rlp.LengthOf(transaction.Signature.RAsSpan.WithoutLeadingZeros());
+                contentLength += Rlp.LengthOf(transaction.Signature.SAsSpan.WithoutLeadingZeros());
+            }
+        }
+
+        return contentLength;
+    }
+}