EIP 7742 implementation

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

@@ -129,14 +129,14 @@
                     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);
             }
             else
             {

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.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,7 @@ 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)
                     ? currentFeePerBlobGas
                     : UInt256.Zero;
             HeadChanged?.Invoke(sender, e);

src/Nethermind/Nethermind.Blockchain/Contracts/CallableContract.cs

@@ -4,6 +4,7 @@
 using System;
 using Nethermind.Abi;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
@@ -24,7 +25,8 @@ public abstract class CallableContract : Contract
         /// <param name="transactionProcessor">Transaction processor on which all <see cref="Call(Nethermind.Core.BlockHeader,Nethermind.Core.Transaction)"/> should be run on.</param>
         /// <param name="abiEncoder">Binary interface encoder/decoder.</param>
         /// <param name="contractAddress">Address where contract is deployed.</param>
-        protected CallableContract(ITransactionProcessor transactionProcessor, IAbiEncoder abiEncoder, Address contractAddress) : base(abiEncoder, contractAddress)
+        /// <param name="specProvider">Address where contract is deployed.</param>
+        protected CallableContract(ITransactionProcessor transactionProcessor, IAbiEncoder abiEncoder, Address contractAddress, ISpecProvider specProvider) : base(specProvider, abiEncoder, contractAddress)
         {
             _transactionProcessor = transactionProcessor ?? throw new ArgumentNullException(nameof(transactionProcessor));
         }
