Implement EIP-7623: Increase calldata cost

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

@@ -110,11 +110,14 @@ public sealed class IntrinsicGasTxValidator : ITxValidator
     public static readonly IntrinsicGasTxValidator Instance = new();
     private IntrinsicGasTxValidator() { }
 
-    public ValidationResult IsWellFormed(Transaction transaction, IReleaseSpec releaseSpec) =>
+    public ValidationResult IsWellFormed(Transaction transaction, IReleaseSpec releaseSpec)
+    {
         // This is unnecessarily calculated twice - at validation and execution times.
-        transaction.GasLimit < IntrinsicGasCalculator.Calculate(transaction, releaseSpec)
+        var intrinsicGas = IntrinsicGasCalculator.Calculate(transaction, releaseSpec, out var floorGas);
+        return transaction.GasLimit < Math.Max(intrinsicGas, floorGas)
             ? TxErrorMessages.IntrinsicGasTooLow
             : ValidationResult.Success;
+    }
 }
 
 public sealed class ReleaseSpecTxValidator(Func<IReleaseSpec, bool> validate) : ITxValidator

src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs

@@ -326,6 +326,11 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec
         /// OP Granite
         bool IsOpGraniteEnabled { get; }
 
+        /// <summary>
+        ///  Increase call data cost
+        /// </summary>
+        bool IsEip7623Enabled { get; }
+
         /// <summary>
         /// Should transactions be validated against chainId.
         /// </summary>

src/Nethermind/Nethermind.Core/Specs/ReleaseSpecDecorator.cs

@@ -79,6 +79,7 @@ public class ReleaseSpecDecorator(IReleaseSpec spec) : IReleaseSpec
     public virtual bool IsEip6780Enabled => spec.IsEip6780Enabled;
     public bool IsEip7702Enabled => spec.IsEip7702Enabled;
     public virtual bool IsRip7212Enabled => spec.IsRip7212Enabled;
+    public bool IsEip7623Enabled => spec.IsEip7623Enabled;
     public virtual bool IsOpGraniteEnabled => spec.IsOpGraniteEnabled;
     public virtual ulong WithdrawalTimestamp => spec.WithdrawalTimestamp;
     public virtual ulong Eip4844TransitionTimestamp => spec.Eip4844TransitionTimestamp;

src/Nethermind/Nethermind.Evm.Test/Eip2028Tests.cs

@@ -23,16 +23,18 @@ private class AfterIstanbul : Eip2028Tests
             public void non_zero_transaction_data_cost_should_be_16()
             {
                 Transaction transaction = new Transaction { Data = new byte[] { 1 }, To = Address.Zero };
-                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec, out var floorGas);
+                floorGas.Should().Be(0);
                 cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataNonZeroEip2028);
             }
 
             [Test]
             public void zero_transaction_data_cost_should_be_4()
             {
                 Transaction transaction = new Transaction { Data = new byte[] { 0 }, To = Address.Zero };
-                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec, out var floorGas);
                 cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataZero);
+                floorGas.Should().Be(0);
             }
         }
 
@@ -45,15 +47,17 @@ private class BeforeIstanbul : Eip2028Tests
             public void non_zero_transaction_data_cost_should_be_68()
             {
                 Transaction transaction = new Transaction { Data = new byte[] { 1 }, To = Address.Zero };
-                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec, out var floorGas);
+                floorGas.Should().Be(0);
                 cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataNonZero);
             }
 
             [Test]
             public void zero_transaction_data_cost_should_be_4()
             {
                 Transaction transaction = new Transaction { Data = new byte[] { 0 }, To = Address.Zero };
-                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                long cost = IntrinsicGasCalculator.Calculate(transaction, Spec, out var floorGas);
+                floorGas.Should().Be(0);
                 cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataZero);
             }
         }

