Refactor TransactionForRpc

src/Nethermind/Nethermind.Core.Test/Builders/TestItem.cs

@@ -38,6 +38,13 @@ static TestItem()
                 Keccaks[i - 1] = Keccak.Compute(PublicKeys[i - 1].Bytes);
                 ValueKeccaks[i - 1] = Keccaks[i - 1];
             }
+
+            byte[] r = new byte[32];
+            byte[] s = new byte[32];
+            r[1] = 1;
+            s[2] = 2;
+            RandomSignatureA = new Signature(r, s, 27);
+            RandomSignatureB = new Signature(r, s, 28);
         }
 
         public static Hash256 KeccakFromNumber(int i)
@@ -92,6 +99,9 @@ public static Hash256 KeccakFromNumber(int i)
         public static Address AddressE = PublicKeyE.Address;
         public static Address AddressF = PublicKeyF.Address;
 
+        public static readonly Signature RandomSignatureA;
+        public static readonly Signature RandomSignatureB;
+
         public static Withdrawal WithdrawalA_1Eth = new() { Address = AddressA, Index = 1, ValidatorIndex = 2001, AmountInGwei = 1_000_000_000 };
         public static Withdrawal WithdrawalB_2Eth = new() { Address = AddressB, Index = 2, ValidatorIndex = 2002, AmountInGwei = 2_000_000_000 };
         public static Withdrawal WithdrawalC_3Eth = new() { Address = AddressC, Index = 3, ValidatorIndex = 2003, AmountInGwei = 3_000_000_000 };

src/Nethermind/Nethermind.Core.Test/Builders/TransactionBuilder.cs

@@ -64,7 +64,7 @@ public TransactionBuilder<T> WithCode(byte[] data)
             return this;
         }
 
-        public TransactionBuilder<T> WithChainId(ulong chainId)
+        public TransactionBuilder<T> WithChainId(ulong? chainId)
         {
             TestObjectInternal.ChainId = chainId;
             return this;
@@ -265,6 +265,16 @@ public TransactionBuilder<T> SignedAndResolved(PrivateKey? privateKey = null)
         protected override void BeforeReturn()
         {
             base.BeforeReturn();
+
+            // Since hash calculation requires certail values to be present in Blob transactions
+            // we initalize them to sane defaults here.
+            // TODO: This should be removed when we have a proper Transaction type hierarchy
+            if (TestObjectInternal.Type == TxType.Blob)
+            {
+                TestObjectInternal.BlobVersionedHashes ??= [];
+                TestObjectInternal.MaxFeePerBlobGas ??= 0;
+            }
+
             if (TestObjectInternal.IsSigned)
             {
                 TestObjectInternal.Hash = TestObjectInternal.CalculateHash();
@@ -282,5 +292,11 @@ public TransactionBuilder<T> WithIsServiceTransaction(bool isServiceTransaction)
             TestObjectInternal.IsServiceTransaction = isServiceTransaction;
             return this;
         }
+
+        public TransactionBuilder<T> WithSourceHash(Hash256? sourceHash)
+        {
+            TestObjectInternal.SourceHash = sourceHash;
+            return this;
+        }
     }
 }

src/Nethermind/Nethermind.Facade/Eth/IFromTransaction.cs

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Int256;
+
+namespace Nethermind.Facade.Eth;
+
+public interface IFromTransaction<out T>
+{
+    T FromTransaction(Transaction tx, TransactionConverterExtraData extraData);
+    T FromTransaction(Transaction tx) => FromTransaction(tx, new TransactionConverterExtraData());
+}
+
+public readonly struct TransactionConverterExtraData
+{
+    public Hash256? BlockHash { get; init; }
+    public long? BlockNumber { get; init; }
+    public int? TxIndex { get; init; }
+    public UInt256? BaseFee { get; init; }
+    public TxReceipt Receipt { get; init; }
+}

src/Nethermind/Nethermind.Facade/Eth/IToTransaction.cs

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+
+namespace Nethermind.Facade.Eth;
+
+// TODO: We might want to lift this to `Core`
+public interface IToTransaction<in T>
+{
+    Transaction ToTransaction(T t);
+    Transaction ToTransactionWithDefaults(T t);
+}

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

