EIP 7742 implementation

src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs

@@ -107,6 +107,7 @@ protected EthereumTestResult RunTest(GeneralStateTest test, ITxTracer txTracer)
             header.ExcessBlobGas = test.CurrentExcessBlobGas ?? (test.Fork is Cancun ? 0ul : null);
             header.BlobGasUsed = BlobGasCalculator.CalculateBlobGas(test.Transaction);
             header.RequestsHash = test.RequestsHash;
+            if (test.Fork is Prague) header.TargetBlobCount = 0;
 
             Stopwatch stopwatch = Stopwatch.StartNew();
             IReleaseSpec? spec = specProvider.GetSpec((ForkActivation)test.CurrentNumber);
@@ -129,14 +130,14 @@ protected EthereumTestResult RunTest(GeneralStateTest test, ITxTracer txTracer)
                     BlobGasUsed = (ulong)test.ParentBlobGasUsed,
                     ExcessBlobGas = (ulong)test.ParentExcessBlobGas,
                 };
-                header.ExcessBlobGas = BlobGasCalculator.CalculateExcessBlobGas(parent, spec);
+                header.ExcessBlobGas = BlobGasCalculator.CalculateExcessBlobGas(parent, spec, header);
             }
 
             ValidationResult txIsValid = _txValidator.IsWellFormed(test.Transaction, spec);
 
             if (txIsValid)
             {
-                transactionProcessor.Execute(test.Transaction, new BlockExecutionContext(header), txTracer);
+                transactionProcessor.Execute(test.Transaction, new BlockExecutionContext(header, spec), txTracer);
             }
             else
             {

src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs

@@ -90,7 +90,8 @@ protected override BlockProcessor CreateBlockProcessor()
                 blockGasLimitContractTransition.Key,
                 new ReadOnlyTxProcessingEnv(
                     WorldStateManager,
-                    BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance));
+                    BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance),
+                SpecProvider);
 
             GasLimitOverrideCache = new AuRaContractGasLimitOverride.Cache();
             GasLimitCalculator = new AuRaContractGasLimitOverride(new[] { gasLimitContract }, GasLimitOverrideCache, false, new FollowOtherMiners(SpecProvider), LimboLogs.Instance);

src/Nethermind/Nethermind.AuRa.Test/Contract/ReportingValidatorContractTests.cs

@@ -7,6 +7,7 @@
 using Nethermind.Consensus.AuRa.Contracts;
 using Nethermind.Core;
 using Nethermind.Core.Extensions;
+using Nethermind.Specs;
 using NSubstitute;
 using NUnit.Framework;
 
@@ -17,15 +18,15 @@ public class ReportingValidatorContractTests
         [Test]
         public void Should_generate_malicious_transaction()
         {
-            ReportingValidatorContract contract = new(AbiEncoder.Instance, new Address("0x1000000000000000000000000000000000000001"), Substitute.For<ISigner>());
+            ReportingValidatorContract contract = new(AbiEncoder.Instance, new Address("0x1000000000000000000000000000000000000001"), Substitute.For<ISigner>(), TestSpecProvider.Instance);
             Transaction transaction = contract.ReportMalicious(new Address("0x75df42383afe6bf5194aa8fa0e9b3d5f9e869441"), 10, []);
             transaction.Data.AsArray().ToHexString().Should().Be("c476dd4000000000000000000000000075df42383afe6bf5194aa8fa0e9b3d5f9e869441000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000");
         }
 
         [Test]
         public void Should_generate_benign_transaction()
         {
-            ReportingValidatorContract contract = new(AbiEncoder.Instance, new Address("0x1000000000000000000000000000000000000001"), Substitute.For<ISigner>());
+            ReportingValidatorContract contract = new(AbiEncoder.Instance, new Address("0x1000000000000000000000000000000000000001"), Substitute.For<ISigner>(), TestSpecProvider.Instance);
             Transaction transaction = contract.ReportBenign(new Address("0x75df42383afe6bf5194aa8fa0e9b3d5f9e869441"), 10);
             transaction.Data.AsArray().ToHexString().Should().Be("d69f13bb00000000000000000000000075df42383afe6bf5194aa8fa0e9b3d5f9e869441000000000000000000000000000000000000000000000000000000000000000a");
         }

