Verkle sync devnet 6

src/Nethermind/Directory.Packages.props

@@ -48,7 +48,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.2.0" />
-    <PackageVersion Include="Nethermind.Verkle" Version="0.2.3-alpha"/>
+    <PackageVersion Include="Nethermind.Verkle" Version="0.2.5-alpha" />
     <PackageVersion Include="Nito.Collections.Deque" Version="1.2.1" />
     <PackageVersion Include="NLog" Version="5.2.8" />
     <PackageVersion Include="NLog.Targets.Seq" Version="3.1.0" />

src/Nethermind/Nethermind.Api/IApiWithNetwork.cs

@@ -51,6 +51,5 @@ public interface IApiWithNetwork : IApiWithBlockchain
         ISyncServer? SyncServer { get; set; }
         IWebSocketsManager WebSocketsManager { get; set; }
         ISubscriptionFactory? SubscriptionFactory { get; set; }
-        VerkleSyncServer? VerkleSyncServer { get; set; }
     }
 }

src/Nethermind/Nethermind.Api/NethermindApi.cs

@@ -233,7 +233,6 @@ public ISealEngine SealEngine
         public CompositePruningTrigger PruningTrigger { get; } = new();
         public IProcessExitSource? ProcessExit { get; set; }
         public CompositeTxGossipPolicy TxGossipPolicy { get; } = new();
-        public VerkleSyncServer? VerkleSyncServer { get; set; }
         public IVerkleTreeStore? VerkleTreeStore { get; set; }
         public IReadOnlyVerkleTreeStore? ReadOnlyVerkleTrieStore { get; set; }
         public VerkleArchiveStore? VerkleArchiveStore { get; set; }

src/Nethermind/Nethermind.Benchmark/Verkle/VerkleWorldStateBenchmark.cs

@@ -293,7 +293,7 @@ public void InsertAndCommitRepeatedlyTimes()
             {
                 if (slot == null)
                 {
-                    worldState.GetAccount(address);
+                    worldState.TryGetAccount(address, out _);
                 }
                 else
                 {

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

@@ -117,6 +117,7 @@ public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks,
                     }
                 }
 
+                public bool CanProcessStatelessBlock { get; } = false;
                 public event EventHandler<BlocksProcessingEventArgs>? BlocksProcessing;
 
                 public event EventHandler<BlockProcessedEventArgs>? BlockProcessed;

src/Nethermind/Nethermind.Blockchain/BlockTree.cs

@@ -59,8 +59,15 @@ public partial class BlockTree : IBlockTree
         public Block? Head { get; private set; }
 
         public BlockHeader? BestSuggestedHeader { get; private set; }
-
         public Block? BestSuggestedBody { get; private set; }
+
+        // for stateless chain
+        public BlockHeader? BestProcessedStatelessHeader { get; private set; }
+        public Block? BestProcessedStatelessBlock { get; private set; }
+
+        public BlockHeader? BestSuggestedStatelessHeader { get; private set; }
+        public Block? BestSuggestedStatelessBlock { get; private set; }
+
         public BlockHeader? LowestInsertedHeader { get; private set; }
         public BlockHeader? BestSuggestedBeaconHeader { get; private set; }
 
@@ -1483,16 +1490,24 @@ void SetTotalDifficultyDeep(BlockHeader current)
         public event EventHandler<BlockReplacementEventArgs>? BlockAddedToMain;
 
         public event EventHandler<OnUpdateMainChainArgs>? OnUpdateMainChain;
+        public event EventHandler<BlockEventArgs>? OnUpdateStatelessChain;
 
         public event EventHandler<BlockEventArgs>? NewBestSuggestedBlock;
 
         public event EventHandler<BlockEventArgs>? NewSuggestedBlock;
 
         public event EventHandler<BlockEventArgs>? NewHeadBlock;
 
+        public void UpdateStatelessBlock(Block block)
+        {
+            BestProcessedStatelessHeader = block.Header;
+            BestProcessedStatelessBlock = block;
+            OnUpdateStatelessChain?.Invoke(this, new BlockEventArgs(block));
+        }
+
         /// <summary>
         /// Can delete a slice of the chain (usually invoked when the chain is corrupted in the DB).
-        /// This will only allow to delete a slice starting somewhere before the head of the chain
+        /// This will only allow deleting a slice starting somewhere before the head of the chain
         /// and ending somewhere after the head (in case there are some hanging levels later).
         /// </summary>
         /// <param name="startNumber">Start level of the slice to delete</param>

src/Nethermind/Nethermind.Blockchain/IBlockTree.cs

@@ -34,6 +34,7 @@ public interface IBlockTree : IBlockFinder
         /// Best header that has been suggested for processing
         /// </summary>
         BlockHeader? BestSuggestedHeader { get; }