src/Nethermind/Nethermind.Evm.Test/Eip7623Tests.cs

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using FluentAssertions;
+using Nethermind.Core;
+using Nethermind.Specs;
+using NUnit.Framework;
+
+namespace Nethermind.Evm.Test;
+
+[TestFixture]
+public class Eip7623Tests : VirtualMachineTestsBase
+{
+    protected override long BlockNumber => MainnetSpecProvider.ParisBlockNumber;
+    protected override ulong Timestamp => MainnetSpecProvider.PragueBlockTimestamp;
+
+    [Test]
+    public void non_zero_data_transaction_floor_cost_should_be_40()
+    {
+        var transaction = new Transaction { Data = new byte[] { 1 }, To = Address.Zero };
+        long cost = IntrinsicGasCalculator.Calculate(transaction, Spec, out var floorGas);
+        floorGas.Should().Be(GasCostOf.Transaction + GasCostOf.TotalCostFloorPerTokenEip7623 * 4);
+        cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataNonZeroEip2028);
+    }
+
+    [Test]
+    public void zero_data_transaction_floor_cost_should_be_10()
+    {
+        var transaction = new Transaction { Data = new byte[] { 0 }, To = Address.Zero };
+        long cost = IntrinsicGasCalculator.Calculate(transaction, Spec, out var floorGas);
+        cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataZero);
+        floorGas.Should().Be(GasCostOf.Transaction + GasCostOf.TotalCostFloorPerTokenEip7623);
+    }
+}

src/Nethermind/Nethermind.Evm.Test/GasPriceExtractorTests.cs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System;
 using System.Linq;
 using FluentAssertions;
 using Nethermind.Core;
@@ -32,7 +33,8 @@ public void Intrinsic_gas_cost_assumption_is_correct()
             Rlp rlp = BuildHeader();
 
             Transaction tx = Build.A.Transaction.WithData(rlp.Bytes).TestObject;
-            long gasCost = IntrinsicGasCalculator.Calculate(tx, Spec);
+            long gasCost = IntrinsicGasCalculator.Calculate(tx, Spec, out var floorGas);
+            floorGas.Should().Be(0);
             gasCost.Should().BeLessThan(21000 + 9600);
         }
 
@@ -42,7 +44,8 @@ public void Keccak_gas_cost_assumption_is_correct()
             Rlp rlp = BuildHeader();
 
             Transaction tx = Build.A.Transaction.WithData(rlp.Bytes).TestObject;
-            long gasCost = IntrinsicGasCalculator.Calculate(tx, Spec);
+            long gasCost = IntrinsicGasCalculator.Calculate(tx, Spec, out var floorGas);
+            floorGas.Should().Be(0);
             gasCost.Should().BeLessThan(21000 + 9600);
 
             byte[] bytecode =

src/Nethermind/Nethermind.Evm.Test/IntrinsicGasCalculatorTests.cs

@@ -33,18 +33,19 @@ public class IntrinsicGasCalculatorTests
             yield return (new List<object> { Address.Zero, (UInt256)1, Address.Zero, (UInt256)1 }, 8600);
         }
 
-        public static IEnumerable<(byte[] Data, int OldCost, int NewCost)> DataTestCaseSource()
+        public static IEnumerable<(byte[] Data, int OldCost, int NewCost, int FloorCost)> DataTestCaseSource()
         {
-            yield return (new byte[] { 0 }, 4, 4);
-            yield return (new byte[] { 1 }, 68, 16);
-            yield return (new byte[] { 0, 0, 1 }, 76, 24);
-            yield return (new byte[] { 1, 1, 0 }, 140, 36);
-            yield return (new byte[] { 0, 0, 1, 1 }, 144, 40);
+            yield return ([0], 4, 4, 21010);
+            yield return ([1], 68, 16, 21040);
+            yield return ([0, 0, 1], 76, 24, 21060);
+            yield return ([1, 1, 0], 140, 36, 21090);
+            yield return ([0, 0, 1, 1], 144, 40, 21100);
         }
         [TestCaseSource(nameof(TestCaseSource))]
         public void Intrinsic_cost_is_calculated_properly((Transaction Tx, long Cost, string Description) testCase)
         {
-            IntrinsicGasCalculator.Calculate(testCase.Tx, Berlin.Instance).Should().Be(testCase.Cost);
+            IntrinsicGasCalculator.Calculate(testCase.Tx, Berlin.Instance, out var floorGas).Should().Be(testCase.Cost);
+            floorGas.Should().Be(0);
         }
 
         [TestCaseSource(nameof(AccessTestCaseSource))]
