fix(eip8141): tighten blob-carrying frame tx validation and accounting

Address review follow-ups on the blob-support PR:
- require MaxFeePerBlobGas for a blob-carrying frame tx and narrow the
  versioned-hash validator to internal
- reserve the blob fee in block production via the instance blob predicate
- return InsufficientSenderBalance for insufficient max fee per blob gas,
  matching the regular path's error classification
- collapse the redundant blob-gas count guard and mark the still-unrouted
  EIP-1559 fee-collector leg on the frame path
- pin the max_cost blob-leg pricing (TXPARAM 0x06) and parameterize the
  blob-count validation tests

Author: Marchhill

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

@@ -850,31 +850,33 @@ static TransactionBuilder<Transaction> MakeTestObject(int blobCount = 1) => Buil
     // EIP-7594 (ethereum/EIPs#11985): a blob-carrying frame tx (EIP-8141) is bound by the same per-tx
     // blob-count limit (BLOB_COUNT_LIMIT = 6) and versioned-hash version byte (0x01) as a type-3 blob tx,
     // matching EELS validate_frame_transaction.
-    [Test]
-    public void IsWellFormed_FrameTxWithSingleValidBlob_ReturnTrue()
+    private static IEnumerable<int> FrameTxWithinBlobCountLimitCases()
     {
-        Transaction tx = BuildBlobFrameTx(blobCount: 1);
-        TxValidator txValidator = new(TestBlockchainIds.ChainId);
-
-        Assert.That(txValidator.IsWellFormed(tx, Bogota.Instance).AsBool(), Is.True);
+        yield return 1;
+        yield return (int)Bogota.Instance.MaxBlobsPerTx; // BLOB_COUNT_LIMIT
     }
 
-    [Test]
-    public void IsWellFormed_FrameTxAtBlobCountLimit_ReturnTrue()
+    [TestCaseSource(nameof(FrameTxWithinBlobCountLimitCases))]
+    public void IsWellFormed_FrameTxWithinBlobCountLimit_ReturnTrue(int blobCount)
     {
-        Transaction tx = BuildBlobFrameTx(blobCount: (int)Bogota.Instance.MaxBlobsPerTx);
+        Transaction tx = BuildBlobFrameTx(blobCount);
         TxValidator txValidator = new(TestBlockchainIds.ChainId);
 
         Assert.That(txValidator.IsWellFormed(tx, Bogota.Instance).AsBool(), Is.True);
     }
 
     [Test]
-    public void IsWellFormed_FrameTxExceedsBlobCountLimit_ReturnFalse()
+    public void IsWellFormed_FrameTxExceedsBlobCountLimit_ReturnBlobGasLimitExceeded()
     {
-        Transaction tx = BuildBlobFrameTx(blobCount: (int)Bogota.Instance.MaxBlobsPerTx + 1);
+        int blobCount = (int)Bogota.Instance.MaxBlobsPerTx + 1;
+        Transaction tx = BuildBlobFrameTx(blobCount);
         TxValidator txValidator = new(TestBlockchainIds.ChainId);
 
-        Assert.That(txValidator.IsWellFormed(tx, Bogota.Instance).AsBool(), Is.False);
+        ValidationResult result = txValidator.IsWellFormed(tx, Bogota.Instance);
+
+        Assert.That(result.AsBool(), Is.False);
+        Assert.That(result.Error, Is.EqualTo(TxErrorMessages.BlobTxGasLimitExceeded(
+            (ulong)blobCount * Eip4844Constants.GasPerBlob, Bogota.Instance.GasCosts.MaxBlobGasPerTx)));
     }
 
     [Test]

src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.BlockProductionTransactionPicker.cs

@@ -126,7 +126,7 @@ private static bool HasEnoughFunds(Transaction transaction, in UInt256 senderBal
                         return false;
                     }
 