+        BlockHeader? BestProcessedStatelessHeader { get; }
 
         /// <summary>
         /// Best block that has been suggested for processing
@@ -178,6 +179,10 @@ AddBlockResult Insert(Block block, BlockTreeInsertBlockOptions insertBlockOption
         /// </summary>
         event EventHandler<OnUpdateMainChainArgs> OnUpdateMainChain;
 
+        event EventHandler<BlockEventArgs> OnUpdateStatelessChain;
+
+        public void UpdateStatelessBlock(Block block);
+
         int DeleteChainSlice(in long startNumber, long? endNumber = null, bool force = false);
 
         bool IsBetterThanHead(BlockHeader? header);

src/Nethermind/Nethermind.Blockchain/ReadOnlyBlockTree.cs

@@ -31,6 +31,7 @@ public ReadOnlyBlockTree(IBlockTree wrapped)
         public BlockHeader Genesis => _wrapped.Genesis;
         public BlockHeader BestSuggestedHeader => _wrapped.BestSuggestedHeader;
         public BlockHeader BestSuggestedBeaconHeader => _wrapped.BestSuggestedBeaconHeader;
+        public BlockHeader BestProcessedStatelessHeader => _wrapped.BestProcessedStatelessHeader;
         public BlockHeader LowestInsertedHeader => _wrapped.LowestInsertedHeader;
 
         public long? LowestInsertedBodyNumber
@@ -152,6 +153,14 @@ public event EventHandler<OnUpdateMainChainArgs>? OnUpdateMainChain
             remove { }
         }
 