@@ -70,11 +71,12 @@ void Test(IReleaseSpec spec, bool supportsAccessLists)
             {
                 if (!supportsAccessLists)
                 {
-                    Assert.Throws<InvalidDataException>(() => IntrinsicGasCalculator.Calculate(tx, spec));
+                    Assert.Throws<InvalidDataException>(() => IntrinsicGasCalculator.Calculate(tx, spec, out var floorGas));
                 }
                 else
                 {
-                    IntrinsicGasCalculator.Calculate(tx, spec).Should().Be(21000 + testCase.Cost, spec.Name);
+                    IntrinsicGasCalculator.Calculate(tx, spec, out var floorGas).Should().Be(21000 + testCase.Cost, spec.Name);
+                    floorGas.Should().Be(0);
                 }
             }
 
@@ -91,31 +93,34 @@ void Test(IReleaseSpec spec, bool supportsAccessLists)
         }
 
         [TestCaseSource(nameof(DataTestCaseSource))]
-        public void Intrinsic_cost_of_data_is_calculated_properly((byte[] Data, int OldCost, int NewCost) testCase)
+        public void Intrinsic_cost_of_data_is_calculated_properly((byte[] Data, int OldCost, int NewCost, int FloorCost) testCase)
         {
             Transaction tx = Build.A.Transaction.SignedAndResolved().WithData(testCase.Data).TestObject;
 
-            void Test(IReleaseSpec spec, bool isAfterRepricing)
+            void Test(IReleaseSpec spec, bool isAfterRepricing, bool floorCostEnabled)
             {
-                IntrinsicGasCalculator.Calculate(tx, spec).Should()
+                IntrinsicGasCalculator.Calculate(tx, spec, out var floorGas).Should()
                     .Be(21000 + (isAfterRepricing ? testCase.NewCost : testCase.OldCost), spec.Name,
                         testCase.Data.ToHexString());
+                floorGas.Should().Be(floorCostEnabled ? testCase.FloorCost : 0);
             }
 
-            Test(Homestead.Instance, false);
-            Test(Frontier.Instance, false);
-            Test(SpuriousDragon.Instance, false);
-            Test(TangerineWhistle.Instance, false);
-            Test(Byzantium.Instance, false);
-            Test(Constantinople.Instance, false);
-            Test(ConstantinopleFix.Instance, false);
-            Test(Istanbul.Instance, true);
-            Test(MuirGlacier.Instance, true);
-            Test(Berlin.Instance, true);
-            Test(GrayGlacier.Instance, true);
-            Test(Shanghai.Instance, true);
-            Test(Cancun.Instance, true);
+            Test(Homestead.Instance, false, false);
+            Test(Frontier.Instance, false, false);
+            Test(SpuriousDragon.Instance, false, false);
+            Test(TangerineWhistle.Instance, false, false);
+            Test(Byzantium.Instance, false, false);
+            Test(Constantinople.Instance, false, false);
+            Test(ConstantinopleFix.Instance, false, false);
+            Test(Istanbul.Instance, true, false);
+            Test(MuirGlacier.Instance, true, false);
+            Test(Berlin.Instance, true, false);
+            Test(GrayGlacier.Instance, true, false);
+            Test(Shanghai.Instance, true, false);
+            Test(Cancun.Instance, true, false);
+            Test(Prague.Instance, true, true);
         }
+
         public static IEnumerable<(AuthorizationTuple[] contractCode, long expectedCost)> AuthorizationListTestCaseSource()
         {
             yield return (
@@ -179,7 +184,7 @@ public void Calculate_TxHasAuthorizationList_ReturnsExpectedCostOfTx((Authorizat
                 .WithAuthorizationCode(testCase.AuthorizationList)
                 .TestObject;
 
-            IntrinsicGasCalculator.Calculate(tx, Prague.Instance)
+            IntrinsicGasCalculator.Calculate(tx, Prague.Instance, out _)
                 .Should().Be(GasCostOf.Transaction + (testCase.ExpectedCost));
         }
 
@@ -198,7 +203,7 @@ public void Calculate_TxHasAuthorizationListBeforePrague_ThrowsInvalidDataExcept
                 )
                 .TestObject;
 
-            Assert.That(() => IntrinsicGasCalculator.Calculate(tx, Cancun.Instance), Throws.InstanceOf<InvalidDataException>());
+            Assert.That(() => IntrinsicGasCalculator.Calculate(tx, Cancun.Instance, out _), Throws.InstanceOf<InvalidDataException>());
         }
     }
 }

