Verkle/testnets

src/Nethermind/Directory.Packages.props

@@ -47,6 +47,7 @@
     <PackageVersion Include="Nethermind.DotNetty.Transport" Version="1.0.1" />
     <PackageVersion Include="Nethermind.Gmp" Version="1.0.1" />
     <PackageVersion Include="Nethermind.Numerics.Int256" Version="1.1.0" />
+    <PackageVersion Include="Nethermind.Verkle" Version="0.1.3-alpha" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageVersion Include="Nito.Collections.Deque" Version="1.1.1" />
     <PackageVersion Include="NLog" Version="5.2.2" />
@@ -82,4 +83,4 @@
     <PackageVersion Include="Websocket.Client" Version="4.6.1" />
     <PackageVersion Include="YamlDotNet" Version="13.1.1" />
   </ItemGroup>
-</Project>
+</Project>

src/Nethermind/Nethermind.AccountAbstraction/Executor/AABlockProducerTransactionsExecutor.cs

@@ -43,7 +43,7 @@ public AABlockProducerTransactionsExecutor(
         public override TxReceipt[] ProcessTransactions(
             Block block,
             ProcessingOptions processingOptions,
-            BlockReceiptsTracer receiptsTracer,
+            BlockExecutionTracer receiptsTracer,
             IReleaseSpec spec)
         {
             IEnumerable<Transaction> transactions = GetTransactions(block);
@@ -81,7 +81,7 @@ private BlockProcessor.TxAction ProcessAccountAbstractionTransaction(
             Block block,
             Transaction currentTx,
             int index,
-            BlockReceiptsTracer receiptsTracer,
+            BlockExecutionTracer receiptsTracer,
             ProcessingOptions processingOptions,
             LinkedHashSet<Transaction> transactionsInBlock)
         {

src/Nethermind/Nethermind.Api/IApiWithBlockchain.cs

@@ -22,6 +22,7 @@
 using Nethermind.State;
 using Nethermind.Trie.Pruning;
 using Nethermind.TxPool;
+using Nethermind.Verkle.Tree;
 
 namespace Nethermind.Api
 {
@@ -43,6 +44,8 @@ public interface IApiWithBlockchain : IApiWithStores, IBlockchainBridgeFactory
         IUnclesValidator? UnclesValidator { get; set; }
         IHeaderValidator? HeaderValidator { get; set; }
         IManualBlockProductionTrigger ManualBlockProductionTrigger { get; }
+        VerkleStateStore? VerkleTrieStore { get; set; }
+        ReadOnlyVerkleStateStore? ReadOnlyVerkleTrieStore { get; set; }
         IReadOnlyTrieStore? ReadOnlyTrieStore { get; set; }
         IRewardCalculatorSource? RewardCalculatorSource { get; set; }
         /// <summary>

src/Nethermind/Nethermind.Api/NethermindApi.cs

@@ -55,6 +55,8 @@
 using Nethermind.Sockets;
 using Nethermind.Synchronization.SnapSync;
 using Nethermind.Synchronization.Blocks;
+using Nethermind.Verkle;
+using Nethermind.Verkle.Tree;
 
 namespace Nethermind.Api
 {
@@ -77,13 +79,15 @@ public IBlockchainBridge CreateBlockchainBridge()
             ReadOnlyBlockTree readOnlyTree = BlockTree!.AsReadOnly();
             LazyInitializer.EnsureInitialized(ref _readOnlyDbProvider, () => new ReadOnlyDbProvider(DbProvider, false));
 
-            // TODO: reuse the same trie cache here
-            ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new(
-                _readOnlyDbProvider,
-                ReadOnlyTrieStore,
-                readOnlyTree,
-                SpecProvider,
-                LogManager);
+            ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = SpecProvider!.GenesisSpec.IsVerkleTreeEipEnabled switch
+            {
+                true =>
+                    // TODO: reuse the same trie cache here
+                    new ReadOnlyTxProcessingEnv(_readOnlyDbProvider, ReadOnlyVerkleTrieStore, readOnlyTree, SpecProvider, LogManager),
+                false =>
+                    // TODO: reuse the same trie cache here
+                    new ReadOnlyTxProcessingEnv(_readOnlyDbProvider, ReadOnlyTrieStore, readOnlyTree, SpecProvider, LogManager)
+            };
 
             IMiningConfig miningConfig = ConfigProvider.GetConfig<IMiningConfig>();
             IBlocksConfig blocksConfig = ConfigProvider.GetConfig<IBlocksConfig>();
@@ -134,6 +138,9 @@ public IBlockchainBridge CreateBlockchainBridge()
         public IManualBlockProductionTrigger ManualBlockProductionTrigger { get; set; } =
             new BuildBlocksWhenRequested();
 
+        public VerkleStateStore? VerkleTrieStore { get; set; }
+        public ReadOnlyVerkleStateStore? ReadOnlyVerkleTrieStore { get; set; }
+
         public IIPResolver? IpResolver { get; set; }
         public IJsonSerializer EthereumJsonSerializer { get; set; }
         public IKeyStore? KeyStore { get; set; }

src/Nethermind/Nethermind.Blockchain/BlockTreeMethodOptions.cs

@@ -69,6 +69,11 @@ public enum BlockTreeSuggestOptions
     /// Force not to set as main block
     /// </summary>
     ForceDontSetAsMain = 8,
+
+    /// <summary>
+    /// If block should be processed without global state
+    /// </summary>
+    ShouldProcessStateless = 16,
 }
 
 public static class BlockTreeSuggestOptionsExtensions

src/Nethermind/Nethermind.Blockchain/TrieStoreBoundaryWatcher.cs

@@ -13,11 +13,11 @@ namespace Nethermind.Blockchain
     /// </summary>
     public class TrieStoreBoundaryWatcher : IDisposable
     {
-        private readonly ITrieStore _trieStore;
+        private readonly IStoreWithReorgBoundary _trieStore;
         private readonly IBlockTree _blockTree;
         private readonly ILogger _logger;
 
-        public TrieStoreBoundaryWatcher(ITrieStore trieStore, IBlockTree blockTree, ILogManager logManager)
+        public TrieStoreBoundaryWatcher(IStoreWithReorgBoundary trieStore, IBlockTree blockTree, ILogManager logManager)
         {
             _trieStore = trieStore;
             _blockTree = blockTree;

src/Nethermind/Nethermind.Config/BlocksConfig.cs

@@ -21,6 +21,7 @@ public class BlocksConfig : IBlocksConfig
         public bool RandomizedBlocks { get; set; }
 
         public ulong SecondsPerSlot { get; set; } = 12;
+        public bool StatelessProcessing { get; set; } = false;
 
 
         public string ExtraData

src/Nethermind/Nethermind.Config/IBlocksConfig.cs

@@ -35,6 +35,9 @@ public interface IBlocksConfig : IConfig
         [ConfigItem(Description = "Seconds per slot.", DefaultValue = "12")]
         ulong SecondsPerSlot { get; set; }
 
+        [ConfigItem(Description = "Should process block stateless if possible.", DefaultValue = "false")]
+        bool StatelessProcessing { get; set; }
+
         byte[] GetExtraDataBytes();
     }
 }

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

@@ -25,7 +25,6 @@ namespace Nethermind.Consensus.AuRa
 {
     public class AuRaBlockProcessor : BlockProcessor
     {
-        private readonly ISpecProvider _specProvider;
         private readonly IBlockTree _blockTree;
         private readonly AuRaContractGasLimitOverride? _gasLimitOverride;
         private readonly ContractRewriter? _contractRewriter;
@@ -57,7 +56,6 @@ public AuRaBlockProcessor(
                 logManager,
                 withdrawalProcessor)
         {
-            _specProvider = specProvider;
             _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
             _logger = logManager?.GetClassLogger<AuRaBlockProcessor>() ?? throw new ArgumentNullException(nameof(logManager));
             _txFilter = txFilter ?? NullTxFilter.Instance;

src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs

@@ -66,12 +66,9 @@ public Task<IBlockProducer> InitBlockProducer(IBlockProductionTrigger? blockProd
             if (logger.IsInfo) logger.Info("Starting Neth Dev block producer & sealer");
 
 
-            ReadOnlyTxProcessingEnv producerEnv = new(
-                readOnlyDbProvider,
-                getFromApi.ReadOnlyTrieStore,
-                readOnlyBlockTree,
-                getFromApi.SpecProvider,
-                getFromApi.LogManager);
+            ReadOnlyTxProcessingEnv producerEnv = _nethermindApi.SpecProvider!.GenesisSpec.IsVerkleTreeEipEnabled
+                ? new ReadOnlyTxProcessingEnv(readOnlyDbProvider, getFromApi.ReadOnlyVerkleTrieStore, readOnlyBlockTree, getFromApi.SpecProvider, getFromApi.LogManager)
+                : new ReadOnlyTxProcessingEnv(readOnlyDbProvider, getFromApi.ReadOnlyTrieStore, readOnlyBlockTree, getFromApi.SpecProvider, getFromApi.LogManager);
 
             BlockProcessor producerProcessor = new(
                 getFromApi!.SpecProvider,

src/Nethermind/Nethermind.Consensus/Processing/BlockExtensions.cs

@@ -12,8 +12,8 @@ internal static class BlockExtensions
     {
         public static Block CreateCopy(this Block block, BlockHeader header) =>
             block is BlockToProduce blockToProduce
-                ? new BlockToProduce(header, blockToProduce.Transactions, blockToProduce.Uncles, blockToProduce.Withdrawals)
-                : new Block(header, block.Transactions, block.Uncles, block.Withdrawals);
+                ? new BlockToProduce(header, blockToProduce.Transactions, blockToProduce.Uncles, blockToProduce.Withdrawals, blockToProduce.ExecutionWitness)
+                : new Block(header, block.Transactions, block.Uncles, block.Withdrawals, block.ExecutionWitness);
 
         public static IEnumerable<Transaction> GetTransactions(this Block block) =>
             block is BlockToProduce blockToProduce

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

@@ -23,6 +23,7 @@ public class BlockProductionTransactionsExecutor : IBlockProductionTransactionsE
             private readonly IWorldState _stateProvider;
             private readonly BlockProductionTransactionPicker _blockProductionTransactionPicker;
             private readonly ILogger _logger;
+            private readonly ILogManager _logManager;
 
             public BlockProductionTransactionsExecutor(
                 ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv,
@@ -46,6 +47,20 @@ public BlockProductionTransactionsExecutor(
                 _stateProvider = stateProvider;
                 _blockProductionTransactionPicker = new BlockProductionTransactionPicker(specProvider);
                 _logger = logManager.GetClassLogger();
+                _logManager = logManager;
+            }
+
+            private BlockProductionTransactionsExecutor(
+                ITransactionProcessorAdapter transactionProcessor,
+                IWorldState stateProvider,
+                BlockProductionTransactionPicker blockProductionTransactionPicker,
+                ILogManager logManager)
+            {
+                _transactionProcessor = transactionProcessor;
+                _stateProvider = stateProvider;
+                _blockProductionTransactionPicker = blockProductionTransactionPicker;
+                _logger = logManager.GetClassLogger();
+                _logManager = logManager;
             }
 
             protected EventHandler<TxProcessedEventArgs>? _transactionProcessed;
@@ -55,13 +70,19 @@ event EventHandler<TxProcessedEventArgs>? IBlockProcessor.IBlockTransactionsExec
                 remove => _transactionProcessed -= value;
             }
 
+            public IBlockProcessor.IBlockTransactionsExecutor WithNewStateProvider(IWorldState worldState)
+            {
+                return new BlockProductionTransactionsExecutor(_transactionProcessor, worldState,
+                    _blockProductionTransactionPicker, _logManager);
+            }
+
             event EventHandler<AddingTxEventArgs>? IBlockProductionTransactionsExecutor.AddingTransaction
             {
                 add => _blockProductionTransactionPicker.AddingTransaction += value;
                 remove => _blockProductionTransactionPicker.AddingTransaction -= value;
             }
 
-            public virtual TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockReceiptsTracer receiptsTracer, IReleaseSpec spec)
+            public virtual TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockExecutionTracer receiptsTracer, IReleaseSpec spec)
             {
                 IEnumerable<Transaction> transactions = GetTransactions(block);
 
@@ -83,7 +104,7 @@ protected TxAction ProcessTransaction(
                 Block block,
                 Transaction currentTx,
                 int index,
-                BlockReceiptsTracer receiptsTracer,
+                BlockExecutionTracer receiptsTracer,
                 ProcessingOptions processingOptions,
                 LinkedHashSet<Transaction> transactionsInBlock,
                 bool addToBlock = true)

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

@@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Linq;
+using Nethermind.Core;
+using Nethermind.Core.Specs;
+using Nethermind.Crypto;
+using Nethermind.Evm.Tracing;
+using Nethermind.Evm.TransactionProcessing;
+using Nethermind.Logging;
+using Nethermind.State;
+
+namespace Nethermind.Consensus.Processing;
+
+public partial class BlockProcessor
+{
+    public class BlockStatelessValidationTransactionsExecutor : IBlockProcessor.IBlockTransactionsExecutor
+    {
+        private ITransactionProcessorAdapter _transactionProcessor;
+        private IWorldState? _stateProvider;
+
+        public BlockStatelessValidationTransactionsExecutor(ITransactionProcessor transactionProcessor)
+            : this(new ExecuteTransactionProcessorAdapter(transactionProcessor))
+        {
+        }
+
+        public BlockStatelessValidationTransactionsExecutor(ITransactionProcessorAdapter transactionProcessor)
+        {
+            _transactionProcessor = transactionProcessor;
+            _stateProvider = null;
+        }
+
+        public BlockStatelessValidationTransactionsExecutor(ITransactionProcessor transactionProcessor, IWorldState worldState)
+            : this(new ExecuteTransactionProcessorAdapter(transactionProcessor), worldState)
+        {
+        }
+
+        public BlockStatelessValidationTransactionsExecutor(ITransactionProcessorAdapter transactionProcessor, IWorldState worldState)
+        {
+            _transactionProcessor = transactionProcessor;
+            _stateProvider = worldState;
+        }
+
+        public event EventHandler<TxProcessedEventArgs>? TransactionProcessed;
+
+        public IBlockProcessor.IBlockTransactionsExecutor WithNewStateProvider(IWorldState worldState)
+        {
+            _transactionProcessor = _transactionProcessor.WithNewStateProvider(worldState);
+            return new BlockStatelessValidationTransactionsExecutor(_transactionProcessor, worldState);
+        }
+
+        public TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockExecutionTracer receiptsTracer, IReleaseSpec spec)
+        {
+            // var ecdsa = new EthereumEcdsa(69420, LimboLogs.Instance);
+            if (!block.IsGenesis)
+            {
+
+                for (int i = 0; i < block.Transactions.Length; i++)
+                {
+                    Transaction currentTx = block.Transactions[i];
+                    // currentTx.SenderAddress = ecdsa.RecoverAddress(currentTx);
+                    ProcessTransaction(block, currentTx, i, receiptsTracer, _stateProvider, processingOptions);
+                }
+                _stateProvider.Commit(spec);
+                _stateProvider.RecalculateStateRoot();
+            }
+            return receiptsTracer.TxReceipts.ToArray();
+        }
+
+        private void ProcessTransaction(Block block, Transaction currentTx, int index, BlockExecutionTracer receiptsTracer, IWorldState worldState, ProcessingOptions processingOptions)
+        {
+            _transactionProcessor.ProcessTransaction(block, currentTx, receiptsTracer, processingOptions, worldState);
+            TransactionProcessed?.Invoke(this, new TxProcessedEventArgs(index, currentTx, receiptsTracer.TxReceipts[index]));
+        }
+    }
+}

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

@@ -30,10 +30,13 @@ public BlockValidationTransactionsExecutor(ITransactionProcessorAdapter transact
             }
 
             public event EventHandler<TxProcessedEventArgs>? TransactionProcessed;
+            public IBlockProcessor.IBlockTransactionsExecutor WithNewStateProvider(IWorldState worldState)
+            {
+                return new BlockValidationTransactionsExecutor(_transactionProcessor, worldState);
+            }
 
-            public TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockReceiptsTracer receiptsTracer, IReleaseSpec spec)
+            public TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, BlockExecutionTracer receiptsTracer, IReleaseSpec spec)
             {
-                Evm.Metrics.ResetBlockStats();
                 for (int i = 0; i < block.Transactions.Length; i++)
                 {
                     Transaction currentTx = block.Transactions[i];
@@ -42,7 +45,7 @@ public TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processing
                 return receiptsTracer.TxReceipts.ToArray();
             }
 
-            private void ProcessTransaction(Block block, Transaction currentTx, int index, BlockReceiptsTracer receiptsTracer, ProcessingOptions processingOptions)
+            private void ProcessTransaction(Block block, Transaction currentTx, int index, BlockExecutionTracer receiptsTracer, ProcessingOptions processingOptions)
             {
                 _transactionProcessor.ProcessTransaction(block, currentTx, receiptsTracer, processingOptions, _stateProvider);
                 TransactionProcessed?.Invoke(this, new TxProcessedEventArgs(index, currentTx, receiptsTracer.TxReceipts[index]));