@@ -0,0 +1,81 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.Linq;
+using Nethermind.Core;
+using Nethermind.Core.Eip2930;
+using Nethermind.Int256;
+using Nethermind.Serialization.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json;
+using System;
+
+namespace Nethermind.Facade.Eth.RpcTransaction;
+
+[JsonConverter(typeof(JsonConverterImpl))]
+public record RpcAccessList
+{
+    private readonly List<Item> _items;
+
+    [JsonConstructor]
+    public RpcAccessList() { }
+
+    private RpcAccessList(List<Item> items)
+    {
+        _items = items;
+    }
+
+    private class Item
+    {
+        public Address Address { get; set; }
+
+        [JsonConverter(typeof(StorageCellIndexConverter))]
+        public IEnumerable<UInt256> StorageKeys { get; set; }
+
+        [JsonConstructor]
+        public Item() { }
+
+        public Item(Address address, List<UInt256> storageKeys)
+        {
+            Address = address;
+            StorageKeys = storageKeys;
+        }
+    }
+
+    public static RpcAccessList FromAccessList(AccessList? accessList) =>
+        accessList is null
+        ? new RpcAccessList([])
+        : new RpcAccessList(accessList.Select(item => new Item(item.Address, [.. item.StorageKeys])).ToList());
+
+    public AccessList ToAccessList()
+    {
+        AccessList.Builder builder = new();
+        foreach (Item item in _items)
+        {
+            builder.AddAddress(item.Address);
+            foreach (UInt256 index in item.StorageKeys)
+            {
+                builder.AddStorage(index);
+            }
+        }
+
+        return builder.Build();
+    }
+
+    public static readonly JsonConverter<RpcAccessList> JsonConverter = new JsonConverterImpl();
+
+    public class JsonConverterImpl : JsonConverter<RpcAccessList>
+    {
+        public override RpcAccessList? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            List<Item> list = JsonSerializer.Deserialize<List<Item>>(ref reader, options);
+            return list is null ? null : new RpcAccessList(list);
+        }
+
+        public override void Write(Utf8JsonWriter writer, RpcAccessList value, JsonSerializerOptions options)
+        {
+            JsonSerializer.Serialize(writer, value._items, options);
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Int256;
+
+namespace Nethermind.Facade.Eth.RpcTransaction;
+
+public class RpcAccessListTransaction : RpcLegacyTransaction
+{
+    // HACK: To ensure that serialized Txs always have a `ChainId` we keep the last loaded `ChainSpec`.
+    // See: https://github.com/NethermindEth/nethermind/pull/6061#discussion_r1321634914
+    public static UInt256? DefaultChainId { get; set; }
+
+    public RpcAccessList AccessList { get; set; }
+
+    public new UInt256 ChainId { get; set; }
+
+    public UInt256 YParity { get; set; }
+
+    /// <summary>
+    /// For backwards compatibility, <c>v</c> is optionally provided as an alternative to <c>yParity</c>.
+    /// This field is <b>DEPRECATED</b> and all use of it should migrate to <c>yParity</c>.
+    /// </summary>
+    public override UInt256 V { get; set; }
+
+    public RpcAccessListTransaction(Transaction transaction, int? txIndex = null, Hash256? blockHash = null, long? blockNumber = null)
+        : base(transaction, txIndex, blockHash, blockNumber)
+    {
+        AccessList = RpcAccessList.FromAccessList(transaction.AccessList);
+        ChainId = transaction.ChainId
+                  ?? DefaultChainId
+                  ?? BlockchainIds.Mainnet;
+        YParity = transaction.Signature?.RecoveryId ?? 0;
+        V = YParity;
+    }
+
+    public new class Converter : IToTransaction<RpcGenericTransaction>, IFromTransaction<RpcAccessListTransaction>
+    {
+        private readonly RpcLegacyTransaction.Converter _baseConverter = new();
+
+        public RpcAccessListTransaction FromTransaction(Transaction tx, TransactionConverterExtraData extraData)
+            => new(tx, txIndex: extraData.TxIndex, blockHash: extraData.BlockHash, blockNumber: extraData.BlockNumber);
+
+        public Transaction ToTransaction(RpcGenericTransaction rpcTx)
+        {
+            var tx = _baseConverter.ToTransaction(rpcTx);
+            tx.AccessList = rpcTx.AccessList?.ToAccessList() ?? Core.Eip2930.AccessList.Empty;
+            return tx;
+        }
+
+        public Transaction ToTransactionWithDefaults(RpcGenericTransaction rpcTx)
+        {
+            var tx = _baseConverter.ToTransactionWithDefaults(rpcTx);
+            tx.AccessList = rpcTx.AccessList?.ToAccessList() ?? Core.Eip2930.AccessList.Empty;
+            return tx;
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Text.Json.Serialization;
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Int256;
+
+namespace Nethermind.Facade.Eth.RpcTransaction;
+
+public class RpcBlobTransaction : RpcEIP1559Transaction
+{
+    public UInt256 MaxFeePerBlobGas { get; set; }
+
+    // TODO: Each item should be a 32 byte array
+    // Currently we don't enforce this (hashes can have any length)
+    public byte[][] BlobVersionedHashes { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+    public override UInt256 GasPrice { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+    public override UInt256 V { get; set; }
+
+    public RpcBlobTransaction(Transaction transaction, int? txIndex = null, Hash256? blockHash = null, long? blockNumber = null, UInt256? baseFee = null)
+        : base(transaction, txIndex, blockHash, blockNumber, baseFee)
+    {
+        MaxFeePerBlobGas = transaction.MaxFeePerBlobGas ?? 0;
+        BlobVersionedHashes = transaction.BlobVersionedHashes ?? [];
+    }
+
+    public new class Converter : IToTransaction<RpcGenericTransaction>, IFromTransaction<RpcBlobTransaction>
+    {
+        private readonly RpcEIP1559Transaction.Converter _baseConverter = new();
+
+        public RpcBlobTransaction FromTransaction(Transaction tx, TransactionConverterExtraData extraData)
+            => new(tx, txIndex: extraData.TxIndex, blockHash: extraData.BlockHash, blockNumber: extraData.BlockNumber, baseFee: extraData.BaseFee);
+
+        public Transaction ToTransaction(RpcGenericTransaction rpcTx)
+        {
+            var tx = _baseConverter.ToTransaction(rpcTx);
+            tx.MaxFeePerBlobGas = rpcTx.MaxFeePerBlobGas;
+            tx.BlobVersionedHashes = rpcTx.BlobVersionedHashes;
+            return tx;
+        }
+
+        public Transaction ToTransactionWithDefaults(RpcGenericTransaction rpcTx)
+        {
+            var tx = _baseConverter.ToTransaction(rpcTx);
+            tx.MaxFeePerBlobGas = rpcTx.MaxFeePerBlobGas;
+            tx.BlobVersionedHashes = rpcTx.BlobVersionedHashes;
+            return tx;
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Int256;
+
+namespace Nethermind.Facade.Eth.RpcTransaction;
+
+public class RpcEIP1559Transaction : RpcAccessListTransaction
+{
+    public UInt256 MaxPriorityFeePerGas { get; set; }
+
+    public UInt256 MaxFeePerGas { get; set; }
+
+    /// <summary>
+    /// The effective gas price paid by the sender in wei. For transactions not yet included in a block, this value should be set equal to the max fee per gas.
+    /// This field is <b>DEPRECATED</b>, please transition to using <c>effectiveGasPrice</c> in the receipt object going forward.
+    /// </summary>
+    public override UInt256 GasPrice { get; set; }
+
+    public RpcEIP1559Transaction(Transaction transaction, int? txIndex = null, Hash256? blockHash = null, long? blockNumber = null, UInt256? baseFee = null)
+        : base(transaction, txIndex, blockHash, blockNumber)
+    {
+        MaxFeePerGas = transaction.MaxFeePerGas;
+        MaxPriorityFeePerGas = transaction.MaxPriorityFeePerGas;
+        GasPrice = baseFee is not null
+                ? transaction.CalculateEffectiveGasPrice(eip1559Enabled: true, baseFee.Value)
+                : transaction.MaxFeePerGas;
+    }
+
+    public new class Converter : IToTransaction<RpcGenericTransaction>, IFromTransaction<RpcEIP1559Transaction>
+    {
+        private readonly RpcAccessListTransaction.Converter _baseConverter = new();
+
+        public RpcEIP1559Transaction FromTransaction(Transaction tx, TransactionConverterExtraData extraData)
+            => new(tx, txIndex: extraData.TxIndex, blockHash: extraData.BlockHash, blockNumber: extraData.BlockNumber, baseFee: extraData.BaseFee);
+
+        public Transaction ToTransaction(RpcGenericTransaction rpcTx)
+        {
+            var tx = _baseConverter.ToTransaction(rpcTx);
+            tx.GasPrice = rpcTx.MaxPriorityFeePerGas ?? 0;
+            tx.DecodedMaxFeePerGas = rpcTx.MaxFeePerGas ?? 0;
+            return tx;
+        }
+
+        public Transaction ToTransactionWithDefaults(RpcGenericTransaction rpcTx)
+        {
+            var tx = _baseConverter.ToTransaction(rpcTx);
+            tx.GasPrice = rpcTx.MaxPriorityFeePerGas ?? 0;
+            tx.DecodedMaxFeePerGas = rpcTx.MaxFeePerGas ?? 0;
+            return tx;
+        }
+    }
+}