src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs

@@ -391,7 +391,7 @@ public void Can_estimate_with_refund()
         Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, _isEip155Enabled).WithCode(initByteCode).WithGasLimit(gasLimit).TestObject;
         Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
 
-        long intrinsic = IntrinsicGasCalculator.Calculate(tx, MuirGlacier.Instance);
+        long intrinsic = IntrinsicGasCalculator.Calculate(tx, MuirGlacier.Instance, out var floorGas);
 
         GethLikeTxMemoryTracer gethTracer = new(GethTraceOptions.Default);
         _transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
@@ -432,8 +432,7 @@ public void Can_estimate_with_destroy_refund_and_below_intrinsic_pre_berlin()
         Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
 
         IReleaseSpec releaseSpec = MuirGlacier.Instance;
-        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
-
+        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec, out var floorGas);
         _transactionProcessor.Execute(initTx, block.Header, NullTxTracer.Instance);
 
         EstimateGasTracer tracer = new();
@@ -498,7 +497,7 @@ public void Can_estimate_with_stipend()
         Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
 
         IReleaseSpec releaseSpec = MuirGlacier.Instance;
-        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
+        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec, out var floorGas);
 
         GethLikeTxMemoryTracer gethTracer = new(GethTraceOptions.Default);
         _transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
@@ -540,7 +539,7 @@ public void Can_estimate_with_stipend_and_refund()
         Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
 
         IReleaseSpec releaseSpec = MuirGlacier.Instance;
-        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
+        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec, out var floorGas);
 
         GethLikeTxMemoryTracer gethTracer = new(GethTraceOptions.Default);
         _transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
@@ -580,7 +579,7 @@ public void Can_estimate_with_single_call()
         Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
 
         IReleaseSpec releaseSpec = Berlin.Instance;
-        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
+        long intrinsic = IntrinsicGasCalculator.Calculate(tx, releaseSpec, out var floorGas);
 
         _transactionProcessor.Execute(initTx, block.Header, NullTxTracer.Instance);
 

src/Nethermind/Nethermind.Evm/GasCostOf.cs

@@ -63,5 +63,9 @@ public static class GasCostOf
         public const long TLoad = WarmStateRead; // eip-1153
         public const long TStore = WarmStateRead; // eip-1153
         public const long PerAuthBaseCost = 2500; // eip-7702
+        public const long TotalCostFloorPerTokenEip7623 = 10;
+
+        public const long TxDataNonZeroMultiplier = TxDataNonZero / TxDataZero;
+        public const long TxDataNonZeroMultiplierEip2028 = TxDataNonZeroEip2028 / TxDataZero;
     }
 }

src/Nethermind/Nethermind.Evm/IntrinsicGasCalculator.cs

@@ -7,27 +7,28 @@
 using System.IO;
 using Nethermind.Core;
 using Nethermind.Core.Eip2930;
+using Nethermind.Core.Extensions;
 using Nethermind.Core.Specs;
 using Nethermind.Int256;