@@ -66,7 +68,7 @@ private bool TryCall(BlockHeader header, Transaction transaction, out byte[] res
 
             try
             {
-                _transactionProcessor.Execute(transaction, new BlockExecutionContext(header), tracer);
+                _transactionProcessor.Execute(transaction, new BlockExecutionContext(header, SpecProvider), tracer);
                 result = tracer.ReturnValue;
                 return tracer.StatusCode == StatusCode.Success;
             }
@@ -87,7 +89,7 @@ private bool TryCall(BlockHeader header, Transaction transaction, out byte[] res
         /// <param name="arguments">Arguments to the function.</param>
         /// <returns>true if function was <see cref="StatusCode.Success"/> otherwise false.</returns>
         protected bool TryCall(BlockHeader header, string functionName, Address sender, out object[] result, params object[] arguments) =>
-            TryCall(header, functionName, sender, DefaultContractGasLimit, out result, arguments);
+            TryCall(header, functionName, sender, DefaultContractGasLimit, out result);
 
         /// <summary>
         /// Same as <see cref="Call(Nethermind.Core.BlockHeader,AbiFunctionDescription,Address,object[])"/> but returns false instead of throwing <see cref="AbiException"/>.

src/Nethermind/Nethermind.Blockchain/Contracts/Contract.cs

@@ -7,6 +7,7 @@
 using Nethermind.Blockchain.Contracts.Json;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Core.Specs;
 using Nethermind.Crypto;
 using Nethermind.Int256;
 using Nethermind.Evm;
@@ -36,18 +37,21 @@ public abstract partial class Contract
         protected IAbiEncoder AbiEncoder { get; }
         public AbiDefinition AbiDefinition { get; }
         public Address? ContractAddress { get; protected set; }
+        protected ISpecProvider SpecProvider { get; set; }
 
         /// <summary>
         /// Creates contract
         /// </summary>
+        /// <param name="specProvider">Binary interface encoder/decoder.</param>
         /// <param name="abiEncoder">Binary interface encoder/decoder.</param>
         /// <param name="contractAddress">Address where contract is deployed.</param>
         /// <param name="abiDefinition">Binary definition of contract.</param>
-        protected Contract(IAbiEncoder? abiEncoder = null, Address? contractAddress = null, AbiDefinition? abiDefinition = null)
+        protected Contract(ISpecProvider specProvider, IAbiEncoder? abiEncoder = null, Address? contractAddress = null, AbiDefinition? abiDefinition = null)
         {
             AbiEncoder = abiEncoder ?? Abi.AbiEncoder.Instance;
             ContractAddress = contractAddress;
             AbiDefinition = abiDefinition ?? new AbiDefinitionParser().Parse(GetType());
+            SpecProvider = specProvider;
         }
 
         protected virtual Transaction GenerateTransaction<T>(Address? contractAddress, byte[] transactionData, Address sender, long gasLimit = DefaultContractGasLimit, BlockHeader header = null)
@@ -178,11 +182,11 @@ protected byte[] CallCore(ITransactionProcessor transactionProcessor, BlockHeade
             {
                 if (callAndRestore)
                 {
-                    transactionProcessor.CallAndRestore(transaction, new BlockExecutionContext(header), tracer);
+                    transactionProcessor.CallAndRestore(transaction, new BlockExecutionContext(header, SpecProvider), tracer);
                 }
                 else
                 {
-                    transactionProcessor.Execute(transaction, new BlockExecutionContext(header), tracer);
+                    transactionProcessor.Execute(transaction, new BlockExecutionContext(header, SpecProvider), tracer);
                 }
 
                 failure = tracer.StatusCode != StatusCode.Success;

src/Nethermind/Nethermind.Blockchain/GenesisLoader.cs

@@ -80,7 +80,7 @@ private void Preallocate(Block genesis)
                     };
 
                     CallOutputTracer outputTracer = new();
-                    _transactionProcessor.Execute(constructorTransaction, new BlockExecutionContext(genesis.Header), outputTracer);
+                    _transactionProcessor.Execute(constructorTransaction, new BlockExecutionContext(genesis.Header, _specProvider), outputTracer);
 
                     if (outputTracer.StatusCode != StatusCode.Success)
                     {

src/Nethermind/Nethermind.Consensus.AuRa/AuRaValidatorFactory.cs

@@ -80,8 +80,8 @@ public AuRaValidatorFactory(IAbiEncoder abiEncoder,
 
         public IAuRaValidator CreateValidatorProcessor(AuRaParameters.Validator validator, BlockHeader parentHeader = null, long? startBlock = null)
         {
-            IValidatorContract GetValidatorContract() => new ValidatorContract(_transactionProcessor, _abiEncoder, validator.GetContractAddress(), _stateProvider, _readOnlyTxProcessorSource, _signer);
-            IReportingValidatorContract GetReportingValidatorContract() => new ReportingValidatorContract(_abiEncoder, validator.GetContractAddress(), _signer);
+            IValidatorContract GetValidatorContract() => new ValidatorContract(_transactionProcessor, _abiEncoder, validator.GetContractAddress(), _stateProvider, _readOnlyTxProcessorSource, _signer, _specProvider);
+            IReportingValidatorContract GetReportingValidatorContract() => new ReportingValidatorContract(_abiEncoder, validator.GetContractAddress(), _signer, _specProvider);
 
             var validSealerStrategy = new ValidSealerStrategy();
             long startBlockNumber = startBlock ?? AuRaValidatorBase.DefaultStartBlockNumber;

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/BlockGasLimitContract.cs

@@ -5,6 +5,7 @@
 using Nethermind.Abi;
 using Nethermind.Blockchain.Contracts;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 using Nethermind.Evm.TransactionProcessing;
 
@@ -24,8 +25,9 @@ public BlockGasLimitContract(
             IAbiEncoder abiEncoder,
             Address contractAddress,
             long transitionBlock,
-            IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
-            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
+            IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
+            ISpecProvider specProvider)
+            : base(specProvider, abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
         {
             Activation = transitionBlock;
             Constant = GetConstant(readOnlyTxProcessorSource);

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/CertifierContract.cs

@@ -3,6 +3,7 @@
 
 using Nethermind.Abi;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Evm.TransactionProcessing;
 
 namespace Nethermind.Consensus.AuRa.Contracts
@@ -22,8 +23,9 @@ public class CertifierContract : RegisterBasedContract, ICertifierContract
         public CertifierContract(
             IAbiEncoder abiEncoder,
             IRegisterContract registerContract,
-            IReadOnlyTxProcessorSource readOnlyTransactionProcessorSource)
-            : base(abiEncoder, registerContract, ServiceTransactionContractRegistryName)
+            IReadOnlyTxProcessorSource readOnlyTransactionProcessorSource,
+            ISpecProvider specProvider)
+            : base(abiEncoder, registerContract, ServiceTransactionContractRegistryName, specProvider)
         {
             Constant = GetConstant(readOnlyTransactionProcessorSource);
         }

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/RandomContract.cs

@@ -5,6 +5,7 @@
 using Nethermind.Abi;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 using Nethermind.Evm.TransactionProcessing;
 
@@ -81,8 +82,9 @@ public RandomContract(
             Address contractAddress,
             IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
             long transitionBlock,
-            ISigner signer)
-            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
+            ISigner signer,
+            ISpecProvider specProvider)
+            : base(specProvider, abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
         {
             _signer = signer;
             Activation = transitionBlock;

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/RegisterBasedContract.cs

@@ -5,6 +5,7 @@
 using Nethermind.Blockchain.Contracts;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Core.Specs;
 
 namespace Nethermind.Consensus.AuRa.Contracts
 {
@@ -18,8 +19,9 @@ public RegisterBasedContract(
             IAbiEncoder abiEncoder,
             IRegisterContract registerContract,
             string registryKey,
+            ISpecProvider specProvider,
             AbiDefinition? abiDefinition = null)
-            : base(abiEncoder, abiDefinition: abiDefinition)
+            : base(specProvider, abiEncoder, abiDefinition: abiDefinition)
         {
             _registerContract = registerContract;
             _registryKey = registryKey;

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/RegisterContract.cs

@@ -6,6 +6,7 @@
 using Nethermind.Blockchain.Contracts;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Core.Specs;
 using Nethermind.Evm.TransactionProcessing;
 
 namespace Nethermind.Consensus.AuRa.Contracts
@@ -33,8 +34,9 @@ public class RegisterContract : Contract, IRegisterContract
         public RegisterContract(
             IAbiEncoder abiEncoder,
             Address contractAddress,
-            IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
-            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
+            IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
+            ISpecProvider specProvider)
+            : base(specProvider, abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
         {
             Constant = GetConstant(readOnlyTxProcessorSource);
         }

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/ReportingValidatorContract.cs

@@ -5,6 +5,7 @@
 using Nethermind.Abi;
 using Nethermind.Blockchain.Contracts;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 
 namespace Nethermind.Consensus.AuRa.Contracts
@@ -47,8 +48,9 @@ public sealed class ReportingValidatorContract : Contract, IReportingValidatorCo
         public ReportingValidatorContract(
             IAbiEncoder abiEncoder,
             Address contractAddress,
-            ISigner signer)
-            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
+            ISigner signer,
+            ISpecProvider specProvider)
+            : base(specProvider, abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
         {
             _signer = signer ?? throw new ArgumentNullException(nameof(signer));
         }

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/RewardContract.cs

@@ -5,6 +5,7 @@
 using Nethermind.Abi;
 using Nethermind.Blockchain.Contracts;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 using Nethermind.Evm.TransactionProcessing;
 
@@ -34,8 +35,8 @@ public sealed class RewardContract : CallableContract, IRewardContract
     {
         public long Activation { get; }
 
-        public RewardContract(ITransactionProcessor transactionProcessor, IAbiEncoder abiEncoder, Address contractAddress, long transitionBlock)
-            : base(transactionProcessor, abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)))
+        public RewardContract(ITransactionProcessor transactionProcessor, IAbiEncoder abiEncoder, Address contractAddress, long transitionBlock, ISpecProvider specProvider)
+            : base(transactionProcessor, abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)), specProvider)
         {
             Activation = transitionBlock;
         }

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/TransactionPermissionContract.cs

@@ -5,6 +5,7 @@
 using Nethermind.Abi;
 using Nethermind.Blockchain.Contracts;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 using Nethermind.Evm.TransactionProcessing;
 
@@ -97,8 +98,9 @@ protected virtual (ITransactionPermissionContract.TxPermissions, bool) CallAllow
         protected TransactionPermissionContract(
             IAbiEncoder abiEncoder,
             Address contractAddress,
-            IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
-            : base(abiEncoder, contractAddress)
+            IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
+            ISpecProvider specProvider)
+            : base(specProvider, abiEncoder, contractAddress)
         {
             Constant = new PermissionConstantContract(this, readOnlyTxProcessorSource);
         }

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/TransactionPermissionContractV1.cs

@@ -4,6 +4,7 @@
 using System;
 using Nethermind.Abi;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 using Nethermind.Evm.TransactionProcessing;
 
@@ -14,14 +15,16 @@ public sealed class TransactionPermissionContractV1 : TransactionPermissionContr
         public TransactionPermissionContractV1(
             IAbiEncoder abiEncoder,
             Address contractAddress,
-            IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
-            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)), readOnlyTxProcessorSource)
+            IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
+            ISpecProvider specProvider)
+            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)), readOnlyTxProcessorSource, specProvider)
         {
         }
 
         protected override object[] GetAllowedTxTypesParameters(Transaction tx, BlockHeader parentHeader) => new object[] { tx.SenderAddress };
 
-        protected override (ITransactionPermissionContract.TxPermissions, bool) CallAllowedTxTypes(PermissionConstantContract.PermissionCallInfo callInfo) =>
+        protected override (ITransactionPermissionContract.TxPermissions, bool) CallAllowedTxTypes(
+            PermissionConstantContract.PermissionCallInfo callInfo) =>
             (Constant.Call<ITransactionPermissionContract.TxPermissions>(callInfo), true);
 
         public override UInt256 Version => UInt256.One;

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/TransactionPermissionContractV2.cs

@@ -4,6 +4,7 @@
 using System;
 using Nethermind.Abi;
 using Nethermind.Core;
+using Nethermind.Core.Specs;
 using Nethermind.Int256;
 using Nethermind.Evm.TransactionProcessing;
 
@@ -16,8 +17,9 @@ public sealed class TransactionPermissionContractV2 : TransactionPermissionContr
         public TransactionPermissionContractV2(
             IAbiEncoder abiEncoder,
             Address contractAddress,
-            IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
-            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)), readOnlyTxProcessorSource)
+            IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
+            ISpecProvider specProvider)
+            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)), readOnlyTxProcessorSource, specProvider)
         {
         }
 

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/TransactionPermissionContractV3.cs

@@ -21,7 +21,7 @@ public TransactionPermissionContractV3(
             Address contractAddress,
             IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
             ISpecProvider specProvider)
-            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)), readOnlyTxProcessorSource)
+            : base(abiEncoder, contractAddress ?? throw new ArgumentNullException(nameof(contractAddress)), readOnlyTxProcessorSource, specProvider)
         {
             _specProvider = specProvider;
         }

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/TransactionPermissionContractV4.cs

@@ -22,7 +22,7 @@ public TransactionPermissionContractV4(
             Address contractAddress,
             IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
             ISpecProvider specProvider)
-            : base(abiEncoder, contractAddress, readOnlyTxProcessorSource)
+            : base(abiEncoder, contractAddress, readOnlyTxProcessorSource, specProvider)
         {
             _specProvider = specProvider;
         }