src/Nethermind/Nethermind.AuRa.Test/Contract/TxPriorityContractTests.cs

@@ -254,7 +254,7 @@ protected override TxPoolTxSource CreateTxPoolTxSource()
                 TxPoolTxSource txPoolTxSource = base.CreateTxPoolTxSource();
 
                 TxPriorityContract = new TxPriorityContract(AbiEncoder.Instance, TestItem.AddressA,
-                    new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance));
+                    new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance), SpecProvider);
 
                 Priorities = new DictionaryContractDataStore<TxPriorityContract.Destination>(
                     new TxPriorityContract.DestinationSortedListContractDataStoreCollection(),

src/Nethermind/Nethermind.AuRa.Test/Contract/ValidatorContractTests.cs

@@ -16,6 +16,7 @@
 using Nethermind.Evm.Tracing;
 using Nethermind.Evm.TransactionProcessing;
 using Nethermind.Logging;
+using Nethermind.Specs;
 using Nethermind.State;
 using NSubstitute;
 using NUnit.Framework;
@@ -52,7 +53,8 @@ public void constructor_throws_ArgumentNullException_on_null_contractAddress()
                     null,
                     _stateProvider,
                     _readOnlyTxProcessorSource,
-                    new Signer(0, TestItem.PrivateKeyD, LimboLogs.Instance));
+                    new Signer(0, TestItem.PrivateKeyD, LimboLogs.Instance),
+                    TestSpecProvider.Instance);
             action.Should().Throw<ArgumentNullException>();
         }
 
@@ -78,12 +80,13 @@ public void finalize_change_should_call_correct_transaction()
                 _contractAddress,
                 _stateProvider,
                 _readOnlyTxProcessorSource,
-                new Signer(0, TestItem.PrivateKeyD, LimboLogs.Instance));
+                new Signer(0, TestItem.PrivateKeyD, LimboLogs.Instance),
+                TestSpecProvider.Instance);
 
             contract.FinalizeChange(_block.Header);
 
             _transactionProcessor.Received().Execute(
-                Arg.Is<Transaction>(t => IsEquivalentTo(expectation, t)), Arg.Is<BlockExecutionContext>(blkCtx => blkCtx.Header.Equals(_block.Header)), Arg.Any<ITxTracer>());
+                Arg.Is<Transaction>(t => IsEquivalentTo(expectation, t)), Arg.Is<BlockHeader>(blockHeader => blockHeader.Equals(_block.Header)), Arg.Any<ITxTracer>());
         }
 
         private static bool IsEquivalentTo(Transaction expected, Transaction item)

src/Nethermind/Nethermind.AuRa.Test/Reward/AuRaRewardCalculatorTests.cs

@@ -20,6 +20,7 @@
 using NSubstitute;
 using NUnit.Framework;
 using Nethermind.Evm;
