feat: Support eth_fillTransaction (#12204)

* feat: Support eth_fillTransaction

* fix(rpc): address eth_fillTransaction review feedback

- Require an explicit `from`; reject the silent zero-address default.
- Reject a `chainId` that doesn't match the node (geth parity).
- Derive blob fields before gas estimation so blob txs estimate correctly.
- Default maxFeePerBlobGas to 2x the blob base fee and fail when it can't be
  computed, instead of emitting "0x0" (below the EIP-4844 minimum of 1).
- Add regression tests for the from and chainId guards.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(rpc): fill eth_fillTransaction fields via polymorphism

Replace the per-type if/switch cascade in eth_fillTransaction with virtual
FillFeeDefaults / PrepareForGasEstimation methods on the TransactionForRpc
hierarchy, driven by a small TxFillContext of node-computed defaults. Each tx
type now populates the fee model it uses without the RPC layer branching on the
concrete type.

Also harden the blob path (moved into BlobTransactionForRpc): bound the blob
count before the KZG work and validate caller-supplied blobVersionedHashes
against the derived commitments instead of silently overwriting them.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(rpc): drop redundant JsonPropertyName on FillTransactionResult

The camelCase naming policy already serializes Tx as "tx".

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(rpc): consolidate eth_fillTransaction tests and cover blob validation

Fold the success and error cases into TestCaseSource-driven tests, and add
coverage for the blob-count bound and the blob-hash mismatch rejection.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore: remove comment

* refactor(rpc): unify eth_fillTransaction fill hooks into one Result-based method

Merge PrepareForGasEstimation and FillFeeDefaults into a single
FillDefaults(in TxFillContext) returning Result, called before gas estimation
to mirror geth's setDefaults order; estimation now runs with the effective
fees, failing like geth when the sender cannot cover them. Split the
unsupported-type and missing-from guards into distinct errors, and trim
comments to the non-obvious invariants.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* feat(rpc): type eth_fillTransaction input as LegacyTransactionForRpc

Add LegacyTransactionJsonConverter, a second polymorphic converter rooted at
LegacyTransactionForRpc (the base of every user-signable tx type), so RPC
methods taking transactions as input can declare that type and reject
output-only types such as Optimism deposit transactions at deserialization.
The base dispatch strips the converter (cached options copy) when
deserializing the exact LegacyTransactionForRpc concrete type to avoid
recursion, and registration happens via ModuleInitializer so the converter is
present in every host before the first parameter bind. This removes the
runtime type guard from eth_fillTransaction.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(rpc): satisfy analyzers in LegacyTransactionJsonConverter

Use a collection expression for the options cache (IDE0028) and suppress
CA2255 with justification: registration must precede the first bind of a
LegacyTransactionForRpc-declared member in any host, which a static
constructor cannot guarantee.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* refactor(rpc): root signable-tx converter at an abstract type

Replace the concrete-rooted, globally-registered LegacyTransactionJsonConverter
with SignableTransactionForRpc, an abstract intermediate base between
TransactionForRpc and LegacyTransactionForRpc that carries the polymorphic
converter as a [JsonConverter] attribute. Because the root is abstract it is
never a concrete leaf, so the converter no longer self-collides and needs no
WithoutSelf; attributing it drops the global options mutation and the
ModuleInitializer. Output-only types (e.g. Optimism deposits) derive from
TransactionForRpc directly, so declaring an input parameter as
SignableTransactionForRpc excludes them via the type system.

Applied to the transaction-input eth_* methods (fillTransaction,
sendTransaction, signTransaction, call, estimateGas, createAccessList).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Lukasz Rozmej <lukasz.rozmej@gmail.com>

Author: 3 people

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

@@ -90,6 +90,49 @@ public override Result<Transaction> ToTransaction(bool validateUserInput = false
         return tx;
     }
 
+    public override Result FillDefaults(in TxFillContext context)
+    {
+        Result baseResult = base.FillDefaults(context);
+        if (!baseResult) return baseResult;
+
+        if (MaxFeePerBlobGas is null)
+        {
+            // Fail rather than default to 0x0, which is below the EIP-4844 minimum blob base fee of 1.
+            if (context.BlobBaseFee is null) return Result.Fail("unable to calculate the current blob base fee");
+            MaxFeePerBlobGas = context.BlobBaseFee.Value * 2;
+        }
+
+        return DeriveSidecar(context.Spec);
+    }
+
+    private Result DeriveSidecar(IReleaseSpec spec)
+    {
+        if (Blobs is not { Length: > 0 }) return Result.Success;
+        if (Commitments is not null && Proofs is not null && BlobVersionedHashes is { Length: > 0 }) return Result.Success;
+
+        // Bound the blob count before the expensive KZG work.
+        ValidationResult blobCountValidation = BlobFieldsTxValidator.ValidateBlobGasLimits(Blobs.Length, spec);
+        if (!blobCountValidation) return Result.Fail(blobCountValidation.Error!);
+
+        IBlobProofsManager proofsManager = IBlobProofsManager.For(spec.BlobProofVersion);
+        ShardBlobNetworkWrapper wrapper = proofsManager.AllocateWrapper(Blobs);
+        proofsManager.ComputeProofsAndCommitments(wrapper);
+
+        if (BlobVersionedHashes is { Length: > 0 })
+        {
+            if (!proofsManager.ValidateHashes(wrapper, BlobVersionedHashes))
+                return Result.Fail("blob versioned hashes do not match the supplied blobs");
+        }
+        else
+        {
+            BlobVersionedHashes = proofsManager.ComputeHashes(wrapper);
+        }
+
+        Commitments = wrapper.Commitments;
+        Proofs = wrapper.Proofs;
+        return Result.Success;
+    }
+
     public new static BlobTransactionForRpc FromTransaction(Transaction tx, in TransactionForRpcContext extraData)
         => new(tx, extraData);
 

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

@@ -66,6 +66,13 @@ public override Result<Transaction> ToTransaction(bool validateUserInput = false
     public override bool ShouldSetBaseFee() =>
         base.ShouldSetBaseFee() || MaxFeePerGas.IsPositive() || MaxPriorityFeePerGas.IsPositive();
 
+    public override Result FillDefaults(in TxFillContext context)
+    {
+        MaxPriorityFeePerGas ??= context.MaxPriorityFeePerGas;
+        MaxFeePerGas ??= context.BaseFee * 2 + MaxPriorityFeePerGas.Value;
+        return Result.Success;
+    }
+
     public new static EIP1559TransactionForRpc FromTransaction(Transaction tx, in TransactionForRpcContext extraData)
         => new(tx, extraData);
 }

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

@@ -14,7 +14,7 @@
 
 namespace Nethermind.Facade.Eth.RpcTransaction;
 
-public class LegacyTransactionForRpc : TransactionForRpc, ITxTyped, IFromTransaction<LegacyTransactionForRpc>
+public class LegacyTransactionForRpc : SignableTransactionForRpc, ITxTyped, IFromTransaction<LegacyTransactionForRpc>
 {
     public static TxType TxType => TxType.Legacy;
 
@@ -134,6 +134,12 @@ public override Result<Transaction> ToTransaction(bool validateUserInput = false
 
     public override bool ShouldSetBaseFee() => GasPrice.IsPositive();
 
+    public override Result FillDefaults(in TxFillContext context)
+    {
+        GasPrice ??= context.GasPrice;
+        return Result.Success;
+    }
+
     public static LegacyTransactionForRpc FromTransaction(Transaction tx, in TransactionForRpcContext extraData) =>
         new(tx, extraData);
 }

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

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: 2026 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Nethermind.Core;
+
+namespace Nethermind.Facade.Eth.RpcTransaction;
+
+/// <summary>
+/// Abstract root of the user-signable transaction types (legacy, access list, EIP-1559, blob,
+/// set-code). Declaring an RPC input parameter as this type restricts it, via the type system, to
+/// transactions a user can submit: output-only types such as Optimism deposits derive from
+/// <see cref="TransactionForRpc"/> directly and are rejected during deserialization.
+/// </summary>
+/// <remarks>
+/// The root is abstract on purpose. Because it is never a concrete leaf, the polymorphic converter
+/// never has to deserialize its own type and needs no self-exclusion — unlike a converter rooted at
+/// a concrete type. The converter is attached via <see cref="JsonConverterAttribute"/> rather than
+/// registered globally, so it applies only where a parameter is declared as this type.
+/// </remarks>
+[JsonConverter(typeof(SignableTransactionJsonConverter))]
+public abstract class SignableTransactionForRpc : TransactionForRpc
+{
+    protected SignableTransactionForRpc() { }
+
+    protected SignableTransactionForRpc(Transaction transaction, in TransactionForRpcContext extraData)
+        : base(transaction, extraData) { }
+
+    internal sealed class SignableTransactionJsonConverter : JsonConverter<SignableTransactionForRpc>
+    {
+        public override SignableTransactionForRpc? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
+            // The base converter matches only TransactionForRpc, so its concrete-type deserialization never re-enters this one.
+            JsonSerializer.Deserialize<TransactionForRpc>(ref reader, options) switch
+            {
+                null => null,
+                SignableTransactionForRpc signable => signable,
+                { Type: var type } => throw new JsonException($"transaction type {type} is not supported as an input")
+            };
+
+        public override void Write(Utf8JsonWriter writer, SignableTransactionForRpc value, JsonSerializerOptions options) =>
+            JsonSerializer.Serialize(writer, value, value.GetType(), options);
+    }
+}

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

@@ -120,6 +120,13 @@ public TransactionForRpc PromoteToEip1559IfTypeDefaulted()
         };
     }
 
