eip 7840 implementation

src/Nethermind/Chains/chiado.json

@@ -78,14 +78,18 @@
     "eip1559ElasticityMultiplier": "0x2",
     "feeCollector": "0x1559000000000000000000000000000000000000",
     "eip1559FeeCollectorTransition": 0,
-    "eip4844BlobGasPriceUpdateFraction": "0x10fafa",
-    "eip4844MaxBlobGasPerBlock": "0x40000",
     "eip4844MinBlobGasPrice": "0x3b9aca00",
-    "eip4844TargetBlobGasPerBlock": "0x20000",
     "registrar": "0x6000000000000000000000000000000000000000",
     "transactionPermissionContract": "0x4000000000000000000000000000000000000001",
     "transactionPermissionContractTransition": "0x0",
-    "terminalTotalDifficulty": "231707791542740786049188744689299064356246512"
+    "terminalTotalDifficulty": "231707791542740786049188744689299064356246512",
+    "blobSchedule": {
+      "cancun": {
+        "target": 1,
+        "max": 2,
+        "baseFeeUpdateFraction": "0x10fafa"
+      }
+    }
   },
   "genesis": {
     "seal": {

src/Nethermind/Chains/foundation.json

@@ -191,7 +191,19 @@
     "eip4844TransitionTimestamp": "0x65F1B057",
     "eip5656TransitionTimestamp": "0x65F1B057",
     "eip6780TransitionTimestamp": "0x65F1B057",
-    "terminalTotalDifficulty": "C70D808A128D7380000"
+    "terminalTotalDifficulty": "C70D808A128D7380000",
+    "blobSchedule": {
+      "cancun": {
+        "target": 3,
+        "max": 6,
+        "baseFeeUpdateFraction": 3338477
+      },
+      "prague": {
+        "target": 6,
+        "max": 9,
+        "baseFeeUpdateFraction":  5007716
+      }
+    }
   },
   "genesis": {
     "seal": {

src/Nethermind/Chains/gnosis.json

@@ -85,14 +85,18 @@
     "eip1559BaseFeeInitialValue": "0x3b9aca00",
     "feeCollector": "0x6BBe78ee9e474842Dbd4AB4987b3CeFE88426A92",
     "eip1559FeeCollectorTransition": 19040000,
-    "eip4844BlobGasPriceUpdateFraction": "0x10fafa",
-    "eip4844MaxBlobGasPerBlock": "0x40000",
     "eip4844MinBlobGasPrice": "0x3b9aca00",
-    "eip4844TargetBlobGasPerBlock": "0x20000",
     "registrar": "0x6B53721D4f2Fb9514B85f5C49b197D857e36Cf03",
     "transactionPermissionContract": "0x7Dd7032AA75A37ea0b150f57F899119C7379A78b",
     "transactionPermissionContractTransition": 9186425,
-    "terminalTotalDifficulty": "8626000000000000000000058750000000000000000000"
+    "terminalTotalDifficulty": "8626000000000000000000058750000000000000000000",
+    "blobSchedule": {
+      "cancun": {
+        "target": 1,
+        "max": 2,
+        "baseFeeUpdateFraction": "0x10fafa"
+      }
+    }
   },
   "genesis": {
     "seal": {

src/Nethermind/Chains/holesky.json

@@ -52,7 +52,17 @@
     "maximumExtraDataSize": "0xffff",
     "minGasLimit": "0x1388",
     "registrar": "0x0000000000000000000000000000000000000000",
-    "MergeForkIdTransition": "0x0"
+    "MergeForkIdTransition": "0x0",
+    "blobSchedule": {
+      "cancun": {
+        "target": 3,
+        "max": 6
+      },
+      "prague": {
+        "target": 6,
+        "max": 9
+      }
+    }
   },
   "genesis": {
     "seal": {

src/Nethermind/Chains/sepolia.json

@@ -66,7 +66,17 @@
     "eip4788TransitionTimestamp": "0x65B97D60",
     "eip4844TransitionTimestamp": "0x65B97D60",
     "eip5656TransitionTimestamp": "0x65B97D60",
-    "eip6780TransitionTimestamp": "0x65B97D60"
+    "eip6780TransitionTimestamp": "0x65B97D60",
+    "blobSchedule": {
+      "cancun": {
+        "target": 3,
+        "max": 6
+      },
+      "prague": {
+        "target": 6,
+        "max": 9
+      }
+    }
   },
   "genesis": {
     "seal": {

src/Nethermind/Nethermind.Blockchain.Test/TransactionSelectorTests.cs

@@ -160,7 +160,7 @@ public static IEnumerable EnoughShardBlobTransactionsSelectedTestCases
                     tx.MaxFeePerBlobGas = 1;
                 });
                 maxTransactionsSelected.Transactions[1].BlobVersionedHashes =
-                    new byte[Eip4844Constants.MaxBlobGasPerTransaction / Eip4844Constants.GasPerBlob - 1][];
+                    new byte[maxTransactionsSelected.ReleaseSpec.MaxBlobCount - 1][];
                 maxTransactionsSelected.ExpectedSelectedTransactions.AddRange(
                     maxTransactionsSelected.Transactions.OrderBy(static t => t.Nonce).Take(2));
                 yield return new TestCaseData(maxTransactionsSelected).SetName("Enough transactions selected");
@@ -174,7 +174,7 @@ public static IEnumerable EnoughShardBlobTransactionsSelectedTestCases
                     enoughTransactionsSelected.Transactions.OrderBy(static t => t.Nonce).ToArray();
                 expectedSelectedTransactions[0].Type = TxType.Blob;
                 expectedSelectedTransactions[0].BlobVersionedHashes =
-                    new byte[Eip4844Constants.MaxBlobGasPerTransaction / Eip4844Constants.GasPerBlob][];
+                    new byte[enoughTransactionsSelected.ReleaseSpec.MaxBlobCount][];
                 expectedSelectedTransactions[0].MaxFeePerBlobGas = 1;
                 expectedSelectedTransactions[1].Type = TxType.Blob;
                 expectedSelectedTransactions[1].BlobVersionedHashes = new byte[1][];

src/Nethermind/Nethermind.Blockchain.Test/TxPoolSourceTests.cs

@@ -36,17 +36,14 @@ public void GetTransactions_should_respect_customizable_blob_gas_limit(int[] blo
         ITxFilterPipeline txFilterPipeline = Substitute.For<ITxFilterPipeline>();
         txFilterPipeline.Execute(Arg.Any<Transaction>(), Arg.Any<BlockHeader>()).Returns(true);
 
-        TestEip4844Config eip4844Config = new(customMaxBlobGasPerBlock);
-
-        TxPoolTxSource transactionSelector = new(txPool, specProvider, transactionComparerProvider, LimboLogs.Instance, txFilterPipeline, eip4844Config);
+        TxPoolTxSource transactionSelector = new(txPool, specProvider, transactionComparerProvider, LimboLogs.Instance, txFilterPipeline);
 
         IEnumerable<Transaction> txs = transactionSelector.GetTransactions(new BlockHeader { }, long.MaxValue);
         int blobsCount = txs.Sum(tx => tx.BlobVersionedHashes?.Length ?? 0);
 
         Assert.Multiple(() =>
         {
-            Assert.That((ulong)blobsCount * eip4844Config.GasPerBlob, Is.LessThanOrEqualTo(eip4844Config.MaxBlobGasPerBlock));
-            Assert.That(blobsCount, Is.LessThanOrEqualTo(eip4844Config.GetMaxBlobsPerBlock()));
+            Assert.That(blobsCount, Is.LessThanOrEqualTo(Cancun.Instance.MaxBlobCount));
         });
     }
 

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

@@ -33,9 +33,9 @@ public static bool Blob_gas_fields_should_be_set(IReleaseSpec spec, ulong? blobG
     }
 
     [TestCaseSource(nameof(BlobsPerBlockCountTestCases))]
-    public bool Blobs_per_block_count_is_valid(ulong blobGasUsed)
+    public bool Blobs_per_block_count_is_valid(IReleaseSpec spec, ulong blobGasUsed)
     {
-        ISpecProvider specProvider = new CustomSpecProvider(((ForkActivation)0, Cancun.Instance));
+        ISpecProvider specProvider = new CustomSpecProvider(((ForkActivation)0, spec));
         BlockValidator blockValidator = new(Always.Valid, Always.Valid, Always.Valid, specProvider, TestLogManager.Instance);
         return blockValidator.ValidateSuggestedBlock(
             Build.A.Block
@@ -53,13 +53,19 @@ public bool Blobs_per_block_count_is_valid(ulong blobGasUsed)
 
     private static IEnumerable<TestCaseData> BlobsPerBlockCountTestCases()
     {
-        yield return new TestCaseData(0UL) { ExpectedResult = true };
+        yield return new TestCaseData(Cancun.Instance, 0UL) { ExpectedResult = true };
+
+        yield return new TestCaseData(Cancun.Instance, (Cancun.Instance.MaxBlobCount - 1) * Eip4844Constants.GasPerBlob) { ExpectedResult = true };
+
+        yield return new TestCaseData(Cancun.Instance, Cancun.Instance.MaxBlobCount * Eip4844Constants.GasPerBlob) { ExpectedResult = true };
+
+        yield return new TestCaseData(Cancun.Instance, (Cancun.Instance.MaxBlobCount + 1) * Eip4844Constants.GasPerBlob) { ExpectedResult = false };
 
-        yield return new TestCaseData(Eip4844Constants.MaxBlobGasPerBlock - Eip4844Constants.GasPerBlob) { ExpectedResult = true };
+        yield return new TestCaseData(Prague.Instance, (Prague.Instance.MaxBlobCount - 1) * Eip4844Constants.GasPerBlob) { ExpectedResult = true };
 
-        yield return new TestCaseData(Eip4844Constants.MaxBlobGasPerBlock) { ExpectedResult = true };
+        yield return new TestCaseData(Prague.Instance, (Prague.Instance.MaxBlobCount) * Eip4844Constants.GasPerBlob) { ExpectedResult = true };
 
-        yield return new TestCaseData(Eip4844Constants.MaxBlobGasPerBlock + Eip4844Constants.GasPerBlob) { ExpectedResult = false };
+        yield return new TestCaseData(Prague.Instance, (Prague.Instance.MaxBlobCount + 1) * Eip4844Constants.GasPerBlob) { ExpectedResult = false };
     }
 
     private static IEnumerable<TestCaseData> BlobGasFieldsPerForkTestCases()

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

@@ -388,10 +388,10 @@ public bool BlobVersionedHash_should_be_correct(byte[] hash)
     }
 
     [TestCaseSource(nameof(ShardBlobTxIncorrectTransactions))]
-    public bool ShardBlobTransaction_fields_should_be_verified(Transaction tx)
+    public bool ShardBlobTransaction_fields_should_be_verified(IReleaseSpec spec, Transaction tx)
     {
         TxValidator txValidator = new(TestBlockchainIds.ChainId);
-        return txValidator.IsWellFormed(tx, Cancun.Instance);
+        return txValidator.IsWellFormed(tx, spec);
     }
 
     [Test]
@@ -695,91 +695,110 @@ static TransactionBuilder<Transaction> MakeTestObject(int blobCount = 1) => Buil
                 .WithMaxFeePerBlobGas(1)
                 .WithShardBlobTxTypeAndFields(blobCount);
 
-            yield return new TestCaseData(MakeTestObject().SignedAndResolved().TestObject)
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject().SignedAndResolved().TestObject)
             {
                 TestName = "A correct shard blob tx",
                 ExpectedResult = true
             };
 
-            yield return new TestCaseData(MakeTestObject(0)
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject(0)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "BlobVersionedHashes are empty",
                 ExpectedResult = false
             };
-            yield return new TestCaseData(MakeTestObject(Eip4844Constants.MinBlobsPerTransaction - 1)
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject(Eip4844Constants.MinBlobsPerTransaction - 1)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Not enough BlobVersionedHashes",
                 ExpectedResult = false
             };
-            yield return new TestCaseData(MakeTestObject(Eip4844Constants.MinBlobsPerTransaction)
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject(Eip4844Constants.MinBlobsPerTransaction)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Bare minimum BlobVersionedHashes",
                 ExpectedResult = true
             };
-            yield return new TestCaseData(MakeTestObject(Eip4844Constants.MinBlobsPerTransaction + 1)
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject(Eip4844Constants.MinBlobsPerTransaction + 1)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "More than minimum BlobVersionedHashes",
                 ExpectedResult = true
             };
-            yield return new TestCaseData(MakeTestObject((int)(Eip4844Constants.MaxBlobGasPerBlock / Eip4844Constants.GasPerBlob - 1))
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject((int)Cancun.Instance.MaxBlobCount - 1)
+                .SignedAndResolved().TestObject)
+            {
+                TestName = "Less than maximum BlobVersionedHashes",
+                ExpectedResult = true
+            };
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject((int)Cancun.Instance.MaxBlobCount)
+                .SignedAndResolved().TestObject)
+            {
+                TestName = "Maximum BlobVersionedHashes",
+                ExpectedResult = true
+            };
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject((int)Cancun.Instance.MaxBlobCount + 1)
+                .SignedAndResolved().TestObject)
+            {
+                TestName = "Too many BlobVersionedHashes",
+                ExpectedResult = false
+            };
+
+            yield return new TestCaseData(Prague.Instance, MakeTestObject((int)Prague.Instance.MaxBlobCount - 1)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Less than maximum BlobVersionedHashes",
                 ExpectedResult = true
             };
-            yield return new TestCaseData(MakeTestObject((int)(Eip4844Constants.MaxBlobGasPerBlock / Eip4844Constants.GasPerBlob))
+            yield return new TestCaseData(Prague.Instance, MakeTestObject((int)Prague.Instance.MaxBlobCount)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Maximum BlobVersionedHashes",
                 ExpectedResult = true
             };
-            yield return new TestCaseData(MakeTestObject((int)(Eip4844Constants.MaxBlobGasPerBlock / Eip4844Constants.GasPerBlob + 1))
+            yield return new TestCaseData(Prague.Instance, MakeTestObject((int)Prague.Instance.MaxBlobCount + 1)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Too many BlobVersionedHashes",
                 ExpectedResult = false
             };
 
-            yield return new TestCaseData(MakeTestObject()
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject()
                 .WithBlobVersionedHashes(new byte[][] { MakeArray(31, KzgPolynomialCommitments.KzgBlobHashVersionV1) })
                 .SignedAndResolved().TestObject)
             {
                 TestName = "BlobVersionedHashes are of a wrong length",
                 ExpectedResult = false
             };
-            yield return new TestCaseData(MakeTestObject()
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject()
                 .With(static tx => ((ShardBlobNetworkWrapper)tx.NetworkWrapper!).Blobs = [])
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Blobs count does not match hashes count",
                 ExpectedResult = false
             };
-            yield return new TestCaseData(MakeTestObject()
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject()
                 .With(static tx => ((ShardBlobNetworkWrapper)tx.NetworkWrapper!).Commitments = [])
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Commitments count does not match hashes count",
                 ExpectedResult = false
             };
-            yield return new TestCaseData(MakeTestObject()
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject()
                 .With(static tx => ((ShardBlobNetworkWrapper)tx.NetworkWrapper!).Proofs = [])
                 .SignedAndResolved().TestObject)
             {
                 TestName = "Proofs count does not match hashes count",
                 ExpectedResult = false
             };
-            yield return new TestCaseData(MakeTestObject()
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject()
                 .With(static tx => ((ShardBlobNetworkWrapper)tx.NetworkWrapper!).Commitments[0][1] ^= 0xFF)
                 .SignedAndResolved().TestObject)
             {
                 TestName = "A commitment does not math hash",
                 ExpectedResult = false
             };
-            yield return new TestCaseData(MakeTestObject()
+            yield return new TestCaseData(Cancun.Instance, MakeTestObject()
                 .With(static tx => ((ShardBlobNetworkWrapper)tx.NetworkWrapper!).Proofs[0][1] ^= 0xFF)
                 .SignedAndResolved().TestObject)
             {

src/Nethermind/Nethermind.Blockchain/ChainHeadInfoProvider.cs

@@ -74,11 +74,12 @@ public bool IsSyncing
 
         private void OnHeadChanged(object? sender, BlockReplacementEventArgs e)
         {
+            IReleaseSpec spec = SpecProvider.GetSpec(e.Block.Header);
             HeadNumber = e.Block.Number;
             BlockGasLimit = e.Block!.GasLimit;
             CurrentBaseFee = e.Block.Header.BaseFeePerGas;
             CurrentFeePerBlobGas =
-                BlobGasCalculator.TryCalculateFeePerBlobGas(e.Block.Header, out UInt256 currentFeePerBlobGas)
+                BlobGasCalculator.TryCalculateFeePerBlobGas(e.Block.Header, spec.BlobBaseFeeUpdateFraction, out UInt256 currentFeePerBlobGas)
                     ? currentFeePerBlobGas
                     : UInt256.Zero;
             HeadChanged?.Invoke(sender, e);

src/Nethermind/Nethermind.Consensus/Messages/BlockErrorMessages.cs

@@ -96,7 +96,7 @@ public static string HeaderGasUsedMismatch(long expected, long actual) =>
         $"HeaderGasUsedMismatch: Gas used in header does not match calculated. Expected {expected}, got {actual}";
 
     public static readonly string BlobGasUsedAboveBlockLimit =
-        $"BlockBlobGasExceeded: A block cannot have more than {Eip4844Constants.MaxBlobGasPerBlock} blob gas.";
+        "BlockBlobGasExceeded: A block cannot have more than {0} blob gas.";
 
     public static string IncorrectExcessBlobGas(ulong? expected, ulong? actual) =>
         $"HeaderExcessBlobGasMismatch: Excess blob gas in header does not match calculated. Expected {expected}, got {actual}";

src/Nethermind/Nethermind.Consensus/Messages/TxErrorMessages.cs

@@ -44,7 +44,7 @@ public static string InvalidTxChainId(ulong expected, ulong? actual) =>
         "blob transaction missing blob hashes";
 
     public static readonly string BlobTxGasLimitExceeded =
-        $"BlobTxGasLimitExceeded: Transaction exceeded {Eip4844Constants.MaxBlobGasPerTransaction}.";
+        "BlobTxGasLimitExceeded: Transaction exceeded {0}.";
 
     public const string BlobTxMissingBlobs =
         "BlobTxMissingBlobs: Blob transaction must have blobs.";

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

@@ -109,7 +109,7 @@ private static bool HasEnoughFounds(Transaction transaction, in UInt256 senderBa
                     }
 
                     if (transaction.SupportsBlobs && (
-                        !BlobGasCalculator.TryCalculateBlobBaseFee(block.Header, transaction, out UInt256 blobBaseFee) ||
+                        !BlobGasCalculator.TryCalculateBlobBaseFee(block.Header, transaction, releaseSpec.BlobBaseFeeUpdateFraction, out UInt256 blobBaseFee) ||
                         senderBalance < (maxFee += blobBaseFee)))
                     {
                         e.Set(TxAction.Skip, $"{maxFee} is higher than sender balance ({senderBalance}), MaxFeePerGas: ({transaction.MaxFeePerGas}), GasLimit {transaction.GasLimit}, BlobBaseFee: {blobBaseFee}");