+using Nethermind.Specs;
 
 namespace Nethermind.AuRa.Test.Reward
 {
@@ -60,21 +61,21 @@ public void SetUp()
         [Test]
         public void constructor_throws_ArgumentNullException_on_null_auraParameters()
         {
-            Action action = () => new AuRaRewardCalculator(null, _abiEncoder, _transactionProcessor);
+            Action action = () => new AuRaRewardCalculator(null, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             action.Should().Throw<ArgumentNullException>();
         }
 
         [Test]
         public void constructor_throws_ArgumentNullException_on_null_encoder()
         {
-            Action action = () => new AuRaRewardCalculator(_auraParameters, null, _transactionProcessor);
+            Action action = () => new AuRaRewardCalculator(_auraParameters, null, _transactionProcessor, TestSpecProvider.Instance);
             action.Should().Throw<ArgumentNullException>();
         }
 
         [Test]
         public void constructor_throws_ArgumentNullException_on_null_transactionProcessor()
         {
-            Action action = () => new AuRaRewardCalculator(_auraParameters, _abiEncoder, null);
+            Action action = () => new AuRaRewardCalculator(_auraParameters, _abiEncoder, null, TestSpecProvider.Instance);
             action.Should().Throw<ArgumentNullException>();
         }
 
@@ -86,7 +87,7 @@ public void constructor_throws_ArgumentException_on_BlockRewardContractTransitio
                 {2, Address.FromNumber(2)}
             };
 
-            Action action = () => new AuRaRewardCalculator(_auraParameters, _abiEncoder, _transactionProcessor);
+            Action action = () => new AuRaRewardCalculator(_auraParameters, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             action.Should().Throw<ArgumentException>();
         }
 
@@ -96,7 +97,7 @@ public void constructor_throws_ArgumentException_on_BlockRewardContractTransitio
         public void calculates_rewards_correctly_before_contract_transition(long blockNumber, ulong expectedReward)
         {
             _block.Header.Number = blockNumber;
-            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor);
+            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             BlockReward[] result = calculator.CalculateRewards(_block);
             result.Should().BeEquivalentTo(new BlockReward(_block.Beneficiary, expectedReward));
         }
@@ -105,7 +106,7 @@ public void calculates_rewards_correctly_before_contract_transition(long blockNu
         public void calculates_rewards_correctly_for_genesis()
         {
             _block.Header.Number = 0;
-            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor);
+            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             BlockReward[] result = calculator.CalculateRewards(_block);
             result.Should().BeEmpty();
         }
@@ -117,7 +118,7 @@ public void calculates_rewards_correctly_after_contract_transition(long blockNum
             _block.Header.Number = blockNumber;
             BlockReward expected = new(_block.Beneficiary, expectedReward, BlockRewardType.External);
             SetupBlockRewards(new Dictionary<Address, BlockReward[]>() { { _address10, new[] { expected } } });
-            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor);
+            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             BlockReward[] result = calculator.CalculateRewards(_block);
             result.Should().BeEquivalentTo(expected);
         }
@@ -143,7 +144,7 @@ public void calculates_rewards_correctly_after_subsequent_contract_transitions(l
             _block.Header.Number = blockNumber;
             BlockReward expected = new(_block.Beneficiary, expectedReward, BlockRewardType.External);
             SetupBlockRewards(new Dictionary<Address, BlockReward[]>() { { address, new[] { expected } } });
-            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor);
+            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             BlockReward[] result = calculator.CalculateRewards(_block);
             result.Should().BeEquivalentTo(expected);
         }
@@ -166,7 +167,7 @@ public void calculates_rewards_correctly_for_uncles(long blockNumber, ulong expe
             };
 
             SetupBlockRewards(new Dictionary<Address, BlockReward[]>() { { _address10, expected } });
-            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor);
+            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             BlockReward[] result = calculator.CalculateRewards(_block);
             result.Should().BeEquivalentTo(expected);
         }
@@ -189,7 +190,7 @@ public void calculates_rewards_correctly_for_external_addresses()
             };
 
             SetupBlockRewards(new Dictionary<Address, BlockReward[]>() { { _address10, expected } });
-            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor);
+            AuRaRewardCalculator calculator = new(_auraParameters, _abiEncoder, _transactionProcessor, TestSpecProvider.Instance);
             BlockReward[] result = calculator.CalculateRewards(_block);
             result.Should().BeEquivalentTo(expected);
         }