+    /// <summary>
+    /// Fills the type-specific fields the caller left unset from node-computed defaults: each
+    /// transaction type populates the fee model it uses, and blob transactions additionally derive
+    /// the KZG sidecar from the supplied blobs.
+    /// </summary>
+    public virtual Result FillDefaults(in TxFillContext context) => Result.Success;
+
     public abstract bool ShouldSetBaseFee();
 
     internal class TransactionJsonConverter : JsonConverter<TransactionForRpc>

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

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: 2026 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core.Specs;
+using Nethermind.Int256;
+
+namespace Nethermind.Facade.Eth.RpcTransaction;
+
+/// <summary>
+/// Node-computed defaults handed to <see cref="TransactionForRpc.FillDefaults"/> so each transaction
+/// type populates the fields it uses without the RPC layer branching on the concrete type.
+/// </summary>
+public readonly struct TxFillContext
+{
+    public required UInt256 GasPrice { get; init; }
+
+    public required UInt256 MaxPriorityFeePerGas { get; init; }
+
+    public required UInt256 BaseFee { get; init; }
+
+    /// <summary>Current blob base fee, or <c>null</c> when it cannot be computed.</summary>
+    public required UInt256? BlobBaseFee { get; init; }
+
+    public required IReleaseSpec Spec { get; init; }
+}

