Add eth_simulate , support array of eth_call for simulation across multiple blocks

src/Nethermind/Nethermind.AccountAbstraction/Executor/UserOperationTracer.cs

@@ -76,7 +76,8 @@ public UserOperationTxTracer(
         public bool IsTracingBlockHash => false;
         public bool IsTracingAccess => true;
         public bool IsTracingFees => false;
-        public bool IsTracing => IsTracingReceipt || IsTracingActions || IsTracingOpLevelStorage || IsTracingMemory || IsTracingInstructions || IsTracingRefunds || IsTracingCode || IsTracingStack || IsTracingBlockHash || IsTracingAccess || IsTracingFees;
+        public bool IsTracing => IsTracingReceipt || IsTracingActions || IsTracingOpLevelStorage || IsTracingMemory || IsTracingInstructions || IsTracingRefunds || IsTracingCode || IsTracingStack || IsTracingBlockHash || IsTracingAccess || IsTracingFees || IsTracingEventLogs;
+        public bool IsTracingEventLogs => false;
 
         public void MarkAsSuccess(Address recipient, long gasSpent, byte[] output, LogEntry[] logs,
             Keccak? stateRoot = null)
@@ -335,5 +336,10 @@ public void ReportFees(UInt256 fees, UInt256 burntFees)
         {
             throw new NotImplementedException();
         }
+
+        public void ReportEvent(LogEntry logEntry)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/Nethermind/Nethermind.Api/NethermindApi.cs

@@ -71,11 +71,13 @@ public NethermindApi(IConfigProvider configProvider, IJsonSerializer jsonSeriali
         }
 
         private IReadOnlyDbProvider? _readOnlyDbProvider;
+        private IReadOnlyDbProvider? _multiCallReadOnlyDbProvider;
 
         public IBlockchainBridge CreateBlockchainBridge()
         {
             ReadOnlyBlockTree readOnlyTree = BlockTree!.AsReadOnly();
             LazyInitializer.EnsureInitialized(ref _readOnlyDbProvider, () => new ReadOnlyDbProvider(DbProvider, false));
+            LazyInitializer.EnsureInitialized(ref _multiCallReadOnlyDbProvider, () => new ReadOnlyDbProvider(DbProvider, true));
 
             // TODO: reuse the same trie cache here
             ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new(
@@ -84,12 +86,18 @@ public IBlockchainBridge CreateBlockchainBridge()
                 readOnlyTree,
                 SpecProvider,
                 LogManager);
+            IMultiCallBlocksProcessingEnv multiCallReadOnlyBlocksProcessingEnv = MultiCallReadOnlyBlocksProcessingEnv.Create(
+                _multiCallReadOnlyDbProvider,
+                SpecProvider,
+                LogManager);
+
 
             IMiningConfig miningConfig = ConfigProvider.GetConfig<IMiningConfig>();
             IBlocksConfig blocksConfig = ConfigProvider.GetConfig<IBlocksConfig>();
 
             return new BlockchainBridge(
                 readOnlyTxProcessingEnv,
+                multiCallReadOnlyBlocksProcessingEnv,
                 TxPool,
                 ReceiptFinder,
                 FilterStore,

src/Nethermind/Nethermind.Blockchain/BlockTree.cs

@@ -684,6 +684,7 @@ public AddBlockResult Insert(Block block, BlockTreeInsertBlockOptions insertBloc
         private AddBlockResult Suggest(Block? block, BlockHeader header, BlockTreeSuggestOptions options = BlockTreeSuggestOptions.ShouldProcess)
         {
             bool shouldProcess = options.ContainsFlag(BlockTreeSuggestOptions.ShouldProcess);
+            bool noPatentCheck = options.ContainsFlag(BlockTreeSuggestOptions.ForceDontValidateParent);
             bool fillBeaconBlock = options.ContainsFlag(BlockTreeSuggestOptions.FillBeaconBlock);
             bool setAsMain = options.ContainsFlag(BlockTreeSuggestOptions.ForceSetAsMain) ||
                              !options.ContainsFlag(BlockTreeSuggestOptions.ForceDontSetAsMain) && !shouldProcess;
@@ -722,7 +723,7 @@ private AddBlockResult Suggest(Block? block, BlockHeader header, BlockTreeSugges
 
             bool parentExists = IsKnownBlock(header.Number - 1, header.ParentHash!) ||
                                 IsKnownBeaconBlock(header.Number - 1, header.ParentHash!);
-            if (!header.IsGenesis && !parentExists)
+            if (!header.IsGenesis && !noPatentCheck && !parentExists)
             {
                 if (_logger.IsTrace) _logger.Trace($"Could not find parent ({header.ParentHash}) of block {header.Hash}");
                 return AddBlockResult.UnknownParent;

src/Nethermind/Nethermind.Blockchain/BlockTreeMethodOptions.cs

@@ -69,6 +69,11 @@ public enum BlockTreeSuggestOptions
     /// Force not to set as main block
     /// </summary>
     ForceDontSetAsMain = 8,
+
+    /// <summary>
+    /// Force skip parent number is known checks
+    /// </summary>
+    ForceDontValidateParent = 8,
 }
 
 public static class BlockTreeSuggestOptionsExtensions

src/Nethermind/Nethermind.Cli/Modules/EthCliModule.cs

@@ -49,6 +49,19 @@ public JsValue GetProof(string address, string[] storageKeys, string? blockParam
             return NodeManager.Post<string>("eth_call", tx, blockParameter ?? "latest").Result;
         }
 
+        [CliFunction("eth", "multicall")]
+        public JsValue MultiCall(ulong version, object[] blockCalls, string? blockParameter = null, bool traceTransfers = true)
+        {
+            return NodeManager.PostJint("eth_multicall", version, blockCalls, blockParameter ?? "latest", traceTransfers).Result;
+        }
+
+        [CliFunction("eth", "multicallV1")]
+        public JsValue MultiCallV1(ulong version, object[] blockCalls, string? blockParameter = null, bool traceTransfers = true)
+        {
+            return NodeManager.PostJint("eth_multicallV1", 1, blockCalls, blockParameter ?? "latest", traceTransfers).Result;
+        }
+
+
         [CliFunction("eth", "getBlockByHash")]
         public JsValue GetBlockByHash(string hash, bool returnFullTransactionObjects)
         {

src/Nethermind/Nethermind.Consensus/Processing/BlockchainProcessor.cs

@@ -690,7 +690,7 @@ private ProcessingBranch PrepareProcessingBranch(Block suggestedBlock, Processin
         private bool RunSimpleChecksAheadOfProcessing(Block suggestedBlock, ProcessingOptions options)
         {
             /* a bit hacky way to get the invalid branch out of the processing loop */
-            if (suggestedBlock.Number != 0 &&
+            if (!options.ContainsFlag(ProcessingOptions.NoValidation) && suggestedBlock.Number != 0 &&
                 !_blockTree.IsKnownBlock(suggestedBlock.Number - 1, suggestedBlock.ParentHash))
             {
                 if (_logger.IsDebug)

src/Nethermind/Nethermind.Consensus/Processing/IMultiCallBlocksProcessingEnv.cs

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using Nethermind.Core.Crypto;
+using Nethermind.Core.Specs;
+using Nethermind.Db;
+using Nethermind.Evm;
+using Nethermind.Logging;
+
+namespace Nethermind.Consensus.Processing;
+
+public interface IMultiCallBlocksProcessingEnv : IReadOnlyTxProcessingEnvBase, IDisposable
+{
+    //Instance VM can be edited during processing
+    ISpecProvider SpecProvider { get; }
+    MultiCallVirtualMachine Machine { get; }
+
+    //We need abilety to get many instances that do not conflict in terms of editable tmp storage - thus we implement env cloning
+    IMultiCallBlocksProcessingEnv Clone();
+
+    //We keep original ProcessingEnv spirit with Build() that can start from any stateRoot
+    IBlockProcessor GetProcessor();
+}

src/Nethermind/Nethermind.Consensus/Processing/IReadOnlyTxProcessingEnv.cs

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Evm.TransactionProcessing;
+
+namespace Nethermind.Consensus.Processing;
+
+public interface IReadOnlyTxProcessingEnv : IReadOnlyTxProcessorSource, IReadOnlyTxProcessingEnvBase
+{
+    ITransactionProcessor TransactionProcessor { get; set; }
+}

src/Nethermind/Nethermind.Consensus/Processing/IReadOnlyTxProcessingEnvBase.cs

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Blockchain;
+using Nethermind.State;
+
+namespace Nethermind.Consensus.Processing;
+
+public interface IReadOnlyTxProcessingEnvBase
+{
+    IStateReader StateReader { get; }
+    IWorldState StateProvider { get; }
+    IBlockTree BlockTree { get; }
+}

src/Nethermind/Nethermind.Consensus/Processing/MultiCallChainProcessor.cs

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+using Nethermind.Db;
+using Nethermind.Evm.Tracing;
+
+namespace Nethermind.Consensus.Processing;
+
+public class MultiCallChainProcessor : OneTimeChainProcessor
+{
+    public MultiCallChainProcessor(IReadOnlyDbProvider readOnlyDbProvider, IBlockchainProcessor processor) : base(readOnlyDbProvider, processor)
+    {
+    }
+
+    public override Block? Process(Block block, ProcessingOptions options, IBlockTracer tracer)
+    {
+        lock (_lock)
+        {
+            Block result;
+            result = _processor.Process(block, options, tracer);
+            return result;
+        }
+    }
+
+    public override void Dispose()
+    {
+        _readOnlyDbProvider.ClearTempChanges();
+        base.Dispose();
+    }
+}

src/Nethermind/Nethermind.Consensus/Processing/MultiCallReadOnlyBlocksProcessingEnv.cs

@@ -0,0 +1,113 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using Nethermind.Blockchain;
+using Nethermind.Blockchain.Receipts;
+using Nethermind.Blockchain.Synchronization;
+using Nethermind.Consensus.Comparers;
+using Nethermind.Consensus.Rewards;
+using Nethermind.Consensus.Validators;
+using Nethermind.Core.Crypto;
+using Nethermind.Core.Specs;
+using Nethermind.Db;
+using Nethermind.Db.Blooms;
+using Nethermind.Evm;
+using Nethermind.Evm.TransactionProcessing;
+using Nethermind.Logging;
+using Nethermind.State;
+using Nethermind.State.Repositories;
+using Nethermind.Trie.Pruning;
+
+namespace Nethermind.Consensus.Processing;
+
+public class MultiCallReadOnlyBlocksProcessingEnv : ReadOnlyTxProcessingEnvBase, IMultiCallBlocksProcessingEnv
+{
+    private readonly ITrieStore? _trieStore;
+    private readonly ILogManager? _logManager;
+    private readonly IBlockValidator _blockValidator;
+    private readonly InMemoryReceiptStorage _receiptStorage;
+    public ITransactionProcessor TransactionProcessor { get; }
+    public ISpecProvider SpecProvider { get; }
+    public MultiCallVirtualMachine Machine { get; }
+
+    //We need ability to get many instances that do not conflict in terms of editable tmp storage - thus we implement env cloning
+    public static IMultiCallBlocksProcessingEnv Create(IReadOnlyDbProvider? readOnlyDbProvider,
+        ISpecProvider? specProvider,
+        ILogManager? logManager
+        )
+    {
+        ReadOnlyDbProvider? DbProvider = new(readOnlyDbProvider, true);
+        TrieStore trieStore = new(readOnlyDbProvider.StateDb, logManager);
+        BlockTree BlockTree = new(readOnlyDbProvider,
+            new ChainLevelInfoRepository(readOnlyDbProvider.BlockInfosDb),
+            specProvider,
+            NullBloomStorage.Instance,
+            new SyncConfig(),
+            logManager);
+
+        return new MultiCallReadOnlyBlocksProcessingEnv(
+            DbProvider,
+            trieStore,
+            BlockTree,
+            specProvider,
+            logManager);
+    }
+
+    public IMultiCallBlocksProcessingEnv Clone()
+    {
+        return Create(DbProvider, SpecProvider, _logManager);
+    }
+
+    private MultiCallReadOnlyBlocksProcessingEnv(
+        IReadOnlyDbProvider? readOnlyDbProvider,
+        ITrieStore? trieStore,
+        IBlockTree? blockTree,
+        ISpecProvider? specProvider,
+        ILogManager? logManager) : base(readOnlyDbProvider, trieStore, blockTree,
+        logManager)
+    {
+
+        _trieStore = trieStore;
+        _logManager = logManager;
+        SpecProvider = specProvider;
+
+
+        _receiptStorage = new InMemoryReceiptStorage();
+
+        Machine = new MultiCallVirtualMachine(BlockhashProvider, specProvider, logManager);
+
+        HeaderValidator headerValidator = new(
+            BlockTree,
+            Always.Valid,
+            SpecProvider,
+            _logManager);
+
+        _blockValidator = new MultiCallBlockValidator(new TxValidator(SpecProvider.ChainId),
+            headerValidator,
+            Always.Valid,
+            SpecProvider,
+            _logManager);
+
+    }
+
+    public IBlockProcessor GetProcessor()
+    {
+        var yransactionProcessor = new TransactionProcessor(SpecProvider, StateProvider, Machine, _logManager);
+
+        return new BlockProcessor(SpecProvider,
+            _blockValidator,
+            NoBlockRewards.Instance,
+            new BlockProcessor.BlockValidationTransactionsExecutor(yransactionProcessor, StateProvider),
+            StateProvider,
+            _receiptStorage,
+            NullWitnessCollector.Instance,
+            _logManager);
+    }
+
+    public void Dispose()
+    {
+        _trieStore?.Dispose();
+        DbProvider.Dispose();
+    }
+}

src/Nethermind/Nethermind.Consensus/Processing/OneTimeProcessor.cs

@@ -14,10 +14,10 @@ public class OneTimeChainProcessor : IBlockchainProcessor
     {
         public ITracerBag Tracers => _processor.Tracers;
 
-        private readonly IBlockchainProcessor _processor;
-        private readonly IReadOnlyDbProvider _readOnlyDbProvider;
+        protected readonly IBlockchainProcessor _processor;
+        protected readonly IReadOnlyDbProvider _readOnlyDbProvider;
 
-        private object _lock = new();
+        protected object _lock = new();
 
         public OneTimeChainProcessor(IReadOnlyDbProvider readOnlyDbProvider, IBlockchainProcessor processor)
         {
@@ -35,7 +35,7 @@ public Task StopAsync(bool processRemainingBlocks = false)
             return _processor.StopAsync(processRemainingBlocks);
         }
 
-        public Block? Process(Block block, ProcessingOptions options, IBlockTracer tracer)
+        public virtual Block? Process(Block block, ProcessingOptions options, IBlockTracer tracer)
         {
             lock (_lock)
             {
@@ -64,7 +64,7 @@ public bool IsProcessingBlocks(ulong? maxProcessingInterval)
         public event EventHandler<IBlockchainProcessor.InvalidBlockEventArgs>? InvalidBlock;
 #pragma warning restore 67
 
-        public void Dispose()
+        public virtual void Dispose()
         {
             _processor?.Dispose();
             _readOnlyDbProvider?.Dispose();