@@ -198,7 +199,7 @@ private void SetupBlockRewards(IDictionary<Address, BlockReward[]> rewards)
         {
             _transactionProcessor.When(x => x.Execute(
                     Arg.Is<Transaction>(t => CheckTransaction(t, rewards.Keys, _rewardData)),
-                    Arg.Is<BlockExecutionContext>(blkCtx => blkCtx.Header.Equals(_block.Header)),
+                    Arg.Is<BlockHeader>(header => header.Equals(_block.Header)),
                     Arg.Is<ITxTracer>(t => t is CallOutputTracer)))
                 .Do(args =>
                 {

src/Nethermind/Nethermind.AuRa.Test/Transactions/TxCertifierFilterTests.cs

@@ -124,7 +124,7 @@ public async Task registry_contract_returns_not_found_when_key_doesnt_exist()
     public async Task registry_contract_returns_not_found_when_contract_doesnt_exist()
     {
         using TestTxPermissionsBlockchain chain = await TestContractBlockchain.ForTest<TestTxPermissionsBlockchain, TxCertifierFilterTests>();
-        RegisterContract contract = new(AbiEncoder.Instance, Address.FromNumber(1000), chain.ReadOnlyTransactionProcessorSource);
+        RegisterContract contract = new(AbiEncoder.Instance, Address.FromNumber(1000), chain.ReadOnlyTransactionProcessorSource, _specProvider);
         contract.TryGetAddress(chain.BlockTree.Head.Header, CertifierContract.ServiceTransactionContractRegistryName, out Address _).Should().BeFalse();
     }
 
@@ -141,11 +141,12 @@ protected override BlockProcessor CreateBlockProcessor()
                 WorldStateManager,
                 BlockTree.AsReadOnly(), SpecProvider,
                 LimboLogs.Instance);
-            RegisterContract = new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, ReadOnlyTransactionProcessorSource);
+            RegisterContract = new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, ReadOnlyTransactionProcessorSource, Substitute.For<ISpecProvider>());
             CertifierContract = new CertifierContract(
                 abiEncoder,
                 RegisterContract,
-                ReadOnlyTransactionProcessorSource);
+                ReadOnlyTransactionProcessorSource,
+                Substitute.For<ISpecProvider>());
 
             return new AuRaBlockProcessor(
                 SpecProvider,

src/Nethermind/Nethermind.AuRa.Test/Validators/ContractBasedValidatorTests.cs

@@ -89,7 +89,7 @@ public void SetUp()
             .Encode(AbiEncodingStyle.IncludeSignature, Arg.Is<AbiSignature>(s => s.Name == "finalizeChange"), Arg.Any<object[]>())
             .Returns(_finalizeChangeData.TransactionData);
 
-        _validatorContract = new ValidatorContract(_transactionProcessor, _abiEncoder, _contractAddress, _stateProvider, _readOnlyTxProcessorSource, new Signer(0, TestItem.PrivateKeyD, LimboLogs.Instance));
+        _validatorContract = new ValidatorContract(_transactionProcessor, _abiEncoder, _contractAddress, _stateProvider, _readOnlyTxProcessorSource, new Signer(0, TestItem.PrivateKeyD, LimboLogs.Instance), TestSpecProvider.Instance);
     }
 
     [TearDown]
@@ -184,13 +184,13 @@ public void loads_initial_validators_from_contract(long blockNumber)
         _transactionProcessor.Received()
             .CallAndRestore(
                 Arg.Is<Transaction>(t => CheckTransaction(t, _getValidatorsData)),
-                Arg.Is<BlockExecutionContext>(blkCtx => blkCtx.Header.Equals(_parentHeader)),
+                Arg.Is<BlockHeader>(blockHeader => blockHeader.Equals(_parentHeader)),
                 Arg.Is<ITxTracer>(t => t is CallOutputTracer));
 
         // finalizeChange should be called
         _transactionProcessor.Received(finalizeChangeCalled ? 1 : 0)
             .Execute(Arg.Is<Transaction>(t => CheckTransaction(t, _finalizeChangeData)),
-                Arg.Is<BlockExecutionContext>(blkCtx => blkCtx.Header.Equals(block.Header)),
+                Arg.Is<BlockHeader>(blockHeader => blockHeader.Equals(block.Header)),
                 Arg.Is<ITxTracer>(t => t is CallOutputTracer));
 
         // initial validator should be true
