Refactor TransactionForRpc (Alternative)

src/Nethermind/Nethermind.Facade/Eth/RpcTransaction/TransactionForRpc.cs

@@ -80,21 +80,20 @@ internal static void RegisterTransactionType<T>() where T : TransactionForRpc, I
 
         public override TransactionForRpc? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            using var document = JsonDocument.ParseValue(ref reader);
-
-            // TODO: For some reason we might get an object wrapped in a String
-            using JsonDocument jsonObject = document.RootElement.ValueKind == JsonValueKind.String
-                ? JsonDocument.Parse(document.RootElement.GetString()!)
-                : document;
-
-            TxType discriminator = DefaultTxType;
-            if (jsonObject.RootElement.TryGetProperty("type", out JsonElement typeProperty))
+            if (reader.ValueIsEscaped)
             {
-                discriminator = (TxType?)typeProperty.Deserialize(typeof(TxType), options) ?? DefaultTxType;
+                string escapedJson = JsonSerializer.Deserialize<string>(ref reader);
+                return JsonSerializer.Deserialize<TransactionForRpc>(escapedJson, options);
             }
 
+            // Copy reader so we can double parse to get type
+            Utf8JsonReader copyReader = reader;
+            TransactionType type = JsonSerializer.Deserialize<TransactionType>(ref copyReader, options);
+
+            TxType discriminator = (TxType)(type.Type ?? (ulong)DefaultTxType);
+
             return _types.TryGetByTxType(discriminator, out Type concreteTxType)
-                ? (TransactionForRpc?)jsonObject.Deserialize(concreteTxType, options)
+                ? (TransactionForRpc?)JsonSerializer.Deserialize(ref reader, concreteTxType, options)
                 : throw new JsonException("Unknown transaction type");
         }
 
@@ -104,6 +103,12 @@ public override void Write(Utf8JsonWriter writer, TransactionForRpc value, JsonS
         }
     }
 
