Merge branch 'master' into optimize-blob-verification

NethermindEth · Jun 10, 2024 · 1679ba1 · 1679ba1
2 parents 89efed6 + 1d6a536
commit 1679ba1
Show file tree

Hide file tree

Showing 70 changed files with 772 additions and 337 deletions.
diff --git a/src/Nethermind/Chains/op-sepolia.json b/src/Nethermind/Chains/op-sepolia.json
@@ -8,6 +8,7 @@
         "bedrockBlockNumber": "0x0",
         "canyonTimestamp": "0x6553a790",
         "ecotoneTimestamp": "0x65D62C10",
+        "fjordTimestamp": "0x66575100",
         "l1FeeRecipient": "0x420000000000000000000000000000000000001A",
         "l1BlockAddress": "0x4200000000000000000000000000000000000015",
         "canyonBaseFeeChangeDenominator": "250",
@@ -60,6 +61,7 @@
     "eip4844TransitionTimestamp": "0x65D62C10",
     "eip5656TransitionTimestamp": "0x65D62C10",
     "eip6780TransitionTimestamp": "0x65D62C10",
+    "eip7212TransitionTimestamp": "0x66575100",
     "terminalTotalDifficulty": "0"
   },
   "genesis": {

diff --git a/src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs
@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using Nethermind.Abi;
+using Nethermind.Blockchain;
 using Nethermind.Consensus;
 using Nethermind.Consensus.AuRa;
 using Nethermind.Consensus.AuRa.Contracts;
@@ -85,7 +86,7 @@ protected override BlockProcessor CreateBlockProcessor()
             BlockGasLimitContract gasLimitContract = new(AbiEncoder.Instance, blockGasLimitContractTransition.Value, blockGasLimitContractTransition.Key,
                 new ReadOnlyTxProcessingEnv(
                     WorldStateManager,
-                    BlockTree, SpecProvider, LimboLogs.Instance));
+                    BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance));
 
             GasLimitOverrideCache = new AuRaContractGasLimitOverride.Cache();
             GasLimitCalculator = new AuRaContractGasLimitOverride(new[] { gasLimitContract }, GasLimitOverrideCache, false, new FollowOtherMiners(SpecProvider), LimboLogs.Instance);

diff --git a/src/Nethermind/Nethermind.AuRa.Test/Contract/TxPriorityContractTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Contract/TxPriorityContractTests.cs
@@ -10,6 +10,7 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using Nethermind.Abi;
+using Nethermind.Blockchain;
 using Nethermind.Blockchain.Data;
 using Nethermind.Consensus.AuRa.Contracts;
 using Nethermind.Consensus.AuRa.Contracts.DataStore;