@@ -603,7 +603,7 @@ private void ValidateFinalizationForChain(ConsecutiveInitiateChangeTestParameter
         // finalizeChange should be called or not based on test spec
         _transactionProcessor.Received(chain.ExpectedFinalizationCount)
             .Execute(Arg.Is<Transaction>(t => CheckTransaction(t, _finalizeChangeData)),
-                Arg.Is<BlockExecutionContext>(blkCtx => blkCtx.Header.Equals(_block.Header)),
+                Arg.Is<BlockHeader>(header => header.Equals(_block.Header)),
                 Arg.Is<ITxTracer>(t => t is CallOutputTracer));
 
         _transactionProcessor.ClearReceivedCalls();
@@ -634,7 +634,7 @@ private void SetupInitialValidators(BlockHeader header, BlockHeader parentHeader
 
         _transactionProcessor.When(x => x.CallAndRestore(
                 Arg.Is<Transaction>(t => CheckTransaction(t, _getValidatorsData)),
-                Arg.Any<BlockExecutionContext>(),
+                Arg.Any<BlockHeader>(),
                 Arg.Is<ITxTracer>(t => t is CallOutputTracer)))
             .Do(args =>
                 args.Arg<ITxTracer>().MarkAsSuccess(

src/Nethermind/Nethermind.Blockchain.Test/BeaconBlockRootHandlerTests.cs

@@ -149,6 +149,6 @@ public void Test_StoreBeaconRoot_AccessListNotNull()
 
         transaction.Hash = transaction.CalculateHash();
         _transactionProcessor.Received().Execute(Arg.Is<Transaction>(t =>
-            t.Hash == transaction.Hash), header, NullTxTracer.Instance);
+            t.Hash == transaction.Hash), new BlockExecutionContext(header, Cancun.Instance), NullTxTracer.Instance);
     }
 }

src/Nethermind/Nethermind.Blockchain.Test/TestEip4844Config.cs

@@ -16,5 +16,5 @@ public TestEip4844Config(ulong? maxBlobGasPerBlock = null)
 
     public ulong GasPerBlob => Eip4844Constants.GasPerBlob;
 
-    public int GetMaxBlobsPerBlock() => (int)(MaxBlobGasPerBlock / GasPerBlob);
+    public ulong GetMaxBlobsPerBlock() => MaxBlobGasPerBlock / GasPerBlob;
 }

src/Nethermind/Nethermind.Blockchain/BeaconBlockRoot/BeaconBlockRootHandler.cs

@@ -5,6 +5,7 @@
 using Nethermind.Core.Eip2930;
 using Nethermind.Core.Specs;
 using Nethermind.Crypto;
+using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 using Nethermind.Evm.TransactionProcessing;
 using Nethermind.Int256;
@@ -62,7 +63,7 @@ public void StoreBeaconRoot(Block block, IReleaseSpec spec, ITxTracer tracer)
 
             transaction.Hash = transaction.CalculateHash();
 
-            processor.Execute(transaction, header, tracer);
+            processor.Execute(transaction, new BlockExecutionContext(header, spec), tracer);
         }
     }
 }

src/Nethermind/Nethermind.Blockchain/ChainHeadInfoProvider.cs

@@ -59,7 +59,8 @@ private void OnHeadChanged(object? sender, BlockReplacementEventArgs e)
             BlockGasLimit = e.Block!.GasLimit;
             CurrentBaseFee = e.Block.Header.BaseFeePerGas;
             CurrentFeePerBlobGas =
-                BlobGasCalculator.TryCalculateFeePerBlobGas(e.Block.Header, out UInt256 currentFeePerBlobGas)
+                BlobGasCalculator.TryCalculateFeePerBlobGas(e.Block.Header, out UInt256 currentFeePerBlobGas,
+                    SpecProvider.GetSpec(e.Block.Header))
                     ? currentFeePerBlobGas
                     : UInt256.Zero;
             HeadChanged?.Invoke(sender, e);