Support for state override parameter in some RPC methods

src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs

@@ -13,13 +13,10 @@
 using Nethermind.Core.Attributes;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Test.Blockchain;
-using Nethermind.Specs;
 using Nethermind.Core.Test.Builders;
-using Nethermind.Db;
 using Nethermind.Evm.Tracing;
 using Nethermind.Logging;
-using Nethermind.State.Repositories;
-using Nethermind.Db.Blooms;
+using Nethermind.Evm;
 using Nethermind.State;
 using Nethermind.Trie;
 using NSubstitute;
@@ -73,7 +70,8 @@ public void AllowToFail(Hash256 hash)
                     _allowedToFail.Add(hash);
                 }
 
-                public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions processingOptions, IBlockTracer blockTracer)
+                public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions processingOptions,
+                    IBlockTracer blockTracer, Dictionary<Address, AccountOverride>? stateOverride)
                 {
                     if (blockTracer != NullBlockTracer.Instance)
                     {

src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
 using Nethermind.Blockchain;
 using Nethermind.Blockchain.Blocks;
 using Nethermind.Blockchain.Find;
@@ -74,12 +75,13 @@ public AuRaBlockProcessor(
 
         public IAuRaValidator AuRaValidator { get; }
 
-        protected override TxReceipt[] ProcessBlock(Block block, IBlockTracer blockTracer, ProcessingOptions options)
+        protected override TxReceipt[] ProcessBlock(Block block, IBlockTracer blockTracer, ProcessingOptions options,
+            Dictionary<Address, AccountOverride>? stateOverride = null)
         {
             ValidateAuRa(block);
             _contractRewriter?.RewriteContracts(block.Number, _stateProvider, _specProvider.GetSpec(block.Header));
             AuRaValidator.OnBlockProcessingStart(block, options);
-            TxReceipt[] receipts = base.ProcessBlock(block, blockTracer, options);
+            TxReceipt[] receipts = base.ProcessBlock(block, blockTracer, options, stateOverride);
             AuRaValidator.OnBlockProcessingEnd(block, receipts, options);
             Metrics.AuRaStep = block.Header?.AuRaStep ?? 0;
             return receipts;

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

@@ -70,7 +70,7 @@ event EventHandler<AddingTxEventArgs>? IBlockProductionTransactionsExecutor.Addi
             }
 
             public virtual TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions,
-                BlockReceiptsTracer receiptsTracer, IReleaseSpec spec)
+                BlockReceiptsTracer receiptsTracer, IReleaseSpec spec, Dictionary<Address, AccountOverride>? stateOverride = null)
             {
                 IEnumerable<Transaction> transactions = GetTransactions(block);
 
@@ -79,8 +79,9 @@ public virtual TxReceipt[] ProcessTransactions(Block block, ProcessingOptions pr
                 BlockExecutionContext blkCtx = new(block.Header);
                 foreach (Transaction currentTx in transactions)
                 {
-                    TxAction action = ProcessTransaction(block, in blkCtx, currentTx, i++, receiptsTracer, processingOptions, transactionsInBlock);
+                    TxAction action = ProcessTransaction(block, in blkCtx, currentTx, i++, receiptsTracer, processingOptions, transactionsInBlock, stateOverride);
                     if (action == TxAction.Stop) break;
+                    stateOverride = null; // Apply override only before the first transaction
                 }
 
                 _stateProvider.Commit(spec, receiptsTracer);
@@ -97,6 +98,7 @@ protected TxAction ProcessTransaction(
                 BlockReceiptsTracer receiptsTracer,
                 ProcessingOptions processingOptions,
                 LinkedHashSet<Transaction> transactionsInBlock,
+                Dictionary<Address, AccountOverride>? stateOverride = null,
                 bool addToBlock = true)
             {
                 AddingTxEventArgs args =
@@ -109,7 +111,7 @@ protected TxAction ProcessTransaction(
                 }
                 else
                 {
-                    TransactionResult result = _transactionProcessor.ProcessTransaction(in blkCtx, currentTx, receiptsTracer, processingOptions, _stateProvider);
+                    TransactionResult result = _transactionProcessor.ProcessTransaction(in blkCtx, currentTx, receiptsTracer, processingOptions, _stateProvider, stateOverride);
 
                     if (result)
                     {

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -30,24 +31,27 @@ public BlockValidationTransactionsExecutor(ITransactionProcessor transactionProc
 
             public event EventHandler<TxProcessedEventArgs>? TransactionProcessed;
 
-            public TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockReceiptsTracer receiptsTracer, IReleaseSpec spec)
+            public TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockReceiptsTracer receiptsTracer,
+                IReleaseSpec spec, Dictionary<Address, AccountOverride>? stateOverride = null)
             {
                 Metrics.ResetBlockStats();
                 BlockExecutionContext blkCtx = CreateBlockExecutionContext(block);
                 for (int i = 0; i < block.Transactions.Length; i++)
                 {
                     block.TransactionProcessed = i;
                     Transaction currentTx = block.Transactions[i];
-                    ProcessTransaction(in blkCtx, currentTx, i, receiptsTracer, processingOptions);
+                    ProcessTransaction(in blkCtx, currentTx, i, receiptsTracer, processingOptions, stateOverride);
+                    stateOverride = null; // Apply override only before the first transaction
                 }
                 return receiptsTracer.TxReceipts.ToArray();
             }
 
             protected virtual BlockExecutionContext CreateBlockExecutionContext(Block block) => new(block.Header);
 
-            protected virtual void ProcessTransaction(in BlockExecutionContext blkCtx, Transaction currentTx, int index, BlockReceiptsTracer receiptsTracer, ProcessingOptions processingOptions)
+            protected virtual void ProcessTransaction(in BlockExecutionContext blkCtx, Transaction currentTx, int index, BlockReceiptsTracer receiptsTracer,
+                ProcessingOptions processingOptions, Dictionary<Address, AccountOverride>? stateOverride = null)
             {
-                TransactionResult result = transactionProcessor.ProcessTransaction(in blkCtx, currentTx, receiptsTracer, processingOptions, stateProvider);
+                TransactionResult result = transactionProcessor.ProcessTransaction(in blkCtx, currentTx, receiptsTracer, processingOptions, stateProvider, stateOverride);
                 if (!result) ThrowInvalidBlockException(result, blkCtx.Header, currentTx, index);
                 TransactionProcessed?.Invoke(this, new TxProcessedEventArgs(index, currentTx, receiptsTracer.TxReceipts[index]));
             }

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

@@ -89,7 +89,8 @@ public event EventHandler<TxProcessedEventArgs> TransactionProcessed
     }
 
     // TODO: move to branch processor
-    public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions options, IBlockTracer blockTracer)
+    public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions options, IBlockTracer blockTracer,
+        Dictionary<Address, AccountOverride>? stateOverride = null)
     {
         if (suggestedBlocks.Count == 0) return Array.Empty<Block>();
 
@@ -121,7 +122,7 @@ the previous head state.*/
                 Task? preWarmTask = suggestedBlock.Transactions.Length < 3
                     ? null
                     : _preWarmer?.PreWarmCaches(suggestedBlock, preBlockStateRoot!, cancellationTokenSource.Token);
-                (Block processedBlock, TxReceipt[] receipts) = ProcessOne(suggestedBlock, options, blockTracer);
+                (Block processedBlock, TxReceipt[] receipts) = ProcessOne(suggestedBlock, options, blockTracer, stateOverride);
                 // Block is processed, we can cancel the prewarm task
                 cancellationTokenSource.Cancel();
                 processedBlocks[i] = processedBlock;
@@ -214,13 +215,14 @@ private void RestoreBranch(Hash256 branchingPointStateRoot)
     }
 
     // TODO: block processor pipeline
-    private (Block Block, TxReceipt[] Receipts) ProcessOne(Block suggestedBlock, ProcessingOptions options, IBlockTracer blockTracer)
+    private (Block Block, TxReceipt[] Receipts) ProcessOne(Block suggestedBlock, ProcessingOptions options, IBlockTracer blockTracer,
+        Dictionary<Address, AccountOverride>? stateOverride)
     {
         if (_logger.IsTrace) _logger.Trace($"Processing block {suggestedBlock.ToString(Block.Format.Short)} ({options})");
 
         ApplyDaoTransition(suggestedBlock);
         Block block = PrepareBlockForProcessing(suggestedBlock);
-        TxReceipt[] receipts = ProcessBlock(block, blockTracer, options);
+        TxReceipt[] receipts = ProcessBlock(block, blockTracer, options, stateOverride);
         ValidateProcessedBlock(suggestedBlock, options, block, receipts);
         if (options.ContainsFlag(ProcessingOptions.StoreReceipts))
         {
@@ -251,7 +253,9 @@ private bool ShouldComputeStateRoot(BlockHeader header) =>
     protected virtual TxReceipt[] ProcessBlock(
         Block block,
         IBlockTracer blockTracer,
-        ProcessingOptions options)
+        ProcessingOptions options,
+        Dictionary<Address, AccountOverride>? stateOverride = null
+    )
     {
         IReleaseSpec spec = _specProvider.GetSpec(block.Header);
 
@@ -263,7 +267,7 @@ protected virtual TxReceipt[] ProcessBlock(
 
         _stateProvider.Commit(spec, commitStorageRoots: false);
 
-        TxReceipt[] receipts = _blockTransactionsExecutor.ProcessTransactions(block, options, ReceiptsTracer, spec);
+        TxReceipt[] receipts = _blockTransactionsExecutor.ProcessTransactions(block, options, ReceiptsTracer, spec, stateOverride);
 
         if (spec.IsEip4844Enabled)
         {

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

@@ -10,11 +10,11 @@
 using System.Threading.Tasks;
 using Nethermind.Blockchain;
 using Nethermind.Blockchain.Find;
-using Nethermind.Config;
 using Nethermind.Core;
 using Nethermind.Core.Attributes;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Extensions;
+using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 using Nethermind.Evm.Tracing.GethStyle;
 using Nethermind.Evm.Tracing.ParityStyle;
@@ -313,7 +313,7 @@ private void RunProcessingLoop()
 
                 if (_logger.IsTrace) _logger.Trace($"Processing block {block.ToString(Block.Format.Short)}).");
                 _stats.Start();
-                Block processedBlock = Process(block, blockRef.ProcessingOptions, _compositeBlockTracer.GetTracer(), out string? error);
+                Block processedBlock = Process(block, blockRef.ProcessingOptions, _compositeBlockTracer.GetTracer(), null, out string? error);
 
                 if (processedBlock is null)
                 {
@@ -356,11 +356,12 @@ private void FireProcessingQueueEmpty()
 
     int IBlockProcessingQueue.Count => _queueCount;
 
-    public Block? Process(Block suggestedBlock, ProcessingOptions options, IBlockTracer tracer)
+    public Block? Process(Block suggestedBlock, ProcessingOptions options, IBlockTracer tracer, Dictionary<Address, AccountOverride>? stateOverride = null)
     {
-        return Process(suggestedBlock, options, tracer, out _);
+        return Process(suggestedBlock, options, tracer, stateOverride, out _);
     }
-    public Block? Process(Block suggestedBlock, ProcessingOptions options, IBlockTracer tracer, out string? error)
+
+    public Block? Process(Block suggestedBlock, ProcessingOptions options, IBlockTracer tracer, Dictionary<Address, AccountOverride>? stateOverride, out string? error)
     {
         error = null;
         if (!RunSimpleChecksAheadOfProcessing(suggestedBlock, options))
@@ -388,7 +389,7 @@ private void FireProcessingQueueEmpty()
         PrepareBlocksToProcess(suggestedBlock, options, processingBranch);
 
         _stopwatch.Restart();
-        Block[]? processedBlocks = ProcessBranch(processingBranch, options, tracer, out error);
+        Block[]? processedBlocks = ProcessBranch(processingBranch, options, tracer, stateOverride, out error);
         if (processedBlocks is null)
         {
             return null;
@@ -475,7 +476,7 @@ private void TraceFailingBranch(in ProcessingBranch processingBranch, Processing
         }
     }
 
-    private Block[]? ProcessBranch(in ProcessingBranch processingBranch, ProcessingOptions options, IBlockTracer tracer, out string? error)
+    private Block[]? ProcessBranch(in ProcessingBranch processingBranch, ProcessingOptions options, IBlockTracer tracer, Dictionary<Address, AccountOverride>? stateOverride, out string? error)
     {
         void DeleteInvalidBlocks(in ProcessingBranch processingBranch, Hash256 invalidBlockHash)
         {
@@ -499,7 +500,8 @@ void DeleteInvalidBlocks(in ProcessingBranch processingBranch, Hash256 invalidBl
                 processingBranch.Root,
                 processingBranch.BlocksToProcess,
                 options,
-                tracer);
+                tracer,
+                stateOverride);
             error = null;
         }
         catch (InvalidBlockException ex)

src/Nethermind/Nethermind.Consensus/Processing/IBlockProcessor.cs

@@ -6,6 +6,7 @@
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Specs;
+using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 
 namespace Nethermind.Consensus.Processing
@@ -19,12 +20,13 @@ public interface IBlockProcessor
         /// <param name="suggestedBlocks">List of blocks to be processed.</param>
         /// <param name="processingOptions">Options to use for processor and transaction processor.</param>
         /// <param name="blockTracer">Block tracer to use. By default either <see cref="NullBlockTracer"/> or <see cref="BlockReceiptsTracer"/></param>
+        /// <param name="stateOverride">Optional state overrides by address.</param>
         /// <returns>List of processed blocks.</returns>
-        Block[] Process(
-            Hash256 newBranchStateRoot,
+        Block[] Process(Hash256 newBranchStateRoot,
             List<Block> suggestedBlocks,
             ProcessingOptions processingOptions,
-            IBlockTracer blockTracer);
+            IBlockTracer blockTracer,
+            Dictionary<Address, AccountOverride>? stateOverride = null);
 
         /// <summary>
         /// Fired when a branch is being processed.
@@ -43,7 +45,9 @@ Block[] Process(
 
         public interface IBlockTransactionsExecutor
         {
-            TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockReceiptsTracer receiptsTracer, IReleaseSpec spec);
+            TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockReceiptsTracer receiptsTracer, IReleaseSpec spec,
+                Dictionary<Address, AccountOverride>? stateOverride = null);
+
             event EventHandler<TxProcessedEventArgs> TransactionProcessed;
         }
     }

src/Nethermind/Nethermind.Consensus/Processing/IBlockchainProcessor.cs

@@ -2,8 +2,10 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Nethermind.Core;
+using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 
 namespace Nethermind.Consensus.Processing
@@ -16,7 +18,7 @@ public interface IBlockchainProcessor : IDisposable
 
         Task StopAsync(bool processRemainingBlocks = false);
 
-        Block? Process(Block block, ProcessingOptions options, IBlockTracer tracer);
+        Block? Process(Block block, ProcessingOptions options, IBlockTracer tracer, Dictionary<Address, AccountOverride>? stateOverride = null);
 
         bool IsProcessingBlocks(ulong? maxProcessingInterval);
 

src/Nethermind/Nethermind.Consensus/Processing/NullBlockProcessor.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 
 namespace Nethermind.Consensus.Processing
@@ -15,7 +16,8 @@ private NullBlockProcessor() { }
 
         public static IBlockProcessor Instance { get; } = new NullBlockProcessor();
 
-        public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions processingOptions, IBlockTracer blockTracer)
+        public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions processingOptions, IBlockTracer blockTracer,
+            Dictionary<Address, AccountOverride>? stateOverride)
         {
             return suggestedBlocks.ToArray();
         }

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

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Nethermind.Core;
-using Nethermind.Db;
+using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 using Nethermind.State;
 
@@ -35,11 +36,11 @@ public Task StopAsync(bool processRemainingBlocks = false)
             return _processor.StopAsync(processRemainingBlocks);
         }
 
-        public Block? Process(Block block, ProcessingOptions options, IBlockTracer tracer)
+        public Block? Process(Block block, ProcessingOptions options, IBlockTracer tracer, Dictionary<Address, AccountOverride> stateOverride)
         {
             lock (_lock)
             {
-                return _processor.Process(block, options, tracer);
+                return _processor.Process(block, options, tracer, stateOverride);
             }
         }
 

src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs

@@ -29,7 +29,7 @@ protected ITransactionProcessor TransactionProcessor
 
         public IVirtualMachine Machine { get; }
 
-        public ICodeInfoRepository CodeInfoRepository { get; }
+        public OverridableCodeInfoRepository CodeInfoRepository { get; }
         public ReadOnlyTxProcessingEnv(
             IWorldStateManager worldStateManager,
             IBlockTree blockTree,
@@ -48,7 +48,7 @@ public ReadOnlyTxProcessingEnv(
             IWorldState? worldStateToWarmUp = null
             ) : base(worldStateManager, readOnlyBlockTree, specProvider, logManager, worldStateToWarmUp)
         {
-            CodeInfoRepository = new CodeInfoRepository((worldStateToWarmUp as IPreBlockCaches)?.Caches.PrecompileCache);
+            CodeInfoRepository = new(new CodeInfoRepository((worldStateToWarmUp as IPreBlockCaches)?.Caches.PrecompileCache));
             Machine = new VirtualMachine(BlockhashProvider, specProvider, CodeInfoRepository, logManager);
             BlockTree = readOnlyBlockTree ?? throw new ArgumentNullException(nameof(readOnlyBlockTree));
             BlockhashProvider = new BlockhashProvider(BlockTree, specProvider, StateProvider, logManager);

src/Nethermind/Nethermind.Consensus/Processing/TransactionProcessorAdapterExtensions.cs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System.Collections.Generic;
 using Nethermind.Core;
 using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
@@ -16,15 +17,16 @@ public static TransactionResult ProcessTransaction(this ITransactionProcessorAda
         Transaction currentTx,
         BlockReceiptsTracer receiptsTracer,
         ProcessingOptions processingOptions,
-        IWorldState stateProvider)
+        IWorldState stateProvider,
+        Dictionary<Address, AccountOverride>? stateOverride)
     {
         if (processingOptions.ContainsFlag(ProcessingOptions.DoNotVerifyNonce))
         {
             currentTx.Nonce = stateProvider.GetNonce(currentTx.SenderAddress!);
         }
 
         using ITxTracer tracer = receiptsTracer.StartNewTxTrace(currentTx);
-        TransactionResult result = transactionProcessor.Execute(currentTx, in blkCtx, receiptsTracer);
+        TransactionResult result = transactionProcessor.Execute(currentTx, in blkCtx, receiptsTracer, stateOverride);
         receiptsTracer.EndTxTrace();
         return result;
     }