-                    if (transaction.SupportsBlobs && (
+                    if (transaction.BlobVersionedHashes is { Length: > 0 } && (
                         !BlobGasCalculator.TryCalculateBlobBaseFee(block.Header, transaction, releaseSpec.BlobBaseFeeUpdateFraction, out UInt256 blobBaseFee) ||
                         senderBalance < (maxFee += blobBaseFee)))
                     {

src/Nethermind/Nethermind.Consensus/Validators/TxValidator.cs

@@ -202,6 +202,11 @@ public ValidationResult IsWellFormed(Transaction transaction, IReleaseSpec relea
         byte[]?[]? blobVersionedHashes = transaction.BlobVersionedHashes;
         if (blobVersionedHashes is { Length: > 0 })
         {
+            if (transaction.MaxFeePerBlobGas is null)
+            {
+                return TxErrorMessages.BlobTxMissingMaxFeePerBlobGas;
+            }
+
             ValidationResult blobGasLimitResult = BlobFieldsTxValidator.ValidateBlobGasLimits(blobVersionedHashes.Length, releaseSpec);
             return !blobGasLimitResult ? blobGasLimitResult : BlobFieldsTxValidator.ValidateBlobVersionedHashes(blobVersionedHashes);
         }
@@ -282,7 +287,7 @@ private static ValidationResult ValidateBlobFields(Transaction transaction, IRel
     /// Validates that every blob versioned hash is present, 32 bytes, and carries the KZG version byte
     /// (EIP-4844 <c>VERSIONED_HASH_VERSION_KZG = 0x01</c>).
     /// </summary>
-    public static ValidationResult ValidateBlobVersionedHashes(byte[]?[] blobVersionedHashes)
+    internal static ValidationResult ValidateBlobVersionedHashes(byte[]?[] blobVersionedHashes)
     {
         foreach (byte[]? versionedHash in blobVersionedHashes)
         {

src/Nethermind/Nethermind.Evm.Test/FrameTxProcessorTests.cs

@@ -173,12 +173,37 @@ public void Execute_BlobFrameTx_MaxFeePerBlobGasBelowBlobBaseFee_Invalid()
         using (Assert.EnterMultipleScope())
         {
             Assert.That(result.TransactionExecuted, Is.False);
-            Assert.That(result.Error, Is.EqualTo(TransactionResult.ErrorType.InsufficientMaxFeePerGasForSenderBalance));
+            Assert.That(result.Error, Is.EqualTo(TransactionResult.ErrorType.InsufficientSenderBalance));
             Assert.That(_stateProvider.GetBalance(Beneficiary), Is.EqualTo(UInt256.Zero), "beneficiary not credited");
             Assert.That(_stateProvider.GetNonce(Sender), Is.EqualTo(0UL), "nonce not consumed");
         }
     }
 
+    [Test]
+    public void Execute_TxParamMaxCost_BlobCarryingFrameTx_ReservesBlobLegAtBlobBaseFeeNotMaxFee()
+    {
+        // TXPARAM 0x06 (max_cost) is consensus-visible mid-transaction and also gates payer solvency.
+        // For a blob-carrying frame tx the blob leg of max_cost is reserved at the actual blob_base_fee,
+        // not max_fee_per_blob_gas, so it must equal the blobless gas leg plus blob_gas × blob_base_fee.
+        DeploySmartSender(ApproveCode(TxFrame.ApproveExecutionAndPayment));
+        DeployContract(Observer, Prepare.EvmCode
+            .PushData(0x06).Op(Instruction.TXPARAM).PushData(0).Op(Instruction.SSTORE)
+            .Op(Instruction.STOP).Done);
+        Transaction tx = FrameTx(nonce: 0, SelfVerifyFrame(), Frame(TxFrame.ModeDefault, target: Observer));
+        tx.BlobVersionedHashes = [new byte[32]];
+        tx.MaxFeePerBlobGas = 1000;
+
+        TransactionResult result = ProcessWithBlobHeader(tx, excessBlobGas: 0);
+
+        Assert.That(result.TransactionExecuted, Is.True);
+        // Gas leg is the same 415_950 the blobless Execute_TxParam_MaxCost case observes (max fee 1).
+        UInt256 expectedMaxCost = 415_950 + ExpectedBlobFee(excessBlobGas: 0, blobCount: 1);
+        AssertStorage(Observer, 0, expectedMaxCost);
+        UInt256 maxFeePricedMaxCost = 415_950 + tx.MaxFeePerBlobGas.Value * BlobGasCalculator.CalculateBlobGas(1);
+        Assert.That(expectedMaxCost, Is.LessThan(maxFeePricedMaxCost),
+            "max_cost priced below the max_fee_per_blob_gas reservation, i.e. at the blob base fee");
+    }
+
     [TestCase(7ul, 2ul, 10ul, 2ul, TestName = "Execute_NonZeroBaseFee_PremiumIsTheRequestedPriorityFee")]
     [TestCase(7ul, 5ul, 8ul, 1ul, TestName = "Execute_NonZeroBaseFee_PremiumCappedByMaxFeeMinusBaseFee")]
     public void Execute_NonZeroBaseFee_PaysBeneficiaryThePremiumAndBurnsTheBaseFee(

src/Nethermind/Nethermind.Evm/BlobGasCalculator.cs

@@ -46,12 +46,9 @@ public static ulong CalculateBlobGas(Transaction[] transactions)
         ulong blobCount = 0UL;
         foreach (Transaction tx in transactions)
         {
-            // EIP-8141: include blob-carrying frame transactions (type 6), not just type-3, in the
-            // block's blob gas — gate on blob hashes instead of the type-level SupportsBlobs.
-            if (tx.BlobVersionedHashes is { Length: > 0 })
-            {
-                blobCount += (ulong)tx.GetBlobCount();
-            }
+            // EIP-8141: blob-carrying frame transactions (type 6) count towards the block's blob gas too,
+            // so the count comes from the blob hashes rather than the type-level SupportsBlobs.
+            blobCount += (ulong)tx.GetBlobCount();
         }
 
         return CalculateBlobGas(blobCount);

src/Nethermind/Nethermind.Evm/TransactionProcessing/TransactionProcessorBase.FrameTx.cs

@@ -104,7 +104,7 @@ private TransactionResult ExecuteFrameTx(Transaction tx, ITxTracer tracer, Execu
             if (tx.MaxFeePerBlobGas.GetValueOrDefault() < feePerBlobGas)
             {
                 TraceLogInvalidTx(tx, "INSUFFICIENT_MAX_FEE_PER_BLOB_GAS");
-                return TransactionResult.ErrorType.InsufficientMaxFeePerGasForSenderBalance.WithDetail(
+                return TransactionResult.ErrorType.InsufficientSenderBalance.WithDetail(
                     BlockErrorMessages.InsufficientMaxFeePerBlobGas(tx.SenderAddress, tx.MaxFeePerBlobGas, feePerBlobGas));
             }
         }
@@ -338,6 +338,8 @@ private TransactionResult ExecuteFrameTx(Transaction tx, ITxTracer tracer, Execu
 
         // EIP-4844 fee-collector chains (e.g. Gnosis) collect the burned blob fee instead of losing
         // it, consistent with the regular path's PayFees; elsewhere the fee is simply burned.
+        // The EIP-1559 base-fee share of a frame tx is not routed to the collector (only burned); no
+        // chain enables both frame txs and the fee collector, so this stays deferred.
         if (!blobFee.IsZero && spec.IsEip4844FeeCollectorEnabled && spec.FeeCollector is not null)
         {
             WorldState.AddToBalanceAndCreateIfNotExists(spec.FeeCollector, blobFee, spec);