-using Nethermind.Core.Extensions;
-
 namespace Nethermind.Evm;
 
 public static class IntrinsicGasCalculator
 {
-    public static long Calculate(Transaction transaction, IReleaseSpec releaseSpec) =>
+    public static long Calculate(Transaction transaction, IReleaseSpec releaseSpec, out long floorGas) =>
         GasCostOf.Transaction
-        + DataCost(transaction, releaseSpec)
+        + DataCost(transaction, releaseSpec, out floorGas)
         + CreateCost(transaction, releaseSpec)
         + AccessListCost(transaction, releaseSpec)
         + AuthorizationListCost(transaction, releaseSpec);
 
     private static long CreateCost(Transaction transaction, IReleaseSpec releaseSpec) =>
         transaction.IsContractCreation && releaseSpec.IsEip2Enabled ? GasCostOf.TxCreate : 0;
 
-    private static long DataCost(Transaction transaction, IReleaseSpec releaseSpec)
+    private static long DataCost(Transaction transaction, IReleaseSpec releaseSpec, out long floorGas)
     {
-        long txDataNonZeroGasCost = releaseSpec.IsEip2028Enabled ? GasCostOf.TxDataNonZeroEip2028 : GasCostOf.TxDataNonZero;
+        long txDataNonZeroMultiplier = releaseSpec.IsEip2028Enabled
+            ? GasCostOf.TxDataNonZeroMultiplierEip2028
+            : GasCostOf.TxDataNonZeroMultiplier;
         Span<byte> data = transaction.Data.GetValueOrDefault().Span;
 
         int totalZeros = data.CountZeros();
@@ -36,9 +37,13 @@ private static long DataCost(Transaction transaction, IReleaseSpec releaseSpec)
             ? EvmPooledMemory.Div32Ceiling((UInt256)data.Length) * GasCostOf.InitCodeWord
             : 0;
 
-        return baseDataCost +
-            totalZeros * GasCostOf.TxDataZero +
-            (data.Length - totalZeros) * txDataNonZeroGasCost;
+        var tokensInCallData = totalZeros + (data.Length - totalZeros) * txDataNonZeroMultiplier;
+
+        floorGas = releaseSpec.IsEip7623Enabled
+            ? GasCostOf.Transaction + tokensInCallData * GasCostOf.TotalCostFloorPerTokenEip7623
+            : 0;
+
+        return baseDataCost + tokensInCallData * GasCostOf.TxDataZero;
     }
 
     private static long AccessListCost(Transaction transaction, IReleaseSpec releaseSpec)

src/Nethermind/Nethermind.Evm/Tracing/GasEstimator.cs

@@ -50,7 +50,7 @@ public GasEstimator(ITransactionProcessor transactionProcessor, IReadOnlyStatePr
                 return gasTracer.CalculateAdditionalGasRequired(tx, releaseSpec);
             }
 
-            long intrinsicGas = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
+            long intrinsicGas = IntrinsicGasCalculator.Calculate(tx, releaseSpec, out var floorGas);
 
             // Setting boundaries for binary search - determine lowest and highest gas can be used during the estimation:
             long leftBound = (gasTracer.GasSpent != 0 && gasTracer.GasSpent >= intrinsicGas)
@@ -65,7 +65,8 @@ public GasEstimator(ITransactionProcessor transactionProcessor, IReadOnlyStatePr
                 return 0;
 
             // Execute binary search to find the optimal gas estimation.
-            return BinarySearchEstimate(leftBound, rightBound, tx, header, gasTracer, errorMargin, token);
+            return Math.Max(floorGas,
+                BinarySearchEstimate(leftBound, rightBound, tx, header, gasTracer, errorMargin, token));
         }
 
         private long BinarySearchEstimate(long leftBound, long rightBound, Transaction tx, BlockHeader header, EstimateGasTracer gasTracer, int errorMargin, CancellationToken token)

src/Nethermind/Nethermind.Evm/TransactionProcessing/SystemTransactionProcessor.cs

@@ -46,7 +46,7 @@ protected override TransactionResult Execute(Transaction tx, in BlockExecutionCo
 
     protected override IReleaseSpec GetSpec(Transaction tx, BlockHeader header) => new SystemTransactionReleaseSpec(base.GetSpec(tx, header), _isAura, header.IsGenesis);
 
-    protected override TransactionResult ValidateGas(Transaction tx, BlockHeader header, long intrinsicGas, bool validate) => TransactionResult.Ok;
+    protected override TransactionResult ValidateGas(Transaction tx, BlockHeader header, long minGasRequired, bool validate) => TransactionResult.Ok;
 
     protected override TransactionResult IncrementNonce(Transaction tx, BlockHeader header, IReleaseSpec spec, ITxTracer tracer, ExecutionOptions opts) => TransactionResult.Ok;