src/Nethermind/Nethermind.JsonRpc.Test/JsonRpcServiceTests.cs

@@ -235,7 +235,7 @@ public void CanHandleOptionalArguments()
     {
         IEthRpcModule ethRpcModule = Substitute.For<IEthRpcModule>();
         HexBytes expected = ToHexBytes("0x01");
-        ethRpcModule.eth_call(Arg.Any<TransactionForRpc>()).ReturnsForAnyArgs(_ => ResultWrapper<HexBytes>.Success(expected));
+        ethRpcModule.eth_call(Arg.Any<SignableTransactionForRpc>()).ReturnsForAnyArgs(_ => ResultWrapper<HexBytes>.Success(expected));
         HexBytes result = RpcTest.AssertSuccess<HexBytes>(TestRequest(ethRpcModule, "eth_call", new LegacyTransactionForRpc()));
         Assert.That(result, Is.EqualTo(expected));
     }
@@ -244,7 +244,7 @@ public void CanHandleOptionalArguments()
     public void Value_type_result_failure_without_error_data_does_not_emit_default_data()
     {
         IEthRpcModule ethRpcModule = Substitute.For<IEthRpcModule>();
-        ethRpcModule.eth_call(Arg.Any<TransactionForRpc>()).ReturnsForAnyArgs(_ => ResultWrapper<HexBytes>.Fail("out of gas", ErrorCodes.ExecutionError));
+        ethRpcModule.eth_call(Arg.Any<SignableTransactionForRpc>()).ReturnsForAnyArgs(_ => ResultWrapper<HexBytes>.Fail("out of gas", ErrorCodes.ExecutionError));
 
         ResultWrapper<HexBytes> response = AssertWrapperResponse<HexBytes>(TestRequest(ethRpcModule, "eth_call", new LegacyTransactionForRpc()));
 
@@ -433,7 +433,7 @@ public void Eth_call_is_working_with_nullable_last_argument(object?[] parameters
     {
         IEthRpcModule ethRpcModule = Substitute.For<IEthRpcModule>();
         HexBytes expected = ToHexBytes("0x");
-        ethRpcModule.eth_call(Arg.Any<TransactionForRpc>(), Arg.Any<BlockParameter?>()).ReturnsForAnyArgs(_ => ResultWrapper<HexBytes>.Success(expected));
+        ethRpcModule.eth_call(Arg.Any<SignableTransactionForRpc>(), Arg.Any<BlockParameter?>()).ReturnsForAnyArgs(_ => ResultWrapper<HexBytes>.Success(expected));
 
         HexBytes result = RpcTest.AssertSuccess<HexBytes>(TestRequest(ethRpcModule, "eth_call", parameters));
         Assert.That(result, Is.EqualTo(expected));
@@ -445,7 +445,7 @@ public void Raw_utf8_params_keep_explicit_nullable_trailing_defaults()
         IEthRpcModule ethRpcModule = Substitute.For<IEthRpcModule>();
         ethRpcModule
             .eth_call(
-                Arg.Any<TransactionForRpc>(),
+                Arg.Any<SignableTransactionForRpc>(),
                 Arg.Any<BlockParameter?>(),
                 Arg.Any<Dictionary<Address, AccountOverride>?>(),
                 Arg.Any<BlockOverride?>())