v2 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 staticGas = IntrinsicGasCalculator.Calculate(transaction, releaseSpec);
+        return transaction.GasLimit < Math.Max(staticGas.IntrinsicGas, staticGas.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);
-                cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataNonZeroEip2028);
+                var cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                cost.FloorGas.Should().Be(0);
+                cost.IntrinsicGas.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);
-                cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataZero);
+                var cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                cost.IntrinsicGas.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataZero);
+                cost.FloorGas.Should().Be(0);
             }
         }
 
@@ -45,16 +47,18 @@ 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);
-                cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataNonZero);
+                var cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                cost.FloorGas.Should().Be(0);
+                cost.IntrinsicGas.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);
-                cost.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataZero);
+                var cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+                cost.FloorGas.Should().Be(0);
+                cost.IntrinsicGas.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 };
+        var cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+        cost.FloorGas.Should().Be(GasCostOf.Transaction + GasCostOf.TotalCostFloorPerTokenEip7623 * 4);
+        cost.IntrinsicGas.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 };
+        var cost = IntrinsicGasCalculator.Calculate(transaction, Spec);
+        cost.IntrinsicGas.Should().Be(GasCostOf.Transaction + GasCostOf.TxDataZero);
+        cost.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,8 +33,9 @@ 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);
-            gasCost.Should().BeLessThan(21000 + 9600);
+            var gasCost = IntrinsicGasCalculator.Calculate(tx, Spec);
+            gasCost.FloorGas.Should().Be(0);
+            gasCost.IntrinsicGas.Should().BeLessThan(21000 + 9600);
         }
 
         [Test]
@@ -42,8 +44,9 @@ 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);
-            gasCost.Should().BeLessThan(21000 + 9600);
+            var gasCost = IntrinsicGasCalculator.Calculate(tx, Spec);
+            gasCost.FloorGas.Should().Be(0);
+            gasCost.IntrinsicGas.Should().BeLessThan(21000 + 9600);
 
             byte[] bytecode =
                 Prepare.EvmCode

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

@@ -33,18 +33,20 @@ 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);
+            var gas = IntrinsicGasCalculator.Calculate(testCase.Tx, Berlin.Instance);
+            gas.IntrinsicGas.Should().Be(testCase.Cost);
+            gas.FloorGas.Should().Be(0);
         }
 
         [TestCaseSource(nameof(AccessTestCaseSource))]
@@ -74,7 +76,9 @@ void Test(IReleaseSpec spec, bool supportsAccessLists)
                 }
                 else
                 {
-                    IntrinsicGasCalculator.Calculate(tx, spec).Should().Be(21000 + testCase.Cost, spec.Name);
+                    var gas = IntrinsicGasCalculator.Calculate(tx, spec);
+                    gas.IntrinsicGas.Should().Be(21000 + testCase.Cost, spec.Name);
+                    gas.FloorGas.Should().Be(0);
                 }
             }
 
@@ -91,31 +95,35 @@ 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()
+                var gas = IntrinsicGasCalculator.Calculate(tx, spec);
+                gas.IntrinsicGas.Should()
                     .Be(21000 + (isAfterRepricing ? testCase.NewCost : testCase.OldCost), spec.Name,
                         testCase.Data.ToHexString());
+                gas.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,8 +187,8 @@ public void Calculate_TxHasAuthorizationList_ReturnsExpectedCostOfTx((Authorizat
                 .WithAuthorizationCode(testCase.AuthorizationList)
                 .TestObject;
 
-            IntrinsicGasCalculator.Calculate(tx, Prague.Instance)
-                .Should().Be(GasCostOf.Transaction + (testCase.ExpectedCost));
+            var gas = IntrinsicGasCalculator.Calculate(tx, Prague.Instance);
+            gas.IntrinsicGas.Should().Be(GasCostOf.Transaction + (testCase.ExpectedCost));
         }
 
         [Test]

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);
+        var staticGas = IntrinsicGasCalculator.Calculate(tx, MuirGlacier.Instance);
 
         GethLikeTxMemoryTracer gethTracer = new(GethTraceOptions.Default);
         _transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