+        public event EventHandler<BlockEventArgs>? OnUpdateStatelessChain
+        {
+            add { }
+            remove { }
+        }
+
+        public void UpdateStatelessBlock(Block block) => _wrapped.UpdateStatelessBlock(block);
+
         public int DeleteChainSlice(in long startNumber, long? endNumber = null, bool force = false)
         {
             var bestKnownNumber = BestKnownNumber;

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

@@ -142,7 +142,7 @@ protected TxAction ProcessTransaction(
 
             public IBlockProcessor.IBlockTransactionsExecutor WithNewStateProvider(IWorldState worldState)
             {
-                return new BlockProductionTransactionsExecutor(_transactionProcessor, worldState,
+                return new BlockProductionTransactionsExecutor(_transactionProcessor.WithNewStateProvider(worldState), worldState,
                     _blockProductionTransactionPicker, _logManager);
             }
 

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

@@ -57,7 +57,7 @@ private void ProcessTransaction(in BlockExecutionContext blkCtx, Transaction cur
 
             public IBlockProcessor.IBlockTransactionsExecutor WithNewStateProvider(IWorldState worldState)
             {
-                return new BlockValidationTransactionsExecutor(_transactionProcessor, worldState);
+                return new BlockValidationTransactionsExecutor(_transactionProcessor.WithNewStateProvider(worldState), worldState);
             }
 
             [DoesNotReturn]

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

@@ -22,6 +22,7 @@
 using Nethermind.Core.Specs;
 using Nethermind.Core.Verkle;
 using Nethermind.Crypto;
+using Nethermind.Db;
 using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 using Nethermind.Evm.Tracing.GethStyle;
@@ -31,6 +32,7 @@
 using Nethermind.Specs.Forks;
 using Nethermind.State;
 using Nethermind.Verkle.Curve;
+using Nethermind.Verkle.Tree.TreeStore;
 using Nethermind.Verkle.Tree.Utils;
 using Metrics = Nethermind.Blockchain.Metrics;
 
@@ -53,6 +55,9 @@ public partial class BlockProcessor : IBlockProcessor
     private readonly IBlockTree _blockTree;
     private const int MaxUncommittedBlocks = 64;
 
+    public bool CanProcessStatelessBlock { get; protected init; }
+    private readonly VerkleWorldState _statelessWorldState;
+
     // these two are test flags that can be used to test witness generation and verification
     public bool ShouldVerifyIncomingWitness { get; set; } = false;
     public bool ShouldGenerateWitness { get; set; } = true;
@@ -74,7 +79,8 @@ public BlockProcessor(
         IBlockTree? blockTree,
         ILogManager? logManager,
         IWithdrawalProcessor? withdrawalProcessor = null,
-        IReceiptsRootCalculator? receiptsRootCalculator = null)
+        IReceiptsRootCalculator? receiptsRootCalculator = null,
+        bool canProcessStatelessBlocks = false)
     {
         _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
         _specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
@@ -90,6 +96,13 @@ public BlockProcessor(
         _blockHashInStateHandlerHandler = new BlockHashInStateHandler();
         _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
 
+        CanProcessStatelessBlock = canProcessStatelessBlocks;
+        if (CanProcessStatelessBlock)
+        {
+            NullVerkleTreeStore stateStore = new();
+            VerkleStateTree? tree = new(stateStore, logManager);
+            _statelessWorldState = new VerkleWorldState(tree, new MemDb(), logManager);
+        }
         ExecutionTracer = new BlockExecutionTracer(true, true);
     }
 
@@ -104,7 +117,8 @@ public event EventHandler<TxProcessedEventArgs> TransactionProcessed
     // TODO: move to branch processor
     public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions options, IBlockTracer blockTracer)
     {
-        if (suggestedBlocks.Count == 0) return Array.Empty<Block>();
+        bool shouldProcessStateless = options.ContainsFlag(ProcessingOptions.StatelessProcessing);
+        if (suggestedBlocks.Count == 0) return [];
 
         TxHashCalculator.CalculateInBackground(suggestedBlocks);
         BlocksProcessing?.Invoke(this, new BlocksProcessingEventArgs(suggestedBlocks));
@@ -113,11 +127,11 @@ public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks,
            In case of invalid blocks on the new branch we will discard the entire branch and come back to
            the previous head state.*/
         Hash256 previousBranchStateRoot = CreateCheckpoint();
-        InitBranch(newBranchStateRoot);
+        InitBranch(newBranchStateRoot, shouldProcessStateless);
 
         bool notReadOnly = !options.ContainsFlag(ProcessingOptions.ReadOnlyChain);
         int blocksCount = suggestedBlocks.Count;
-        Block[] processedBlocks = new Block[blocksCount];
+        var processedBlocks = new Block[blocksCount];
         using IDisposable tracker = _witnessCollector.TrackOnThisThread();
         try
         {
@@ -133,14 +147,14 @@ the previous head state.*/
                 processedBlocks[i] = processedBlock;
 
                 // be cautious here as AuRa depends on processing
-                PreCommitBlock(newBranchStateRoot, suggestedBlocks[i].Number);
+                if(!options.ContainsFlag(ProcessingOptions.StatelessProcessing)) PreCommitBlock(newBranchStateRoot, suggestedBlocks[i].Number);
                 if (notReadOnly)
                 {
                     _witnessCollector.Persist(processedBlock.Hash!);
                     BlockProcessed?.Invoke(this, new BlockProcessedEventArgs(processedBlock, receipts));
                 }
 
-                // CommitBranch in parts if we have long running branch
+                // CommitBranch in parts if we have long-running branch
                 bool isFirstInBatch = i == 0;
                 bool isLastInBatch = i == blocksCount - 1;
                 bool isNotAtTheEdge = !isFirstInBatch && !isLastInBatch;
@@ -150,7 +164,7 @@ the previous head state.*/
                     if (_logger.IsInfo) _logger.Info($"Commit part of a long blocks branch {i}/{blocksCount}");
                     previousBranchStateRoot = CreateCheckpoint();
                     Hash256? newStateRoot = suggestedBlocks[i].StateRoot;
-                    InitBranch(newStateRoot, false);
+                    InitBranch(newStateRoot, shouldProcessStateless, false);
                 }
             }
 
@@ -173,8 +187,9 @@ the previous head state.*/
     public event EventHandler<BlocksProcessingEventArgs>? BlocksProcessing;
 
     // TODO: move to branch processor
-    protected virtual void InitBranch(Hash256 branchStateRoot, bool incrementReorgMetric = true)
+    protected virtual void InitBranch(Hash256 branchStateRoot, bool processStateless, bool incrementReorgMetric = true)
     {
+        if (processStateless) return;
         /* Please note that we do not reset the state if branch state root is null.
            That said, I do not remember in what cases we receive null here.*/
         if (branchStateRoot is not null && _stateProvider.StateRoot != branchStateRoot)
@@ -278,9 +293,27 @@ private void VerifyIncomingWitness(Block block)
         }
     }
 
-    protected virtual (IBlockProcessor.IBlockTransactionsExecutor, IWorldState) GetOrCreateExecutorAndState(Block block)
+    protected virtual (IBlockProcessor.IBlockTransactionsExecutor, IWorldState) GetOrCreateExecutorAndState(Block block, bool processStateless)
     {
-        return (_blockTransactionsExecutor, _stateProvider);
+        IBlockProcessor.IBlockTransactionsExecutor? blockTransactionsExecutor;
+        IWorldState worldState;
+
+        if (block.IsGenesis || !processStateless)
+        {
+            blockTransactionsExecutor = _blockTransactionsExecutor;
+            worldState = _stateProvider;
+        }
+        else
+        {
+            _logger.Info($"Getting stateless providers");
+            Banderwagon stateRoot = Banderwagon.FromBytes(block.ExecutionWitness!.StateRoot!.Bytes.ToArray())!.Value;
+            _statelessWorldState.Reset();
+            _statelessWorldState.InsertExecutionWitness(block.ExecutionWitness!, stateRoot);
+            worldState = _statelessWorldState;
+            blockTransactionsExecutor = _blockTransactionsExecutor.WithNewStateProvider(worldState);
+        }
+
+        return (blockTransactionsExecutor, worldState);
     }
 
     // TODO: block processor pipeline
@@ -289,9 +322,8 @@ protected virtual TxReceipt[] ProcessBlock(
         IBlockTracer blockTracer,
         ProcessingOptions options)
     {
-
         (IBlockProcessor.IBlockTransactionsExecutor? blockTransactionsExecutor, IWorldState worldState) =
-            GetOrCreateExecutorAndState(block);
+            GetOrCreateExecutorAndState(block, options.ContainsFlag(ProcessingOptions.StatelessProcessing));
 
         IReleaseSpec spec = _specProvider.GetSpec(block.Header);
 
@@ -355,6 +387,15 @@ protected virtual TxReceipt[] ProcessBlock(
         }
         else
         {
+            // we dont store the execution witness on disk so when we run blocks after restart, this fails
+            if (!block.IsGenesis && block.Body.ExecutionWitness is not null)
+            {
+                var verkleWorldState = worldState as VerkleWorldState;
+                ExecutionWitness? witness = block.Body.ExecutionWitness;
+                verkleWorldState?.UpdateWithPostStateValues(witness);
+                block.Body.ExecutionWitness = witness;
+            }
+
             worldState.Commit(spec);
         }
 

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

@@ -407,13 +407,17 @@ private void FireProcessingQueueEmpty()
             if (_logger.IsDebug) _logger.Debug($"Skipped processing of {suggestedBlock.ToString(Block.Format.FullHashAndNumber)}, last processed is null: {true}, processedBlocks.Length: {processedBlocks.Length}");
         }
 
-        bool updateHead = !options.ContainsFlag(ProcessingOptions.DoNotUpdateHead);
-        if (updateHead)
+        bool updateHead = processingBranch.Blocks.Count != 0 &&
+                          !options.ContainsFlag(ProcessingOptions.DoNotUpdateHead);
+        if (updateHead) _blockTree.UpdateMainChain(processingBranch.Blocks, true);
+
+        if (options.ContainsFlag(ProcessingOptions.StatelessProcessing))
         {
-            if (_logger.IsTrace) _logger.Trace($"Updating main chain: {lastProcessed}, blocks count: {processedBlocks.Length}");
-            _blockTree.UpdateMainChain(processingBranch.Blocks, true);
+            foreach (Block? block in processedBlocks)
+            {
+                _blockTree.UpdateStatelessBlock(block);
+            }
         }
-
         bool readonlyChain = options.ContainsFlag(ProcessingOptions.ReadOnlyChain);
         long blockProcessingTimeInMs = _stopwatch.ElapsedMilliseconds;
         if (!readonlyChain)
@@ -608,7 +612,7 @@ private void PrepareBlocksToProcess(Block suggestedBlock, ProcessingOptions opti
     private ProcessingBranch PrepareProcessingBranch(Block suggestedBlock, ProcessingOptions options)
     {
         BlockHeader branchingPoint = null;
-        List<Block> blocksToBeAddedToMain = new();
+        List<Block> blocksToBeAddedToMain = [];
 
         bool branchingCondition;
         bool suggestedBlockIsPostMerge = suggestedBlock.IsPostMerge;
@@ -730,7 +734,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.StatelessProcessing) && suggestedBlock.Number != 0 &&
             !_blockTree.IsKnownBlock(suggestedBlock.Number - 1, suggestedBlock.ParentHash))
         {
             if (_logger.IsDebug)

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

@@ -30,7 +30,7 @@ Block[] Process(
             ProcessingOptions processingOptions,
             IBlockTracer blockTracer);
 
-        public bool CanProcessStatelessBlock => false;
+        public bool CanProcessStatelessBlock { get; }
 
         /// <summary>
         /// Fired when a branch is being processed.

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

@@ -15,6 +15,8 @@ private NullBlockProcessor() { }
 
         public static IBlockProcessor Instance { get; } = new NullBlockProcessor();
 
+        public bool CanProcessStatelessBlock { get; } = false;
+
         public Block[] Process(Hash256 newBranchStateRoot, List<Block> suggestedBlocks, ProcessingOptions processingOptions, IBlockTracer blockTracer)
         {
             return suggestedBlocks.ToArray();