+    private class TransactionType
+    {
+        // Hex value
+        public ulong? Type { get; set; }
+    }
+
     internal class TransactionConverter
     {
         private delegate TransactionForRpc FromTransactionFunc(Transaction tx, TransactionConverterExtraData extraData);

src/Nethermind/Nethermind.JsonRpc.Test/JsonRpcSocketsClientTests.cs

@@ -80,7 +80,7 @@ static async Task<int> CountNumberOfMessages(Socket socket, CancellationToken to
                     byte[] buffer = new byte[10];
                     while (true)
                     {
-                        ReceiveResult? result = await stream.ReceiveAsync(buffer);
+                        ReceiveResult? result = await stream.ReceiveAsync(buffer).ConfigureAwait(false);
                         if (result?.EndOfMessage == true)
                         {
                             messages++;
@@ -108,7 +108,7 @@ static async Task<int> CountNumberOfMessages(Socket socket, CancellationToken to
             Task<int> sendMessages = Task.Run(async () =>
             {
                 using Socket socket = new(ipEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
-                await socket.ConnectAsync(ipEndPoint);
+                await socket.ConnectAsync(ipEndPoint).ConfigureAwait(false);
 
                 using IpcSocketMessageStream stream = new(socket);
                 using JsonRpcSocketsClient<IpcSocketMessageStream> client = new(
@@ -124,17 +124,17 @@ static async Task<int> CountNumberOfMessages(Socket socket, CancellationToken to
                 for (int i = 0; i < messageCount; i++)
                 {
                     using JsonRpcResult result = JsonRpcResult.Single(RandomSuccessResponse(1_000, () => disposeCount++), default);
-                    await client.SendJsonRpcResult(result);
-                    await Task.Delay(10);
+                    await client.SendJsonRpcResult(result).ConfigureAwait(false);
+                    await Task.Delay(1).ConfigureAwait(false);
                 }
 
                 disposeCount.Should().Be(messageCount);
-                await cts.CancelAsync();
+                await cts.CancelAsync().ConfigureAwait(false);
 
                 return messageCount;
             });
 
-            await Task.WhenAll(sendMessages, receiveMessages);
+            await Task.WhenAll(sendMessages, receiveMessages).ConfigureAwait(false);
             int sent = sendMessages.Result;
             int received = receiveMessages.Result;
 
@@ -158,7 +158,7 @@ async Task<int> ReadMessages(Socket socket, IList<byte[]> receivedMessages, Canc
                     byte[] buffer = new byte[bufferSize];
                     while (true)
                     {
-                        ReceiveResult? result = await stream.ReceiveAsync(buffer);
+                        ReceiveResult? result = await stream.ReceiveAsync(buffer).ConfigureAwait(false);
                         if (result is not null)
                         {
                             msg.AddRange(buffer.Take(result.Read));
@@ -190,14 +190,14 @@ async Task<int> ReadMessages(Socket socket, IList<byte[]> receivedMessages, Canc
 
             Task<int> receiveMessages = OneShotServer(
                 ipEndPoint,
-                async socket => await ReadMessages(socket, receivedMessages, cts.Token)
+                async socket => await ReadMessages(socket, receivedMessages, cts.Token).ConfigureAwait(false)
             );
 
             Task<int> sendMessages = Task.Run(async () =>
             {
                 int messageCount = 0;
                 using Socket socket = new(ipEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
-                await socket.ConnectAsync(ipEndPoint);
+                await socket.ConnectAsync(ipEndPoint).ConfigureAwait(false);
 
                 using IpcSocketMessageStream stream = new(socket);
                 using JsonRpcSocketsClient<IpcSocketMessageStream> client = new(
@@ -216,20 +216,20 @@ async Task<int> ReadMessages(Socket socket, IList<byte[]> receivedMessages, Canc
                     messageCount++;
                     var msg = Enumerable.Range(11, i).Select(x => (byte)x).ToArray();
                     sentMessages.Add(msg);
-                    await stream.WriteAsync(msg);
-                    await stream.WriteEndOfMessageAsync();
+                    await stream.WriteAsync(msg).ConfigureAwait(false);
+                    await stream.WriteEndOfMessageAsync().ConfigureAwait(false);
                     if (i % 10 == 0)
                     {
-                        await Task.Delay(10);
+                        await Task.Delay(1).ConfigureAwait(false);
                     }
                 }
                 stream.Close();
-                await cts.CancelAsync();
+                await cts.CancelAsync().ConfigureAwait(false);
 
                 return messageCount;
             });
 
-            await Task.WhenAll(sendMessages, receiveMessages);
+            await Task.WhenAll(sendMessages, receiveMessages).ConfigureAwait(false);
             int sent = sendMessages.Result;
             int received = receiveMessages.Result;
 

src/Nethermind/Nethermind.JsonRpc.Test/RpcTest.cs

@@ -35,19 +35,19 @@ public static async Task<string> TestSerializedRequest<T>(T module, string metho
         JsonRpcContext context = module is IContextAwareRpcModule { Context: not null } contextAwareModule ?
             contextAwareModule.Context :
             new JsonRpcContext(RpcEndpoint.Http);
-        using JsonRpcResponse response = await service.SendRequestAsync(request, context);
+        using JsonRpcResponse response = await service.SendRequestAsync(request, context).ConfigureAwait(false);
 
         EthereumJsonSerializer serializer = new();
 
         Stream stream = new MemoryStream();
-        long size = await serializer.SerializeAsync(stream, response);
+        long size = await serializer.SerializeAsync(stream, response).ConfigureAwait(false);
 
         // for coverage (and to prove that it does not throw
         Stream indentedStream = new MemoryStream();
-        await serializer.SerializeAsync(indentedStream, response, true);
+        await serializer.SerializeAsync(indentedStream, response, true).ConfigureAwait(false);
 
         stream.Seek(0, SeekOrigin.Begin);
-        string serialized = await new StreamReader(stream).ReadToEndAsync();
+        string serialized = await new StreamReader(stream).ReadToEndAsync().ConfigureAwait(false);
 
         size.Should().Be(serialized.Length);