@@ -404,7 +404,7 @@ public void Can_estimate_with_refund()
         GasEstimator estimator = new(_transactionProcessor, _stateProvider, _specProvider, blocksConfig);
 
         long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
-        actualIntrinsic.Should().Be(intrinsic);
+        actualIntrinsic.Should().Be(staticGas.IntrinsicGas);
         IReleaseSpec releaseSpec = Berlin.Instance;
         tracer.CalculateAdditionalGasRequired(tx, releaseSpec).Should().Be(RefundOf.SSetReversedEip2200 + GasCostOf.CallStipend - GasCostOf.SStoreNetMeteredEip2200 + 1);
         tracer.GasSpent.Should().Be(54764L);
@@ -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);
-
+        var staticGas = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
         _transactionProcessor.Execute(initTx, block.Header, NullTxTracer.Instance);
 
         EstimateGasTracer tracer = new();
@@ -446,7 +445,7 @@ public void Can_estimate_with_destroy_refund_and_below_intrinsic_pre_berlin()
         GasEstimator estimator = new(_transactionProcessor, _stateProvider, _specProvider, blocksConfig);
 
         long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
-        actualIntrinsic.Should().Be(intrinsic);
+        actualIntrinsic.Should().Be(staticGas.IntrinsicGas);
         tracer.CalculateAdditionalGasRequired(tx, releaseSpec).Should().Be(24080);
         tracer.GasSpent.Should().Be(35228L);
         long estimate = estimator.Estimate(tx, block.Header, tracer, 0);
@@ -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);
+        var staticGas = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
 
         GethLikeTxMemoryTracer gethTracer = new(GethTraceOptions.Default);
         _transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
@@ -511,7 +510,7 @@ public void Can_estimate_with_stipend()
         GasEstimator estimator = new(_transactionProcessor, _stateProvider, _specProvider, blocksConfig);
 
         long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
-        actualIntrinsic.Should().Be(intrinsic);
+        actualIntrinsic.Should().Be(staticGas.IntrinsicGas);
         tracer.CalculateAdditionalGasRequired(tx, releaseSpec).Should().Be(2300);
         tracer.GasSpent.Should().Be(85669L);
         long estimate = estimator.Estimate(tx, block.Header, tracer, 0);
@@ -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);
+        var staticGas = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
 
         GethLikeTxMemoryTracer gethTracer = new(GethTraceOptions.Default);
         _transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
@@ -553,7 +552,7 @@ public void Can_estimate_with_stipend_and_refund()
         GasEstimator estimator = new(_transactionProcessor, _stateProvider, _specProvider, blocksConfig);
 
         long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
-        actualIntrinsic.Should().Be(intrinsic);
+        actualIntrinsic.Should().Be(staticGas.IntrinsicGas);
         tracer.CalculateAdditionalGasRequired(tx, releaseSpec).Should().Be(RefundOf.SSetReversedEip2200 + GasCostOf.CallStipend);
         tracer.GasSpent.Should().Be(87429L);
         long estimate = estimator.Estimate(tx, block.Header, tracer, 0);
@@ -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);
+        var staticGas = IntrinsicGasCalculator.Calculate(tx, releaseSpec);
 
         _transactionProcessor.Execute(initTx, block.Header, NullTxTracer.Instance);
 
@@ -591,7 +590,7 @@ public void Can_estimate_with_single_call()
         GasEstimator estimator = new(_transactionProcessor, _stateProvider, _specProvider, blocksConfig);
 
         long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
-        actualIntrinsic.Should().Be(intrinsic);
+        actualIntrinsic.Should().Be(staticGas.IntrinsicGas);
         tracer.CalculateAdditionalGasRequired(tx, releaseSpec).Should().Be(1);
         tracer.GasSpent.Should().Be(54224L);
         long estimate = estimator.Estimate(tx, block.Header, tracer, 0);

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;
     }
 }