@@ -254,7 +255,7 @@ protected override TxPoolTxSource CreateTxPoolTxSource()
                 TxPoolTxSource txPoolTxSource = base.CreateTxPoolTxSource();
 
                 TxPriorityContract = new TxPriorityContract(AbiEncoder.Instance, TestItem.AddressA,
-                    new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree, SpecProvider, LimboLogs.Instance));
+                    new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance));
 
                 Priorities = new DictionaryContractDataStore<TxPriorityContract.Destination>(
                     new TxPriorityContract.DestinationSortedListContractDataStoreCollection(),

diff --git a/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxCertifierFilterTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxCertifierFilterTests.cs
@@ -6,6 +6,7 @@
 using FluentAssertions;
 using Nethermind.Abi;
 using Nethermind.AuRa.Test.Contract;
+using Nethermind.Blockchain;
 using Nethermind.Consensus.AuRa;
 using Nethermind.Consensus.AuRa.Contracts;
 using Nethermind.Consensus.AuRa.Transactions;
@@ -138,7 +139,7 @@ protected override BlockProcessor CreateBlockProcessor()
             AbiEncoder abiEncoder = AbiEncoder.Instance;
             ReadOnlyTransactionProcessorSource = new ReadOnlyTxProcessingEnv(
                 WorldStateManager,
-                BlockTree, SpecProvider,
+                BlockTree.AsReadOnly(), SpecProvider,
                 LimboLogs.Instance);
             RegisterContract = new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, ReadOnlyTransactionProcessorSource);
             CertifierContract = new CertifierContract(

diff --git a/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs b/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs
@@ -8,6 +8,7 @@
 using FluentAssertions;
 using Nethermind.Abi;
 using Nethermind.AuRa.Test.Contract;
+using Nethermind.Blockchain;
 using Nethermind.Consensus.AuRa;
 using Nethermind.Consensus.AuRa.Contracts;
 using Nethermind.Consensus.AuRa.Transactions;
@@ -277,12 +278,12 @@ protected override BlockProcessor CreateBlockProcessor()
             IReadOnlyTrieStore trieStore = new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly();
             IReadOnlyTxProcessorSource txProcessorSource = new ReadOnlyTxProcessingEnv(
                 WorldStateManager,
-                BlockTree,
+                BlockTree.AsReadOnly(),
                 SpecProvider,
                 LimboLogs.Instance);
 
             VersionedTransactionPermissionContract transactionPermissionContract = new(AbiEncoder.Instance, _contractAddress, 1,
-                new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree, SpecProvider, LimboLogs.Instance), TransactionPermissionContractVersions, LimboLogs.Instance, SpecProvider);
+                new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance), TransactionPermissionContractVersions, LimboLogs.Instance, SpecProvider);
 
             TxPermissionFilterCache = new PermissionBasedTxFilter.Cache();
             PermissionBasedTxFilter = new PermissionBasedTxFilter(transactionPermissionContract, TxPermissionFilterCache, LimboLogs.Instance);

diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockCachePreWarmer.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockCachePreWarmer.cs
@@ -70,26 +70,36 @@ private void PreWarmCachesParallel(Block suggestedBlock, Hash256 parentStateRoot
 
         void WarmupWithdrawals(ParallelOptions parallelOptions, IReleaseSpec spec, Block block, Hash256 stateRoot)
         {
+            if (parallelOptions.CancellationToken.IsCancellationRequested) return;
             if (spec.WithdrawalsEnabled && block.Withdrawals is not null)
             {
-                ReadOnlyTxProcessingEnv env = _envPool.Get();
-                try
-                {
-                    using IReadOnlyTransactionProcessor transactionProcessor = env.Build(stateRoot);
-                    Parallel.For(0, block.Withdrawals.Length, parallelOptions,
-                        i => env.StateProvider.WarmUp(block.Withdrawals[i].Address)
-                    );
-                }
-                finally
-                {
-                    env.Reset();
-                    _envPool.Return(env);
-                }
+                Parallel.For(0, block.Withdrawals.Length, parallelOptions,
+                    i =>
+                    {
+                        ReadOnlyTxProcessingEnv env = _envPool.Get();
+                        Hash256 stateBefore = env.StateProvider.StateRoot;
+                        env.StateProvider.StateRoot = stateRoot;
+                        try
+                        {
+                            env.StateProvider.WarmUp(block.Withdrawals[i].Address);
+                        }
+                        catch (Exception ex)
+                        {
+                            if (_logger.IsDebug) _logger.Error($"Error pre-warming withdrawal {i}", ex);
+                        }
+                        finally
+                        {
+                            env.StateProvider.StateRoot = stateBefore;
+                            env.Reset();
+                            _envPool.Return(env);
+                        }
+                    });
             }
         }
 
         void WarmupTransactions(ParallelOptions parallelOptions, IReleaseSpec spec, Block block, Hash256 stateRoot)
         {
+            if (parallelOptions.CancellationToken.IsCancellationRequested) return;
             Parallel.For(0, block.Transactions.Length, parallelOptions, i =>
             {
                 // If the transaction has already been processed or being processed, exit early

diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs
@@ -7,7 +7,6 @@
 using Nethermind.Consensus.Rewards;
 using Nethermind.Consensus.Validators;
 using Nethermind.Core.Specs;
-using Nethermind.Db;
 using Nethermind.Logging;
 using Nethermind.State;
 
@@ -41,7 +40,16 @@ public ReadOnlyChainProcessingEnv(
             IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor =
                 blockTransactionsExecutor ?? new BlockProcessor.BlockValidationTransactionsExecutor(_txEnv.TransactionProcessor, StateProvider);
 
-            BlockProcessor = new BlockProcessor(
+            BlockProcessor = CreateBlockProcessor(txEnv, blockValidator, rewardCalculator, receiptStorage, specProvider, logManager, transactionsExecutor);
+
+            _blockProcessingQueue = new BlockchainProcessor(_txEnv.BlockTree, BlockProcessor, recoveryStep, _txEnv.StateReader, logManager, BlockchainProcessor.Options.NoReceipts);
+            BlockProcessingQueue = _blockProcessingQueue;
+            ChainProcessor = new OneTimeChainProcessor(txEnv.StateProvider, _blockProcessingQueue);
+        }
+
+        protected virtual IBlockProcessor CreateBlockProcessor(ReadOnlyTxProcessingEnv txEnv, IBlockValidator blockValidator, IRewardCalculator rewardCalculator, IReceiptStorage receiptStorage, ISpecProvider specProvider, ILogManager logManager, IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor)
+        {
+            return new BlockProcessor(
                 specProvider,
                 blockValidator,
                 rewardCalculator,
@@ -50,10 +58,6 @@ public ReadOnlyChainProcessingEnv(
                 receiptStorage,
                 new BlockhashStore(txEnv.BlockTree, specProvider, StateProvider),
                 logManager);
-
-            _blockProcessingQueue = new BlockchainProcessor(_txEnv.BlockTree, BlockProcessor, recoveryStep, _txEnv.StateReader, logManager, BlockchainProcessor.Options.NoReceipts);
-            BlockProcessingQueue = _blockProcessingQueue;
-            ChainProcessor = new OneTimeChainProcessor(txEnv.StateProvider, _blockProcessingQueue);
         }
 
         public void Dispose()

diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs
@@ -12,52 +12,48 @@
 
 // ReSharper disable MemberCanBePrivate.Global
 // ReSharper disable UnusedAutoPropertyAccessor.Global
-namespace Nethermind.Consensus.Processing
+namespace Nethermind.Consensus.Processing;
+
+public class ReadOnlyTxProcessingEnv : IReadOnlyTxProcessorSource
 {
-    public class ReadOnlyTxProcessingEnv : IReadOnlyTxProcessorSource
+    protected readonly ISpecProvider _specProvider;
+    protected readonly ILogManager? _logManager;
+
+    public IStateReader StateReader { get; }
+    public IWorldState StateProvider { get; }
+    public ITransactionProcessor TransactionProcessor { get; set; }
+    public IBlockTree BlockTree { get; }
+
+    public ReadOnlyTxProcessingEnv(
+      IWorldStateManager? worldStateManager,
+      IReadOnlyBlockTree? readOnlyBlockTree,
+      ISpecProvider? specProvider,
+      ILogManager? logManager,
+      PreBlockCaches? preBlockCaches = null)
+    {
+        ArgumentNullException.ThrowIfNull(worldStateManager);
+        ArgumentNullException.ThrowIfNull(readOnlyBlockTree);
+        ArgumentNullException.ThrowIfNull(specProvider);
+
+        StateReader = worldStateManager.GlobalStateReader;
+        StateProvider = worldStateManager.CreateResettableWorldState(preBlockCaches);
+        BlockTree = readOnlyBlockTree;
+        _specProvider = specProvider;
+        _logManager = logManager;
+        TransactionProcessor = CreateTransactionProcessor();
+    }
+
+    protected virtual TransactionProcessor CreateTransactionProcessor()
+    {
+        BlockhashProvider blockhashProvider = new(BlockTree, _specProvider, StateProvider, _logManager);
+        VirtualMachine virtualMachine = new(blockhashProvider, _specProvider, _logManager);
+        return new TransactionProcessor(_specProvider, StateProvider, virtualMachine, _logManager);
+    }
+
+    public IReadOnlyTransactionProcessor Build(Hash256 stateRoot) => new ReadOnlyTransactionProcessor(TransactionProcessor, StateProvider, stateRoot);
+
+    public void Reset()
     {
-        public IStateReader StateReader { get; }
-        public IWorldState StateProvider { get; }
-        public ITransactionProcessor TransactionProcessor { get; set; }
-        public IBlockTree BlockTree { get; }
-        public IBlockhashProvider BlockhashProvider { get; }
-        public IVirtualMachine Machine { get; }
-        public ISpecProvider SpecProvider { get; }
-
-        public ReadOnlyTxProcessingEnv(
-            IWorldStateManager worldStateManager,
-            IBlockTree? blockTree,
-            ISpecProvider? specProvider,
-            ILogManager? logManager)
-            : this(worldStateManager, blockTree?.AsReadOnly(), specProvider, logManager)
-        {
-        }
-
-        public ReadOnlyTxProcessingEnv(
-            IWorldStateManager worldStateManager,
-            IReadOnlyBlockTree? readOnlyBlockTree,
-            ISpecProvider? specProvider,
-            ILogManager? logManager,
-            PreBlockCaches? preBlockCaches = null)
-        {
-            ArgumentNullException.ThrowIfNull(specProvider);
-            ArgumentNullException.ThrowIfNull(worldStateManager);
-            SpecProvider = specProvider;
-            StateReader = worldStateManager.GlobalStateReader;
-            StateProvider = worldStateManager.CreateResettableWorldState(preBlockCaches);
-
-            BlockTree = readOnlyBlockTree ?? throw new ArgumentNullException(nameof(readOnlyBlockTree));
-            BlockhashProvider = new BlockhashProvider(BlockTree, specProvider, StateProvider, logManager);
-
-            Machine = new VirtualMachine(BlockhashProvider, specProvider, logManager);
-            TransactionProcessor = new TransactionProcessor(specProvider, StateProvider, Machine, logManager);
-        }
-
-        public IReadOnlyTransactionProcessor Build(Hash256 stateRoot) => new ReadOnlyTransactionProcessor(TransactionProcessor, StateProvider, stateRoot);
-
-        public void Reset()
-        {
-            StateProvider.Reset();
-        }
+        StateProvider.Reset();
     }
 }
diff --git a/src/Nethermind/Nethermind.Core/Collections/ThrowHelper.cs b/src/Nethermind/Nethermind.Core/Collections/ThrowHelper.cs
@@ -51,13 +51,6 @@ public static void ThrowArgumentOutOfRangeException_SizeHint()
         throw new ArgumentOutOfRangeException("sizeHint");
     }
 
-    [DoesNotReturn]
-    [StackTraceHidden]
-    public static void ThrowArgumentNullException_Options()
-    {
-        throw new ArgumentNullException("options");
-    }
-
     [DoesNotReturn]
     [StackTraceHidden]
     public static void ThrowArgumentNullException_WritingStream()

diff --git a/src/Nethermind/Nethermind.Core/Threading/ThreadExtensions.cs b/src/Nethermind/Nethermind.Core/Threading/ThreadExtensions.cs
@@ -10,7 +10,7 @@ public static class ThreadExtensions
 {
     public readonly struct Disposable : IDisposable
     {
-        private readonly Thread _thread;
+        private readonly Thread? _thread;
         private readonly ThreadPriority _previousPriority;
 
         internal Disposable(Thread thread)
@@ -22,7 +22,10 @@ internal Disposable(Thread thread)
 
         public void Dispose()
         {
-            _thread.Priority = _previousPriority;
+            if (_thread is not null && Thread.CurrentThread == _thread)
+            {
+                _thread.Priority = _previousPriority;
+            }
         }
     }
 

diff --git a/src/Nethermind/Nethermind.Init/Steps/RegisterRpcModules.cs b/src/Nethermind/Nethermind.Init/Steps/RegisterRpcModules.cs
@@ -114,18 +114,7 @@ public virtual async Task Execute(CancellationToken cancellationToken)
             _api.LogManager);
         rpcModuleProvider.RegisterBoundedByCpuCount(debugModuleFactory, _jsonRpcConfig.Timeout);
 
-        TraceModuleFactory traceModuleFactory = new(
-            _api.WorldStateManager,
-            _api.BlockTree,
-            _jsonRpcConfig,
-            _api.BlockPreprocessor,
-            _api.RewardCalculatorSource,
-            _api.ReceiptStorage,
-            _api.SpecProvider,
-            _api.PoSSwitcher,
-            _api.LogManager);
-
-        rpcModuleProvider.RegisterBoundedByCpuCount(traceModuleFactory, _jsonRpcConfig.Timeout);
+        RegisterTraceRpcModule(rpcModuleProvider);
 
         StepDependencyException.ThrowIfNull(_api.EthereumEcdsa);
 
@@ -249,4 +238,31 @@ protected virtual void RegisterEthRpcModule(IRpcModuleProvider rpcModuleProvider
         rpcModuleProvider.RegisterBounded(ethModuleFactory,
             _jsonRpcConfig.EthModuleConcurrentInstances ?? Environment.ProcessorCount, _jsonRpcConfig.Timeout);
     }
+
+    protected ModuleFactoryBase<ITraceRpcModule> CreateTraceModuleFactory()
+    {
+        StepDependencyException.ThrowIfNull(_api.WorldStateManager);
+        StepDependencyException.ThrowIfNull(_api.BlockTree);
+        StepDependencyException.ThrowIfNull(_api.RewardCalculatorSource);
+        StepDependencyException.ThrowIfNull(_api.ReceiptStorage);
+        StepDependencyException.ThrowIfNull(_api.SpecProvider);
+
+        return new TraceModuleFactory(
+            _api.WorldStateManager,
+            _api.BlockTree,
+            _jsonRpcConfig,
+            _api.BlockPreprocessor,
+            _api.RewardCalculatorSource,
+            _api.ReceiptStorage,
+            _api.SpecProvider,
+            _api.PoSSwitcher,
+            _api.LogManager);
+    }
+
+    protected virtual void RegisterTraceRpcModule(IRpcModuleProvider rpcModuleProvider)
+    {
+        ModuleFactoryBase<ITraceRpcModule> traceModuleFactory = CreateTraceModuleFactory();
+
+        rpcModuleProvider.RegisterBoundedByCpuCount(traceModuleFactory, _jsonRpcConfig.Timeout);
+    }
 }
diff --git a/src/Nethermind/Nethermind.Init/Steps/StepInitializationException.cs b/src/Nethermind/Nethermind.Init/Steps/StepInitializationException.cs
@@ -18,7 +18,7 @@ public StepDependencyException(string message)
         {
         }
 
-        public static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpression("argument")] string? paramName = null)
+        public static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpression(nameof(argument))] string? paramName = null)
         {
             if (argument is not null)
                 return;

diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/JsonRpcServiceTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/JsonRpcServiceTests.cs
@@ -38,12 +38,17 @@ public class JsonRpcServiceTests
     [SetUp]
     public void Initialize()
     {
-        Assembly jConfig = typeof(JsonRpcConfig).Assembly;
         _configurationProvider = new ConfigProvider();
         _logManager = LimboLogs.Instance;
         _context = new JsonRpcContext(RpcEndpoint.Http);
     }
 
+    [TearDown]
+    public void TearDown()
+    {
+        _context?.Dispose();
+    }
+
     private IJsonRpcService _jsonRpcService = null!;
     private IConfigProvider _configurationProvider = null!;
     private ILogManager _logManager = null!;

diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/RpcModuleProviderTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/RpcModuleProviderTests.cs
@@ -28,6 +28,12 @@ public void Initialize()
             _context = new JsonRpcContext(RpcEndpoint.Http);
         }
 
+        [TearDown]
+        public void TearDown()
+        {
+            _context?.Dispose();
+        }
+
         [Test]
         public void Module_provider_will_recognize_disabled_modules()
         {